ark-grpc 0.9.2

// This file is @generated by prost-build.
/// Contact information for the exposed API.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#contact-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Contact {
    /// The identifying name of the contact person/organization.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The URL pointing to the contact information. This MUST be in the form of a URL.
    #[prost(string, tag = "2")]
    pub url: ::prost::alloc::string::String,
    /// The email address of the contact person/organization. This MUST be in the form of an email
    /// address.
    #[prost(string, tag = "3")]
    pub email: ::prost::alloc::string::String,
    /// Extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "4")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// License information for the exposed API.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#license-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct License {
    /// REQUIRED. The license name used for the API.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// An SPDX license expression for the API. The identifier field is mutually exclusive of the
    /// url field.
    #[prost(string, tag = "2")]
    pub identifier: ::prost::alloc::string::String,
    /// A URL to the license used for the API. This MUST be in the form of a URL.
    /// The url field is mutually exclusive of the identifier field.
    #[prost(string, tag = "3")]
    pub url: ::prost::alloc::string::String,
    /// Extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "4")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Info captures OpenAPI Info object.
/// NOTE: A generated value will be used for the required fields if they are left empty.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#info-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Info {
    /// REQUIRED. The title of the API.
    #[prost(string, tag = "1")]
    pub title: ::prost::alloc::string::String,
    /// A short summary of the API.
    #[prost(string, tag = "2")]
    pub summary: ::prost::alloc::string::String,
    /// A description of the API. CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// A URL to the Terms of Service for the API. This MUST be in the form of a URL.
    #[prost(string, tag = "4")]
    pub terms_of_service: ::prost::alloc::string::String,
    /// The contact information for the exposed API.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#contact-object>
    #[prost(message, optional, tag = "5")]
    pub contact: ::core::option::Option<Contact>,
    /// The license information for the exposed API.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#license-object>
    #[prost(message, optional, tag = "6")]
    pub license: ::core::option::Option<License>,
    /// REQUIRED. The version of the OpenAPI document.
    #[prost(string, tag = "7")]
    pub version: ::prost::alloc::string::String,
    /// Extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "8")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// An object representing a Server Variable for server URL template substitution.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#server-variable-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerVariable {
    /// An enumeration of string values to be used if the substitution options are from a limited
    /// set. The array MUST NOT be empty.
    #[prost(string, repeated, tag = "1")]
    pub enum_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// REQUIRED. The default value to use for substitution, which SHALL be sent if an alternate
    /// value is not supplied. Note this behavior is different than the Schema Object’s
    /// treatment of default values, because in those cases parameter values are optional. If
    /// the enum is defined, the value MUST exist in the enum’s values.
    #[prost(string, tag = "2")]
    pub default_value: ::prost::alloc::string::String,
    /// An optional description for the server variable.
    /// CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "4")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// An object representing a Server.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#server-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Server {
    /// REQUIRED. A URL to the target host. This URL supports Server Variables and MAY be relative,
    /// to indicate that the host location is relative to the location where the OpenAPI document
    /// is being served. Variable substitutions will be made when a variable is named in
    /// {brackets}.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    /// An optional string describing the host designated by the URL.
    /// CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// A map between a variable name and its value. The value is used for substitution in the
    /// server’s URL template.
    #[prost(map = "string, message", tag = "3")]
    pub variables: ::std::collections::HashMap<::prost::alloc::string::String, ServerVariable>,
    /// Extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "4")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Lists the required security schemes to execute this operation.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#security-requirement-object>
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SecurityRequirement {
    /// Each name MUST correspond to a security scheme which is declared in the Security Schemes
    /// under the Components Object. If the security scheme is of type "oauth2" or
    /// "openIdConnect", then the value is a list of scope names required for the execution,
    /// and the list MAY be empty if authorization does not require a specified scope. For
    /// other security scheme types, the array MAY contain a list of role names which are
    /// required for the execution, but are not otherwise defined or exchanged in-band.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "2")]
    pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Allows referencing an external resource for extended documentation.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#external-documentation-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExternalDocumentation {
    /// A description of the target documentation. CommonMark syntax MAY be used for rich text
    /// representation.
    #[prost(string, tag = "1")]
    pub description: ::prost::alloc::string::String,
    /// REQUIRED. The URL for the target documentation. This MUST be in the form of a URL.
    #[prost(string, tag = "2")]
    pub url: ::prost::alloc::string::String,
    /// Extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "3")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Adds metadata to a single tag that is used by the Operation Object.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#tag-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Tag {
    /// REQUIRED. The name of the tag.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A description for the tag. CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Additional external documentation for this tag.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#external-documentation-object>
    #[prost(message, optional, tag = "3")]
    pub external_docs: ::core::option::Option<ExternalDocumentation>,
    /// Extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "4")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// See: <https://spec.openapis.org/oas/latest.html#discriminator-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Discriminator {
    /// REQUIRED. The name of the property in the payload that will hold the discriminator value.
    #[prost(string, tag = "1")]
    pub property_name: ::prost::alloc::string::String,
    /// An object to hold mappings between payload values and schema names or references.
    #[prost(map = "string, string", tag = "2")]
    pub mapping:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "3")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// FieldConfiguration provides additional field level properties used when generating the OpenAPI
/// v3.1 file. These properties are not defined by OpenAPIv3, but they are used to control the
/// generation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FieldConfiguration {
    /// Alternative parameter name when used as path parameter. If set, this will
    /// be used as the complete parameter name when this field is used as a path
    /// parameter. Use this to avoid having auto-generated path parameter names
    /// for overlapping paths.
    #[prost(string, tag = "1")]
    pub path_param_name: ::prost::alloc::string::String,
    /// Marks this field as required.
    #[prost(bool, tag = "2")]
    pub required: bool,
}
/// Schema represents an OpenAPI v3.1 Schema object, providing a structured definition for data
/// types used in the API.
///
/// For detailed information on the Schema object, refer to the OpenAPI Specification:
/// <https://spec.openapis.org/oas/v3.1.0#schema-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Schema {
    /// Adds support for polymorphism by specifying a discriminator object name that differentiates
    /// between schemas.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#discriminator-object>
    #[prost(message, optional, tag = "1")]
    pub discriminator: ::core::option::Option<Discriminator>,
    /// Additional external documentation related to this schema.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#external-documentation-object>
    #[prost(message, optional, tag = "3")]
    pub external_docs: ::core::option::Option<ExternalDocumentation>,
    /// Extra can be used to add any other field in the schema. Since OpenAPI v3.1 arbitrary fields
    /// can be used in the schema objects. This field can be utilized to add those extra
    /// fields. Some of the JSON schema validation properties or core properties that are not
    /// captured as part of the gRPC REST Gateway OpenAPI objects.
    #[prost(map = "string, message", tag = "4")]
    pub extra: ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
    /// Ref is used to define an external reference to include in the message.
    /// This could be a fully qualified proto message reference and start with a '.',
    /// and that type must be available in the proto files or their dependencies.
    /// If no message is identified, the Ref will be used verbatim in the output.
    ///
    /// For example:
    /// `ref: ".google.protobuf.Timestamp"`.
    ///
    /// NOTE: This reference will only be honored when used in top-level schemas in responses only.
    #[prost(string, tag = "5")]
    pub r#ref: ::prost::alloc::string::String,
    /// Configuration related to schema generation for OpenAPI documentation.
    #[prost(message, optional, tag = "6")]
    pub config: ::core::option::Option<FieldConfiguration>,
    /// The "$schema" keyword is used to identify the schema dialect and its associated URI for
    /// validation.
    ///
    /// See: <https://json-schema.org/draft/2020-12/json-schema-core#name-the-schema-keyword>
    #[prost(string, tag = "10")]
    pub schema: ::prost::alloc::string::String,
    /// The title of the schema.
    #[prost(string, tag = "11")]
    pub title: ::prost::alloc::string::String,
    /// A regular expression pattern that the schema value should match.
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.3.3>
    #[prost(string, tag = "12")]
    pub pattern: ::prost::alloc::string::String,
    /// A list of property names that are required in this schema.
    #[prost(string, repeated, tag = "13")]
    pub required: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// An array of unique values for enum validation.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.1.2>
    #[prost(string, repeated, tag = "14")]
    pub r#enum: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The value of "multipleOf" MUST be a number, strictly greater than 0.
    /// A numeric instance is valid only if division by this keyword's value results in an integer.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.2.1>
    #[prost(double, tag = "15")]
    pub multiple_of: f64,
    /// Maximum represents an inclusive upper limit for a numeric instance. The
    /// value of MUST be a number, representing an inclusive upper limit for a numeric instance.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.2.2>
    #[prost(double, tag = "16")]
    pub maximum: f64,
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.2.3>
    #[prost(double, tag = "17")]
    pub exclusive_maximum: f64,
    /// minimum represents an inclusive lower limit for a numeric instance. The
    /// value of MUST be a number, representing an inclusive lower limit for a numeric instance.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.2.4>
    #[prost(double, tag = "18")]
    pub minimum: f64,
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.2.5>
    #[prost(double, tag = "19")]
    pub exclusive_minimum: f64,
    /// A string instance is valid against this keyword if its length is
    /// less than, or equal to, the value of this keyword.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.3.1>
    #[prost(uint64, tag = "20")]
    pub max_length: u64,
    /// A string instance is valid against this keyword if its length is
    /// greater than, or equal to, the value of this keyword.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.3.2>
    #[prost(uint64, tag = "21")]
    pub min_length: u64,
    /// An array instance is valid against "maxItems" if its size is
    /// less than, or equal to, the value of this keyword.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.4.1>
    #[prost(uint64, tag = "22")]
    pub max_items: u64,
    /// An array instance is valid against "minItems" if its size is
    /// greater than, or equal to, the value of this keyword.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.4.2>
    #[prost(uint64, tag = "23")]
    pub min_items: u64,
    /// If set to true, all items must be unique.
    #[prost(bool, tag = "24")]
    pub unique_items: bool,
    #[prost(uint64, tag = "25")]
    pub max_properties: u64,
    #[prost(uint64, tag = "26")]
    pub min_properties: u64,
    /// Indicates what type this schema holds. In JSON schema draft 2020, this can be a singular
    /// value or a list of values. For simplicity of structure, types is always a list but if
    /// it contains only one item, in the generated file, it will be a single string and not a
    /// list.
    #[prost(enumeration = "SchemaDataType", repeated, tag = "27")]
    pub types: ::prost::alloc::vec::Vec<i32>,
    /// A description of the schema using CommonMark syntax.
    #[prost(string, tag = "28")]
    pub description: ::prost::alloc::string::String,
    /// The items keyword specifies the schema for items in an array.
    #[prost(message, optional, boxed, tag = "29")]
    pub items: ::core::option::Option<::prost::alloc::boxed::Box<schema::Item>>,
    /// The properties keyword specifies the schema for properties in an object.
    ///
    /// Defining any property here for proto messages merges them with the automatically generated
    /// ones.
    #[prost(map = "string, message", tag = "30")]
    pub properties: ::std::collections::HashMap<::prost::alloc::string::String, Schema>,
    /// The additionalProperties keyword specifies the schema for additional properties in an
    /// object.
    #[prost(message, optional, boxed, tag = "31")]
    pub additional_properties: ::core::option::Option<::prost::alloc::boxed::Box<Schema>>,
    /// The default keyword provides a default JSON value associated with the schema.
    #[prost(message, optional, tag = "32")]
    pub default: ::core::option::Option<::prost_types::Value>,
    /// The allOf keyword specifies that an instance must validate against all the schemas defined
    /// in the array.
    ///
    /// See: <https://json-schema.org/draft/2020-12/json-schema-core#name-allof>
    #[prost(message, repeated, tag = "33")]
    pub all_of: ::prost::alloc::vec::Vec<Schema>,
    /// The anyOf keyword specifies that an instance must validate against at least one of the
    /// schemas defined in the array.
    ///
    /// See: <https://json-schema.org/draft/2020-12/json-schema-core#name-anyof>
    #[prost(message, repeated, tag = "34")]
    pub any_of: ::prost::alloc::vec::Vec<Schema>,
    /// The oneOf keyword specifies that an instance must validate against exactly one of the
    /// schemas defined in the array.
    ///
    /// See: <https://json-schema.org/draft/2020-12/json-schema-core#name-oneof>
    #[prost(message, repeated, tag = "35")]
    pub one_of: ::prost::alloc::vec::Vec<Schema>,
    /// The not keyword specifies that an instance must not validate against the schema defined.
    ///
    /// See: <https://json-schema.org/draft/2020-12/json-schema-core#name-not>
    #[prost(message, optional, boxed, tag = "36")]
    pub not: ::core::option::Option<::prost::alloc::boxed::Box<Schema>>,
    /// The readOnly keyword specifies that a property is read-only.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-9.4>
    #[prost(bool, tag = "37")]
    pub read_only: bool,
    /// The writeOnly keyword specifies that a property is write-only.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-9.4>
    #[prost(bool, tag = "38")]
    pub write_only: bool,
    /// Examples of valid instances for the schema.
    ///
    /// See: <https://json-schema.org/draft/2020-12/json-schema-validation#section-9.5>
    #[prost(message, repeated, tag = "39")]
    pub examples: ::prost::alloc::vec::Vec<::prost_types::Value>,
    /// The format keyword specifies a predefined format for the schema value.
    ///
    /// See: <https://json-schema.org/draft-06/json-schema-validation#rfc.section.8>
    #[prost(string, tag = "40")]
    pub format: ::prost::alloc::string::String,
    /// The deprecated keyword specifies that the schema is deprecated.
    ///
    /// See: <https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-9.3>
    #[prost(bool, tag = "41")]
    pub deprecated: bool,
}
/// Nested message and enum types in `Schema`.
pub mod schema {
    /// Represents a list of schemas for array validation or for object properties.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SchemaList {
        #[prost(message, repeated, tag = "1")]
        pub items: ::prost::alloc::vec::Vec<super::Schema>,
    }
    /// Represents an item in a SchemaList, which can be a schema or another SchemaList.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Item {
        #[prost(oneof = "item::Value", tags = "1, 2")]
        pub value: ::core::option::Option<item::Value>,
    }
    /// Nested message and enum types in `Item`.
    pub mod item {
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Value {
            #[prost(message, tag = "1")]
            Schema(::prost::alloc::boxed::Box<super::super::Schema>),
            #[prost(message, tag = "2")]
            List(super::SchemaList),
        }
    }
}
/// Reference allows referencing other components in the OpenAPI document, both internally and
/// externally. For detailed information on the Reference object, refer to the OpenAPI
/// Specification: <https://spec.openapis.org/oas/latest.html#reference-object>
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Reference {
    /// REQUIRED. The reference identifier. This MUST be in the form of a URI.
    /// For proto messages, a fully qualified message name can be used (relative links are allowed
    /// where proto file is deduced).
    ///
    /// Example: ".google.protobuf.Timestamp"
    #[prost(string, tag = "1")]
    pub uri: ::prost::alloc::string::String,
    /// A short summary that, by default, SHOULD override that of the referenced component.
    /// If the referenced object-type does not allow a summary field, then this field has no
    /// effect.
    #[prost(string, tag = "2")]
    pub summary: ::prost::alloc::string::String,
    /// A description that, by default, SHOULD override that of the referenced component.
    /// CommonMark syntax MAY be used for rich text representation.
    /// If the referenced object-type does not allow a description field, then this field has no
    /// effect.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
}
/// The Link object represents a possible design-time link for a response. The presence of a link
/// does not guarantee the caller’s ability to successfully invoke it, rather it provides a known
/// relationship and traversal mechanism between responses and other operations.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#link-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Link {
    /// ref is a reference to an existing link object. If used, all other fields in this object get
    /// ignored.
    #[prost(message, optional, tag = "1")]
    pub r#ref: ::core::option::Option<Reference>,
    /// A map representing parameters to pass to an operation as specified with
    /// operationId or identified via operationRef. The key is the parameter name to be used,
    /// whereas the value can be a constant or an expression to be evaluated and passed to the
    /// linked operation. The parameter name can be qualified using the parameter location
    /// \[{in}.\]{name} for operations that use the same parameter name in different locations
    /// (e.g. path.id).
    #[prost(map = "string, message", tag = "4")]
    pub parameters:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
    /// A literal value or {expression} to use as a request body when calling the target operation.
    #[prost(message, optional, tag = "5")]
    pub request_body: ::core::option::Option<::prost_types::Value>,
    /// A description of the link. CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "6")]
    pub description: ::prost::alloc::string::String,
    /// A server object to be used by the target operation.
    #[prost(message, optional, tag = "7")]
    pub server: ::core::option::Option<Server>,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "8")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
    #[prost(oneof = "link::Operation", tags = "2, 3")]
    pub operation: ::core::option::Option<link::Operation>,
}
/// Nested message and enum types in `Link`.
pub mod link {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Operation {
        /// A relative or absolute URI reference to an OAS operation. This field is mutually
        /// exclusive of the operationId field, and MUST point to an Operation Object.
        /// Relative operationRef values MAY be used to locate an existing Operation Object in the
        /// OpenAPI definition.
        #[prost(string, tag = "2")]
        OperationRef(::prost::alloc::string::String),
        /// The name of an existing, resolvable OAS operation, as defined with a unique
        /// operationId. This field is mutually exclusive of the operationRef field.
        ///
        /// NOTE: If a path (relative or absolute) to another service method is used, that
        /// operation ID will be substituted. Example: ".google.protobuf.Timestamp"
        #[prost(string, tag = "3")]
        OperationId(::prost::alloc::string::String),
    }
}
/// See: <https://spec.openapis.org/oas/latest.html#example-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Example {
    /// ref is a reference to an existing example object. If used, all other fields in this object
    /// get ignored.
    #[prost(message, optional, tag = "1")]
    pub r#ref: ::core::option::Option<Reference>,
    /// Short description for the example.
    #[prost(string, tag = "2")]
    pub summary: ::prost::alloc::string::String,
    /// Long description for the example. CommonMark syntax MAY be used for rich text
    /// representation.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Embedded literal example. The value field and externalValue field are mutually exclusive.
    /// To represent examples of media types that cannot naturally represented in JSON or YAML,
    /// use a string value to contain the example, escaping where necessary.
    #[prost(message, optional, tag = "4")]
    pub value: ::core::option::Option<::prost_types::Value>,
    /// A URI that points to the literal example. This provides the capability to reference
    /// examples that cannot easily be included in JSON or YAML documents. The value field and
    /// externalValue field are mutually exclusive. See the rules for resolving Relative
    /// References.
    #[prost(string, tag = "5")]
    pub external_value: ::prost::alloc::string::String,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "6")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// A single encoding definition applied to a single schema property.
///
/// See: <https://spec.openapis.org/oas/latest.html#encoding-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Encoding {
    /// The Content-Type for encoding a specific property. Default value depends on the property
    /// type: for object - application/json;
    /// for array – the default is defined based on the inner type;
    /// for all other cases the default is application/octet-stream.
    /// The value can be a specific media type (e.g. application/json),
    /// a wildcard media type (e.g. image/\*), or a comma-separated list of the two types.
    #[prost(string, tag = "1")]
    pub content_type: ::prost::alloc::string::String,
    /// A map allowing additional information to be provided as headers, for example
    /// Content-Disposition. Content-Type is described separately and SHALL be ignored in this
    /// section. This property SHALL be ignored if the request body media type is not a
    /// multipart.
    #[prost(map = "string, message", tag = "2")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, Header>,
    /// Describes how a specific property value will be serialized depending on its type.
    /// See Parameter Object for details on the style property. The behavior follows the same
    /// values as query parameters, including default values. This property SHALL be ignored if
    /// the request body media type is not application/x-www-form-urlencoded or
    /// multipart/form-data. If a value is explicitly defined, then the value of contentType
    /// (implicit or explicit) SHALL be ignored.
    #[prost(string, tag = "3")]
    pub style: ::prost::alloc::string::String,
    /// When this is true, property values of type array or object generate separate parameters for
    /// each value of the array, or key-value-pair of the map. For other types of properties
    /// this property has no effect. When style is form, the default value is true. For all
    /// other styles, the default value is false. This property SHALL be ignored if the request
    /// body media type is not application/x-www-form-urlencoded or multipart/form-data.
    /// If a value is explicitly defined, then the value of contentType (implicit or explicit)
    /// SHALL be ignored.
    #[prost(bool, tag = "4")]
    pub explode: bool,
    /// Determines whether the parameter value SHOULD allow reserved characters,
    /// as defined by \[RFC3986\] :/?#\[\]@!$&'()\*+,;= to be included without percent-encoding.
    /// The default value is false. This property SHALL be ignored if the request body media
    /// type is not application/x-www-form-urlencoded or multipart/form-data.
    /// If a value is explicitly defined, then the value of contentType (implicit or explicit)
    /// SHALL be ignored.
    #[prost(bool, tag = "5")]
    pub allow_reserved: bool,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "6")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Each Media Type Object provides schema and examples for the media type identified by its key.
///
/// See: <https://spec.openapis.org/oas/latest.html#media-type-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MediaType {
    /// The schema defining the content of the request, response, or parameter.
    #[prost(message, optional, tag = "1")]
    pub schema: ::core::option::Option<Schema>,
    /// Example of the parameter’s potential value.
    /// The example SHOULD match the specified schema and encoding properties if present.
    /// The example field is mutually exclusive of the examples field. Furthermore,
    /// if referencing a schema that contains an example, the example value SHALL override the
    /// example provided by the schema. To represent examples of media types that cannot naturally
    /// be represented in JSON or YAML, a string value can contain the example with escaping
    /// where necessary.
    #[prost(message, optional, tag = "2")]
    pub example: ::core::option::Option<::prost_types::Value>,
    /// Examples of the parameter’s potential value. Each example SHOULD contain a value in the
    /// correct format as specified in the parameter encoding. The examples field is mutually
    /// exclusive of the example field. Furthermore, if referencing a schema that contains an
    /// example, the examples value SHALL override the example provided by the schema.
    #[prost(map = "string, message", tag = "3")]
    pub examples: ::std::collections::HashMap<::prost::alloc::string::String, Example>,
    /// A map between a property name and its encoding information. The key, being the property
    /// name, MUST exist in the schema as a property. The encoding object SHALL only apply to
    /// requestBody objects when the media type is multipart or
    /// application/x-www-form-urlencoded.
    #[prost(map = "string, message", tag = "4")]
    pub encoding: ::std::collections::HashMap<::prost::alloc::string::String, Encoding>,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "5")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Header object follows the structure of the Parameter object with the following changes:
///
/// 1. name MUST NOT be specified, it is given in the corresponding headers map.
/// 1. in MUST NOT be specified, it is implicitly in header.
/// 1. All traits that are affected by the location MUST be applicable to a location of header (for
///    example, style).
///
/// See: <https://spec.openapis.org/oas/v3.1.0#header-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Header {
    /// ref is a reference to an existing header object. If used, all other fields in this object
    /// get ignored.
    #[prost(message, optional, tag = "1")]
    pub r#ref: ::core::option::Option<Reference>,
    /// A description of the link. CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Determines whether this parameter is mandatory.
    /// If the parameter location is "path", this property is REQUIRED and its value MUST be true.
    /// Otherwise, the property MAY be included and its default value is false.
    #[prost(bool, tag = "3")]
    pub required: bool,
    /// Specifies that a parameter is deprecated and SHOULD be transitioned out of usage. Default
    /// value is false.
    #[prost(bool, tag = "4")]
    pub deprecated: bool,
    /// Sets the ability to pass empty-valued parameters.
    /// This is valid only for query parameters and allows sending a parameter with an empty value.
    /// Default value is false. If style is used, and if behavior is n/a (cannot be serialized),
    /// the value of allowEmptyValue SHALL be ignored. Use of this property is NOT RECOMMENDED,
    /// as it is likely to be removed in a later revision.
    #[prost(bool, tag = "5")]
    pub allow_empty_value: bool,
    /// Describes how the parameter value will be serialized depending on the type of the parameter
    /// value. Default value for header parameters is "simple".
    #[prost(string, tag = "6")]
    pub style: ::prost::alloc::string::String,
    /// When this is true, parameter values of type array or object generate separate parameters
    /// for each value of the array or key-value pair of the map. For other types of parameters
    /// this property has no effect. When style is form, the default value is true. For all
    /// other styles, the default value is false.
    #[prost(bool, tag = "7")]
    pub explode: bool,
    /// The schema defining the type used for the parameter.
    #[prost(message, optional, tag = "8")]
    pub schema: ::core::option::Option<Schema>,
    /// Example of the parameter’s potential value.
    /// The example SHOULD match the specified schema and encoding properties if present.
    /// The example field is mutually exclusive of the examples field. Furthermore,
    /// if referencing a schema that contains an example, the example value SHALL override the
    /// example provided by the schema. To represent examples of media types that cannot naturally
    /// be represented in JSON or YAML, a string value can contain the example with escaping
    /// where necessary.
    #[prost(message, optional, tag = "9")]
    pub example: ::core::option::Option<::prost_types::Value>,
    /// Examples of the parameter’s potential value. Each example SHOULD contain a value in the
    /// correct format as specified in the parameter encoding. The examples field is mutually
    /// exclusive of the example field. Furthermore, if referencing a schema that contains an
    /// example, the examples value SHALL override the example provided by the schema.
    #[prost(map = "string, message", tag = "10")]
    pub examples: ::std::collections::HashMap<::prost::alloc::string::String, Example>,
    /// A map containing the representations for the parameter.
    /// The key is the media type and the value describes it. The map MUST only contain one entry.
    #[prost(map = "string, message", tag = "11")]
    pub content: ::std::collections::HashMap<::prost::alloc::string::String, MediaType>,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "12")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Describes a single operation parameter.
/// A unique parameter is defined by a combination of a name and location.
///
/// See: <https://spec.openapis.org/oas/latest.html#parameter-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Parameter {
    /// ref is a reference to an existing parameter object. If used, all other fields in this
    /// object get ignored.
    #[prost(message, optional, tag = "1")]
    pub r#ref: ::core::option::Option<Reference>,
    /// REQUIRED. The name of the parameter. Parameter names are case sensitive.
    /// If in is "path", the name field MUST correspond to a template expression occurring within
    /// the path field in the Paths Object. See Path Templating for further information.
    /// If in is "header" and the name field is
    /// "Accept", "Content-Type" or "Authorization", the parameter definition SHALL be ignored.
    /// For all other cases, the name corresponds to the parameter name used by the in property.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// REQUIRED. The location of the parameter. Possible values are "query", "header", "path" or
    /// "cookie".
    #[prost(string, tag = "3")]
    pub r#in: ::prost::alloc::string::String,
    /// A description of the link. CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Determines whether this parameter is mandatory.
    /// If the parameter location is "path", this property is REQUIRED and its value MUST be true.
    /// Otherwise, the property MAY be included and its default value is false.
    #[prost(bool, tag = "5")]
    pub required: bool,
    /// Specifies that a parameter is deprecated and SHOULD be transitioned out of usage. Default
    /// value is false.
    #[prost(bool, tag = "6")]
    pub deprecated: bool,
    /// Sets the ability to pass empty-valued parameters.
    /// This is valid only for query parameters and allows sending a parameter with an empty value.
    /// Default value is false. If style is used, and if behavior is n/a (cannot be serialized),
    /// the value of allowEmptyValue SHALL be ignored. Use of this property is NOT RECOMMENDED,
    /// as it is likely to be removed in a later revision.
    #[prost(bool, tag = "7")]
    pub allow_empty_value: bool,
    /// Describes how the parameter value will be serialized depending on the type of the parameter
    /// value. Default value for header parameters is "simple".
    #[prost(string, tag = "8")]
    pub style: ::prost::alloc::string::String,
    /// When this is true, parameter values of type array or object generate separate parameters
    /// for each value of the array or key-value pair of the map. For other types of parameters
    /// this property has no effect. When style is form, the default value is true. For all
    /// other styles, the default value is false.
    #[prost(bool, tag = "9")]
    pub explode: bool,
    ///
    /// Determines whether the parameter value SHOULD allow reserved characters, as defined by
    /// \[RFC3986\] : /?#\[\]@!$&'()\*+,;= to be included without percent-encoding.
    ///   This property only applies to parameters with an in value of query. The default value is
    /// false.
    #[prost(bool, tag = "10")]
    pub allow_reserved: bool,
    /// The schema defining the type used for the parameter.
    #[prost(message, optional, tag = "11")]
    pub schema: ::core::option::Option<Schema>,
    /// Example of the parameter’s potential value.
    /// The example SHOULD match the specified schema and encoding properties if present.
    /// The example field is mutually exclusive of the examples field. Furthermore,
    /// if referencing a schema that contains an example, the example value SHALL override the
    /// example provided by the schema. To represent examples of media types that cannot naturally
    /// be represented in JSON or YAML, a string value can contain the example with escaping
    /// where necessary.
    #[prost(message, optional, tag = "12")]
    pub example: ::core::option::Option<::prost_types::Value>,
    /// Examples of the parameter’s potential value. Each example SHOULD contain a value in the
    /// correct format as specified in the parameter encoding. The examples field is mutually
    /// exclusive of the example field. Furthermore, if referencing a schema that contains an
    /// example, the examples value SHALL override the example provided by the schema.
    #[prost(map = "string, message", tag = "13")]
    pub examples: ::std::collections::HashMap<::prost::alloc::string::String, Example>,
    /// A map containing the representations for the parameter.
    /// The key is the media type and the value describes it. The map MUST only contain one entry.
    #[prost(map = "string, message", tag = "14")]
    pub content: ::std::collections::HashMap<::prost::alloc::string::String, MediaType>,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "15")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Response {
    /// ref is a reference to an existing response object. If used, all other fields in this object
    /// get ignored.
    #[prost(message, optional, tag = "1")]
    pub r#ref: ::core::option::Option<Reference>,
    /// A description which by default SHOULD override that of the referenced component.
    /// CommonMark syntax MAY be used for rich text representation.
    /// If the referenced object-type does not allow a description field, then this field has no
    /// effect.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Maps a header name to its definition. \[RFC7230\] states header names are case insensitive.
    /// If a response header is defined with the name "Content-Type", it SHALL be ignored.
    #[prost(map = "string, message", tag = "3")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, Header>,
    /// A map containing descriptions of potential response payloads.
    /// The key is a media type or media type range and the value describes it.
    /// For responses that match multiple keys, only the most specific key is applicable. e.g.
    /// text/plain overrides text/\*
    #[prost(map = "string, message", tag = "4")]
    pub content: ::std::collections::HashMap<::prost::alloc::string::String, MediaType>,
    /// A map of operations links that can be followed from the response. The key of the map is a
    /// short name for the link, following the naming constraints of the names for Component
    /// Objects.
    #[prost(map = "string, message", tag = "5")]
    pub links: ::std::collections::HashMap<::prost::alloc::string::String, Link>,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "6")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Describes a single request body.
///
/// See: <https://spec.openapis.org/oas/latest.html#request-body-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestBody {
    /// ref is a reference to an existing request body object. If used, all other fields in this
    /// object get ignored.
    #[prost(message, optional, tag = "1")]
    pub r#ref: ::core::option::Option<Reference>,
    /// A brief description of the request body. This could contain examples of use.
    /// CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// REQUIRED. The content of the request body. The key is a media type or media type range and
    /// the value describes it. For requests that match multiple keys, only the most specific
    /// key is applicable. e.g. text/plain overrides text/\*
    #[prost(map = "string, message", tag = "3")]
    pub content: ::std::collections::HashMap<::prost::alloc::string::String, MediaType>,
    /// Determines if the request body is required in the request. Defaults to false.
    #[prost(bool, tag = "4")]
    pub required: bool,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "5")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Defines a security scheme that can be used by the operations.
///
/// See: <https://spec.openapis.org/oas/latest.html#security-scheme-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SecurityScheme {
    /// ref is a reference to an existing response object. If used, all other fields in this object
    /// get ignored.
    #[prost(message, optional, tag = "1")]
    pub r#ref: ::core::option::Option<Reference>,
    /// REQUIRED. The type of the security scheme.
    /// Valid values are "apiKey", "http", "mutualTLS", "oauth2", "openIdConnect".
    #[prost(string, tag = "2")]
    pub r#type: ::prost::alloc::string::String,
    /// A brief description of the request body. This could contain examples of use.
    /// CommonMark syntax MAY be used for rich text representation.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// REQUIRED. The name of the header, query or cookie parameter to be used.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// REQUIRED. The location of the API key. Valid values are "query", "header" or "cookie".
    #[prost(string, tag = "5")]
    pub r#in: ::prost::alloc::string::String,
    /// REQUIRED. The name of the HTTP Authorization scheme to be used in the
    /// Authorization header as defined in \[RFC7235\].
    /// The values used SHOULD be registered in the IANA Authentication Scheme registry.
    #[prost(string, tag = "6")]
    pub scheme: ::prost::alloc::string::String,
    /// A hint to the client to identify how the bearer token is formatted.
    /// Bearer tokens are usually generated by an authorization server,
    /// so this information is primarily for documentation purposes.
    #[prost(string, tag = "7")]
    pub bearer_format: ::prost::alloc::string::String,
    /// REQUIRED. An object containing configuration information for the flow types supported.
    #[prost(message, optional, tag = "8")]
    pub flows: ::core::option::Option<security_scheme::OAuthFlows>,
    /// REQUIRED. OpenId Connect URL to discover OAuth2 configuration values.
    /// This MUST be in the form of a URL. The OpenID Connect standard requires the use of TLS.
    #[prost(string, tag = "9")]
    pub open_id_connect_url: ::prost::alloc::string::String,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "10")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Nested message and enum types in `SecurityScheme`.
pub mod security_scheme {
    /// Configuration details for a supported OAuth Flow
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#oauth-flow-object>
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct OAuthFlow {
        #[prost(string, tag = "1")]
        pub authorization_url: ::prost::alloc::string::String,
        #[prost(string, tag = "2")]
        pub token_url: ::prost::alloc::string::String,
        #[prost(string, tag = "3")]
        pub refresh_url: ::prost::alloc::string::String,
        #[prost(map = "string, string", tag = "4")]
        pub scopes: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// extensions that start with "x-" such as "x-foo" used to describe extra functionality
        /// that is not covered by standard OpenAPI specification.
        ///
        /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
        #[prost(map = "string, message", tag = "5")]
        pub extensions:
            ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
    }
    /// See: <https://spec.openapis.org/oas/latest.html#oauth-flows-object>
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct OAuthFlows {
        /// Configuration for the OAuth Implicit flow
        #[prost(message, optional, tag = "1")]
        pub implicit: ::core::option::Option<OAuthFlow>,
        /// Configuration for the OAuth Resource Owner Password flow
        #[prost(message, optional, tag = "2")]
        pub password: ::core::option::Option<OAuthFlow>,
        /// Configuration for the OAuth Client Credentials flow. Previously called application in
        /// OpenAPI 2.0.
        #[prost(message, optional, tag = "3")]
        pub client_credentials: ::core::option::Option<OAuthFlow>,
        /// Configuration for the OAuth Authorization Code flow. Previously called accessCode in
        /// OpenAPI 2.0.
        #[prost(message, optional, tag = "4")]
        pub authorization_code: ::core::option::Option<OAuthFlow>,
        /// extensions that start with "x-" such as "x-foo" used to describe extra functionality
        /// that is not covered by standard OpenAPI specification.
        ///
        /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
        #[prost(map = "string, message", tag = "5")]
        pub extensions:
            ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
    }
}
/// Describes a single API operation on a path.
///
/// NOTE: this operation object is a partial implementation of the OpenAPI Operation object.
/// Fields overridden here will only impact this method but will be used for all different
/// HTTP bindings of the same method.
///
/// See: <https://spec.openapis.org/oas/v3.1.0#operation-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Operation {
    /// A list of tags for API documentation control.
    /// Tags can be used for logical grouping of operations by resources or any other qualifier.
    #[prost(string, repeated, tag = "1")]
    pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// A short summary of what the operation does.
    ///
    /// Default is the proto docstring for this method.
    #[prost(string, tag = "2")]
    pub summary: ::prost::alloc::string::String,
    /// A verbose explanation of the operation behavior. CommonMark syntax MAY be used for rich
    /// text representation.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Additional external documentation for this operation.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#external-documentation-object>
    #[prost(message, optional, tag = "4")]
    pub external_docs: ::core::option::Option<ExternalDocumentation>,
    /// Override the operation ID, if left unset, a default value will be provided.
    #[prost(string, tag = "5")]
    pub operation_id: ::prost::alloc::string::String,
    /// A list of parameters that are applicable for this operation. Note that path and query
    /// parameters get populated by the generator and will override any overlapping keys.
    ///
    /// You might use this to define headers and values that are not defined on the request
    /// payload.
    #[prost(message, repeated, tag = "6")]
    pub parameters: ::prost::alloc::vec::Vec<Parameter>,
    /// The list of possible responses returned from executing this operation.
    ///
    /// NOTE: This list is additive meaning that it will override any generated response from the
    /// proto files.
    #[prost(map = "string, message", tag = "7")]
    pub responses: ::std::collections::HashMap<::prost::alloc::string::String, Response>,
    /// Declares this operation to be deprecated.
    /// Consumers SHOULD refrain from usage of the declared operation. Default value is false.
    #[prost(bool, tag = "11")]
    pub deprecated: bool,
    /// A declaration of which security mechanisms can be used for this operation.
    /// The list of values includes alternative security requirement objects that can be used.
    /// Only one of the security requirement objects need to be satisfied to authorize a request.
    /// To make security optional, an empty security requirement ({}) can be included in the array.
    /// This definition overrides any declared top-level security.
    /// To remove a top-level security declaration, an empty array can be used.
    #[prost(message, repeated, tag = "12")]
    pub security: ::prost::alloc::vec::Vec<SecurityRequirement>,
    /// An alternative server array to service this operation.
    /// If an alternative server object is specified at the Path Item Object or Root level,
    /// it will be overridden by this value.
    #[prost(message, repeated, tag = "13")]
    pub servers: ::prost::alloc::vec::Vec<Server>,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "14")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// Holds a set of reusable objects for different aspects of the OAS. All objects defined within the
/// components object will have no effect on the API unless they are explicitly referenced from
/// properties outside the components object.
///
/// See: <https://spec.openapis.org/oas/latest.html#components-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Components {
    #[prost(map = "string, message", tag = "1")]
    pub schemas: ::std::collections::HashMap<::prost::alloc::string::String, Schema>,
    #[prost(map = "string, message", tag = "2")]
    pub responses: ::std::collections::HashMap<::prost::alloc::string::String, Response>,
    #[prost(map = "string, message", tag = "3")]
    pub parameters: ::std::collections::HashMap<::prost::alloc::string::String, Parameter>,
    #[prost(map = "string, message", tag = "4")]
    pub examples: ::std::collections::HashMap<::prost::alloc::string::String, Example>,
    #[prost(map = "string, message", tag = "5")]
    pub request_bodies: ::std::collections::HashMap<::prost::alloc::string::String, RequestBody>,
    #[prost(map = "string, message", tag = "6")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, Header>,
    #[prost(map = "string, message", tag = "7")]
    pub security_schemes:
        ::std::collections::HashMap<::prost::alloc::string::String, SecurityScheme>,
    #[prost(map = "string, message", tag = "8")]
    pub links: ::std::collections::HashMap<::prost::alloc::string::String, Link>,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "11")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
}
/// DocumentConfiguration allows for controlling the default responses
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DocumentConfiguration {
    /// default_responses is used to control the default responses generated in this OpenAPI
    /// document.
    #[prost(map = "string, message", tag = "1")]
    pub default_responses: ::std::collections::HashMap<::prost::alloc::string::String, Response>,
}
/// This is the root object of the OpenAPI document.
/// See: <https://spec.openapis.org/oas/v3.1.0#openapi-object>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Document {
    /// REQUIRED. Provides metadata about the API. The metadata MAY be used by tooling as required.
    /// NOTE: A generated value will be used for the required fields if they are left empty.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#info-object>
    #[prost(message, optional, tag = "1")]
    pub info: ::core::option::Option<Info>,
    /// An array of Server Objects, which provide connectivity information to a target server.
    /// If the servers property is not provided, or is an empty array,
    /// the default value would be a Server Object with a url value of /.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#server-object>
    #[prost(message, repeated, tag = "2")]
    pub servers: ::prost::alloc::vec::Vec<Server>,
    /// Holds a set of reusable objects for different aspects of the OAS. All objects defined
    /// within the components object will have no effect on the API unless they are explicitly
    /// referenced from properties outside the components object.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#components-object>
    #[prost(message, optional, tag = "5")]
    pub components: ::core::option::Option<Components>,
    /// A declaration of which security mechanisms can be used across the API. The list of values
    /// includes alternative security requirement objects that can be used. Only one of the
    /// security requirement objects need to be satisfied to authorize a request. Individual
    /// operations can override this definition. To make security optional, an empty security
    /// requirement ({}) can be included in the array.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#security-requirement-object>
    #[prost(message, repeated, tag = "6")]
    pub security: ::prost::alloc::vec::Vec<SecurityRequirement>,
    /// A list of tags used by the document with additional metadata. The order of the tags can be
    /// used to reflect on their order by the parsing tools. Not all tags that are used by the
    /// Operation Object must be declared. The tags that are not declared MAY be organized
    /// randomly or based on the tools’ logic. Each tag name in the list MUST be unique.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#tag-object>
    #[prost(message, repeated, tag = "7")]
    pub tags: ::prost::alloc::vec::Vec<Tag>,
    /// Additional external documentation.
    ///
    /// See: <https://spec.openapis.org/oas/v3.1.0#external-documentation-object>
    #[prost(message, optional, tag = "8")]
    pub external_docs: ::core::option::Option<ExternalDocumentation>,
    /// extensions that start with "x-" such as "x-foo" used to describe extra functionality that
    /// is not covered by standard OpenAPI specification.
    ///
    /// See: <https://spec.openapis.org/oas/latest.html#specification-extensions>
    #[prost(map = "string, message", tag = "9")]
    pub extensions:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost_types::Value>,
    /// DocumentConfiguration is used to change the behavior of documentation generation such as
    /// default responses.
    #[prost(message, optional, tag = "10")]
    pub config: ::core::option::Option<DocumentConfiguration>,
}
/// Enum for the data type of a schema.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SchemaDataType {
    Unknown = 0,
    Array = 1,
    Boolean = 2,
    Integer = 3,
    Null = 4,
    Number = 5,
    Object = 6,
    String = 7,
}
impl SchemaDataType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unknown => "UNKNOWN",
            Self::Array => "ARRAY",
            Self::Boolean => "BOOLEAN",
            Self::Integer => "INTEGER",
            Self::Null => "NULL",
            Self::Number => "NUMBER",
            Self::Object => "OBJECT",
            Self::String => "STRING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNKNOWN" => Some(Self::Unknown),
            "ARRAY" => Some(Self::Array),
            "BOOLEAN" => Some(Self::Boolean),
            "INTEGER" => Some(Self::Integer),
            "NULL" => Some(Self::Null),
            "NUMBER" => Some(Self::Number),
            "OBJECT" => Some(Self::Object),
            "STRING" => Some(Self::String),
            _ => None,
        }
    }
}