dtsgenerator/dist/core/openApiV3.d.ts

import { JsonSchemaDraft07 } from './jsonSchemaDraft07';
export declare namespace OpenApisV3 {
    interface SchemaJson {
        openapi: string;
        info: SchemaJson.Definitions.Info;
        servers?: SchemaJson.Definitions.Server[];
        paths: SchemaJson.Definitions.Paths;
        components?: SchemaJson.Definitions.Components;
        security?: SchemaJson.Definitions.SecurityRequirement[];
        tags?: SchemaJson.Definitions.Tag[];
        externalDocs?: SchemaJson.Definitions.ExternalDocs;
    }
    namespace SchemaJson {
        namespace Definitions {
            type Any = Record<string, any>;
            type AnyOrExpression = Any | Expression;
            type AnysOrExpressions = Record<string, AnyOrExpression>;
            interface Callback {
            }
            type CallbackOrReference = Callback | Reference;
            type CallbacksOrReferences = Record<string, CallbackOrReference>;
            interface Components {
                schemas?: SchemasOrReferences;
                responses?: ResponsesOrReferences;
                parameters?: ParametersOrReferences;
                examples?: ExamplesOrReferences;
                requestBodies?: RequestBodiesOrReferences;
                headers?: HeadersOrReferences;
                securitySchemes?: SecuritySchemesOrReferences;
                links?: LinksOrReferences;
                callbacks?: CallbacksOrReferences;
            }
            interface Contact {
                name?: string;
                url?: string;
                email?: string;
            }
            type DefaultType = null | any[] | number | boolean | string;
            interface Discriminator {
                propertyName: string;
                mapping?: Strings;
            }
            interface Encoding {
                contentType?: string;
                headers?: HeadersOrReferences;
                style?: string;
                explode?: boolean;
                allowReserved?: boolean;
            }
            type Encodings = Record<string, Encoding>;
            interface Example {
                summary?: string;
                description?: string;
                value?: Any;
                externalValue?: string;
            }
            type ExampleOrReference = Example | Reference;
            type ExamplesOrReferences = Record<string, ExampleOrReference>;
            type Expression = Record<string, any>;
            interface ExternalDocs {
                description?: string;
                url: string;
            }
            interface Header {
                description?: string;
                required?: boolean;
                deprecated?: boolean;
                allowEmptyValue?: boolean;
                style?: string;
                explode?: boolean;
                allowReserved?: boolean;
                schema?: SchemaOrReference;
                example?: Any;
                examples?: ExamplesOrReferences;
                content?: MediaTypes;
            }
            type HeaderOrReference = Header | Reference;
            type HeadersOrReferences = Record<string, HeaderOrReference>;
            interface Info {
                title: string;
                description?: string;
                termsOfService?: string;
                contact?: Contact;
                license?: License;
                version: string;
            }
            interface License {
                name: string;
                url?: string;
            }
            interface Link {
                operationRef?: string;
                operationId?: string;
                parameters?: AnysOrExpressions;
                requestBody?: AnyOrExpression;
                description?: string;
                server?: Server;
            }
            type LinkOrReference = Link | Reference;
            type LinksOrReferences = Record<string, LinkOrReference>;
            interface MediaType {
                schema?: SchemaOrReference;
                example?: Any;
                examples?: ExamplesOrReferences;
                encoding?: Encodings;
            }
            type MediaTypes = Record<string, MediaType>;
            interface OauthFlow {
                authorizationUrl?: string;
                tokenUrl?: string;
                refreshUrl?: string;
                scopes?: Strings;
            }
            interface OauthFlows {
                implicit?: OauthFlow;
                password?: OauthFlow;
                clientCredentials?: OauthFlow;
                authorizationCode?: OauthFlow;
            }
            interface Operation {
                tags?: string[];
                summary?: string;
                description?: string;
                externalDocs?: ExternalDocs;
                operationId?: string;
                parameters?: ParameterOrReference[];
                requestBody?: RequestBodyOrReference;
                responses: ResponsesOrReferences;
                callbacks?: CallbacksOrReferences;
                deprecated?: boolean;
                security?: SecurityRequirement[];
                servers?: Server[];
            }
            interface Parameter {
                name: string;
                in: string;
                description?: string;
                required?: boolean;
                deprecated?: boolean;
                allowEmptyValue?: boolean;
                style?: string;
                explode?: boolean;
                allowReserved?: boolean;
                schema?: SchemaOrReference;
                example?: Any;
                examples?: ExamplesOrReferences;
                content?: MediaTypes;
            }
            type ParameterOrReference = Parameter | Reference;
            type ParametersOrReferences = Record<string, ParameterOrReference>;
            interface PathItem {
                $ref?: string;
                summary?: string;
                description?: string;
                get?: Operation;
                put?: Operation;
                post?: Operation;
                delete?: Operation;
                options?: Operation;
                head?: Operation;
                patch?: Operation;
                trace?: Operation;
                servers?: Server[];
                parameters?: ParameterOrReference[];
            }
            type PathItemOrReference = PathItem | Reference;
            type Paths = Record<string, PathItemOrReference>;
            interface Reference {
                $ref: string;
            }
            type RequestBodiesOrReferences = Record<string, RequestBodyOrReference>;
            interface RequestBody {
                description?: string;
                content: MediaTypes;
                required?: boolean;
            }
            type RequestBodyOrReference = RequestBody | Reference;
            interface Response {
                description: string;
                headers?: HeadersOrReferences;
                content?: MediaTypes;
                links?: LinksOrReferences;
            }
            type ResponseOrReference = Response | Reference;
            type ResponsesOrReferences = Record<string, ResponseOrReference>;
            type SchemaOrReference = JsonSchemaDraft07.SchemaObject | Reference;
            type SchemasOrReferences = Record<string, SchemaOrReference>;
            interface SecurityRequirement {
            }
            interface SecurityScheme {
                type: string;
                description?: string;
                name?: string;
                in?: string;
                scheme?: string;
                bearerFormat?: string;
                flows?: OauthFlows;
                openIdConnectUrl?: string;
            }
            type SecuritySchemeOrReference = SecurityScheme | Reference;
            type SecuritySchemesOrReferences = Record<string, SecuritySchemeOrReference>;
            interface Server {
                url: string;
                description?: string;
                variables?: ServerVariables;
            }
            interface ServerVariable {
                enum?: string[];
                default: string;
                description?: string;
            }
            type ServerVariables = Record<string, ServerVariable>;
            type SpecificationExtension = null | number | boolean | string | any[];
            type Strings = Record<string, string>;
            interface Tag {
                name: string;
                description?: string;
                externalDocs?: ExternalDocs;
            }
            interface Xml {
                name?: string;
                namespace?: string;
                prefix?: string;
                attribute?: boolean;
                wrapped?: boolean;
            }
        }
    }
}