"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// test/e2e/deterministicOrdering.ts
var deterministicOrdering_exports = {};
__export(deterministicOrdering_exports, {
  exclude: () => exclude,
  input: () => input
});
module.exports = __toCommonJS(deterministicOrdering_exports);
var exclude = true;
var input = {
  title: "DeterministicOrdering",
  type: "object",
  required: ["swagger", "info", "paths"],
  additionalProperties: false,
  patternProperties: {
    "^x-": {
      $ref: "#/definitions/vendorExtension"
    }
  },
  properties: {
    swagger: {
      type: "string",
      enum: ["2.0"],
      description: "The Swagger version of this document."
    },
    info: {
      $ref: "#/definitions/info"
    },
    host: {
      type: "string",
      pattern: "^[^{}/ :\\\\]+(?::\\d+)?$",
      description: "The host (name or ip) of the API. Example: 'swagger.io'"
    },
    basePath: {
      type: "string",
      pattern: "^/",
      description: "The base path to the API. Example: '/api'."
    },
    schemes: {
      $ref: "#/definitions/schemesList"
    },
    consumes: {
      description: "A list of MIME types accepted by the API.",
      allOf: [
        {
          $ref: "#/definitions/mediaTypeList"
        }
      ]
    },
    produces: {
      description: "A list of MIME types the API can produce.",
      allOf: [
        {
          $ref: "#/definitions/mediaTypeList"
        }
      ]
    },
    paths: {
      $ref: "#/definitions/paths"
    },
    definitions: {
      $ref: "#/definitions/definitions"
    },
    parameters: {
      $ref: "#/definitions/parameterDefinitions"
    },
    responses: {
      $ref: "#/definitions/responseDefinitions"
    },
    security: {
      $ref: "#/definitions/security"
    },
    securityDefinitions: {
      $ref: "#/definitions/securityDefinitions"
    },
    tags: {
      type: "array",
      items: {
        $ref: "#/definitions/tag"
      },
      uniqueItems: true
    },
    externalDocs: {
      $ref: "#/definitions/externalDocs"
    }
  },
  definitions: {
    info: {
      type: "object",
      description: "General information about the API.",
      required: ["version", "title"],
      additionalProperties: false,
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      properties: {
        title: {
          type: "string",
          description: "A unique and precise title of the API."
        },
        version: {
          type: "string",
          description: "A semantic version number of the API."
        },
        description: {
          type: "string",
          description: "A longer description of the API. Should be different from the title.  GitHub Flavored Markdown is allowed."
        },
        termsOfService: {
          type: "string",
          description: "The terms of service for the API."
        },
        contact: {
          $ref: "#/definitions/contact"
        },
        license: {
          $ref: "#/definitions/license"
        }
      }
    },
    contact: {
      type: "object",
      description: "Contact information for the owners of the API.",
      additionalProperties: false,
      properties: {
        name: {
          type: "string",
          description: "The identifying name of the contact person/organization."
        },
        url: {
          type: "string",
          description: "The URL pointing to the contact information.",
          format: "uri"
        },
        email: {
          type: "string",
          description: "The email address of the contact person/organization.",
          format: "email"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    license: {
      type: "object",
      required: ["name"],
      additionalProperties: false,
      properties: {
        name: {
          type: "string",
          description: "The name of the license type. It's encouraged to use an OSI compatible license."
        },
        url: {
          type: "string",
          description: "The URL pointing to the license.",
          format: "uri"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    paths: {
      type: "object",
      description: "Relative paths to the individual endpoints. They must be relative to the 'basePath'.",
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        },
        "^/": {
          $ref: "#/definitions/pathItem"
        }
      },
      additionalProperties: false
    },
    definitions: {
      type: "object",
      additionalProperties: {
        $ref: "#/definitions/schema"
      },
      description: "One or more JSON objects describing the schemas being consumed and produced by the API."
    },
    parameterDefinitions: {
      type: "object",
      additionalProperties: {
        $ref: "#/definitions/parameter"
      },
      description: "One or more JSON representations for parameters"
    },
    responseDefinitions: {
      type: "object",
      additionalProperties: {
        $ref: "#/definitions/response"
      },
      description: "One or more JSON representations for parameters"
    },
    externalDocs: {
      type: "object",
      additionalProperties: false,
      description: "information about external documentation",
      required: ["url"],
      properties: {
        description: {
          type: "string"
        },
        url: {
          type: "string",
          format: "uri"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    examples: {
      type: "object",
      additionalProperties: true
    },
    mimeType: {
      type: "string",
      description: "The MIME type of the HTTP message."
    },
    operation: {
      type: "object",
      required: ["responses"],
      additionalProperties: false,
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      properties: {
        tags: {
          type: "array",
          items: {
            type: "string"
          },
          uniqueItems: true
        },
        summary: {
          type: "string",
          description: "A brief summary of the operation."
        },
        description: {
          type: "string",
          description: "A longer description of the operation, GitHub Flavored Markdown is allowed."
        },
        externalDocs: {
          $ref: "#/definitions/externalDocs"
        },
        operationId: {
          type: "string",
          description: "A unique identifier of the operation."
        },
        produces: {
          description: "A list of MIME types the API can produce.",
          allOf: [
            {
              $ref: "#/definitions/mediaTypeList"
            }
          ]
        },
        consumes: {
          description: "A list of MIME types the API can consume.",
          allOf: [
            {
              $ref: "#/definitions/mediaTypeList"
            }
          ]
        },
        parameters: {
          $ref: "#/definitions/parametersList"
        },
        responses: {
          $ref: "#/definitions/responses"
        },
        schemes: {
          $ref: "#/definitions/schemesList"
        },
        deprecated: {
          type: "boolean",
          default: false
        },
        security: {
          $ref: "#/definitions/security"
        }
      }
    },
    pathItem: {
      type: "object",
      additionalProperties: false,
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      properties: {
        $ref: {
          type: "string"
        },
        get: {
          $ref: "#/definitions/operation"
        },
        put: {
          $ref: "#/definitions/operation"
        },
        post: {
          $ref: "#/definitions/operation"
        },
        delete: {
          $ref: "#/definitions/operation"
        },
        options: {
          $ref: "#/definitions/operation"
        },
        head: {
          $ref: "#/definitions/operation"
        },
        patch: {
          $ref: "#/definitions/operation"
        },
        parameters: {
          $ref: "#/definitions/parametersList"
        }
      }
    },
    responses: {
      type: "object",
      description: "Response objects names can either be any valid HTTP status code or 'default'.",
      minProperties: 1,
      additionalProperties: false,
      patternProperties: {
        "^([0-9]{3})$|^(default)$": {
          $ref: "#/definitions/responseValue"
        },
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      not: {
        type: "object",
        additionalProperties: false,
        patternProperties: {
          "^x-": {
            $ref: "#/definitions/vendorExtension"
          }
        }
      }
    },
    responseValue: {
      oneOf: [
        {
          $ref: "#/definitions/response"
        },
        {
          $ref: "#/definitions/jsonReference"
        }
      ]
    },
    response: {
      type: "object",
      required: ["description"],
      properties: {
        description: {
          type: "string"
        },
        schema: {
          oneOf: [
            {
              $ref: "#/definitions/schema"
            },
            {
              $ref: "#/definitions/fileSchema"
            }
          ]
        },
        headers: {
          $ref: "#/definitions/headers"
        },
        examples: {
          $ref: "#/definitions/examples"
        }
      },
      additionalProperties: false,
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    headers: {
      type: "object",
      additionalProperties: {
        $ref: "#/definitions/header"
      }
    },
    header: {
      type: "object",
      additionalProperties: false,
      required: ["type"],
      properties: {
        type: {
          type: "string",
          enum: ["string", "number", "integer", "boolean", "array"]
        },
        format: {
          type: "string"
        },
        items: {
          $ref: "#/definitions/primitivesItems"
        },
        collectionFormat: {
          $ref: "#/definitions/collectionFormat"
        },
        default: {
          $ref: "#/definitions/default"
        },
        maximum: {
          $ref: "#/definitions/maximum"
        },
        exclusiveMaximum: {
          $ref: "#/definitions/exclusiveMaximum"
        },
        minimum: {
          $ref: "#/definitions/minimum"
        },
        exclusiveMinimum: {
          $ref: "#/definitions/exclusiveMinimum"
        },
        maxLength: {
          $ref: "#/definitions/maxLength"
        },
        minLength: {
          $ref: "#/definitions/minLength"
        },
        pattern: {
          $ref: "#/definitions/pattern"
        },
        maxItems: {
          $ref: "#/definitions/maxItems"
        },
        minItems: {
          $ref: "#/definitions/minItems"
        },
        uniqueItems: {
          $ref: "#/definitions/uniqueItems"
        },
        enum: {
          $ref: "#/definitions/enum"
        },
        multipleOf: {
          $ref: "#/definitions/multipleOf"
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    vendorExtension: {
      description: "Any property starting with x- is valid.",
      additionalProperties: true,
      additionalItems: true
    },
    bodyParameter: {
      type: "object",
      required: ["name", "in", "schema"],
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      properties: {
        description: {
          type: "string",
          description: "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
        },
        name: {
          type: "string",
          description: "The name of the parameter."
        },
        in: {
          type: "string",
          description: "Determines the location of the parameter.",
          enum: ["body"]
        },
        required: {
          type: "boolean",
          description: "Determines whether or not this parameter is required or optional.",
          default: false
        },
        schema: {
          $ref: "#/definitions/schema"
        }
      },
      additionalProperties: false
    },
    headerParameterSubSchema: {
      additionalProperties: false,
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      properties: {
        required: {
          type: "boolean",
          description: "Determines whether or not this parameter is required or optional.",
          default: false
        },
        in: {
          type: "string",
          description: "Determines the location of the parameter.",
          enum: ["header"]
        },
        description: {
          type: "string",
          description: "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
        },
        name: {
          type: "string",
          description: "The name of the parameter."
        },
        type: {
          type: "string",
          enum: ["string", "number", "boolean", "integer", "array"]
        },
        format: {
          type: "string"
        },
        items: {
          $ref: "#/definitions/primitivesItems"
        },
        collectionFormat: {
          $ref: "#/definitions/collectionFormat"
        },
        default: {
          $ref: "#/definitions/default"
        },
        maximum: {
          $ref: "#/definitions/maximum"
        },
        exclusiveMaximum: {
          $ref: "#/definitions/exclusiveMaximum"
        },
        minimum: {
          $ref: "#/definitions/minimum"
        },
        exclusiveMinimum: {
          $ref: "#/definitions/exclusiveMinimum"
        },
        maxLength: {
          $ref: "#/definitions/maxLength"
        },
        minLength: {
          $ref: "#/definitions/minLength"
        },
        pattern: {
          $ref: "#/definitions/pattern"
        },
        maxItems: {
          $ref: "#/definitions/maxItems"
        },
        minItems: {
          $ref: "#/definitions/minItems"
        },
        uniqueItems: {
          $ref: "#/definitions/uniqueItems"
        },
        enum: {
          $ref: "#/definitions/enum"
        },
        multipleOf: {
          $ref: "#/definitions/multipleOf"
        }
      }
    },
    queryParameterSubSchema: {
      additionalProperties: false,
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      properties: {
        required: {
          type: "boolean",
          description: "Determines whether or not this parameter is required or optional.",
          default: false
        },
        in: {
          type: "string",
          description: "Determines the location of the parameter.",
          enum: ["query"]
        },
        description: {
          type: "string",
          description: "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
        },
        name: {
          type: "string",
          description: "The name of the parameter."
        },
        allowEmptyValue: {
          type: "boolean",
          default: false,
          description: "allows sending a parameter by name only or with an empty value."
        },
        type: {
          type: "string",
          enum: ["string", "number", "boolean", "integer", "array"]
        },
        format: {
          type: "string"
        },
        items: {
          $ref: "#/definitions/primitivesItems"
        },
        collectionFormat: {
          $ref: "#/definitions/collectionFormatWithMulti"
        },
        default: {
          $ref: "#/definitions/default"
        },
        maximum: {
          $ref: "#/definitions/maximum"
        },
        exclusiveMaximum: {
          $ref: "#/definitions/exclusiveMaximum"
        },
        minimum: {
          $ref: "#/definitions/minimum"
        },
        exclusiveMinimum: {
          $ref: "#/definitions/exclusiveMinimum"
        },
        maxLength: {
          $ref: "#/definitions/maxLength"
        },
        minLength: {
          $ref: "#/definitions/minLength"
        },
        pattern: {
          $ref: "#/definitions/pattern"
        },
        maxItems: {
          $ref: "#/definitions/maxItems"
        },
        minItems: {
          $ref: "#/definitions/minItems"
        },
        uniqueItems: {
          $ref: "#/definitions/uniqueItems"
        },
        enum: {
          $ref: "#/definitions/enum"
        },
        multipleOf: {
          $ref: "#/definitions/multipleOf"
        }
      }
    },
    formDataParameterSubSchema: {
      additionalProperties: false,
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      properties: {
        required: {
          type: "boolean",
          description: "Determines whether or not this parameter is required or optional.",
          default: false
        },
        in: {
          type: "string",
          description: "Determines the location of the parameter.",
          enum: ["formData"]
        },
        description: {
          type: "string",
          description: "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
        },
        name: {
          type: "string",
          description: "The name of the parameter."
        },
        allowEmptyValue: {
          type: "boolean",
          default: false,
          description: "allows sending a parameter by name only or with an empty value."
        },
        type: {
          type: "string",
          enum: ["string", "number", "boolean", "integer", "array", "file"]
        },
        format: {
          type: "string"
        },
        items: {
          $ref: "#/definitions/primitivesItems"
        },
        collectionFormat: {
          $ref: "#/definitions/collectionFormatWithMulti"
        },
        default: {
          $ref: "#/definitions/default"
        },
        maximum: {
          $ref: "#/definitions/maximum"
        },
        exclusiveMaximum: {
          $ref: "#/definitions/exclusiveMaximum"
        },
        minimum: {
          $ref: "#/definitions/minimum"
        },
        exclusiveMinimum: {
          $ref: "#/definitions/exclusiveMinimum"
        },
        maxLength: {
          $ref: "#/definitions/maxLength"
        },
        minLength: {
          $ref: "#/definitions/minLength"
        },
        pattern: {
          $ref: "#/definitions/pattern"
        },
        maxItems: {
          $ref: "#/definitions/maxItems"
        },
        minItems: {
          $ref: "#/definitions/minItems"
        },
        uniqueItems: {
          $ref: "#/definitions/uniqueItems"
        },
        enum: {
          $ref: "#/definitions/enum"
        },
        multipleOf: {
          $ref: "#/definitions/multipleOf"
        }
      }
    },
    pathParameterSubSchema: {
      additionalProperties: false,
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      required: ["required"],
      properties: {
        required: {
          type: "boolean",
          enum: [true],
          description: "Determines whether or not this parameter is required or optional."
        },
        in: {
          type: "string",
          description: "Determines the location of the parameter.",
          enum: ["path"]
        },
        description: {
          type: "string",
          description: "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
        },
        name: {
          type: "string",
          description: "The name of the parameter."
        },
        type: {
          type: "string",
          enum: ["string", "number", "boolean", "integer", "array"]
        },
        format: {
          type: "string"
        },
        items: {
          $ref: "#/definitions/primitivesItems"
        },
        collectionFormat: {
          $ref: "#/definitions/collectionFormat"
        },
        default: {
          $ref: "#/definitions/default"
        },
        maximum: {
          $ref: "#/definitions/maximum"
        },
        exclusiveMaximum: {
          $ref: "#/definitions/exclusiveMaximum"
        },
        minimum: {
          $ref: "#/definitions/minimum"
        },
        exclusiveMinimum: {
          $ref: "#/definitions/exclusiveMinimum"
        },
        maxLength: {
          $ref: "#/definitions/maxLength"
        },
        minLength: {
          $ref: "#/definitions/minLength"
        },
        pattern: {
          $ref: "#/definitions/pattern"
        },
        maxItems: {
          $ref: "#/definitions/maxItems"
        },
        minItems: {
          $ref: "#/definitions/minItems"
        },
        uniqueItems: {
          $ref: "#/definitions/uniqueItems"
        },
        enum: {
          $ref: "#/definitions/enum"
        },
        multipleOf: {
          $ref: "#/definitions/multipleOf"
        }
      }
    },
    nonBodyParameter: {
      type: "object",
      required: ["name", "in", "type"],
      oneOf: [
        {
          $ref: "#/definitions/headerParameterSubSchema"
        },
        {
          $ref: "#/definitions/formDataParameterSubSchema"
        },
        {
          $ref: "#/definitions/queryParameterSubSchema"
        },
        {
          $ref: "#/definitions/pathParameterSubSchema"
        }
      ]
    },
    parameter: {
      oneOf: [
        {
          $ref: "#/definitions/bodyParameter"
        },
        {
          $ref: "#/definitions/nonBodyParameter"
        }
      ]
    },
    schema: {
      id: "JSONSchema",
      type: "object",
      description: "A deterministic version of a JSON Schema object.",
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      properties: {
        $ref: {
          type: "string"
        },
        format: {
          type: "string"
        },
        title: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/title"
        },
        description: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/description"
        },
        default: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/default"
        },
        multipleOf: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/multipleOf"
        },
        maximum: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/maximum"
        },
        exclusiveMaximum: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum"
        },
        minimum: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/minimum"
        },
        exclusiveMinimum: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum"
        },
        maxLength: {
          $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
        },
        minLength: {
          $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
        },
        pattern: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/pattern"
        },
        maxItems: {
          $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
        },
        minItems: {
          $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
        },
        uniqueItems: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/uniqueItems"
        },
        maxProperties: {
          $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
        },
        minProperties: {
          $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
        },
        required: {
          $ref: "http://json-schema.org/draft-04/schema#/definitions/stringArray"
        },
        enum: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/enum"
        },
        additionalProperties: {
          anyOf: [
            {
              $ref: "#/definitions/schema"
            },
            {
              type: "boolean"
            }
          ],
          default: {}
        },
        type: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/type"
        },
        items: {
          anyOf: [
            {
              $ref: "#/definitions/schema"
            },
            {
              type: "array",
              minItems: 1,
              items: {
                $ref: "#/definitions/schema"
              }
            }
          ],
          default: {}
        },
        allOf: {
          type: "array",
          minItems: 1,
          items: {
            $ref: "#/definitions/schema"
          }
        },
        properties: {
          type: "object",
          additionalProperties: {
            $ref: "#/definitions/schema"
          },
          default: {}
        },
        discriminator: {
          type: "string"
        },
        readOnly: {
          type: "boolean",
          default: false
        },
        xml: {
          $ref: "#/definitions/xml"
        },
        externalDocs: {
          $ref: "#/definitions/externalDocs"
        },
        example: {}
      },
      additionalProperties: false
    },
    fileSchema: {
      type: "object",
      description: "A deterministic version of a JSON Schema object.",
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      },
      required: ["type"],
      properties: {
        format: {
          type: "string"
        },
        title: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/title"
        },
        description: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/description"
        },
        default: {
          $ref: "http://json-schema.org/draft-04/schema#/properties/default"
        },
        required: {
          $ref: "http://json-schema.org/draft-04/schema#/definitions/stringArray"
        },
        type: {
          type: "string",
          enum: ["file"]
        },
        readOnly: {
          type: "boolean",
          default: false
        },
        externalDocs: {
          $ref: "#/definitions/externalDocs"
        },
        example: {}
      },
      additionalProperties: false
    },
    primitivesItems: {
      type: "object",
      additionalProperties: false,
      properties: {
        type: {
          type: "string",
          enum: ["string", "number", "integer", "boolean", "array"]
        },
        format: {
          type: "string"
        },
        items: {
          $ref: "#/definitions/primitivesItems"
        },
        collectionFormat: {
          $ref: "#/definitions/collectionFormat"
        },
        default: {
          $ref: "#/definitions/default"
        },
        maximum: {
          $ref: "#/definitions/maximum"
        },
        exclusiveMaximum: {
          $ref: "#/definitions/exclusiveMaximum"
        },
        minimum: {
          $ref: "#/definitions/minimum"
        },
        exclusiveMinimum: {
          $ref: "#/definitions/exclusiveMinimum"
        },
        maxLength: {
          $ref: "#/definitions/maxLength"
        },
        minLength: {
          $ref: "#/definitions/minLength"
        },
        pattern: {
          $ref: "#/definitions/pattern"
        },
        maxItems: {
          $ref: "#/definitions/maxItems"
        },
        minItems: {
          $ref: "#/definitions/minItems"
        },
        uniqueItems: {
          $ref: "#/definitions/uniqueItems"
        },
        enum: {
          $ref: "#/definitions/enum"
        },
        multipleOf: {
          $ref: "#/definitions/multipleOf"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    security: {
      type: "array",
      items: {
        $ref: "#/definitions/securityRequirement"
      },
      uniqueItems: true
    },
    securityRequirement: {
      type: "object",
      additionalProperties: {
        type: "array",
        items: {
          type: "string"
        },
        uniqueItems: true
      }
    },
    xml: {
      type: "object",
      additionalProperties: false,
      properties: {
        name: {
          type: "string"
        },
        namespace: {
          type: "string"
        },
        prefix: {
          type: "string"
        },
        attribute: {
          type: "boolean",
          default: false
        },
        wrapped: {
          type: "boolean",
          default: false
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    tag: {
      type: "object",
      additionalProperties: false,
      required: ["name"],
      properties: {
        name: {
          type: "string"
        },
        description: {
          type: "string"
        },
        externalDocs: {
          $ref: "#/definitions/externalDocs"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    securityDefinitions: {
      type: "object",
      additionalProperties: {
        oneOf: [
          {
            $ref: "#/definitions/basicAuthenticationSecurity"
          },
          {
            $ref: "#/definitions/apiKeySecurity"
          },
          {
            $ref: "#/definitions/oauth2ImplicitSecurity"
          },
          {
            $ref: "#/definitions/oauth2PasswordSecurity"
          },
          {
            $ref: "#/definitions/oauth2ApplicationSecurity"
          },
          {
            $ref: "#/definitions/oauth2AccessCodeSecurity"
          }
        ]
      }
    },
    basicAuthenticationSecurity: {
      type: "object",
      additionalProperties: false,
      required: ["type"],
      properties: {
        type: {
          type: "string",
          enum: ["basic"]
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    apiKeySecurity: {
      type: "object",
      additionalProperties: false,
      required: ["type", "name", "in"],
      properties: {
        type: {
          type: "string",
          enum: ["apiKey"]
        },
        name: {
          type: "string"
        },
        in: {
          type: "string",
          enum: ["header", "query"]
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    oauth2ImplicitSecurity: {
      type: "object",
      additionalProperties: false,
      required: ["type", "flow", "authorizationUrl"],
      properties: {
        type: {
          type: "string",
          enum: ["oauth2"]
        },
        flow: {
          type: "string",
          enum: ["implicit"]
        },
        scopes: {
          $ref: "#/definitions/oauth2Scopes"
        },
        authorizationUrl: {
          type: "string",
          format: "uri"
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    oauth2PasswordSecurity: {
      type: "object",
      additionalProperties: false,
      required: ["type", "flow", "tokenUrl"],
      properties: {
        type: {
          type: "string",
          enum: ["oauth2"]
        },
        flow: {
          type: "string",
          enum: ["password"]
        },
        scopes: {
          $ref: "#/definitions/oauth2Scopes"
        },
        tokenUrl: {
          type: "string",
          format: "uri"
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    oauth2ApplicationSecurity: {
      type: "object",
      additionalProperties: false,
      required: ["type", "flow", "tokenUrl"],
      properties: {
        type: {
          type: "string",
          enum: ["oauth2"]
        },
        flow: {
          type: "string",
          enum: ["application"]
        },
        scopes: {
          $ref: "#/definitions/oauth2Scopes"
        },
        tokenUrl: {
          type: "string",
          format: "uri"
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    oauth2AccessCodeSecurity: {
      type: "object",
      additionalProperties: false,
      required: ["type", "flow", "authorizationUrl", "tokenUrl"],
      properties: {
        type: {
          type: "string",
          enum: ["oauth2"]
        },
        flow: {
          type: "string",
          enum: ["accessCode"]
        },
        scopes: {
          $ref: "#/definitions/oauth2Scopes"
        },
        authorizationUrl: {
          type: "string",
          format: "uri"
        },
        tokenUrl: {
          type: "string",
          format: "uri"
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {
          $ref: "#/definitions/vendorExtension"
        }
      }
    },
    oauth2Scopes: {
      type: "object",
      additionalProperties: {
        type: "string"
      }
    },
    mediaTypeList: {
      type: "array",
      items: {
        $ref: "#/definitions/mimeType"
      },
      uniqueItems: true
    },
    parametersList: {
      type: "array",
      description: "The parameters needed to send a valid API call.",
      additionalItems: false,
      items: {
        oneOf: [
          {
            $ref: "#/definitions/parameter"
          },
          {
            $ref: "#/definitions/jsonReference"
          }
        ]
      },
      uniqueItems: true
    },
    schemesList: {
      type: "array",
      description: "The transfer protocol of the API.",
      items: {
        type: "string",
        enum: ["http", "https", "ws", "wss"]
      },
      uniqueItems: true
    },
    collectionFormat: {
      type: "string",
      enum: ["csv", "ssv", "tsv", "pipes"],
      default: "csv"
    },
    collectionFormatWithMulti: {
      type: "string",
      enum: ["csv", "ssv", "tsv", "pipes", "multi"],
      default: "csv"
    },
    title: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/title"
    },
    description: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/description"
    },
    default: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/default"
    },
    multipleOf: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/multipleOf"
    },
    maximum: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/maximum"
    },
    exclusiveMaximum: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum"
    },
    minimum: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/minimum"
    },
    exclusiveMinimum: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum"
    },
    maxLength: {
      $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
    },
    minLength: {
      $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
    },
    pattern: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/pattern"
    },
    maxItems: {
      $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
    },
    minItems: {
      $ref: "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
    },
    uniqueItems: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/uniqueItems"
    },
    enum: {
      $ref: "http://json-schema.org/draft-04/schema#/properties/enum"
    },
    jsonReference: {
      type: "object",
      required: ["$ref"],
      additionalProperties: false,
      properties: {
        $ref: {
          type: "string"
        }
      }
    }
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  exclude,
  input
});
