zod-openapi 1.0.2 → 2.0.0

package/lib-types/create/schema/array.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodArray } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createArraySchema: (zodArray: ZodArray<any, any>, state: SchemaState) => oas31.SchemaObject;

package/lib-types/create/schema/boolean.d.ts

@@ -1,3 +1,3 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodBoolean } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 export declare const createBooleanSchema: (_zodBoolean: ZodBoolean) => oas31.SchemaObject;

package/lib-types/create/schema/catch.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodCatch } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createCatchSchema: (zodCatch: ZodCatch<any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/date.d.ts

@@ -1,3 +1,3 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodDate } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 export declare const createDateSchema: (_zodDate: ZodDate) => oas31.SchemaObject;

package/lib-types/create/schema/default.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodDefault } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createDefaultSchema: (zodDefault: ZodDefault<any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/discriminatedUnion.d.ts

@@ -1,5 +1,5 @@
-import { oas31 } from 'openapi3-ts';
 import { AnyZodObject, ZodDiscriminatedUnion } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createDiscriminatedUnionSchema: (zodDiscriminatedUnion: ZodDiscriminatedUnion<any, any>, state: SchemaState) => oas31.SchemaObject;
 export declare const mapDiscriminator: (schemas: (oas31.SchemaObject | oas31.ReferenceObject)[], zodObjects: AnyZodObject[], discriminator: unknown) => oas31.SchemaObject['discriminator'];

package/lib-types/create/schema/enum.d.ts

@@ -1,3 +1,3 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodEnum } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 export declare const createEnumSchema: (zodEnum: ZodEnum<any>) => oas31.SchemaObject;

package/lib-types/create/schema/index.d.ts

@@ -1,5 +1,5 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodType, ZodTypeDef } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { ComponentsObject, CreationType } from '../components';
 export interface SchemaState {
     components: ComponentsObject;

package/lib-types/create/schema/intersection.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodIntersection } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createIntersectionSchema: (zodIntersection: ZodIntersection<any, any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/literal.d.ts

@@ -1,3 +1,3 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodLiteral } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 export declare const createLiteralSchema: (zodLiteral: ZodLiteral<any>) => oas31.SchemaObject;

package/lib-types/create/schema/manual.d.ts

@@ -1,3 +1,3 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodType, ZodTypeDef } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 export declare const createManualTypeSchema: <Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>) => oas31.SchemaObject;

package/lib-types/create/schema/metadata.d.ts

@@ -1,5 +1,5 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodType, ZodTypeDef } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createSchemaWithMetadata: <Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
 export declare const enhanceWithMetadata: (schemaOrRef: oas31.SchemaObject | oas31.ReferenceObject, metadata: oas31.SchemaObject | oas31.ReferenceObject) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/nativeEnum.d.ts

@@ -1,5 +1,5 @@
-import { oas31 } from 'openapi3-ts';
 import { EnumLike, ZodNativeEnum } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createNativeEnumSchema: <T extends EnumLike>(zodEnum: ZodNativeEnum<T>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
 interface StringsAndNumbers {

package/lib-types/create/schema/null.d.ts

@@ -1,3 +1,3 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodNull } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 export declare const createNullSchema: (_zodNull: ZodNull) => oas31.SchemaObject;

package/lib-types/create/schema/nullable.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodNullable } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createNullableSchema: (zodNullable: ZodNullable<any>, state: SchemaState) => oas31.SchemaObject;

package/lib-types/create/schema/number.d.ts

@@ -1,5 +1,5 @@
-import { oas30, oas31 } from 'openapi3-ts';
 import { ZodNumber, ZodNumberCheck } from 'zod';
+import { oas30, oas31 } from '../../openapi3-ts/dist';
 import { ZodOpenApiVersion } from '../document';
 import { SchemaState } from '.';
 export declare const createNumberSchema: (zodNumber: ZodNumber, state: SchemaState) => oas31.SchemaObject;

package/lib-types/create/schema/object.d.ts

@@ -1,5 +1,5 @@
-import { oas31 } from 'openapi3-ts';
 import { UnknownKeysParam, ZodObject, ZodRawShape } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createObjectSchema: <T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam>(zodObject: ZodObject<T, UnknownKeys, any, any, any>, state: SchemaState) => oas31.SchemaObject;
 export declare const createExtendedSchema: (zodObject: ZodObject<any, any, any, any, any>, baseZodObject: ZodObject<any, any, any, any, any>, schemaRef: string, state: SchemaState) => oas31.SchemaObject;

package/lib-types/create/schema/optional.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodOptional } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createOptionalSchema: (zodOptional: ZodOptional<any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/pipeline.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodPipeline } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createPipelineSchema: (zodPipeline: ZodPipeline<any, any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/preprocess.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodEffects } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createPreprocessSchema: (zodPreprocess: ZodEffects<any, any, any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/record.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodRecord } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createRecordSchema: (zodRecord: ZodRecord<any, any>, state: SchemaState) => oas31.SchemaObject;

package/lib-types/create/schema/refine.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodEffects } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createRefineSchema: (zodRefine: ZodEffects<any, any, any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/string.d.ts

@@ -1,3 +1,3 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodString } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 export declare const createStringSchema: (zodString: ZodString) => oas31.SchemaObject;

package/lib-types/create/schema/transform.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodEffects } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createTransformSchema: (zodTransform: ZodEffects<any, any, any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/tuple.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodTuple } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createTupleSchema: (zodTuple: ZodTuple<any, any>, state: SchemaState) => oas31.SchemaObject;

package/lib-types/create/schema/union.d.ts

@@ -1,4 +1,4 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodUnion } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 import { SchemaState } from '.';
 export declare const createUnionSchema: (zodUnion: ZodUnion<any>, state: SchemaState) => oas31.SchemaObject;

package/lib-types/create/schema/unknown.d.ts

@@ -1,3 +1,3 @@
-import { oas31 } from 'openapi3-ts';
 import { ZodUnknown } from 'zod';
+import { oas31 } from '../../openapi3-ts/dist';
 export declare const createUnknownSchema: (_zodUnknown: ZodUnknown) => oas31.SchemaObject;

package/lib-types/extendZod.d.ts

@@ -1,6 +1,6 @@
-import { oas30, oas31 } from 'openapi3-ts';
 import { UnknownKeysParam, ZodDate, ZodObject, ZodRawShape, ZodTypeAny, z } from 'zod';
 import { CreationType } from './create/components';
+import { oas30, oas31 } from './openapi3-ts/dist';
 type SchemaObject = oas30.SchemaObject & oas31.SchemaObject;
 interface ZodOpenApiMetadata<T extends ZodTypeAny, TInferred = z.infer<T>> extends SchemaObject {
     example?: TInferred;

package/lib-types/index.d.ts

@@ -1,2 +1,3 @@
 export * from './create/document';
 export * from './extendZod';
+export * from './openapi3-ts/dist';

package/lib-types/openapi3-ts/dist/dsl/openapi-builder30.d.ts

@@ -0,0 +1,31 @@
+import * as oa from '../model/openapi30';
+export declare class OpenApiBuilder {
+    rootDoc: oa.OpenAPIObject;
+    static create(doc?: oa.OpenAPIObject): OpenApiBuilder;
+    constructor(doc?: oa.OpenAPIObject);
+    getSpec(): oa.OpenAPIObject;
+    getSpecAsJson(replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
+    getSpecAsYaml(): string;
+    private static isValidOpenApiVersion;
+    addOpenApiVersion(openApiVersion: string): OpenApiBuilder;
+    addInfo(info: oa.InfoObject): OpenApiBuilder;
+    addContact(contact: oa.ContactObject): OpenApiBuilder;
+    addLicense(license: oa.LicenseObject): OpenApiBuilder;
+    addTitle(title: string): OpenApiBuilder;
+    addDescription(description: string): OpenApiBuilder;
+    addTermsOfService(termsOfService: string): OpenApiBuilder;
+    addVersion(version: string): OpenApiBuilder;
+    addPath(path: string, pathItem: oa.PathItemObject): OpenApiBuilder;
+    addSchema(name: string, schema: oa.SchemaObject | oa.ReferenceObject): OpenApiBuilder;
+    addResponse(name: string, response: oa.ResponseObject | oa.ReferenceObject): OpenApiBuilder;
+    addParameter(name: string, parameter: oa.ParameterObject | oa.ReferenceObject): OpenApiBuilder;
+    addExample(name: string, example: oa.ExampleObject | oa.ReferenceObject): OpenApiBuilder;
+    addRequestBody(name: string, reqBody: oa.RequestBodyObject | oa.ReferenceObject): OpenApiBuilder;
+    addHeader(name: string, header: oa.HeaderObject | oa.ReferenceObject): OpenApiBuilder;
+    addSecurityScheme(name: string, secScheme: oa.SecuritySchemeObject | oa.ReferenceObject): OpenApiBuilder;
+    addLink(name: string, link: oa.LinkObject | oa.ReferenceObject): OpenApiBuilder;
+    addCallback(name: string, callback: oa.CallbackObject | oa.ReferenceObject): OpenApiBuilder;
+    addServer(server: oa.ServerObject): OpenApiBuilder;
+    addTag(tag: oa.TagObject): OpenApiBuilder;
+    addExternalDocs(extDoc: oa.ExternalDocumentationObject): OpenApiBuilder;
+}

package/lib-types/openapi3-ts/dist/dsl/openapi-builder31.d.ts

@@ -0,0 +1,32 @@
+import * as oa from '../model/openapi31';
+export declare class OpenApiBuilder {
+    rootDoc: oa.OpenAPIObject;
+    static create(doc?: oa.OpenAPIObject): OpenApiBuilder;
+    constructor(doc?: oa.OpenAPIObject);
+    getSpec(): oa.OpenAPIObject;
+    getSpecAsJson(replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
+    getSpecAsYaml(): string;
+    private static isValidOpenApiVersion;
+    addOpenApiVersion(openApiVersion: string): OpenApiBuilder;
+    addInfo(info: oa.InfoObject): OpenApiBuilder;
+    addContact(contact: oa.ContactObject): OpenApiBuilder;
+    addLicense(license: oa.LicenseObject): OpenApiBuilder;
+    addTitle(title: string): OpenApiBuilder;
+    addDescription(description: string): OpenApiBuilder;
+    addTermsOfService(termsOfService: string): OpenApiBuilder;
+    addVersion(version: string): OpenApiBuilder;
+    addPath(path: string, pathItem: oa.PathItemObject): OpenApiBuilder;
+    addSchema(name: string, schema: oa.SchemaObject | oa.ReferenceObject): OpenApiBuilder;
+    addResponse(name: string, response: oa.ResponseObject | oa.ReferenceObject): OpenApiBuilder;
+    addParameter(name: string, parameter: oa.ParameterObject | oa.ReferenceObject): OpenApiBuilder;
+    addExample(name: string, example: oa.ExampleObject | oa.ReferenceObject): OpenApiBuilder;
+    addRequestBody(name: string, reqBody: oa.RequestBodyObject | oa.ReferenceObject): OpenApiBuilder;
+    addHeader(name: string, header: oa.HeaderObject | oa.ReferenceObject): OpenApiBuilder;
+    addSecurityScheme(name: string, secScheme: oa.SecuritySchemeObject | oa.ReferenceObject): OpenApiBuilder;
+    addLink(name: string, link: oa.LinkObject | oa.ReferenceObject): OpenApiBuilder;
+    addCallback(name: string, callback: oa.CallbackObject | oa.ReferenceObject): OpenApiBuilder;
+    addServer(server: oa.ServerObject): OpenApiBuilder;
+    addTag(tag: oa.TagObject): OpenApiBuilder;
+    addExternalDocs(extDoc: oa.ExternalDocumentationObject): OpenApiBuilder;
+    addWebhook(webhook: string, webhookItem: oa.PathItemObject): OpenApiBuilder;
+}

package/lib-types/openapi3-ts/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * as oas30 from "./oas30";
+export * as oas31 from "./oas31";
+export { Server, ServerVariable } from "./model/server";

package/lib-types/openapi3-ts/dist/model/oas-common.d.ts

@@ -0,0 +1,15 @@
+import { ISpecificationExtension } from './specification-extension';
+export interface ServerObject extends ISpecificationExtension {
+    url: string;
+    description?: string;
+    variables?: {
+        [v: string]: ServerVariableObject;
+    };
+}
+export interface ServerVariableObject extends ISpecificationExtension {
+    enum?: string[] | boolean[] | number[];
+    default: string | boolean | number;
+    description?: string;
+}
+export declare function getExtension(obj: ISpecificationExtension | undefined, extensionName: string): any;
+export declare function addExtension(obj: ISpecificationExtension | undefined, extensionName: string, extension: any): void;

package/lib-types/openapi3-ts/dist/model/openapi30.d.ts

@@ -0,0 +1,291 @@
+import { ServerObject } from './oas-common';
+import { ISpecificationExtension } from './specification-extension';
+export * from './oas-common';
+export type { ISpecificationExtension, SpecificationExtension } from './specification-extension';
+export interface OpenAPIObject extends ISpecificationExtension {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+export interface InfoObject extends ISpecificationExtension {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+export interface ContactObject extends ISpecificationExtension {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface LicenseObject extends ISpecificationExtension {
+    name: string;
+    url?: string;
+}
+export interface ComponentsObject extends ISpecificationExtension {
+    schemas?: {
+        [schema: string]: SchemaObject | ReferenceObject;
+    };
+    responses?: {
+        [response: string]: ResponseObject | ReferenceObject;
+    };
+    parameters?: {
+        [parameter: string]: ParameterObject | ReferenceObject;
+    };
+    examples?: {
+        [example: string]: ExampleObject | ReferenceObject;
+    };
+    requestBodies?: {
+        [request: string]: RequestBodyObject | ReferenceObject;
+    };
+    headers?: {
+        [header: string]: HeaderObject | ReferenceObject;
+    };
+    securitySchemes?: {
+        [securityScheme: string]: SecuritySchemeObject | ReferenceObject;
+    };
+    links?: {
+        [link: string]: LinkObject | ReferenceObject;
+    };
+    callbacks?: {
+        [callback: string]: CallbackObject | ReferenceObject;
+    };
+}
+export interface PathsObject extends ISpecificationExtension {
+    [path: string]: PathItemObject;
+}
+export type PathObject = PathsObject;
+export declare function getPath(pathsObject: PathsObject, path: string): PathItemObject | undefined;
+export interface PathItemObject extends ISpecificationExtension {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    servers?: ServerObject[];
+    parameters?: (ParameterObject | ReferenceObject)[];
+}
+export interface OperationObject extends ISpecificationExtension {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses: ResponsesObject;
+    callbacks?: CallbacksObject;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+}
+export interface ExternalDocumentationObject extends ISpecificationExtension {
+    description?: string;
+    url: string;
+}
+export type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+export type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+export interface BaseParameterObject extends ISpecificationExtension {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: SchemaObject | ReferenceObject;
+    examples?: {
+        [param: string]: ExampleObject | ReferenceObject;
+    };
+    example?: any;
+    content?: ContentObject;
+}
+export interface ParameterObject extends BaseParameterObject {
+    name: string;
+    in: ParameterLocation;
+}
+export interface RequestBodyObject extends ISpecificationExtension {
+    description?: string;
+    content: ContentObject;
+    required?: boolean;
+}
+export interface ContentObject {
+    [mediatype: string]: MediaTypeObject;
+}
+export interface MediaTypeObject extends ISpecificationExtension {
+    schema?: SchemaObject | ReferenceObject;
+    examples?: ExamplesObject;
+    example?: any;
+    encoding?: EncodingObject;
+}
+export interface EncodingObject extends ISpecificationExtension {
+    [property: string]: EncodingPropertyObject | any;
+}
+export interface EncodingPropertyObject {
+    contentType?: string;
+    headers?: {
+        [key: string]: HeaderObject | ReferenceObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    [key: string]: any;
+}
+export interface ResponsesObject extends ISpecificationExtension {
+    default?: ResponseObject | ReferenceObject;
+    [statuscode: string]: ResponseObject | ReferenceObject | any;
+}
+export interface ResponseObject extends ISpecificationExtension {
+    description: string;
+    headers?: HeadersObject;
+    content?: ContentObject;
+    links?: LinksObject;
+}
+export interface CallbacksObject extends ISpecificationExtension {
+    [name: string]: CallbackObject | ReferenceObject | any;
+}
+export interface CallbackObject extends ISpecificationExtension {
+    [name: string]: PathItemObject | any;
+}
+export interface HeadersObject {
+    [name: string]: HeaderObject | ReferenceObject;
+}
+export interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+    [property: string]: any;
+}
+export interface LinksObject {
+    [name: string]: LinkObject | ReferenceObject;
+}
+export interface LinkObject extends ISpecificationExtension {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: LinkParametersObject;
+    requestBody?: any | string;
+    description?: string;
+    server?: ServerObject;
+    [property: string]: any;
+}
+export interface LinkParametersObject {
+    [name: string]: any | string;
+}
+export interface HeaderObject extends BaseParameterObject {
+    $ref?: string;
+}
+export interface TagObject extends ISpecificationExtension {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    [extension: string]: any;
+}
+export interface ExamplesObject {
+    [name: string]: ExampleObject | ReferenceObject;
+}
+export interface ReferenceObject {
+    $ref: string;
+}
+export declare function isReferenceObject(obj: any): obj is ReferenceObject;
+export type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
+export type SchemaObjectFormat = 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string;
+export interface SchemaObject extends ISpecificationExtension {
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XmlObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    examples?: any[];
+    deprecated?: boolean;
+    type?: SchemaObjectType | SchemaObjectType[];
+    format?: SchemaObjectFormat;
+    allOf?: (SchemaObject | ReferenceObject)[];
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    not?: SchemaObject | ReferenceObject;
+    items?: SchemaObject | ReferenceObject;
+    properties?: {
+        [propertyName: string]: SchemaObject | ReferenceObject;
+    };
+    additionalProperties?: SchemaObject | ReferenceObject | boolean;
+    description?: string;
+    default?: any;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+}
+export declare function isSchemaObject(schema: SchemaObject | ReferenceObject): schema is SchemaObject;
+export interface SchemasObject {
+    [schema: string]: SchemaObject;
+}
+export interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+        [key: string]: string;
+    };
+}
+export interface XmlObject extends ISpecificationExtension {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+export type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+export interface SecuritySchemeObject extends ISpecificationExtension {
+    type: SecuritySchemeType;
+    description?: string;
+    name?: string;
+    in?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OAuthFlowsObject;
+    openIdConnectUrl?: string;
+}
+export interface OAuthFlowsObject extends ISpecificationExtension {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+}
+export interface OAuthFlowObject extends ISpecificationExtension {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: ScopesObject;
+}
+export interface ScopesObject extends ISpecificationExtension {
+    [scope: string]: any;
+}
+export interface SecurityRequirementObject {
+    [name: string]: string[];
+}