path: root/buildscripts/idl/tests/compatibility_test_pass/new/compatibility_test_pass_new.idl

# Copyright (C) 2021-present MongoDB, Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the Server Side Public License, version 1,
# as published by MongoDB, Inc.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# Server Side Public License for more details.
#
# You should have received a copy of the Server Side Public License
# along with this program. If not, see
# <http://www.mongodb.com/licensing/server-side-public-license>.
#
# As a special exception, the copyright holders give permission to link the
# code of portions of this program with the OpenSSL library under certain
# conditions as described in each individual source file and distribute
# linked combinations including the program with the OpenSSL library. You
# must comply with the Server Side Public License in all respects for
# all of the code used other than as permitted herein. If you modify file(s)
# with this exception, you may extend this exception to your version of the
# file(s), but you are not obligated to do so. If you do not wish to do so,
# delete this exception statement from your version. If you delete this
# exception statement from all source files in the program, then also delete
# it in the license file.
#

global:
    cpp_namespace: "mongo"

imports:
    - "mongo/idl/basic_types.idl"
    - "../buildscripts/idl/tests/compatibility_test_pass/new/imports.idl"

types:
    intStringToInt:
        bson_serialization_type: int
        description: "The bson_serialization_type changes from [int, string] in the old command's
                      reply field type to int in the new command's reply field type"
        cpp_type: "std::int32_t"

    intStringBoolToIntString:
        bson_serialization_type:
                                - int
                                - string
        description: "The bson_serialization_type changes from [int, string, bool] in the old
                      command's reply field type to [int, string] in the new command's reply
                      field type"
        cpp_type: "std::int32_t"

    intStringToIntStringBool:
        bson_serialization_type:
                                - int
                                - string
                                - bool
        description: "The bson_serialization_type changes from [int, string] in the old command's
                      reply field type to [int, string, bool] in the new command's reply field
                      type"
        cpp_type: "std::int32_t"

    intToIntString:
        bson_serialization_type:
                                - int
                                - string
        description: "The bson_serialization_type changes from [int] in the old command
                      parameter's type to [int, string] in the new command parameter's type"
        cpp_type: "std::int32_t"

    bsonSerializationTypeAnyAllowed:
        bson_serialization_type:
                                - int
                                - any
        description: "The bson_serialization_type contains 'any'"
        cpp_type: "std::int32_t"

enums:
    NewReplyFieldEnumSubset:
        description: "The new reply type is an enum that is a subset of the old reply type's
                      enum values"
        type: string
        values:
            valueOne: "one"
            valueTwo: "two"

    EnumSuperset:
        description: "The new enum is a superset of the old enum values"
        type: string
        values:
            valueOne: "one"
            valueTwo: "two"
            valueThree: "three"

structs:
    StableNewFieldReply:
        description: "This reply contains a field that is unstable in the old command but is
                      stable in the new command."
        fields:
            stableNewField:
                type: string
                unstable: false

    RequiredNewFieldReply:
        description: "This reply contains a field that is optional in the old command but is
                      required in the new command."
        fields:
            requiredNewField:
                type: string
                unstable: false

    OptionalNewField:
        description: "This struct contains a field that is required in the old command but is
                      optional in the new command."
        fields:
            optionalNewField:
                type: string
                optional: true
                unstable: false

    AddedNewFieldReply:
        description: "This reply contains a field that is added in the new command."
        fields:
            addedNewField:
                type: string
                unstable: false

    UnstableOldFieldReply:
        description: "This reply contains a field that is unstable in the old command and is
                      unstable and optional in the new command."
        fields:
            unstableOldField:
                type: string
                unstable: true
                optional: true

    EnumSubsetReply:
        description: "This reply contains an enum field where the new enum values is a subset
                      of the old reply type's enum values"
        fields:
            replyField:
                type: NewReplyFieldEnumSubset
                unstable: false

    BsonSubsetReply:
        description: "This reply contains a field type where the new bson_serialization_type
                      is a subset of the old bson_serialization_type"
        fields:
            bsonSubsetReplyField:
                type: intStringToInt
                unstable: false

    BsonSubsetReplyTwo:
        description: "This reply contains a field type where the new bson_serialization_type
                      is a subset of the old bson_serialization_type"
        fields:
            bsonSubsetReplyFieldTwo:
                type: intStringBoolToIntString
                unstable: false

    StructFieldTypeRecursiveReplyOne:
        description: "This reply contains a field whose new type is a struct that is
                      compatible with the old field type"
        fields:
            structReplyField:
                type: StableNewFieldReply
                unstable: false

    StructFieldTypeRecursiveReplyTwo:
        description: "This reply contains a field whose new type is a struct that is
                      compatible with the old field type"
        fields:
            structReplyField:
                type: StructType
                unstable: false

    StructType:
        description: "This struct contains a field whose new type is compatible with the
                      old field type"
        fields:
            fieldOne:
                type: BsonSubsetReply
                unstable: false

    OldVariantTypeReply:
        description: "This reply contains an old field that has a variant type while the new field
                      is not a variant type"
        fields:
            oldVariantTypeReplyField:
                type: int
                unstable: false

    NewVariantSubsetReply:
        description: "This reply contains a field whose new variant types are a subset
                      of the old variant types"
        fields:
            variantSubsetReplyField:
                unstable: false
                type:
                    variant: [int, string, array<string>]

    NewVariantSubsetReplyTwo:
        description: "This reply contains a field whose new variant types are a subset
                      of the old variant types"
        fields:
            variantSubsetReplyFieldTwo:
                unstable: false
                type:
                    variant: [int, string, array<string>]

    VariantRecursiveReply:
        description: "This reply contains a field that has a new variant type that is compatible
                      with the old variant type"
        fields:
            variantRecursiveReplyField:
                unstable: false
                type:
                    variant: [int, intStringBoolToIntString,
                              array<intStringBoolToIntString>, array<string>]

    OldVariantStructReply:
        description: "This reply contains a field whose new variant type does not have a variant
                      struct type while the old one does"
        fields:
            variantStructReplyField:
                unstable: false
                type:
                    variant: [int, string, array<string>]

    VariantStructRecursiveReply:
        description: "This reply contains a field that has a new variant struct type that is
                      compatible with the old variant struct type"
        fields:
            variantStructRecursiveReplyField:
                unstable: false
                type:
                    variant: [int, StructFieldTypeRecursiveReplyTwo,
                              array<StructFieldTypeRecursiveReplyTwo>, array<string>]

    CommandParamStructRecursiveOne:
        description: "This command parameter struct type contains a stable and optional
                      field while the old struct field is unstable"
        fields:
            unstableToStableOptionalField:
                type: string
                optional: true
                unstable: false

    CommandParamStructRecursiveTwo:
        description: "This command parameter struct type contains a field whose new type is
                      a superset of the old field type"
        fields:
            supersetField:
                type: intToIntString
                unstable: false

    OldValidatorStruct:
        description: "This struct contains a field where the old version contains a validator while
                      the new version does not"
        fields:
            oldValidatorField:
                type: int
                unstable: false

    ValidatorsEqualStruct:
        description: "This struct contains a field where the new and old validator are exactly equal"
        fields:
            validatorsEqualField:
                type: double
                unstable: false
                validator:
                    lt: 0.0
                    gt: -1.1
                    lte: 2.0
                    gte: -2.98
                    callback: "callback"

    NewCommandParameterStruct:
        description: "The new command parameter's type and the
                     old command parameter's type are both structs"

    AddedOptionalTypeFieldStruct:
        description: "This struct contains a field that is added and optional in the new version"
        fields:
            addedOptionalTypeField:
                type: string
                optional: true
                unstable: false

    StableOptionalTypeFieldStruct:
        description: "This struct contains a field that is stable and optional in the new version
                      but unstable in the corresponding old version"
        fields:
            stableOptionalTypeField:
                type: string
                optional: true
                unstable: false

    StableWithDefaultTypeFieldStruct:
        description: "This struct contains a field that is stable and required with a default value
                      in the new version but unstable in the corresponding old version"
        fields:
            stableWithDefaultTypeField:
                type: string
                default: ""
                unstable: false

    RemovedUnstableTypeFieldStruct:
        description: "This struct contains a field that is unstable in the old version and
                      is removed in the new version"

    AddedUnstableTypeFieldStruct:
        description: "This struct contains a field that is added and unstable in the new version"
        fields:
            addedUnstableTypeField:
                type: string
                unstable: true

    KeptUnstableTypeFieldStruct:
        description: "This struct contains a field that is unstable in the new version and also
                      exists in the old version"
        fields:
            keptUnstableTypeField:
                type: string
                unstable: true

    StructCommandParameterTypeRecursive:
        description: "This param struct type contains a field that is compatible between the
                      old and new versions"
        fields:
            structCommandParameterTypeRecursiveField:
                type: intStringToIntStringBool
                unstable: false

    VariantSupersetStruct:
        description: "This struct contains a field where the new variant types are a superset
                      of the old variant types"
        fields:
            variantSupersetField:
                unstable: false
                type:
                    variant: [int, bool, string, array<string>]

    VariantSupersetStructTwo:
        description: "This struct contains a field where the new variant types are a superset
                      of the old variant types"
        fields:
            variantSupersetFieldTwo:
                unstable: false
                type:
                    variant: [int, bool, string, double, array<string>]

    OldTypeNotVariantStruct:
        description: "This struct contains a field where the new type is variant while the
                      old one is not"
        fields:
            variantField:
                unstable: false
                type:
                    variant: [int, bool, array<string>]

    VariantRecursiveStruct:
        description: "This struct contains a field where the new variant types are
                      compatible with the old variant types"
        fields:
            variantRecursiveField:
                unstable: false
                type:
                    variant: [int, intStringToIntStringBool,
                              array<intStringToIntStringBool>, array<string>]

    VariantStructSupersetStruct:
        description: "This struct contains a field where the new variant types contains a struct
                      while the old one does not"
        fields:
            variantStructSupersetField:
                unstable: false
                type:
                    variant: [int, string, NewCommandParameterStruct,
                              array<NewCommandParameterStruct>, array<string>]

    VariantStructRecursiveStruct:
        description: "This struct contains a field where the old variant struct and the new
                      variant struct are compatible"
        fields:
            variantStructRecursiveField:
                unstable: false
                type:
                    variant: [int, string, StructCommandParameterTypeRecursive,
                              array<StructCommandParameterTypeRecursive>, array<string>]

    BsonSerializationTypeAnyReply:
        description: "This reply contains a field whose type is 'any' and is explicitly allowed"
        fields:
            anyTypeField:
                type: bsonSerializationTypeAnyAllowed
                unstable: false

    NewlyAddedBsonSerializationTypeAnyReply:
        description: "This reply contains a newly added field whose type has a bson_serialization_type
                        that contains 'any' that is explicitly allowed"
        fields:
            newlyAddedBsonSerializationTypeAnyReplyField:
                type: bsonSerializationTypeAnyAllowed
                unstable: false

    OldUnstableTypeChangesReply:
        description: "This reply contains a field that is unstable in the old version and has type changes"
        fields:
            oldUnstableTypeChangesReplyField:
                unstable: true
                type: intStringToIntStringBool
                validator:
                    lt: 0

    NewlyAddedBsonSerializationTypeAnyStruct:
        description: "This struct contains a newly added field whose type has a bson_serialization_type
                        that contains 'any' that is explicitly allowed"
        fields:
            newlyAddedBsonSerializationTypeAnyStructField:
                type: bsonSerializationTypeAnyAllowed
                optional: true
                unstable: false

    OldUnstableTypeChangesStruct:
        description: "This struct contains a field that is unstable in the old version and has type changes"
        fields:
            oldUnstableTypeChangesField:
                type: intStringBoolToIntString
                optional: true
                unstable: false
                validator:
                    lt: 0

    BsonSerializationTypeAnyWithVariantReply:
        description: "This reply contains a new reply field with variant types where one of the
                      bson serialization types is 'any' and is explicitly allowed"
        fields:
            anyTypeField:
                unstable: false
                type:
                    variant: [bsonSerializationTypeAnyAllowed, StructFieldTypeRecursiveReplyTwo,
                              array<bsonSerializationTypeAnyAllowed>,
                              array<StructFieldTypeRecursiveReplyTwo>]

    ArrayTypeStruct:
        description: "Struct with ArrayType field."
        fields:
            ArrayCommandParameter:
                type: array<string>
                unstable: false

    MissingUnstableFieldNewFieldStruct:
        description: "This struct contains a field that missing the 'unstable' field in the new
                      command."
        fields:
            missingUnstableFieldNewField:
                type: string

    MissingUnstableFieldOldFieldStruct:
        description: "This struct contains a field that missing the 'unstable' field in the old
                      command."
        fields:
            missingUnstableFieldNewField:
                type: string
                unstable: false

    CompatibleChainedStructReply:
        description: "This reply contains an compatible chained struct"
        chained_structs:
            StructFieldTypeRecursiveReplyTwo: StructFieldTypeRecursiveReplyTwo

    CompatibleChainedStructType:
        description: "This struct type contains an compatible chained struct"
        chained_structs:
            StructCommandParameterTypeRecursive: StructCommandParameterTypeRecursive

    NewOptionalBoolStruct:
        description: "This struct gets another field of type optionalBool."
        fields:
            ok1:
                type: bool
                unstable: false
                optional: true
            ok2:
                type: optionalBool
                unstable: false

    OptionalBoolEquivalenceStruct:
        description: "First two fields get the types swapped."
        fields:
            ok1:
                type: optionalBool
                unstable: false
            ok2:
                type: bool
                unstable: false
                optional: true
            ok3:
                type: optionalBool
                unstable: false

    OptionalBoolToBoolStruct:
        description: "optionalBool field replaced by bool"
        fields:
            ok:
                type: bool
                unstable: false

    BoolToOptionalBoolStruct:
        description: "bool field replaced by optionalBool"
        fields:
            ok:
                type: optionalBool
                unstable: false

    ReplyWithNewArrayTypeField:
        description: "new field is of ArrayType"
        fields:
            ok:
                type: bool
                unstable: false
            newArrayTypeField:
                type: array<int>
                optional: true
                unstable: false

    ReplyWithNewNestedArrayTypeField:
        description: "new field is a struct with a field of ArrayType"
        fields:
            ok:
                type: bool
                unstable: false
            newStructWithArrayTypeField:
                type: ArrayTypeStruct
                optional: true
                unstable: false

commands:
    testCommand:
        description: "new passing test command, there was no change from the old version"
        command_name: testCommand
        namespace: ignored
        cpp_name: testCommand
        strict: true
        api_version: "1"
        reply_type: OkReply

    addedCommand:
        description: "new command is added and should pass"
        command_name: addedCommand
        namespace: ignored
        cpp_name: addedCommand
        strict: true
        api_version: "1"
        reply_type: OkReply

    strictFalseCommand:
        description: "command passes with strict: false in both versions of the command"
        command_name: strictFalseCommand
        namespace: ignored
        cpp_name: strictFalseCommand
        strict: false
        api_version: "1"
        reply_type: OkReply

    strictTrueToFalseCommand:
        description: "command passes when it switches from strict: true to switch: false"
        command_name: strictTrueToFalseCommand
        namespace: ignored
        cpp_name: strictTrueToFalseCommand
        strict: false
        api_version: "1"
        reply_type: OkReply

    addedCommandParameter:
        description: "new optional command parameter is added and should pass"
        command_name: addedCommandParameter
        namespace: ignored
        cpp_name: addedCommandParameter
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParameter:
                type: string
                optional: true
                unstable: false

    addedCommandParameterStable:
        description: "new command has an optional stable parameter that is unstable
                      in the corresponding old command and still passes"
        command_name: addedCommandParameterStable
        namespace: ignored
        cpp_name: addedCommandParameterStable
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newOptionalStableParam:
                type: string
                optional: true
                unstable: false

    addedCommandParameterStableWithDefault:
        description: "new command has a required stable parameter with a default value
                      that is unstable in the corresponding old command and still passes"
        command_name: addedCommandParameterStableWithDefault
        namespace: ignored
        cpp_name: addedCommandParameterStableWithDefault
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newStableParamWithDefault:
                type: string
                default: ""
                unstable: false

    removeCommandParameterUnstable:
        description: "new command removes parameter that is unstable
                      in the corresponding old command and still passes"
        command_name: removeCommandParameterUnstable
        namespace: ignored
        cpp_name: removeCommandParameterUnstable
        strict: true
        api_version: "1"
        reply_type: OkReply

    addedCommandParameterOptional:
        description: "new command has an optional parameter that is required
                      in the corresponding old command and still passes"
        command_name: addedCommandParameterOptional
        namespace: ignored
        cpp_name: addedCommandParameterOptional
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newOptionalParam:
                type: string
                optional: true
                unstable: false

    addedUnstableCommandParameter:
        description: "new command has a new unstable parameter that did not
                      exist in the corresponding old command and still passes"
        command_name: addedUnstableCommandParameter
        namespace: ignored
        cpp_name: addedUnstableCommandParameter
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newUnstableParam:
                type: string
                unstable: true

    keptUnstableCommandParameter:
        description: "new command has an unstable parameter that also
                      exists in the corresponding old command and still passes"
        command_name: keptUnstableCommandParameter
        namespace: ignored
        cpp_name: keptUnstableCommandParameter
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            unstableParam:
                type: string
                unstable: true

    newCommandParameterType:
        description: "new command passes because its command parameter type is compatible with
                     the corresponding old command's parameter type"
        command_name: newCommandParameterType
        namespace: ignored
        cpp_name: newCommandParameterType
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            compatibleParameter:
                type: string
                unstable: false

    newCommandParameterTypeEnumSuperset:
        description: "new command passes because its command parameter type is an enum that is
                      a superset of the corresponding old command parameter's type's enum values"
        command_name: newCommandParameterTypeEnumSuperset
        namespace: ignored
        cpp_name: newCommandParameterTypeEnumSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            parameterEnumSuperset:
                type: EnumSuperset
                unstable: false

    newCommandParameterTypeStruct:
        description: "new command passes because its command parameter type is a struct and the
                      corresponding old command parameter type is also a struct"
        command_name: newCommandParameterTypeStruct
        namespace: ignored
        cpp_name: newCommandParameterTypeStruct
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            parameterStruct:
                type: NewCommandParameterStruct
                unstable: false

    newCommandParameterTypeBsonSuperset:
        description: "new command passes because its parameter type has a bson_serialization_type
                      that is a superset of the corresponding old command parameter type's
                      bson_serialization_type"
        command_name: newCommandParameterTypeBsonSuperset
        namespace: ignored
        cpp_name: newCommandParameterTypeBsonSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            bsonSupersetParam:
                type: intToIntString
                unstable: false

    newCommandParameterTypeStructRecursiveOne:
        description: "new command passes because its parameter type is a struct that is
                      compatible with the old parameter type struct"
        command_name: newCommandParameterTypeStructRecursiveOne
        namespace: ignored
        cpp_name: newCommandParameterTypeStructRecursiveOne
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            unstableToStableOptionalStructParameter:
                type: CommandParamStructRecursiveOne
                unstable: false

    newCommandParameterTypeStructRecursiveTwo:
        description: "new command passes because its parameter type is a struct that is
                      compatible with the old parameter type struct"
        command_name: newCommandParameterTypeStructRecursiveTwo
        namespace: ignored
        cpp_name: newCommandParameterTypeStructRecursiveTwo
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            supersetStructParameter:
                type: CommandParamStructRecursiveTwo
                unstable: false

    newlyAddedParamBsonAnyAllowList:
        description: "command passes when its parameter is newly added and has bson type 'any'
                      that is explicitly allowed"
        command_name: newlyAddedParamBsonAnyAllowList
        namespace: ignored
        cpp_name: newlyAddedParamBsonAnyAllowList
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newlyAddedBsonAnyAllowListParam:
                type: bsonSerializationTypeAnyAllowed
                optional: true
                unstable: false

    oldUnstableParamTypeChanges:
        description: "command passes when it has an old unstable param with incompatible type changes"
        command_name: oldUnstableParamTypeChanges
        namespace: ignored
        cpp_name: oldUnstableParamTypeChanges
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            oldUnstableTypeChangesParam:
                type: intStringBoolToIntString
                optional: true
                unstable: false
                validator:
                    lt: 0

    newlyAddedTypeFieldBsonAnyAllowList:
        description: "command passes when its type field is newly added and has bson type 'any'
                      that is explicitly allowed"
        command_name: newlyAddedTypeFieldBsonAnyAllowList
        namespace: type
        type: NewlyAddedBsonSerializationTypeAnyStruct
        cpp_name: newlyAddedTypeFieldBsonAnyAllowList
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldUnstableTypeChanges:
        description: "command passes when it has an old unstable type field with incompatible type changes"
        command_name: oldUnstableTypeChanges
        namespace: type
        type: OldUnstableTypeChangesStruct
        cpp_name: oldUnstableParamTypeChanges
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldCommandParameterValidator:
        description: "new command passes when it contains a parameter that does not contain a validator
                      that is present in the old parameter"
        command_name: oldCommandParameterValidator
        namespace: ignored
        cpp_name: oldCommandParameterValidator
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParam:
                type: int
                unstable: false

    commandParameterValidatorsEqual:
        description: "new command passes because it contains a parameter that contains a validator
                      that is exactly equal to the old parameter validator"
        command_name: commandParameterValidatorsEqual
        namespace: ignored
        cpp_name: commandParameterValidatorsEqual
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            newParam:
                type: double
                unstable: false
                validator:
                    lt: 0.0
                    gt: -1.1
                    lte: 2.0
                    gte: -2.98
                    callback: "callback"

    oldCommandTypeValidator:
        description: "new command passes because it contains a type that does not contain a validator
                      that is present in the old type"
        command_name: oldCommandTypeValidator
        namespace: type
        type: OldValidatorStruct
        cpp_name: oldCommandTypeValidator
        strict: true
        api_version: "1"
        reply_type: OkReply

    commandTypeValidatorsEqual:
        description: "new command passes because it contains a type that contains a validator
                      that is exactly equal to the old type validator"
        command_name: commandTypeValidatorsEqual
        namespace: type
        type: ValidatorsEqualStruct
        cpp_name: commandTypeValidatorsEqual
        strict: true
        api_version: "1"
        reply_type: OkReply

    newReplyFieldStable:
        description: "new command contains a stable reply field that is unstable
                      in the corresponding old command and still passes"
        command_name: newReplyFieldStable
        namespace: ignored
        cpp_name: newReplyFieldStable
        strict: true
        api_version: "1"
        reply_type: StableNewFieldReply

    newReplyFieldRequired:
        description: "new command contains a required reply field that is optional
                      in the corresponding old command and still passes"
        command_name: newReplyFieldRequired
        namespace: ignored
        cpp_name: newReplyFieldRequired
        strict: true
        api_version: "1"
        reply_type: RequiredNewFieldReply

    newReplyFieldAdded:
        description: "new command adds a new reply field and still passes"
        command_name: newReplyFieldAdded
        namespace: ignored
        cpp_name: newReplyFieldAdded
        strict: true
        api_version: "1"
        reply_type: AddedNewFieldReply

    oldReplyFieldUnstable:
        description: "old reply field is unstable so new commmand passes even if its new reply
                      field is unstable"
        command_name: oldReplyFieldUnstable
        namespace: ignored
        cpp_name: oldReplyFieldUnstable
        strict: true
        api_version: "1"
        reply_type: UnstableOldFieldReply

    importedReplyCommand:
        description: "reply is imported and should pass"
        command_name: importedReplyCommand
        namespace: ignored
        cpp_name: importedReplyCommand
        strict: true
        api_version: "1"
        reply_type: ImportedStableNewFieldReply

    newReplyFieldTypeEnumSubset:
        description: "new command passes because its reply field type is an enum that is
                      a subset of the corresponding old reply field type's enum values"
        command_name: newReplyFieldTypeEnumSubset
        namespace: ignored
        cpp_name: newReplyFieldTypeEnumSubset
        strict: true
        api_version: "1"
        reply_type: EnumSubsetReply

    newReplyFieldTypeBsonSubset:
        description: "new command passes because its reply field type has a
                      bson_serialization_type that is a subset of the corresponding
                      old reply field type's bson_serialization_type"
        command_name: newReplyFieldTypeBsonSubset
        namespace: ignored
        cpp_name: newReplyFieldTypeBsonSubset
        strict: true
        api_version: "1"
        reply_type: BsonSubsetReply

    newReplyFieldTypeBsonSubsetTwo:
        description: "new command passes because its reply field type has a
                      bson_serialization_type that is a subset of the corresponding
                      old reply field type's bson_serialization_type"
        command_name: newReplyFieldTypeBsonSubsetTwo
        namespace: ignored
        cpp_name: newReplyFieldTypeBsonSubsetTwo
        strict: true
        api_version: "1"
        reply_type: BsonSubsetReplyTwo

    newReplyFieldTypeStructRecursiveOne:
        description: "new command passes because its reply field type is a struct that is
                      compatible with the old reply field type struct"
        command_name: newReplyFieldTypeStructRecursiveOne
        namespace: ignored
        cpp_name: newReplyFieldTypeStructRecursiveOne
        strict: true
        api_version: "1"
        reply_type: StructFieldTypeRecursiveReplyOne

    newReplyFieldTypeStructRecursiveTwo:
        description: "new command passes because its reply field type is a struct that is
                      compatible with the old reply field type struct"
        command_name: newReplyFieldTypeStructRecursiveTwo
        namespace: ignored
        cpp_name: newReplyFieldTypeStructRecursiveTwo
        strict: true
        api_version: "1"
        reply_type: StructFieldTypeRecursiveReplyTwo

    newNamespaceIgnored:
        description: "new command passes when its namespace is changed to ignored"
        command_name: newNamespaceIgnored
        namespace: ignored
        cpp_name: newNamespaceIgnored
        strict: true
        api_version: "1"
        reply_type: OkReply

    newNamespaceConcatenateWithDbOrUuid:
        description: "new command passes when its namespace is changed to
                      concatenate_with_db_or_uuid from concatenate_with_db"
        command_name: newNamespaceConcatenateWithDbOrUuid
        namespace: concatenate_with_db_or_uuid
        cpp_name: newNamespaceConcatenateWithDbOrUuid
        strict: true
        api_version: "1"
        reply_type: OkReply

    newNamespaceTypeToIgnored:
        description: "new command passes when its namespace is changed from type to ignored"
        command_name: newNamespaceTypeToIgnored
        namespace: ignored
        cpp_name: newNamespaceTypeToIgnored
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldNamespaceTypeNamespaceString:
        description: "If old command has namespace: type and type: namespacestring,
                      the new namespace can be changed to concatenate_with_db"
        command_name: oldNamespaceTypeNamespaceString
        namespace: concatenate_with_db
        cpp_name: oldNamespaceTypeNamespaceString
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldNamespaceTypeNamespaceStringTwo:
        description: "If old command has namespace: type and type: namespacestring,
                      the new namespace can be changed to concatenate_with_db_or_uuid"
        command_name: oldNamespaceTypeNamespaceStringTwo
        namespace: concatenate_with_db_or_uuid
        cpp_name: oldNamespaceTypeNamespaceStringTwo
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeSuperset:
        description: "new command passes because its type is a superset
                      of the old type"
        command_name: newTypeSuperset
        namespace: type
        type: intStringToIntStringBool
        cpp_name: newTypeSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeEnumSuperset:
        description: "new command passes because its type is an enum that is
                      a superset of the corresponding old type's enum values"
        command_name: newTypeEnumSuperset
        namespace: type
        type: EnumSuperset
        cpp_name: newTypeEnumSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldOptional:
        description: "new command type contains an optional field that is required
                      in the corresponding old command and still passes"
        command_name: newTypeFieldOptional
        namespace: type
        type: OptionalNewField
        cpp_name: newTypeFieldOptional
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldAddedOptional:
        description: "new optional type field is added and should pass"
        command_name: newTypeFieldAddedOptional
        namespace: type
        type: AddedOptionalTypeFieldStruct
        cpp_name: newTypeFieldAddedOptional
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldStableOptional:
        description: "new command has an optional type field that is unstable
                      in the corresponding old command and still passes"
        command_name: newTypeFieldStableOptional
        namespace: type
        type: StableOptionalTypeFieldStruct
        cpp_name: newTypeFieldStableOptional
        strict: true
        api_version: "1"
        reply_type: OkReply

    newTypeFieldStableWithDefault:
        description: "new command has a required type field with a default value
                      that is unstable in the corresponding old command and still passes"
        command_name: newTypeFieldStableWithDefault
        namespace: type
        type: StableWithDefaultTypeFieldStruct
        cpp_name: newTypeFieldStableWithDefault
        strict: true
        api_version: "1"
        reply_type: OkReply

    removeTypeFieldUnstable:
        description: "new command removes type field that is unstable
                      in the corresponding old command and still passes"
        command_name: removeTypeFieldUnstable
        namespace: type
        type: RemovedUnstableTypeFieldStruct
        cpp_name: removeTypeFieldUnstable
        strict: true
        api_version: "1"
        reply_type: OkReply

    addedUnstableTypeField:
        description: "new command has a new unstable type field that does not
                      exist in the corresponding old command and still passes"
        command_name: addedUnstableTypeField
        namespace: type
        type: AddedUnstableTypeFieldStruct
        cpp_name: addedUnstableTypeField
        strict: true
        api_version: "1"
        reply_type: OkReply

    keptUnstableTypeField:
        description: "new command has an unstable type field that also
                      exists in the corresponding old command and still passes"
        command_name: keptUnstableTypeField
        namespace: type
        type: KeptUnstableTypeFieldStruct
        cpp_name: keptUnstableTypeField
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldReplyFieldVariantType:
        description: "new command passes when its reply field type is not a variant type while
                      the old reply field is a variant type"
        command_name: oldReplyFieldVariantType
        namespace: ignored
        cpp_name: oldReplyFieldVariantType
        strict: true
        api_version: "1"
        reply_type: OldVariantTypeReply

    newReplyFieldVariantSubset:
        description: "new command when its reply field type is a variant type that is
                      a subset of the old reply field variant types"
        command_name: newReplyFieldVariantSubset
        namespace: ignored
        cpp_name: newReplyFieldVariantSubset
        strict: true
        api_version: "1"
        reply_type: NewVariantSubsetReply

    newReplyFieldVariantSubsetTwo:
        description: "new command when its reply field type is a variant type that is
                      a subset of the old reply field variant types"
        command_name: newReplyFieldVariantSubsetTwo
        namespace: ignored
        cpp_name: newReplyFieldVariantSubsetTwo
        strict: true
        api_version: "1"
        reply_type: NewVariantSubsetReplyTwo

    replyFieldVariantRecursive:
        description: "new command passes when its reply field type is a variant type that is
                      compatible with the old reply field variant type"
        command_name: replyFieldVariantRecursive
        namespace: ignored
        cpp_name: replyFieldVariantRecursive
        strict: true
        api_version: "1"
        reply_type: VariantRecursiveReply

    oldReplyFieldVariantStruct:
        description: "new command passes if it doesn't have a variant struct type while the
                      old command does"
        command_name: oldReplyFieldVariantStruct
        namespace: ignored
        cpp_name: oldReplyFieldVariantStruct
        strict: true
        api_version: "1"
        reply_type: OldVariantStructReply

    replyFieldVariantStructRecursive:
        description: "new command passes when its reply field type has a variant struct type
                      that is compatible with the old reply field variant struct type"
        command_name: replyFieldVariantStructRecursive
        namespace: ignored
        cpp_name: replyFieldVariantStructRecursive
        strict: true
        api_version: "1"
        reply_type: VariantStructRecursiveReply

    newlyAddedReplyFieldTypeBsonAnyAllowed:
        description: "command passes because it has a newly added reply field type has a bson_serialization_type
                      that contains 'any' that is explicitly allowed"
        command_name: newlyAddedReplyFieldTypeBsonAnyAllowed
        namespace: ignored
        cpp_name: newlyAddedReplyFieldTypeBsonAnyAllowed
        strict: true
        api_version: "1"
        reply_type: NewlyAddedBsonSerializationTypeAnyReply

    oldUnstableReplyFieldTypeChanges:
        description: "command passes when it has an old unstable reply field with incompatible type changes"
        command_name: oldUnstableReplyFieldTypeChanges
        namespace: ignored
        cpp_name: oldUnstableReplyFieldTypeChanges
        strict: true
        api_version: "1"
        reply_type: OldUnstableTypeChangesReply

    commandAllowedAnyTypes:
        description: "new command that has parameter and reply type with
                      explicitly allowed 'any' bson serialization type passes"
        command_name: commandAllowedAnyTypes
        namespace: type
        type: bsonSerializationTypeAnyAllowed
        cpp_name: commandAllowedAnyTypes
        strict: true
        api_version: "1"
        reply_type: BsonSerializationTypeAnyReply
        fields:
            anyTypeParam:
                type: bsonSerializationTypeAnyAllowed
                unstable: false

    commandAllowedAnyTypesWithVariant:
        description: "command that has reply variant types with
                      explicitly allowed 'any' bson serialization type passes"
        command_name: commandAllowedAnyTypesWithVariant
        namespace: ignored
        cpp_name: commandAllowedAnyTypesWithVariant
        strict: true
        api_version: "1"
        reply_type: BsonSerializationTypeAnyWithVariantReply

    newParamVariantSuperset:
        description: "new command passes because its parameter type is a variant type that is
                      a superset of the old parameter variant types"
        command_name: newParamVariantSuperset
        namespace: ignored
        cpp_name: newParamVariantSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantSupersetParam:
                unstable: false
                type:
                    variant: [int, bool, string, array<string>]

    newParamVariantSupersetTwo:
        description: "new command passes because its parameter type is a variant type that is
                      a superset of the old parameter variant types"
        command_name: newParamVariantSupersetTwo
        namespace: ignored
        cpp_name: newParamVariantSupersetTwo
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantSupersetParam:
                unstable: false
                type:
                    variant: [int, string, bool, double, array<string>]

    oldParamTypeNotVariant:
        description: "new command passes because its parameter type is variant while the old
                      param type is not"
        command_name: newParamTypeNotVariant
        namespace: ignored
        cpp_name: newParamTypeNotVariant
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantParam:
                unstable: false
                type:
                    variant: [int, string, array<string>]

    newParamVariantRecursive:
        description: "new command passes because its param type is a variant type that is
                      compatible with the old param variant type"
        command_name: newParamVariantRecursive
        namespace: ignored
        cpp_name: newParamVariantRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantRecursiveParam:
                unstable: false
                type:
                    variant: [int, intStringToIntStringBool,
                              array<intStringToIntStringBool>, array<string>]

    newParamVariantStructSuperset:
        description: "new command passes because its parameter type is a variant type that is
                      a subset of the old parameter variant types"
        command_name: newParamVariantStructSuperset
        namespace: ignored
        cpp_name: newParamVariantStructSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantStructSupersetParam:
                unstable: false
                type:
                    variant: [int, string, NewCommandParameterStruct,
                              array<NewCommandParameterStruct>, array<string>]

    newParamVariantStructRecursive:
        description: "new command passes because its parameter type has a variant
                      struct type that is compatible with the old parameter variant
                      struct type"
        command_name: newParamVariantStructRecursive
        namespace: ignored
        cpp_name: newParamVariantStructRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            variantStructRecursiveParam:
                unstable: false
                type:
                    variant: [int, string, StructCommandParameterTypeRecursive,
                              array<StructCommandParameterTypeRecursive>, array<string>]

    newCommandTypeVariantSuperset:
        description: "new command passes because its type is a variant type that is
                      a superset of the old type variant types"
        command_name: newCommandTypeVariantSuperset
        namespace: type
        type: VariantSupersetStruct
        cpp_name: newCommandTypeVariantSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeVariantSupersetTwo:
        description: "new command passes because its type is a variant type that is
                      a superset of the old command type variant types"
        command_name: newCommandTypeVariantSupersetTwo
        namespace: type
        type: VariantSupersetStructTwo
        cpp_name: newCommandTypeVariantSupersetTwo
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldCommandTypeNotVariant:
        description: "new command passes because its type is variant while the old
                      type is not"
        command_name: oldCommandTypeNotVariant
        namespace: type
        type: OldTypeNotVariantStruct
        cpp_name: oldCommandTypeNotVariant
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeVariantRecursive:
        description: "new command passes because its type is a variant type that is passes
                      compatible with the old command type variant type"
        command_name: newCommandTypeVariantRecursive
        namespace: type
        type: VariantRecursiveStruct
        cpp_name: newCommandTypeVariantRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeVariantStructSuperset:
        description: "new command passes because its type is a variant type that is
                      a superset of the old command type variant types"
        command_name: newCommandTypeVariantStructSuperset
        namespace: type
        type: VariantStructSupersetStruct
        cpp_name: newCommandTypeVariantStructSuperset
        strict: true
        api_version: "1"
        reply_type: OkReply

    newCommandTypeVariantStructRecursive:
        description: "new command passes because its type has a variant
                      struct type that is compatible with the old command type variant
                      struct type"
        command_name: newCommandTypeVariantStructRecursive
        namespace: type
        type: VariantStructRecursiveStruct
        cpp_name: newCommandTypeVariantStructRecursive
        strict: true
        api_version: "1"
        reply_type: OkReply

    oldReplyFieldValidator:
        description: "new command passes because it contains a reply field that does not contain a validator
                      that is present in the old reply field"
        command_name: oldReplyFieldValidator
        namespace: ignored
        cpp_name: oldReplyFieldValidator
        strict: true
        api_version: "1"
        reply_type: OldValidatorStruct

    replyFieldValidatorsEqual:
        description: "new command passes because it contains a reply field that contains a validator
                      that is exactly equal to the old reply field validator"
        command_name: replyFieldValidatorsEqual
        namespace: ignored
        cpp_name: replyFieldValidatorsEqual
        strict: true
        api_version: "1"
        reply_type: ValidatorsEqualStruct

    simpleCheckEqual:
        description: "new command passes because its simple check is equal to
                      the old check"
        command_name: simpleCheckEqual
        namespace: ignored
        cpp_name: simpleCheckEqual
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            simple:
                check: check

    simplePrivilegeEqual:
        description: "new command passes because its simple privilege is equal to
                      the old privilege"
        command_name: simplePrivilegeEqual
        namespace: ignored
        cpp_name: simplePrivilegeEqual
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            simple:
                privilege:
                    resource_pattern: resourcePattern
                    action_type: [actionTypeThree, actionTypeOne, actionTypeTwo]

    newSimpleActionTypeSubset:
        description: "new command passes because its simple privilege action_type is a subset
                      of the old privilege action_type"
        command_name: newSimpleActionTypeSubset
        namespace: ignored
        cpp_name: newSimpleActionTypeSubset
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            simple:
                privilege:
                    resource_pattern: resourcePattern
                    action_type: [actionTypeThree, actionTypeOne]

    ArrayCommand:
        description: "new command will pass because the command type and the field type are of
                      ArrayType of a type that is compatible with the old command."
        command_name: arrayCommand
        namespace: type
        type: array<ArrayTypeStruct>
        cpp_name: arrayCommand
        strict: true
        api_version: "1"
        fields:
            parameterStruct:
                type: array<ArrayTypeStruct>
                unstable: false
        reply_type: ArrayTypeStruct

    complexActionTypesSubset:
        description: "new command passes when the action types are a subset"
        command_name: complexActionTypesSubset
        namespace: ignored
        cpp_name: complexActionTypesSubset
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            complex:
                - privilege:
                    resource_pattern: resourcePatternTwo
                    action_type: actionTypeOne
                - check: checkOne
                - privilege:
                    resource_pattern: resourcePattern
                    action_type: [actionTypeOne, actionTypeTwo, actionTypeThree]

    complexActionTypesSubsetTwo:
        description: "new command passes when the action types are a subset"
        command_name: complexActionTypesSubsetTwo
        namespace: ignored
        cpp_name: complexActionTypesSubsetTwo
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            complex:
                - privilege:
                    resource_pattern: resourcePatternTwo
                    action_type: [actionTypeOne, actionTypeTwo]
                - check: checkOne
                - privilege:
                    resource_pattern: resourcePattern
                    action_type: [actionTypeOne, actionTypeTwo]

    complexChecksSubset:
        description: "new command passes when the complex checks are a subset of the old checks"
        command_name: complexChecksSubset
        namespace: ignored
        cpp_name: complexChecksSubset
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            complex:
                - check: checkThree
                - check: checkTwo

    addedAggStage:
        description: "new command passes when a agg stage is added"
        command_name: addedAggStage
        namespace: ignored
        cpp_name: addedAggStage
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            complex:
                - privilege:
                    resource_pattern: resourcePatternTwo
                    action_type: [actionTypeOne, actionTypeTwo]
                - check: checkOne
                - privilege:
                    resource_pattern: resourcePattern
                    action_type: [actionTypeOne, actionTypeTwo]
                - privilege:
                    agg_stage: aggStage
                    resource_pattern: resourcePatternThree
                    action_type: actionTypeThree

    removedAggStage:
        description: "new command passes when a agg stage is removed"
        command_name: removedAggStage
        namespace: ignored
        cpp_name: removedAggStage
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            complex:
                - privilege:
                    resource_pattern: resourcePatternTwo
                    action_type: [actionTypeOne, actionTypeTwo]
                - check: checkOne
                - privilege:
                    resource_pattern: resourcePattern
                    action_type: [actionTypeOne, actionTypeTwo]

    removedComplexPrivilege:
        description: "new command passes when a complex privilege is removed"
        command_name: removedComplexPrivilege
        namespace: ignored
        cpp_name: removedComplexPrivilege
        strict: true
        api_version: "1"
        reply_type: OkReply
        access_check:
            complex:
                - check: checkOne
                - privilege:
                    resource_pattern: resourcePattern
                    action_type: [actionTypeOne, actionTypeTwo, actionTypeThree]

    addedAccessCheckField:
        description: "new command passes because it adds the access_check field when the api_version is not '1'"
        command_name: addedAccessCheckField
        namespace: ignored
        cpp_name: addedAccessCheckField
        strict: true
        api_version: ""
        reply_type: OkReply
        access_check:
            none: true

    newReplyFieldMissingUnstableField:
        description: "new command passes because it does not have an api_version even though it
                      contains a reply field that is missing the 'unstable' field"
        command_name: newReplyFieldMissingUnstableField
        namespace: ignored
        cpp_name: newReplyFieldMissingUnstableField
        strict: true
        api_version: ""
        reply_type: MissingUnstableFieldNewFieldStruct

    oldReplyFieldMissingUnstableField:
        description: "old command passes even though it contains a reply field that is missing the
                      'unstable' field"
        command_name: oldReplyFieldMissingUnstableField
        namespace: ignored
        cpp_name: oldReplyFieldMissingUnstableField
        strict: true
        api_version: "1"
        reply_type: MissingUnstableFieldOldFieldStruct

    newCommandTypeFieldMissingUnstableField:
        description: "new command passes because it does not have an api_version even though it
                      contains a command type field that is missing the 'unstable' field"
        command_name: newCommandTypeFieldMissingUnstableField
        namespace: type
        cpp_name: newCommandTypeFieldMissingUnstableField
        strict: true
        api_version: ""
        type: MissingUnstableFieldNewFieldStruct
        reply_type: OkReply

    oldCommandTypeFieldMissingUnstableField:
        description: "old command passes even though it
                      contains a command type field that is missing the 'unstable' field"
        command_name: oldCommandTypeFieldMissingUnstableField
        namespace: type
        cpp_name: oldCommandTypeFieldMissingUnstableField
        strict: true
        api_version: "1"
        type: MissingUnstableFieldOldFieldStruct
        reply_type: OkReply

    newParameterMissingUnstableField:
        description: "new command passes because it does not have an api_version even though it
                      contains a parameter that is missing the 'unstable' field"
        command_name: newParameterMissingUnstableField
        namespace: ignored
        cpp_name: newParameterMissingUnstableField
        strict: true
        api_version: ""
        fields:
            missingUnstableFieldNewParameter:
                type: int
        reply_type: OkReply

    oldParameterMissingUnstableField:
        description: "old command passes even though it
                      contains a parameter that is missing the 'unstable' field"
        command_name: oldParameterMissingUnstableField
        namespace: ignored
        cpp_name: oldParameterMissingUnstableField
        strict: true
        api_version: "1"
        fields:
            missingUnstableFieldOldParameter:
                type: int
                unstable: false
        reply_type: OkReply

    chainedStructCompatible:
        description: "new command passes because it contains a chained struct that has compatible
                      fields"
        command_name: chainedStructCompatible
        namespace: ignored
        cpp_name: chainedStructCompatible
        strict: true
        api_version: "1"
        reply_type: OkReply
        chained_structs:
            VariantStructRecursiveStruct: VariantStructRecursiveStruct

    replyWithCompatibleChainedStruct:
        description: "new command passes because its reply contains a chained struct that has
                      compatible fields"
        command_name: replyWithCompatibleChainedStruct
        namespace: ignored
        cpp_name: replyWithCompatibleChainedStruct
        strict: true
        api_version: "1"
        reply_type: CompatibleChainedStructReply

    typeWithCompatibleChainedStruct:
        description: "new command passes because its type contains a chained struct that has
                      compatible fields"
        command_name: typeWithCompatibleChainedStruct
        namespace: type
        type: CompatibleChainedStructType
        cpp_name: typeWithCompatibleChainedStruct
        strict: true
        api_version: "1"
        reply_type: OkReply

    incompatibleChainedType:
        description: "new command passes because its chained types are compatible"
        command_name: incompatibleChainedType
        namespace: ignored
        cpp_name: incompatibleChainedType
        strict: true
        api_version: "1"
        reply_type: OkReply
        chained_types:
            intToIntString: intToIntString

    newParameterOptionalBool:
        description: "new command can add parameters of type optionalBoolean"
        command_name: newParameterOptionalBool
        namespace: ignored
        cpp_name: newParameterOptionalBool
        strict: true
        api_version: "1"
        reply_type: OkReply
        fields:
            flag:
                type: optionalBool
                unstable: false

    newReplyOptionalBool:
        description: "new command can add reply fields of type optionalBoolean"
        command_name: newReplyOptionalBool
        namespace: ignored
        cpp_name: newReplyOptionalBool
        strict: true
        api_version: "1"
        reply_type: NewOptionalBoolStruct

    newCommandTypeOptionalBool:
        description: "new command can add type fields of type optionalBoolean"
        command_name: newCommandTypeOptionalBool
        namespace: type
        type: NewOptionalBoolStruct
        cpp_name: newCommandTypeOptionalBool
        strict: true
        api_version: "1"
        reply_type: OkReply

    optionalBoolParameterEquivalence:
        description: "new command gets first two parameter types swapped"
        command_name: optionalBoolParameterEquivalence
        namespace: ignored
        cpp_name: optionalBoolParameterEquivalence
        strict: true
        api_version: "1"
        fields:
            flag1:
                unstable: false
                type: optionalBool
            flag2:
                unstable: false
                type: bool
                optional: true
            flag3:
                unstable: false
                type: optionalBool
        reply_type: OkReply

    optionalBoolReplyEquivalence:
        description: "new command gets first two reply field types swapped"
        command_name: optionalBoolReplyEquivalence
        namespace: ignored
        cpp_name: optionalBoolReplyEquivalence
        strict: true
        api_version: "1"
        reply_type: OptionalBoolEquivalenceStruct

    optionalBoolCommandTypeEquivalence:
        description: "new command gets first two type field types swapped"
        command_name: optionalBoolCommandTypeEquivalence
        namespace: type
        type: OptionalBoolEquivalenceStruct
        cpp_name: optionalBoolCommandTypeEquivalence
        strict: true
        api_version: "1"
        reply_type: OkReply

    boolToOptionalBoolParameter:
        description: "new command parameter has type optionalBool instead of bool"
        command_name: boolToOptionalBoolParameter
        namespace: ignored
        cpp_name: boolToOptionalBoolParameter
        strict: true
        api_version: "1"
        fields:
            flag:
                unstable: false
                type: optionalBool
        reply_type: OkReply

    boolToOptionalBoolCommandType:
        description: "new command type has type optionalBool instead of bool"
        command_name: boolTooptionalBoolCommandType
        namespace: type
        type: BoolToOptionalBoolStruct
        cpp_name: boolTooptionalBoolCommandType
        strict: true
        api_version: "1"
        reply_type: OkReply

    optionalBoolToBoolReply:
        description: "new command gets bool reply instead of optionalBool"
        command_name: optionalBoolToBoolReply
        namespace: ignored
        cpp_name: optionalBoolToBoolReply
        strict: true
        api_version: "1"
        reply_type: OptionalBoolToBoolStruct

    commandWithNewArrayTypeParameterAndArrayTypeReply:
        description: "new command adds a new ArrayType parameter and a reply type with an ArrayType"
        command_name: commandWithNewArrayTypeParameterAndArrayTypeReply
        namespace: type
        type: array<int>
        cpp_name: commandWithNewArrayTypeParameterAndArrayTypeReply
        strict: true
        api_version: "1"
        fields:
            newArrayTypeParameter:
                type: array<int>
                optional: true
                unstable: false
        reply_type: ReplyWithNewArrayTypeField

    commandWithNewNestedArrayTypeParameterAndNestedArrayTypeReply:
        description: "new command adds a new parameter with a nested ArrayType field and a reply type with a nested ArrayType"
        command_name: commandWithNewNestedArrayTypeParameterAndNestedArrayTypeReply
        namespace: type
        type: ArrayTypeStruct
        cpp_name: commandWithNewNestedArrayTypeParameterAndNestedArrayTypeReply
        strict: true
        api_version: "1"
        fields:
            newNestedArrayTypeParameter:
                type: ArrayTypeStruct
                optional: true
                unstable: false
        reply_type: ReplyWithNewNestedArrayTypeField