{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
    "ApiVersion": {
      "description": "- since API version formats range from\nAzure ARM API date style (2018-01-01) to semver (1.2.3)\nand virtually any other text, this value tends to be an\nopaque string with the possibility of a modifier to indicate\nthat it is a range.\n\noptions:\n- prepend a dash or append a plus to indicate a range\n(ie, '2018-01-01+' or '-2019-01-01', or '1.0+' )\n\n- semver-range style (ie, '^1.0.0' or '~1.0.0' )",
      "type": "object",
      "properties": {
        "version": {
          "description": "the actual api version string used in the API",
          "type": "string"
        },
        "range": {
          "enum": [
            "+",
            "-"
          ],
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "version"
      ]
    },
    "ApiVersions": {
      "description": "a collection of api versions",
      "type": "array",
      "items": {
        "$ref": "#/definitions/ApiVersion"
      }
    },
    "Schema": {
      "type": "object",
      "properties": {
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for Schema"
        },
        "type": {
          "$ref": "#/definitions/AllSchemaTypes",
          "description": "the schema type"
        },
        "summary": {
          "description": "a short description",
          "type": "string"
        },
        "example": {
          "description": "example information"
        },
        "defaultValue": {
          "description": "If the value isn't sent on the wire, the service will assume this"
        },
        "serialization": {
          "$ref": "#/definitions/SerializationFormats",
          "description": "per-serialization information for this Schema"
        },
        "apiVersions": {
          "description": "API versions that this applies to. Undefined means all versions",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ApiVersion"
          }
        },
        "deprecated": {
          "$ref": "#/definitions/Deprecation",
          "description": "Represent the deprecation information if api is deprecated.",
          "default": "undefined"
        },
        "origin": {
          "description": "where did this aspect come from (jsonpath or 'modelerfour:<soemthing>')",
          "type": "string"
        },
        "externalDocs": {
          "$ref": "#/definitions/ExternalDocumentation",
          "description": "External Documentation Links"
        },
        "protocol": {
          "$ref": "#/definitions/Protocols",
          "description": "per-protocol information for this aspect"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ]
    },
    "Deprecation": {
      "description": "Represent information about a deprecation",
      "type": "object",
      "properties": {
        "reason": {
          "description": "Reason why this was deprecated.",
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "Extensions": {
      "description": "A dictionary of open-ended 'x-*' extensions propogated from the original source document.",
      "type": "object",
      "properties": {
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "uri": {
      "description": "an URI",
      "type": "string"
    },
    "ExternalDocumentation": {
      "description": "a reference to external documentation",
      "type": "object",
      "properties": {
        "description": {
          "type": "string"
        },
        "url": {
          "description": "an URI",
          "type": "string"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "url"
      ]
    },
    "Languages": {
      "description": "custom extensible metadata for individual language generators",
      "type": "object",
      "properties": {
        "default": {
          "$ref": "#/definitions/Language"
        },
        "csharp": {
          "$ref": "#/definitions/Language"
        },
        "python": {
          "$ref": "#/definitions/Language"
        },
        "ruby": {
          "$ref": "#/definitions/Language"
        },
        "go": {
          "$ref": "#/definitions/Language"
        },
        "typescript": {
          "$ref": "#/definitions/Language"
        },
        "javascript": {
          "$ref": "#/definitions/Language"
        },
        "powershell": {
          "$ref": "#/definitions/Language"
        },
        "java": {
          "$ref": "#/definitions/Language"
        },
        "c": {
          "$ref": "#/definitions/Language"
        },
        "cpp": {
          "$ref": "#/definitions/Language"
        },
        "swift": {
          "$ref": "#/definitions/Language"
        },
        "objectivec": {
          "$ref": "#/definitions/Language"
        },
        "sputnik": {
          "$ref": "#/definitions/Language"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "default"
      ]
    },
    "Protocols": {
      "description": "custom extensible metadata for individual protocols (ie, HTTP, etc)",
      "type": "object",
      "properties": {
        "http": {
          "$ref": "#/definitions/Protocol"
        },
        "amqp": {
          "$ref": "#/definitions/Protocol"
        },
        "mqtt": {
          "$ref": "#/definitions/Protocol"
        },
        "jsonrpc": {
          "$ref": "#/definitions/Protocol"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "Metadata": {
      "description": "common pattern for Metadata on aspects",
      "type": "object",
      "properties": {
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for this aspect"
        },
        "protocol": {
          "$ref": "#/definitions/Protocols",
          "description": "per-protocol information for this aspect"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol"
      ]
    },
    "Language": {
      "description": "the bare-minimum fields for per-language metadata on a given aspect",
      "type": "object",
      "properties": {
        "name": {
          "description": "name used in actual implementation",
          "type": "string"
        },
        "description": {
          "description": "description text - describes this node.",
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": {
        "type": "object"
      },
      "required": [
        "description",
        "name"
      ]
    },
    "CSharpLanguage": {
      "type": "object",
      "defaultProperties": [],
      "additionalProperties": false
    },
    "Protocol": {
      "description": "the bare-minimum fields for per-protocol metadata on a given aspect",
      "type": "object",
      "defaultProperties": [],
      "additionalProperties": false
    },
    "email": {
      "type": "string"
    },
    "Contact": {
      "description": "contact information",
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "url": {
          "description": "an URI",
          "type": "string"
        },
        "email": {
          "type": "string"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "License": {
      "description": "license information",
      "type": "object",
      "properties": {
        "name": {
          "description": "the nameof the license",
          "type": "string"
        },
        "url": {
          "description": "an uri pointing to the full license text",
          "type": "string"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "name"
      ]
    },
    "Info": {
      "description": "code model information",
      "type": "object",
      "properties": {
        "title": {
          "description": "the title of this service.",
          "type": "string"
        },
        "description": {
          "description": "a text description of the service",
          "type": "string"
        },
        "termsOfService": {
          "description": "an uri to the terms of service specified to access the service",
          "type": "string"
        },
        "contact": {
          "$ref": "#/definitions/Contact",
          "description": "contact information for the service"
        },
        "license": {
          "$ref": "#/definitions/License",
          "description": "license information for th service"
        },
        "externalDocs": {
          "$ref": "#/definitions/ExternalDocumentation",
          "description": "External Documentation"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "title"
      ]
    },
    "XmlSerlializationFormat": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "namespace": {
          "type": "string"
        },
        "prefix": {
          "type": "string"
        },
        "attribute": {
          "type": "boolean"
        },
        "wrapped": {
          "type": "boolean"
        },
        "text": {
          "type": "boolean"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "attribute",
        "text",
        "wrapped"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/SerializationFormat"
        }
      ]
    },
    "SerializationFormats": {
      "description": "custom extensible metadata for individual serialization formats",
      "type": "object",
      "properties": {
        "json": {
          "$ref": "#/definitions/SerializationFormat"
        },
        "xml": {
          "$ref": "#/definitions/XmlSerlializationFormat"
        },
        "protobuf": {
          "$ref": "#/definitions/SerializationFormat"
        },
        "binary": {
          "$ref": "#/definitions/SerializationFormat"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "SchemaType": {
      "description": "possible schema types that indicate the type of schema.",
      "type": "string",
      "enum": [
        "array",
        "dictionary",
        "boolean",
        "integer",
        "number",
        "object",
        "string",
        "unixtime",
        "byte-array",
        "binary",
        "char",
        "date",
        "time",
        "date-time",
        "duration",
        "uuid",
        "uri",
        "arm-id",
        "credential",
        "odata-query",
        "any",
        "any-object",
        "choice",
        "sealed-choice",
        "conditional",
        "sealed-conditional",
        "flag",
        "constant",
        "or",
        "xor",
        "not",
        "unknown",
        "group"
      ]
    },
    "CompoundSchemaTypes": {
      "description": "Compound schemas are used to construct complex objects or offer choices of a set of schemas.\n\n(ie, allOf, anyOf, oneOf )",
      "enum": [
        "or",
        "xor"
      ],
      "type": "string"
    },
    "PrimitiveSchemaTypes": {
      "description": "Schema types that are primitive language values",
      "enum": [
        "arm-id",
        "boolean",
        "char",
        "credential",
        "date",
        "date-time",
        "duration",
        "integer",
        "number",
        "string",
        "time",
        "unixtime",
        "uri",
        "uuid"
      ],
      "type": "string"
    },
    "ValueSchemaTypes": {
      "description": "schema types that are non-object or complex types",
      "enum": [
        "arm-id",
        "array",
        "boolean",
        "byte-array",
        "char",
        "choice",
        "conditional",
        "credential",
        "date",
        "date-time",
        "duration",
        "flag",
        "integer",
        "number",
        "sealed-choice",
        "sealed-conditional",
        "string",
        "time",
        "unixtime",
        "uri",
        "uuid"
      ],
      "type": "string"
    },
    "ObjectSchemaTypes": {
      "description": "schema types that can be objects",
      "enum": [
        "dictionary",
        "object",
        "or"
      ],
      "type": "string"
    },
    "AllSchemaTypes": {
      "description": "all schema types",
      "enum": [
        "any",
        "any-object",
        "arm-id",
        "array",
        "binary",
        "boolean",
        "byte-array",
        "char",
        "choice",
        "conditional",
        "constant",
        "credential",
        "date",
        "date-time",
        "dictionary",
        "duration",
        "flag",
        "group",
        "integer",
        "not",
        "number",
        "object",
        "odata-query",
        "or",
        "sealed-choice",
        "sealed-conditional",
        "string",
        "time",
        "unixtime",
        "uri",
        "uuid",
        "xor"
      ],
      "type": "string"
    },
    "SerializationFormat": {
      "type": "object",
      "properties": {
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "ValueSchema": {
      "description": "schema types that are non-object or complex types",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "PrimitiveSchema": {
      "description": "Schema types that are primitive language values",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ValueSchema"
        }
      ]
    },
    "ComplexSchema": {
      "description": "schema types that can be objects",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "Value": {
      "description": "common base interface for properties, parameters and the like.",
      "type": "object",
      "properties": {
        "schema": {
          "$ref": "#/definitions/Schema",
          "description": "the schema of this Value"
        },
        "required": {
          "description": "if the value is marked 'required'.",
          "type": "boolean"
        },
        "nullable": {
          "description": "can null be passed in instead",
          "type": "boolean"
        },
        "assumedValue": {
          "description": "the value that the remote will assume if this value is not present"
        },
        "clientDefaultValue": {
          "description": "the value that the client should provide if the consumer doesn't provide one"
        },
        "summary": {
          "description": "a short description",
          "type": "string"
        },
        "apiVersions": {
          "description": "API versions that this applies to. Undefined means all versions",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ApiVersion"
          }
        },
        "deprecated": {
          "$ref": "#/definitions/Deprecation",
          "description": "Represent the deprecation information if api is deprecated.",
          "default": "undefined"
        },
        "origin": {
          "description": "where did this aspect come from (jsonpath or 'modelerfour:<soemthing>')",
          "type": "string"
        },
        "externalDocs": {
          "$ref": "#/definitions/ExternalDocumentation",
          "description": "External Documentation Links"
        },
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for this aspect"
        },
        "protocol": {
          "$ref": "#/definitions/Protocols",
          "description": "per-protocol information for this aspect"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "schema"
      ]
    },
    "Property": {
      "description": "a property is a child value in an object",
      "type": "object",
      "properties": {
        "readOnly": {
          "description": "if the property is marked read-only (ie, not intended to be sent to the service)",
          "type": "boolean"
        },
        "serializedName": {
          "description": "the wire name of this property",
          "type": "string"
        },
        "flattenedNames": {
          "description": "when a property is flattened, the property will be the set of serialized names to get to that target property.\n\nIf flattenedName is present, then this property is a flattened property.\n\n(ie, ['properties','name'] )",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "isDiscriminator": {
          "description": "if this property is used as a discriminator for a polymorphic type",
          "type": "boolean"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "schema",
        "serializedName"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Value"
        }
      ]
    },
    "ImplementationLocation": {
      "type": "string",
      "enum": [
        "Method",
        "Client",
        "Context"
      ]
    },
    "Parameter": {
      "description": "a definition of an discrete input for an operation",
      "type": "object",
      "properties": {
        "implementation": {
          "$ref": "#/definitions/ImplementationLocation",
          "description": "suggested implementation location for this parameter"
        },
        "flattened": {
          "description": "When a parameter is flattened, it will be left in the list, but marked hidden (so, don't generate those!)",
          "type": "boolean"
        },
        "groupedBy": {
          "$ref": "#/definitions/Parameter",
          "description": "When a parameter is grouped into another, this will tell where the parameter got grouped into."
        },
        "isPartialBody": {
          "description": "If this parameter is only part of the body request(for multipart and form bodies.)",
          "type": "boolean"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "schema"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Value"
        }
      ]
    },
    "VirtualParameter": {
      "type": "object",
      "properties": {
        "originalParameter": {
          "$ref": "#/definitions/Parameter",
          "description": "the original body parameter that this parameter is in effect replacing"
        },
        "pathToProperty": {
          "description": "if this parameter is for a nested property, this is the path of properties it takes to get there",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Property"
          }
        },
        "targetProperty": {
          "$ref": "#/definitions/Property",
          "description": "the target property this virtual parameter represents"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "originalParameter",
        "pathToProperty",
        "protocol",
        "schema",
        "targetProperty"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Parameter"
        }
      ]
    },
    "BinaryResponse": {
      "description": "a response where the content should be treated as a binary instead of a value or object",
      "type": "object",
      "properties": {
        "binary": {
          "description": "indicates that this response is a binary stream",
          "type": "boolean",
          "const": true
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "binary",
        "language",
        "protocol"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Response"
        }
      ]
    },
    "SchemaResponse": {
      "description": "a response that should be deserialized into a result of type(schema)",
      "type": "object",
      "properties": {
        "schema": {
          "$ref": "#/definitions/Schema",
          "description": "the content returned by the service for a given operaiton"
        },
        "nullable": {
          "description": "indicates whether the response can be 'null'",
          "type": "boolean"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "schema"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Response"
        }
      ]
    },
    "Operation": {
      "description": "represents a single callable endpoint with a discrete set of inputs, and any number of output possibilities (responses or exceptions)",
      "type": "object",
      "properties": {
        "operationId": {
          "description": "Original Operation ID if present.\nThis can be used to identify the original id of an operation before it is styled.\nTHIS IS NOT the name of the operation that should be used in the generator. Use `.language.default.name` for this",
          "type": "string"
        },
        "parameters": {
          "description": "common parameters when there are multiple requests",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Parameter"
          }
        },
        "signatureParameters": {
          "description": "a common filtered list of parameters that is (assumably) the actual method signature parameters",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Parameter"
          }
        },
        "requestMediaTypes": {
          "$ref": "#/definitions/Record<string,Request>",
          "description": "Mapping of all the content types available for this operation to the coresponding request."
        },
        "specialHeaders": {
          "description": "List of headers that parameters should not handle as parameters but with special logic.\nSee https://github.com/Azure/autorest/tree/main/packages/extensions/modelerfour for configuration `skip-special-headers` to exclude headers.",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "requests": {
          "description": "the different possibilities to build the request.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Request"
          }
        },
        "responses": {
          "description": "responses that indicate a successful call",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Response"
          }
        },
        "exceptions": {
          "description": "responses that indicate a failed call",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Response"
          }
        },
        "profile": {
          "$ref": "#/definitions/Record<string,ApiVersion>",
          "description": "the apiVersion to use for a given profile name"
        },
        "summary": {
          "description": "a short description",
          "type": "string"
        },
        "apiVersions": {
          "description": "API versions that this applies to. Undefined means all versions",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ApiVersion"
          }
        },
        "deprecated": {
          "$ref": "#/definitions/Deprecation",
          "description": "Represent the deprecation information if api is deprecated.",
          "default": "undefined"
        },
        "origin": {
          "description": "where did this aspect come from (jsonpath or 'modelerfour:<soemthing>')",
          "type": "string"
        },
        "externalDocs": {
          "$ref": "#/definitions/ExternalDocumentation",
          "description": "External Documentation Links"
        },
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for this aspect"
        },
        "protocol": {
          "$ref": "#/definitions/Protocols",
          "description": "per-protocol information for this aspect"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol"
      ]
    },
    "OperationGroup": {
      "description": "an operation group represents a container around set of operations",
      "type": "object",
      "properties": {
        "$key": {
          "type": "string"
        },
        "operations": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/Operation"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "$key",
        "language",
        "operations",
        "protocol"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Metadata"
        }
      ]
    },
    "AnySchema": {
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "AnyObjectSchema": {
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "ArraySchema": {
      "description": "a Schema that represents and array of values",
      "type": "object",
      "properties": {
        "elementType": {
          "$ref": "#/definitions/Schema",
          "description": "elementType of the array"
        },
        "maxItems": {
          "description": "maximum number of elements in the array",
          "type": "number"
        },
        "minItems": {
          "description": "minimum number of elements in the array",
          "type": "number"
        },
        "uniqueItems": {
          "description": "if the elements in the array should be unique",
          "type": "boolean"
        },
        "nullableItems": {
          "description": "if elements in the array should be nullable",
          "type": "boolean"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "elementType",
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ValueSchema"
        }
      ]
    },
    "ByteArraySchema": {
      "description": "a schema that represents a ByteArray value",
      "type": "object",
      "properties": {
        "format": {
          "description": "date-time format",
          "enum": [
            "base64url",
            "byte"
          ],
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "format",
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ValueSchema"
        }
      ]
    },
    "BinarySchema": {
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "StringSchema": {
      "description": "a Schema that represents a string value",
      "type": "object",
      "properties": {
        "maxLength": {
          "description": "the maximum length of the string",
          "type": "number"
        },
        "minLength": {
          "description": "the minimum length of the string",
          "type": "number"
        },
        "pattern": {
          "description": "a regular expression that the string must be validated against",
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "ODataQuerySchema": {
      "description": "a schema that represents a ODataQuery value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "CredentialSchema": {
      "description": "a schema that represents a Credential value",
      "type": "object",
      "properties": {
        "maxLength": {
          "description": "the maximum length of the string",
          "type": "number"
        },
        "minLength": {
          "description": "the minimum length of the string",
          "type": "number"
        },
        "pattern": {
          "description": "a regular expression that the string must be validated against",
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "UriSchema": {
      "description": "a schema that represents a Uri value",
      "type": "object",
      "properties": {
        "maxLength": {
          "description": "the maximum length of the string",
          "type": "number"
        },
        "minLength": {
          "description": "the minimum length of the string",
          "type": "number"
        },
        "pattern": {
          "description": "a regular expression that the string must be validated against",
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "UuidSchema": {
      "description": "a schema that represents a Uuid value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "ArmIdSchema": {
      "description": "a schema that represents a Uuid value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "ChoiceSchema": {
      "description": "a schema that represents a choice of several values (ie, an 'enum')",
      "type": "object",
      "properties": {
        "choiceType": {
          "$ref": "#/definitions/PrimitiveSchema",
          "description": "the primitive type for the choices"
        },
        "choices": {
          "description": "the possible choices for in the set",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ChoiceValue"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "choiceType",
        "choices",
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ValueSchema"
        }
      ]
    },
    "ChoiceValue": {
      "description": "an individual choice in a ChoiceSchema",
      "type": "object",
      "properties": {
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for this value"
        },
        "value": {
          "description": "the actual value",
          "type": [
            "string",
            "number",
            "boolean"
          ]
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "value"
      ]
    },
    "SealedChoiceSchema": {
      "description": "a schema that represents a choice of several values (ie, an 'enum')",
      "type": "object",
      "properties": {
        "choiceType": {
          "$ref": "#/definitions/PrimitiveSchema",
          "description": "the primitive type for the choices"
        },
        "choices": {
          "description": "the possible choices for in the set",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ChoiceValue"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "choiceType",
        "choices",
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ValueSchema"
        }
      ]
    },
    "ConditionalSchema": {
      "description": "a schema that represents a value dependent on another",
      "type": "object",
      "properties": {
        "conditionalType": {
          "$ref": "#/definitions/PrimitiveSchema",
          "description": "the primitive type for the conditional"
        },
        "conditions": {
          "description": "the possible conditinal values",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConditionalValue"
          }
        },
        "sourceValue": {
          "$ref": "#/definitions/Value",
          "description": "the source value that drives the target value (property or parameter)"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "conditionalType",
        "conditions",
        "language",
        "protocol",
        "sourceValue",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ValueSchema"
        }
      ]
    },
    "ConditionalValue": {
      "description": "an individual value in a ConditionalSchema",
      "type": "object",
      "properties": {
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for this value"
        },
        "target": {
          "description": "the actual value",
          "type": [
            "string",
            "number",
            "boolean"
          ]
        },
        "source": {
          "description": "the actual value",
          "type": [
            "string",
            "number",
            "boolean"
          ]
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "source",
        "target"
      ]
    },
    "SealedConditionalSchema": {
      "description": "a schema that represents a value dependent on another (not overridable)",
      "type": "object",
      "properties": {
        "conditionalType": {
          "$ref": "#/definitions/PrimitiveSchema",
          "description": "the primitive type for the condition"
        },
        "conditions": {
          "description": "the possible conditional values",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConditionalValue"
          }
        },
        "sourceValue": {
          "$ref": "#/definitions/Value",
          "description": "the source value that drives the target value"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "conditionalType",
        "conditions",
        "language",
        "protocol",
        "sourceValue",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ValueSchema"
        }
      ]
    },
    "ConstantValue": {
      "description": "a container for the actual constant value",
      "type": "object",
      "properties": {
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for this value"
        },
        "value": {
          "description": "the actual constant value to use"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "value"
      ]
    },
    "ConstantSchema": {
      "description": "a schema that represents a constant value",
      "type": "object",
      "properties": {
        "valueType": {
          "$ref": "#/definitions/Schema",
          "description": "the schema type of the constant value (ie, StringSchema, NumberSchema, etc)"
        },
        "value": {
          "$ref": "#/definitions/ConstantValue",
          "description": "the actual constant value"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type",
        "value",
        "valueType"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "DictionarySchema": {
      "description": "a schema that represents a key-value collection",
      "type": "object",
      "properties": {
        "elementType": {
          "$ref": "#/definitions/Schema",
          "description": "the element type of the dictionary. (Keys are always strings)"
        },
        "nullableItems": {
          "description": "if elements in the dictionary should be nullable",
          "type": "boolean"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "elementType",
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ComplexSchema"
        }
      ]
    },
    "FlagValue": {
      "type": "object",
      "properties": {
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for this value"
        },
        "value": {
          "type": "number"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "value"
      ]
    },
    "FlagSchema": {
      "type": "object",
      "properties": {
        "choices": {
          "description": "the possible choices for in the set",
          "type": "array",
          "items": {
            "$ref": "#/definitions/FlagValue"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "choices",
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ValueSchema"
        }
      ]
    },
    "NumberSchema": {
      "description": "a Schema that represents a Number value",
      "type": "object",
      "properties": {
        "precision": {
          "description": "precision (# of bits?) of the number",
          "type": "number"
        },
        "multipleOf": {
          "description": "if present, the number must be an exact multiple of this value",
          "type": "number"
        },
        "maximum": {
          "description": "if present, the value must be lower than or equal to this (unless exclusiveMaximum is true)",
          "type": "number"
        },
        "exclusiveMaximum": {
          "description": "if present, the value must be lower than maximum",
          "type": "boolean"
        },
        "minimum": {
          "description": "if present, the value must be highter than or equal to this (unless exclusiveMinimum is true)",
          "type": "number"
        },
        "exclusiveMinimum": {
          "description": "if present, the value must be higher than minimum",
          "type": "boolean"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "precision",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "SchemaContext": {
      "type": "string",
      "enum": [
        "input",
        "output",
        "exception"
      ]
    },
    "SchemaUsage": {
      "type": "object",
      "properties": {
        "usage": {
          "description": "contexts in which the schema is used",
          "type": "array",
          "items": {
            "$ref": "#/definitions/SchemaContext"
          }
        },
        "serializationFormats": {
          "description": "Known media types in which this schema can be serialized",
          "type": "array",
          "items": {
            "$ref": "#/definitions/KnownMediaType"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "Relations": {
      "type": "object",
      "properties": {
        "immediate": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ComplexSchema"
          }
        },
        "all": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ComplexSchema"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "all",
        "immediate"
      ]
    },
    "Discriminator": {
      "type": "object",
      "properties": {
        "property": {
          "$ref": "#/definitions/Property"
        },
        "immediate": {
          "$ref": "#/definitions/Record<string,ComplexSchema>"
        },
        "all": {
          "$ref": "#/definitions/Record<string,ComplexSchema>"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "all",
        "immediate",
        "property"
      ]
    },
    "GroupProperty": {
      "type": "object",
      "properties": {
        "originalParameter": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/Parameter"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "originalParameter",
        "protocol",
        "schema",
        "serializedName"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Property"
        }
      ]
    },
    "GroupSchema": {
      "type": "object",
      "properties": {
        "properties": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/GroupProperty"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        },
        {
          "$ref": "#/definitions/SchemaUsage"
        }
      ]
    },
    "ObjectSchema": {
      "description": "a schema that represents a type with child properties.",
      "type": "object",
      "properties": {
        "discriminator": {
          "$ref": "#/definitions/Discriminator",
          "description": "the property of the polymorphic descriminator for this type, if there is one"
        },
        "properties": {
          "description": "the collection of properties that are in this object",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Property"
          }
        },
        "maxProperties": {
          "description": "maximum number of properties permitted",
          "type": "number"
        },
        "minProperties": {
          "description": "minimum number of properties permitted",
          "type": "number"
        },
        "parents": {
          "$ref": "#/definitions/Relations"
        },
        "children": {
          "$ref": "#/definitions/Relations"
        },
        "discriminatorValue": {
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ComplexSchema"
        },
        {
          "$ref": "#/definitions/SchemaUsage"
        }
      ]
    },
    "BooleanSchema": {
      "description": "a schema that represents a boolean value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "CharSchema": {
      "description": "a schema that represents a Char value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "OrSchema": {
      "description": "an OR relationship between several schemas",
      "type": "object",
      "properties": {
        "anyOf": {
          "description": "the set of schemas that this schema is composed of. Every schema is optional",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ComplexSchema"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "anyOf",
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/ComplexSchema"
        }
      ]
    },
    "XorSchema": {
      "description": "an XOR relationship between several schemas",
      "type": "object",
      "properties": {
        "oneOf": {
          "description": "the set of schemas that this must be one and only one of.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Schema"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "oneOf",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "NotSchema": {
      "description": "a NOT relationship between schemas",
      "type": "object",
      "properties": {
        "not": {
          "$ref": "#/definitions/Schema",
          "description": "the schema that this may not be."
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "not",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Schema"
        }
      ]
    },
    "DurationSchema": {
      "description": "a schema that represents a Duration value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "DateTimeSchema": {
      "description": "a schema that represents a DateTime value",
      "type": "object",
      "properties": {
        "format": {
          "description": "date-time format",
          "enum": [
            "date-time",
            "date-time-rfc1123"
          ],
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "format",
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "DateSchema": {
      "description": "a schema that represents a Date value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "TimeSchema": {
      "description": "a schema that represents a Date value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "UnixTimeSchema": {
      "description": "a schema that represents a UnixTime value",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/PrimitiveSchema"
        }
      ]
    },
    "Schemas": {
      "description": "the full set of schemas for a given service, categorized into convenient collections",
      "type": "object",
      "properties": {
        "arrays": {
          "description": "a collection of items",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ArraySchema"
          }
        },
        "dictionaries": {
          "description": "an associative array (ie, dictionary, hashtable, etc)",
          "type": "array",
          "items": {
            "$ref": "#/definitions/DictionarySchema"
          }
        },
        "booleans": {
          "description": "a true or false value",
          "type": "array",
          "items": {
            "$ref": "#/definitions/BooleanSchema"
          }
        },
        "numbers": {
          "description": "a number value",
          "type": "array",
          "items": {
            "$ref": "#/definitions/NumberSchema"
          }
        },
        "objects": {
          "description": "an object of some type",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ObjectSchema"
          }
        },
        "strings": {
          "description": "a string of characters",
          "type": "array",
          "items": {
            "$ref": "#/definitions/StringSchema"
          }
        },
        "unixtimes": {
          "description": "UnixTime",
          "type": "array",
          "items": {
            "$ref": "#/definitions/UnixTimeSchema"
          }
        },
        "byteArrays": {
          "description": "ByteArray -- an array of bytes",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ByteArraySchema"
          }
        },
        "streams": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/Schema"
          }
        },
        "chars": {
          "description": "a single character",
          "type": "array",
          "items": {
            "$ref": "#/definitions/CharSchema"
          }
        },
        "dates": {
          "description": "a Date",
          "type": "array",
          "items": {
            "$ref": "#/definitions/DateSchema"
          }
        },
        "times": {
          "description": "a time",
          "type": "array",
          "items": {
            "$ref": "#/definitions/TimeSchema"
          }
        },
        "dateTimes": {
          "description": "a DateTime",
          "type": "array",
          "items": {
            "$ref": "#/definitions/DateTimeSchema"
          }
        },
        "durations": {
          "description": "a Duration",
          "type": "array",
          "items": {
            "$ref": "#/definitions/DurationSchema"
          }
        },
        "uuids": {
          "description": "a universally unique identifier",
          "type": "array",
          "items": {
            "$ref": "#/definitions/UuidSchema"
          }
        },
        "uris": {
          "description": "an URI of some kind",
          "type": "array",
          "items": {
            "$ref": "#/definitions/UriSchema"
          }
        },
        "armIds": {
          "description": "an URI of some kind",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ArmIdSchema"
          }
        },
        "credentials": {
          "description": "a password or credential",
          "type": "array",
          "items": {
            "$ref": "#/definitions/CredentialSchema"
          }
        },
        "odataQueries": {
          "description": "OData Query",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ODataQuerySchema"
          }
        },
        "choices": {
          "description": "- this is essentially can be thought of as an 'enum'\nthat is a choice between one of several items, but an unspecified value is permitted.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ChoiceSchema"
          }
        },
        "sealedChoices": {
          "description": "- this is essentially can be thought of as an 'enum'\nthat is a choice between one of several items, but an unknown value is not allowed.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/SealedChoiceSchema"
          }
        },
        "conditionals": {
          "description": "ie, when 'profile' is 'production', use '2018-01-01' for apiversion",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConditionalSchema"
          }
        },
        "sealedConditionals": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/SealedConditionalSchema"
          }
        },
        "flags": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/FlagSchema"
          }
        },
        "constants": {
          "description": "a constant value",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ConstantSchema"
          }
        },
        "ors": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/OrSchema"
          }
        },
        "xors": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/XorSchema"
          }
        },
        "binaries": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/BinarySchema"
          }
        },
        "unknowns": {
          "description": "it's possible that we just may make this an error\nin representation.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Schema"
          }
        },
        "groups": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/GroupSchema"
          }
        },
        "any": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/AnySchema"
          }
        },
        "anyObjects": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/AnyObjectSchema"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "Security": {
      "description": "The security information for the API surface",
      "type": "object",
      "properties": {
        "authenticationRequired": {
          "description": "indicates that the API surface requires authentication",
          "type": "boolean"
        },
        "schemes": {
          "items": {
            "type": "SecuritySchemeFull"
          },
          "type": "array"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "authenticationRequired",
        "schemes"
      ]
    },
    "SecurityScheme": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "type"
      ]
    },
    "OAuth2SecurityScheme": {
      "type": "object",
      "properties": {
        "scopes": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "scopes",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/SecurityScheme"
        }
      ]
    },
    "KeySecurityScheme": {
      "type": "object",
      "properties": {
        "in": {
          "type": "string",
          "const": "header"
        },
        "name": {
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "in",
        "name",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/SecurityScheme"
        }
      ]
    },
    "ValueOrFactory": {
      "anyOf": [
        {
          "$ref": "#/definitions/ApiVersion"
        },
        {
          "type": "object",
          "defaultProperties": [],
          "additionalProperties": false
        }
      ]
    },
    "Example": {
      "description": "example data [UNFINISHED]",
      "type": "object",
      "properties": {
        "summary": {
          "type": "string"
        },
        "description": {
          "type": "string"
        },
        "value": {},
        "externalValue": {
          "description": "an URI",
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "AADTokenSecurityScheme": {
      "type": "object",
      "properties": {
        "scopes": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "scopes",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/SecurityScheme"
        }
      ]
    },
    "AzureKeySecurityScheme": {
      "type": "object",
      "properties": {
        "headerName": {
          "type": "string"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "headerName",
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/SecurityScheme"
        }
      ]
    },
    "HttpMethod": {
      "description": "standard HTTP protocol methods",
      "type": "string",
      "enum": [
        "get",
        "put",
        "post",
        "delete",
        "options",
        "head",
        "patch",
        "trace"
      ]
    },
    "ParameterLocation": {
      "description": "the location that this parameter is placed in the http request",
      "type": "string",
      "enum": [
        "query",
        "header",
        "cookie",
        "path",
        "body",
        "uri",
        "virtual",
        "none"
      ]
    },
    "Scheme": {
      "type": "string",
      "const": "bearer"
    },
    "SecurityType": {
      "type": "string",
      "enum": [
        "apiKey",
        "http",
        "oauth2",
        "openIdConnect"
      ]
    },
    "AuthorizationCodeOAuthFlow": {
      "type": "object",
      "properties": {
        "authorizationUrl": {
          "description": "an URI",
          "type": "string"
        },
        "tokenUrl": {
          "description": "an URI",
          "type": "string"
        },
        "refreshUrl": {
          "description": "an URI",
          "type": "string"
        },
        "scopes": {
          "$ref": "#/definitions/Record<string,string>"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "authorizationUrl",
        "scopes",
        "tokenUrl"
      ]
    },
    "BearerHTTPSecurityScheme": {
      "type": "object",
      "properties": {
        "scheme": {
          "type": "string",
          "const": "bearer"
        },
        "bearerFormat": {
          "type": "string"
        },
        "type": {
          "type": "string",
          "const": "http"
        },
        "description": {
          "type": "string"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "scheme",
        "type"
      ]
    },
    "ClientCredentialsFlow": {
      "type": "object",
      "properties": {
        "tokenUrl": {
          "description": "an URI",
          "type": "string"
        },
        "refreshUrl": {
          "description": "an URI",
          "type": "string"
        },
        "scopes": {
          "$ref": "#/definitions/Record<string,string>"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "scopes",
        "tokenUrl"
      ]
    },
    "ImplicitOAuthFlow": {
      "type": "object",
      "properties": {
        "authorizationUrl": {
          "description": "an URI",
          "type": "string"
        },
        "refreshUrl": {
          "description": "an URI",
          "type": "string"
        },
        "scopes": {
          "$ref": "#/definitions/Record<string,string>"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "authorizationUrl",
        "scopes"
      ]
    },
    "NonBearerHTTPSecurityScheme": {
      "type": "object",
      "properties": {
        "scheme": {
          "type": "string"
        },
        "description": {
          "type": "string"
        },
        "type": {
          "type": "string",
          "const": "http"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "scheme",
        "type"
      ]
    },
    "OAuthFlows": {
      "type": "object",
      "properties": {
        "implicit": {
          "$ref": "#/definitions/ImplicitOAuthFlow"
        },
        "password": {
          "$ref": "#/definitions/PasswordOAuthFlow"
        },
        "clientCredentials": {
          "$ref": "#/definitions/ClientCredentialsFlow"
        },
        "authorizationCode": {
          "$ref": "#/definitions/AuthorizationCodeOAuthFlow"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false
    },
    "HTTPSecurityScheme": {
      "anyOf": [
        {
          "$ref": "#/definitions/BearerHTTPSecurityScheme"
        },
        {
          "$ref": "#/definitions/NonBearerHTTPSecurityScheme"
        }
      ]
    },
    "APIKeySecurityScheme": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "const": "apiKey"
        },
        "name": {
          "type": "string"
        },
        "in": {
          "$ref": "#/definitions/ParameterLocation"
        },
        "description": {
          "type": "string"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "in",
        "name",
        "type"
      ]
    },
    "OpenIdConnectSecurityScheme": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "const": "openIdConnect"
        },
        "openIdConnectUrl": {
          "description": "an URI",
          "type": "string"
        },
        "description": {
          "type": "string"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "openIdConnectUrl",
        "type"
      ]
    },
    "PasswordOAuthFlow": {
      "type": "object",
      "properties": {
        "tokenUrl": {
          "description": "an URI",
          "type": "string"
        },
        "refreshUrl": {
          "description": "an URI",
          "type": "string"
        },
        "scopes": {
          "$ref": "#/definitions/Record<string,string>"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "scopes",
        "tokenUrl"
      ]
    },
    "SecurityRequirement": {
      "description": "common ways of serializing simple parameters",
      "type": "object",
      "defaultProperties": [],
      "additionalProperties": false
    },
    "SerializationStyle": {
      "description": "The Serialization Style used for the parameter.\n\nDescribes how the parameter value will be serialized depending on the type of the parameter value.",
      "type": "string",
      "enum": [
        "matrix",
        "label",
        "simple",
        "form",
        "spaceDelimited",
        "pipeDelimited",
        "deepObject",
        "json",
        "xml",
        "binary",
        "tabDelimited"
      ]
    },
    "QueryEncodingStyle": {
      "enum": [
        "deepObject",
        "form",
        "pipeDelimited",
        "spaceDelimited"
      ],
      "type": "string"
    },
    "PathEncodingStyle": {
      "enum": [
        "label",
        "matrix",
        "simple"
      ],
      "type": "string"
    },
    "Default": {
      "description": "A catch-all for all un-handled response codes.",
      "type": "string",
      "const": "default"
    },
    "StatusCode": {
      "enum": [
        100,
        101,
        102,
        103,
        200,
        201,
        202,
        203,
        204,
        205,
        206,
        207,
        208,
        226,
        300,
        301,
        302,
        303,
        304,
        305,
        306,
        307,
        308,
        400,
        401,
        402,
        403,
        404,
        405,
        406,
        407,
        408,
        409,
        410,
        411,
        412,
        413,
        414,
        415,
        416,
        417,
        418,
        421,
        422,
        423,
        424,
        425,
        426,
        428,
        429,
        431,
        451,
        500,
        501,
        502,
        503,
        504,
        505,
        506,
        507,
        508,
        510,
        511,
        "default"
      ]
    },
    "HttpParameter": {
      "description": "extended metadata for HTTP operation parameters",
      "type": "object",
      "properties": {
        "in": {
          "description": "the location that this parameter is placed in the http request",
          "enum": [
            "body",
            "cookie",
            "header",
            "none",
            "path",
            "query",
            "uri",
            "virtual"
          ],
          "type": "string"
        },
        "style": {
          "$ref": "#/definitions/SerializationStyle",
          "description": "the Serialization Style used for the parameter."
        },
        "explode": {
          "description": "when set, 'form' style parameters generate separate parameters for each value of an array.",
          "type": "boolean"
        },
        "skipUriEncoding": {
          "description": "when set, this indicates that the content of the parameter should not be subject to URI encoding rules.",
          "type": "boolean"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "in"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Protocol"
        }
      ]
    },
    "HttpRequest": {
      "description": "HTTP operation protocol data",
      "type": "object",
      "properties": {
        "path": {
          "description": "A relative path to an individual endpoint.\n\nThe field name MUST begin with a slash.\nThe path is appended (no relative URL resolution) to the expanded URL from the Server Object's url field in order to construct the full URL.\nPath templating is allowed.\n\nWhen matching URLs, concrete (non-templated) paths would be matched before their templated counterparts.",
          "type": "string"
        },
        "uri": {
          "description": "the base URI template for the operation. This will be a template that has Uri parameters to craft the base url to use.",
          "type": "string"
        },
        "method": {
          "$ref": "#/definitions/HttpMethod",
          "description": "the HTTP Method used to process this operation"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "method",
        "path",
        "uri"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Protocol"
        }
      ]
    },
    "HttpWithBodyRequest": {
      "type": "object",
      "properties": {
        "knownMediaType": {
          "$ref": "#/definitions/KnownMediaType",
          "description": "a normalized value for the media type (ie, distills down to a well-known moniker (ie, 'json'))"
        },
        "mediaTypes": {
          "description": "must contain at least one media type to send for the body",
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "knownMediaType",
        "mediaTypes",
        "method",
        "path",
        "uri"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/HttpRequest"
        }
      ]
    },
    "HttpBinaryRequest": {
      "type": "object",
      "properties": {
        "binary": {
          "type": "boolean",
          "const": true
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "binary",
        "knownMediaType",
        "mediaTypes",
        "method",
        "path",
        "uri"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/HttpWithBodyRequest"
        }
      ]
    },
    "HttpMultipartRequest": {
      "type": "object",
      "properties": {
        "multipart": {
          "description": "indicates that the HTTP Request should be a multipart request\n\nie, that it has multiple requests in a single request.",
          "type": "boolean",
          "const": true
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "knownMediaType",
        "mediaTypes",
        "method",
        "multipart",
        "path",
        "uri"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/HttpWithBodyRequest"
        }
      ]
    },
    "HttpHeader": {
      "type": "object",
      "properties": {
        "header": {
          "type": "string"
        },
        "schema": {
          "$ref": "#/definitions/Schema"
        },
        "language": {
          "$ref": "#/definitions/Languages"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "header",
        "language",
        "schema"
      ]
    },
    "HttpResponse": {
      "type": "object",
      "properties": {
        "statusCodes": {
          "description": "the possible HTTP status codes that this response MUST match one of.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/StatusCode"
          }
        },
        "knownMediaType": {
          "$ref": "#/definitions/KnownMediaType",
          "description": "canonical response type (ie, 'json')."
        },
        "mediaTypes": {
          "description": "The possible media types that this response MUST match one of.",
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "headers": {
          "description": "content returned by the service in the HTTP headers",
          "type": "array",
          "items": {
            "$ref": "#/definitions/HttpHeader"
          }
        },
        "headerGroups": {
          "description": "sets of HTTP headers grouped together into a single schema",
          "type": "array",
          "items": {
            "$ref": "#/definitions/GroupSchema"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "statusCodes"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Protocol"
        }
      ]
    },
    "HttpBinaryResponse": {
      "type": "object",
      "properties": {
        "binary": {
          "description": "binary responses",
          "type": "boolean",
          "const": true
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "binary",
        "statusCodes"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/HttpResponse"
        }
      ]
    },
    "HttpModel": {
      "description": "code model metadata for HTTP protocol",
      "type": "object",
      "properties": {
        "security": {
          "description": "a collection of security requirements for the service",
          "type": "array",
          "items": {
            "$ref": "#/definitions/SecurityRequirement"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "allOf": [
        {
          "$ref": "#/definitions/Protocol"
        }
      ]
    },
    "Record<string,any>": {
      "type": "object",
      "defaultProperties": [],
      "additionalProperties": {
        "type": "object"
      }
    },
    "Record<string,Request>": {
      "type": "object",
      "defaultProperties": [],
      "additionalProperties": false
    },
    "Request": {
      "type": "object",
      "properties": {
        "parameters": {
          "description": "the parameter inputs to the operation",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Parameter"
          }
        },
        "signatureParameters": {
          "description": "a filtered list of parameters that is (assumably) the actual method signature parameters",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Parameter"
          }
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Metadata"
        }
      ]
    },
    "Response": {
      "description": "a response from a service.",
      "type": "object",
      "properties": {},
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol"
      ],
      "allOf": [
        {
          "$ref": "#/definitions/Metadata"
        }
      ]
    },
    "Record<string,ApiVersion>": {
      "type": "object",
      "defaultProperties": [],
      "additionalProperties": false
    },
    "ConstantType": {
      "type": "object",
      "properties": {
        "language": {
          "$ref": "#/definitions/Languages",
          "description": "per-language information for Schema"
        },
        "type": {
          "$ref": "#/definitions/AllSchemaTypes",
          "description": "the schema type"
        },
        "summary": {
          "description": "a short description",
          "type": "string"
        },
        "example": {
          "description": "example information"
        },
        "defaultValue": {
          "description": "If the value isn't sent on the wire, the service will assume this"
        },
        "serialization": {
          "$ref": "#/definitions/SerializationFormats",
          "description": "per-serialization information for this Schema"
        },
        "apiVersions": {
          "description": "API versions that this applies to. Undefined means all versions",
          "type": "array",
          "items": {
            "$ref": "#/definitions/ApiVersion"
          }
        },
        "deprecated": {
          "$ref": "#/definitions/Deprecation",
          "description": "Represent the deprecation information if api is deprecated.",
          "default": "undefined"
        },
        "origin": {
          "description": "where did this aspect come from (jsonpath or 'modelerfour:<soemthing>')",
          "type": "string"
        },
        "externalDocs": {
          "$ref": "#/definitions/ExternalDocumentation",
          "description": "External Documentation Links"
        },
        "protocol": {
          "$ref": "#/definitions/Protocols",
          "description": "per-protocol information for this aspect"
        },
        "extensions": {
          "$ref": "#/definitions/Record<string,any>",
          "description": "additional metadata extensions dictionary"
        }
      },
      "defaultProperties": [],
      "additionalProperties": false,
      "required": [
        "language",
        "protocol",
        "type"
      ]
    },
    "KnownMediaType": {
      "type": "string",
      "enum": [
        "json",
        "xml",
        "form",
        "binary",
        "multipart",
        "text",
        "unknown"
      ]
    },
    "Record<string,ComplexSchema>": {
      "type": "object",
      "defaultProperties": [],
      "additionalProperties": {
        "$ref": "#/definitions/ComplexSchema"
      }
    },
    "Record<string,string>": {
      "type": "object",
      "defaultProperties": [],
      "additionalProperties": {
        "type": "string"
      }
    }
  },
  "description": "the model that contains all the information required to generate a service api",
  "type": "object",
  "properties": {
    "info": {
      "$ref": "#/definitions/Info",
      "description": "Code model information"
    },
    "schemas": {
      "$ref": "#/definitions/Schemas",
      "description": "All schemas for the model"
    },
    "operationGroups": {
      "description": "All operations",
      "type": "array",
      "items": {
        "$ref": "#/definitions/OperationGroup"
      }
    },
    "globalParameters": {
      "description": "all global parameters (ie, ImplementationLocation = client )",
      "type": "array",
      "items": {
        "$ref": "#/definitions/Parameter"
      }
    },
    "security": {
      "$ref": "#/definitions/Security"
    },
    "language": {
      "$ref": "#/definitions/Languages",
      "description": "per-language information for this aspect"
    },
    "protocol": {
      "$ref": "#/definitions/Protocols",
      "description": "per-protocol information for this aspect"
    },
    "extensions": {
      "$ref": "#/definitions/Record<string,any>",
      "description": "additional metadata extensions dictionary"
    }
  },
  "defaultProperties": [],
  "additionalProperties": false,
  "required": [
    "info",
    "language",
    "operationGroups",
    "protocol",
    "schemas",
    "security"
  ],
  "title": "CodeModel"
}