export default {
  description: "Validation schema for the Lazy OpenAPI Specification 3.0.X.",
  type: "object",
  properties: {
    openapi: {
      type: "string",
      pattern: "^3\\.0\\.\\d(-.+)?$"
    },
    info: {
      $ref: "#/definitions/$Info"
    },
    externalDocs: {
      $ref: "#/definitions/$ExternalDocumentation"
    },
    servers: {
      type: "array",
      items: {
        $ref: "#/definitions/$Server"
      }
    },
    security: {
      type: "array",
      items: {
        $ref: "#/definitions/$SecurityRequirement"
      }
    },
    tags: {
      type: "array",
      items: {
        $ref: "#/definitions/$Tag"
      },
      uniqueItems: true
    },
    paths: {
      $ref: "#/definitions/$Paths"
    },
    components: {
      $ref: "#/definitions/$Components"
    }
  },
  patternProperties: {
    "^x-": {}
  },
  additionalProperties: false,
  definitions: {
    $Reference: {
      type: "object",
      required: ["$ref"],
      properties: {
        $ref: {
          type: "string",
          format: "uri-reference"
        }
      }
    },
    $Info: {
      type: "object",
      properties: {
        title: {
          type: "string"
        },
        description: {
          type: "string"
        },
        termsOfService: {
          type: "string",
          format: "uri-reference"
        },
        contact: {
          $ref: "#/definitions/$Contact"
        },
        license: {
          $ref: "#/definitions/$License"
        },
        version: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Contact: {
      type: "object",
      properties: {
        name: {
          type: "string"
        },
        url: {
          type: "string",
          format: "uri-reference"
        },
        email: {
          type: "string",
          format: "email"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $License: {
      type: "object",
      required: ["name"],
      properties: {
        name: {
          type: "string"
        },
        url: {
          type: "string",
          format: "uri-reference"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Server: {
      type: "object",
      required: ["url"],
      properties: {
        url: {
          type: "string"
        },
        description: {
          type: "string"
        },
        variables: {
          type: "object",
          additionalProperties: {
            $ref: "#/definitions/$ServerVariable"
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $ServerVariable: {
      type: "object",
      required: ["default"],
      properties: {
        enum: {
          type: "array",
          items: {
            type: "string"
          }
        },
        default: {
          type: "string"
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Components: {
      type: "object",
      properties: {
        schemas: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$Schema"
                  }
                }
              ]
            }
          }
        },
        responses: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$Response"
                  }
                }
              ]
            }
          }
        },
        parameters: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$Parameter"
                  }
                }
              ]
            }
          }
        },
        examples: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$Example"
                  }
                }
              ]
            }
          }
        },
        requestBodies: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$RequestBody"
                  }
                }
              ]
            }
          }
        },
        headers: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$Header"
                  }
                }
              ]
            }
          }
        },
        securitySchemes: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$SecurityScheme"
                  }
                }
              ]
            }
          }
        },
        links: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$Link"
                  }
                }
              ]
            }
          }
        },
        callbacks: {
          type: "object",
          patternProperties: {
            "^[a-zA-Z0-9\\.\\-_]+$": {
              switch: [
                {
                  if: {
                    required: ["$ref"]
                  },
                  then: {
                    $ref: "#/definitions/$Reference"
                  }
                },
                {
                  then: {
                    $ref: "#/definitions/$Callback"
                  }
                }
              ]
            }
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Discriminator: {
      type: "object",
      required: ["propertyName"],
      properties: {
        propertyName: {
          type: "string"
        },
        mapping: {
          type: "object",
          additionalProperties: {
            type: "string"
          }
        }
      }
    },
    $XML: {
      type: "object",
      properties: {
        name: {
          type: "string"
        },
        namespace: {
          type: "string",
          format: "uri"
        },
        prefix: {
          type: "string"
        },
        attribute: {
          type: "boolean",
          default: false
        },
        wrapped: {
          type: "boolean",
          default: false
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Response: {
      anyOf: [
        {
          $ref: "#/definitions/$MediaType"
        },
        {
          $ref: "#/definitions/$$Response"
        }
      ]
    },
    $$Response: {
      type: "object",
      // required: ["description"],
      properties: {
        description: {
          type: "string"
        },
        headers: {
          type: "object",
          additionalProperties: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Header"
                }
              }
            ]
          }
        },
        content: {
          type: "object",
          additionalProperties: {
            $ref: "#/definitions/$MediaType"
          }
        },
        links: {
          type: "object",
          additionalProperties: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Link"
                }
              }
            ]
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Schema: {
      anyOf: [
        {
          $ref: "#/definitions/$$Schema"
        },
        {
          $ref: "#/definitions/$SimpleBooleanSchema"
        },
        {
          $ref: "#/definitions/$SimpleIntegerSchema"
        },
        {
          $ref: "#/definitions/$SimpleNumberSchema"
        },
        {
          $ref: "#/definitions/$SimpleStringSchema"
        },
        {
          $ref: "#/definitions/$SimpleArraySchema"
        },
        {
          $ref: "#/definitions/$SimpleObjectSchema"
        }
      ]
    },
    $$Schema: {
      type: "object",
      properties: {
        title: {
          type: "string"
        },
        multipleOf: {
          type: "number",
          minimum: 0,
          exclusiveMinimum: 0
        },
        maximum: {
          type: "number"
        },
        exclusiveMaximum: {
          type: "boolean",
          default: false
        },
        minimum: {
          type: "number"
        },
        exclusiveMinimum: {
          type: "boolean",
          default: false
        },
        maxLength: {
          type: "integer",
          minimum: 0
        },
        minLength: {
          type: "integer",
          minimum: 0,
          default: 0
        },
        pattern: {
          type: "string",
          format: "regex"
        },
        maxItems: {
          type: "integer",
          minimum: 0
        },
        minItems: {
          type: "integer",
          minimum: 0,
          default: 0
        },
        uniqueItems: {
          type: "boolean",
          default: false
        },
        maxProperties: {
          type: "integer",
          minimum: 0
        },
        minProperties: {
          type: "integer",
          minimum: 0,
          default: 0
        },
        required: {
          type: "array",
          items: {
            type: "string"
          },
          minItems: 1,
          uniqueItems: true,
          errorMessage: {
            type:
              "should be an array of property names required within an object schema"
          }
        },
        enum: {
          type: "array",
          items: {},
          minItems: 1,
          uniqueItems: false
        },
        type: {
          type: "string",
          enum: ["array", "boolean", "integer", "number", "object", "string"]
        },
        not: {
          switch: [
            {
              if: {
                required: ["$ref"]
              },
              then: {
                $ref: "#/definitions/$Reference"
              }
            },
            {
              then: {
                $ref: "#/definitions/$Schema"
              }
            }
          ]
        },
        allOf: {
          type: "array",
          items: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Schema"
                }
              }
            ]
          }
        },
        oneOf: {
          type: "array",
          items: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Schema"
                }
              }
            ]
          }
        },
        anyOf: {
          type: "array",
          items: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Schema"
                }
              }
            ]
          }
        },
        items: {
          anyOf: [
            { $ref: "#/definitions/$Reference" },
            {
              $ref: "#/definitions/$Schema"
            },
            {
              type: "array",
              items: {
                anyOf: [
                  { $ref: "#/definitions/$Reference" },
                  {
                    $ref: "#/definitions/$Schema"
                  }
                ]
              }
            }
          ]
        },
        properties: {
          type: "object",
          additionalProperties: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Schema"
                }
              }
            ]
          }
        },
        additionalProperties: {
          default: true,
          switch: [
            {
              if: {
                type: "object",
                required: ["$ref"]
              },
              then: {
                $ref: "#/definitions/$Reference"
              }
            },
            {
              if: {
                type: "object"
              },
              then: {
                $ref: "#/definitions/$Schema"
              }
            },
            {
              then: {
                type: "boolean",
                errorMessage:
                  "should be a Reference Object, Schema Object, or boolean value"
              }
            }
          ]
        },
        description: {
          type: "string"
        },
        format: {
          type: "string"
        },
        default: {},
        nullable: {
          type: "boolean",
          default: false
        },
        discriminator: {
          $ref: "#/definitions/$Discriminator"
        },
        readOnly: {
          type: "boolean",
          default: false
        },
        writeOnly: {
          type: "boolean",
          default: false
        },
        example: {},
        externalDocs: {
          $ref: "#/definitions/$ExternalDocumentation"
        },
        deprecated: {
          type: "boolean",
          default: false
        },
        xml: {
          $ref: "#/definitions/$XML"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $SimpleObjectSchema: {},
    $SimpleIntegerSchema: {
      type: "number"
    },
    $SimpleNumberSchema: {
      type: "number"
    },
    $SimpleStringSchema: {
      type: "string"
    },
    $SimpleBooleanSchema: {
      type: "boolean"
    },
    $SimpleArraySchema: {
      type: "array"
    },
    $MediaType: {
      anyOf: [
        {
          $ref: "#/definitions/$Schema"
        },
        {
          $ref: "#/definitions/$$MediaType"
        }
      ]
    },
    $$MediaType: {
      type: "object",
      properties: {
        schema: {
          switch: [
            {
              if: {
                required: ["$ref"]
              },
              then: {
                $ref: "#/definitions/$Reference"
              }
            },
            {
              then: {
                $ref: "#/definitions/$Schema"
              }
            }
          ]
        },
        example: {},
        examples: {
          type: "object",
          additionalProperties: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Example"
                }
              }
            ]
          }
        },
        encoding: {
          type: "object",
          additionalProperties: {
            $ref: "#/definitions/$Encoding"
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false,
      allOf: [
        {
          $ref: "#/definitions/$ExampleXORExamples"
        }
      ]
    },
    $Example: {
      type: "object",
      properties: {
        summary: {
          type: "string"
        },
        description: {
          type: "string"
        },
        value: {},
        externalValue: {
          type: "string",
          format: "uri-reference"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Header: {
      type: "object",
      properties: {
        description: {
          type: "string"
        },
        required: {
          type: "boolean",
          default: false
        },
        deprecated: {
          type: "boolean",
          default: false
        },
        allowEmptyValue: {
          type: "boolean",
          default: false
        },
        style: {
          type: "string",
          enum: ["simple"],
          default: "simple"
        },
        explode: {
          type: "boolean"
        },
        allowReserved: {
          type: "boolean",
          default: false
        },
        schema: {
          switch: [
            {
              if: {
                required: ["$ref"]
              },
              then: {
                $ref: "#/definitions/$Reference"
              }
            },
            {
              then: {
                $ref: "#/definitions/$Schema"
              }
            }
          ]
        },
        content: {
          type: "object",
          additionalProperties: {
            $ref: "#/definitions/$MediaType"
          },
          minProperties: 1,
          maxProperties: 1
        },
        example: {},
        examples: {
          type: "object",
          additionalProperties: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Example"
                }
              }
            ]
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false,
      allOf: [
        {
          $ref: "#/definitions/$ExampleXORExamples"
        },
        {
          $ref: "#/definitions/$SchemaXORContent"
        }
      ]
    },
    $Paths: {
      type: "object",
      patternProperties: {
        "^\\/": {
          $ref: "#/definitions/$PathItem"
        },
        "^x-": {}
      },
      additionalProperties: false,
      errorMessage: {
        additionalProperties: "should only have path names that start with `/`"
      }
    },
    $LazyLazyParams: {
      type: "object",
      additionalProperties: {
        $ref: "#/definitions/$Schema"
      }
    },
    $LazyParams: {
      type: "object",
      properties: {
        query: {
          $ref: "#/definitions/$LazyLazyParams"
        },
        header: {
          $ref: "#/definitions/$LazyLazyParams"
        },
        path: {
          $ref: "#/definitions/$LazyLazyParams"
        },
        cookie: {
          $ref: "#/definitions/$LazyLazyParams"
        }
      }
    },
    $PathItem: {
      switch: [
        {
          if: {
            required: ["$ref"]
          },
          then: {
            $ref: "#/definitions/$Reference"
          }
        },
        {
          then: {
            $ref: "#/definitions/$Schema"
          }
        }
      ],
      anyOf: [
        {
          $ref: "#/definitions/$Operation"
        },
        {
          $ref: "#/definitions/$$PathItem"
        }
      ]
    },
    $$PathItem: {
      type: "object",
      properties: {
        $ref: {
          type: "string"
        },
        summary: {
          type: "string"
        },
        description: {
          type: "string"
        },
        servers: {
          type: "array",
          items: {
            $ref: "#/definitions/$Server"
          }
        },
        parameters: {
          anyOf: [
            {
              $ref: "#/definitions/$LazyParams"
            },
            {
              $ref: "#/definitions/$LazyLazyParams"
            },
            {
              type: "array",
              items: {
                switch: [
                  {
                    if: {
                      required: ["$ref"]
                    },
                    then: {
                      $ref: "#/definitions/$Reference"
                    }
                  },
                  {
                    then: {
                      $ref: "#/definitions/$Parameter"
                    }
                  }
                ]
              },
              uniqueItems: true
            }
          ]
        }
      },
      patternProperties: {
        "^(get|put|post|delete|options|head|patch|trace)$": {
          $ref: "#/definitions/$Operation"
        },
        "^x-": {}
      },
      additionalProperties: false
    },
    $Operation: {
      anyOf: [
        {
          $ref: "#/definitions/$Responses"
        },
        {
          $ref: "#/definitions/$$Operation"
        }
      ]
    },
    $$Operation: {
      type: "object",
      required: ["responses"],
      properties: {
        tags: {
          type: "array",
          items: {
            type: "string"
          }
        },
        summary: {
          type: "string"
        },
        description: {
          type: "string"
        },
        externalDocs: {
          $ref: "#/definitions/$ExternalDocumentation"
        },
        operationId: {
          type: "string"
        },
        parameters: {
          anyOf: [
            {
              $ref: "#/definitions/$LazyParams"
            },
            {
              $ref: "#/definitions/$LazyLazyParams"
            },
            {
              type: "array",
              items: {
                switch: [
                  {
                    if: {
                      required: ["$ref"]
                    },
                    then: {
                      $ref: "#/definitions/$Reference"
                    }
                  },
                  {
                    then: {
                      $ref: "#/definitions/$Parameter"
                    }
                  }
                ]
              },
              uniqueItems: true
            }
          ]
        },
        requestBody: {
          switch: [
            {
              if: {
                required: ["$ref"]
              },
              then: {
                $ref: "#/definitions/$Reference"
              }
            },
            {
              then: {
                $ref: "#/definitions/$RequestBody"
              }
            }
          ]
        },
        responses: {
          $ref: "#/definitions/$Responses"
        },
        callbacks: {
          type: "object",
          additionalProperties: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Callback"
                }
              }
            ]
          }
        },
        deprecated: {
          type: "boolean",
          default: false
        },
        security: {
          type: "array",
          items: {
            $ref: "#/definitions/$SecurityRequirement"
          }
        },
        servers: {
          type: "array",
          items: {
            $ref: "#/definitions/$Server"
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Responses: {
      anyOf: [
        {
          $ref: "#/definitions/$Response"
        },
        {
          $ref: "#/definitions/$$Responses"
        }
      ]
    },
    $$Responses: {
      type: "object",
      properties: {
        default: {
          switch: [
            {
              if: {
                required: ["$ref"]
              },
              then: {
                $ref: "#/definitions/$Reference"
              }
            },
            {
              then: {
                $ref: "#/definitions/$Response"
              }
            }
          ]
        }
      },
      patternProperties: {
        "^[1-5](?:\\d{2}|XX)$": {
          switch: [
            {
              if: {
                required: ["$ref"]
              },
              then: {
                $ref: "#/definitions/$Reference"
              }
            },
            {
              then: {
                $ref: "#/definitions/$Response"
              }
            }
          ]
        },
        "^x-": {}
      },
      minProperties: 1,
      additionalProperties: false,
      not: {
        type: "object",
        minProperties: 1,
        additionalProperties: false,
        patternProperties: {
          "^x-": {}
        }
      },
      errorMessage: {
        minProperties: "should define at least one response",
        not:
          "should define at least one response, in addition to any vendor extension (`x-*`) fields",
        additionalProperties:
          "should only have three-digit status codes, `default`, and vendor extensions (`x-*`) as properties"
      }
    },
    $SecurityRequirement: {
      type: "object",
      additionalProperties: {
        type: "array",
        items: {
          type: "string"
        }
      }
    },
    $Tag: {
      type: "object",
      required: ["name"],
      properties: {
        name: {
          type: "string"
        },
        description: {
          type: "string"
        },
        externalDocs: {
          $ref: "#/definitions/$ExternalDocumentation"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $ExternalDocumentation: {
      type: "object",
      required: ["url"],
      properties: {
        description: {
          type: "string"
        },
        url: {
          type: "string",
          format: "uri-reference"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $ExampleXORExamples: {
      description: "Example and examples are mutually exclusive",
      errorMessage:
        "should not have both `example` and `examples`, as they are mutually exclusive",
      not: {
        required: ["example", "examples"]
      }
    },
    $SchemaXORContent: {
      description:
        "Schema and content are mutually exclusive, at least one is required",
      switch: [
        {
          if: {
            required: ["schema", "content"]
          },
          then: false
        },
        {
          if: {
            required: ["schema"]
          },
          then: true
        },
        {
          if: {
            required: ["content"]
          },
          then: {
            description:
              "Some properties are not allowed if content is present",
            errorMessage:
              "should not have `style`, `explode`, `allowReserved`, `example`, or `examples` when `content` is present",
            allOf: [
              {
                not: {
                  required: ["style"]
                }
              },
              {
                not: {
                  required: ["explode"]
                }
              },
              {
                not: {
                  required: ["allowReserved"]
                }
              },
              {
                not: {
                  required: ["example"]
                }
              },
              {
                not: {
                  required: ["examples"]
                }
              }
            ]
          }
        },
        {
          then: {
            required: ["schema", "content"]
          }
        }
      ],
      errorMessage: "should have either a `schema` or `content` property"
    },
    $Parameter: {
      type: "object",
      properties: {
        name: {
          type: "string"
        },
        in: {
          type: "string"
        },
        description: {
          type: "string"
        },
        required: {
          type: "boolean",
          default: false
        },
        deprecated: {
          type: "boolean",
          default: false
        },
        allowEmptyValue: {
          type: "boolean",
          default: false
        },
        style: {
          type: "string"
        },
        explode: {
          type: "boolean"
        },
        allowReserved: {
          type: "boolean",
          default: false
        },
        schema: {
          switch: [
            {
              if: {
                required: ["$ref"]
              },
              then: {
                $ref: "#/definitions/$Reference"
              }
            },
            {
              then: {
                $ref: "#/definitions/$Schema"
              }
            }
          ]
        },
        content: {
          type: "object",
          additionalProperties: {
            $ref: "#/definitions/$MediaType"
          },
          minProperties: 1,
          maxProperties: 1
        },
        example: {},
        examples: {
          type: "object",
          additionalProperties: {
            switch: [
              {
                if: {
                  required: ["$ref"]
                },
                then: {
                  $ref: "#/definitions/$Reference"
                }
              },
              {
                then: {
                  $ref: "#/definitions/$Example"
                }
              }
            ]
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false,
      required: ["name", "in"],
      allOf: [
        {
          $ref: "#/definitions/$ExampleXORExamples"
        },
        {
          $ref: "#/definitions/$SchemaXORContent"
        },
        {
          $ref: "#/definitions/$ParameterLocation"
        }
      ]
    },
    $ParameterLocation: {
      description: "Parameter location",
      switch: [
        {
          if: {
            required: ["in"],
            properties: {
              in: {
                enum: ["path"]
              }
            }
          },
          then: {
            description: "Parameter in path",
            required: ["required"],
            properties: {
              style: {
                enum: ["matrix", "label", "simple"],
                default: "simple"
              },
              required: {
                enum: [true]
              }
            }
          }
        },
        {
          if: {
            required: ["in"],
            properties: {
              in: {
                enum: ["query"]
              }
            }
          },
          then: {
            description: "Parameter in query",
            properties: {
              style: {
                enum: ["form", "spaceDelimited", "pipeDelimited", "deepObject"],
                default: "form"
              }
            }
          }
        },
        {
          if: {
            required: ["in"],
            properties: {
              in: {
                enum: ["header"]
              }
            }
          },
          then: {
            description: "Parameter in header",
            properties: {
              style: {
                enum: ["simple"],
                default: "simple"
              }
            }
          }
        },
        {
          if: {
            required: ["in"],
            properties: {
              in: {
                enum: ["cookie"]
              }
            }
          },
          then: {
            description: "Parameter in cookie",
            properties: {
              style: {
                enum: ["form"],
                default: "form"
              }
            }
          }
        },
        {
          then: {
            required: ["in"],
            properties: {
              in: {
                enum: ["path", "query", "header", "cookie"]
              }
            }
          }
        }
      ]
    },
    $RequestBody: {
      anyOf: [
        {
          $ref: "#/definitions/$MediaType"
        },
        {
          $ref: "#/definitions/$$RequestBody"
        }
      ]
    },
    $$RequestBody: {
      type: "object",
      required: ["content"],
      properties: {
        description: {
          type: "string"
        },
        content: {
          type: "object",
          additionalProperties: {
            $ref: "#/definitions/$MediaType"
          }
        },
        required: {
          type: "boolean",
          default: false
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $SecurityScheme: {
      type: "object",
      switch: [
        {
          if: {
            required: ["type"],
            properties: {
              type: {
                enum: ["apiKey"]
              }
            }
          },
          then: {
            $ref: "#/definitions/$APIKeySecurityScheme"
          }
        },
        {
          if: {
            required: ["type"],
            properties: {
              type: {
                enum: ["http"]
              }
            }
          },
          then: {
            $ref: "#/definitions/$HTTPSecurityScheme"
          }
        },
        {
          if: {
            required: ["type"],
            properties: {
              type: {
                enum: ["oauth2"]
              }
            }
          },
          then: {
            $ref: "#/definitions/$OAuth2SecurityScheme"
          }
        },
        {
          if: {
            required: ["type"],
            properties: {
              type: {
                enum: ["openIdConnect"]
              }
            }
          },
          then: {
            $ref: "#/definitions/$OpenIdConnectSecurityScheme"
          }
        },
        {
          then: {
            required: ["type"],
            properties: {
              type: {
                type: "string",
                enum: ["apiKey", "http", "oauth2", "openIdConnect"]
              }
            }
          }
        }
      ]
    },
    $APIKeySecurityScheme: {
      type: "object",
      required: ["type", "name", "in"],
      properties: {
        type: {
          type: "string",
          enum: ["apiKey"]
        },
        name: {
          type: "string"
        },
        in: {
          type: "string",
          enum: ["header", "query", "cookie"]
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $HTTPSecurityScheme: {
      type: "object",
      required: ["scheme", "type"],
      properties: {
        scheme: {
          type: "string"
        },
        bearerFormat: {
          type: "string"
        },
        description: {
          type: "string"
        },
        type: {
          type: "string",
          enum: ["http"]
        }
      },
      patternProperties: {
        "^x-": {}
      },
      switch: [
        {
          if: {
            not: {
              required: ["scheme"],
              properties: {
                scheme: {
                  enum: ["bearer"]
                }
              }
            }
          },
          then: {
            properties: {
              bearerFormat: {
                enum: [null]
              }
            },
            errorMessage:
              "should NOT have a `bearerFormat` property without `scheme: bearer` being set"
          }
        }
      ],
      additionalProperties: false
    },
    $OAuth2SecurityScheme: {
      type: "object",
      required: ["type", "flows"],
      properties: {
        type: {
          type: "string",
          enum: ["oauth2"]
        },
        flows: {
          $ref: "#/definitions/$OAuthFlows"
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $OpenIdConnectSecurityScheme: {
      type: "object",
      required: ["type", "openIdConnectUrl"],
      properties: {
        type: {
          type: "string",
          enum: ["openIdConnect"]
        },
        openIdConnectUrl: {
          type: "string",
          format: "uri-reference"
        },
        description: {
          type: "string"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $OAuthFlows: {
      type: "object",
      properties: {
        implicit: {
          $ref: "#/definitions/$ImplicitOAuthFlow"
        },
        password: {
          $ref: "#/definitions/$PasswordOAuthFlow"
        },
        clientCredentials: {
          $ref: "#/definitions/$ClientCredentialsFlow"
        },
        authorizationCode: {
          $ref: "#/definitions/$AuthorizationCodeOAuthFlow"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $ImplicitOAuthFlow: {
      type: "object",
      required: ["authorizationUrl", "scopes"],
      properties: {
        authorizationUrl: {
          type: "string",
          format: "uri-reference"
        },
        refreshUrl: {
          type: "string",
          format: "uri-reference"
        },
        scopes: {
          type: "object",
          additionalProperties: {
            type: "string"
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $PasswordOAuthFlow: {
      type: "object",
      required: ["tokenUrl"],
      properties: {
        tokenUrl: {
          type: "string",
          format: "uri-reference"
        },
        refreshUrl: {
          type: "string",
          format: "uri-reference"
        },
        scopes: {
          type: "object",
          additionalProperties: {
            type: "string"
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $ClientCredentialsFlow: {
      type: "object",
      required: ["tokenUrl"],
      properties: {
        tokenUrl: {
          type: "string",
          format: "uri-reference"
        },
        refreshUrl: {
          type: "string",
          format: "uri-reference"
        },
        scopes: {
          type: "object",
          additionalProperties: {
            type: "string"
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $AuthorizationCodeOAuthFlow: {
      type: "object",
      required: ["authorizationUrl", "tokenUrl"],
      properties: {
        authorizationUrl: {
          type: "string",
          format: "uri-reference"
        },
        tokenUrl: {
          type: "string",
          format: "uri-reference"
        },
        refreshUrl: {
          type: "string",
          format: "uri-reference"
        },
        scopes: {
          type: "object",
          additionalProperties: {
            type: "string"
          }
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false
    },
    $Link: {
      type: "object",
      properties: {
        operationId: {
          type: "string"
        },
        operationRef: {
          type: "string",
          format: "uri-reference"
        },
        parameters: {
          type: "object",
          additionalProperties: {}
        },
        requestBody: {},
        description: {
          type: "string"
        },
        server: {
          $ref: "#/definitions/$Server"
        }
      },
      patternProperties: {
        "^x-": {}
      },
      additionalProperties: false,
      not: {
        description: "Operation Id and Operation Ref are mutually exclusive",
        required: ["operationId", "operationRef"]
      }
    },
    $Callback: {
      type: "object",
      additionalProperties: {
        $ref: "#/definitions/$PathItem"
      },
      patternProperties: {
        "^x-": {}
      }
    },
    $Encoding: {
      type: "object",
      properties: {
        contentType: {
          type: "string"
        },
        headers: {
          type: "object",
          additionalProperties: {
            $ref: "#/definitions/$Header"
          }
        },
        style: {
          type: "string",
          enum: ["form", "spaceDelimited", "pipeDelimited", "deepObject"]
        },
        explode: {
          type: "boolean"
        },
        allowReserved: {
          type: "boolean",
          default: false
        }
      },
      additionalProperties: false
    }
  }
};