zod-openapi 2.18.0 → 2.19.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,1055 @@
+import { ZodType, AnyZodObject, ZodTypeDef, ZodTypeAny, z, ZodDate, ZodObject } from 'zod';
+
+type IExtensionName = `x-${string}`;
+type IExtensionType = any;
+type ISpecificationExtension = {
+    [extensionName: IExtensionName]: IExtensionType;
+};
+declare class SpecificationExtension implements ISpecificationExtension {
+    [extensionName: IExtensionName]: any;
+    static isValidExtension(extensionName: string): boolean;
+    getExtension(extensionName: string): any;
+    addExtension(extensionName: string, payload: any): void;
+    listExtensions(): string[];
+}
+
+interface ServerObject extends ISpecificationExtension {
+    url: string;
+    description?: string;
+    variables?: {
+        [v: string]: ServerVariableObject;
+    };
+}
+interface ServerVariableObject extends ISpecificationExtension {
+    enum?: string[] | boolean[] | number[];
+    default: string | boolean | number;
+    description?: string;
+}
+declare function getExtension(obj: ISpecificationExtension | undefined, extensionName: string): any;
+declare function addExtension(obj: ISpecificationExtension | undefined, extensionName: string, extension: any): void;
+
+interface OpenAPIObject$1 extends ISpecificationExtension {
+    openapi: string;
+    info: InfoObject$1;
+    servers?: ServerObject[];
+    paths: PathsObject$1;
+    components?: ComponentsObject$2;
+    security?: SecurityRequirementObject$1[];
+    tags?: TagObject$1[];
+    externalDocs?: ExternalDocumentationObject$1;
+}
+interface InfoObject$1 extends ISpecificationExtension {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject$1;
+    license?: LicenseObject$1;
+    version: string;
+}
+interface ContactObject$1 extends ISpecificationExtension {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+interface LicenseObject$1 extends ISpecificationExtension {
+    name: string;
+    url?: string;
+}
+interface ComponentsObject$2 extends ISpecificationExtension {
+    schemas?: {
+        [schema: string]: SchemaObject$2 | ReferenceObject$1;
+    };
+    responses?: {
+        [response: string]: ResponseObject$1 | ReferenceObject$1;
+    };
+    parameters?: {
+        [parameter: string]: ParameterObject$1 | ReferenceObject$1;
+    };
+    examples?: {
+        [example: string]: ExampleObject$1 | ReferenceObject$1;
+    };
+    requestBodies?: {
+        [request: string]: RequestBodyObject$1 | ReferenceObject$1;
+    };
+    headers?: {
+        [header: string]: HeaderObject$1 | ReferenceObject$1;
+    };
+    securitySchemes?: {
+        [securityScheme: string]: SecuritySchemeObject$1 | ReferenceObject$1;
+    };
+    links?: {
+        [link: string]: LinkObject$1 | ReferenceObject$1;
+    };
+    callbacks?: {
+        [callback: string]: CallbackObject$1 | ReferenceObject$1;
+    };
+}
+interface PathsObject$1 extends ISpecificationExtension {
+    [path: string]: PathItemObject$1;
+}
+type PathObject$1 = PathsObject$1;
+declare function getPath$1(pathsObject: PathsObject$1, path: string): PathItemObject$1 | undefined;
+interface PathItemObject$1 extends ISpecificationExtension {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject$1;
+    put?: OperationObject$1;
+    post?: OperationObject$1;
+    delete?: OperationObject$1;
+    options?: OperationObject$1;
+    head?: OperationObject$1;
+    patch?: OperationObject$1;
+    trace?: OperationObject$1;
+    servers?: ServerObject[];
+    parameters?: (ParameterObject$1 | ReferenceObject$1)[];
+}
+interface OperationObject$1 extends ISpecificationExtension {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject$1;
+    operationId?: string;
+    parameters?: (ParameterObject$1 | ReferenceObject$1)[];
+    requestBody?: RequestBodyObject$1 | ReferenceObject$1;
+    responses: ResponsesObject$1;
+    callbacks?: CallbacksObject$1;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject$1[];
+    servers?: ServerObject[];
+}
+interface ExternalDocumentationObject$1 extends ISpecificationExtension {
+    description?: string;
+    url: string;
+}
+type ParameterLocation$1 = 'query' | 'header' | 'path' | 'cookie';
+type ParameterStyle$1 = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+interface BaseParameterObject$1 extends ISpecificationExtension {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: ParameterStyle$1;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: SchemaObject$2 | ReferenceObject$1;
+    examples?: {
+        [param: string]: ExampleObject$1 | ReferenceObject$1;
+    };
+    example?: any;
+    content?: ContentObject$1;
+}
+interface ParameterObject$1 extends BaseParameterObject$1 {
+    name: string;
+    in: ParameterLocation$1;
+}
+interface RequestBodyObject$1 extends ISpecificationExtension {
+    description?: string;
+    content: ContentObject$1;
+    required?: boolean;
+}
+interface ContentObject$1 {
+    [mediatype: string]: MediaTypeObject$1;
+}
+interface MediaTypeObject$1 extends ISpecificationExtension {
+    schema?: SchemaObject$2 | ReferenceObject$1;
+    examples?: ExamplesObject$1;
+    example?: any;
+    encoding?: EncodingObject$1;
+}
+interface EncodingObject$1 extends ISpecificationExtension {
+    [property: string]: EncodingPropertyObject$1 | any;
+}
+interface EncodingPropertyObject$1 {
+    contentType?: string;
+    headers?: {
+        [key: string]: HeaderObject$1 | ReferenceObject$1;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    [key: string]: any;
+}
+interface ResponsesObject$1 extends ISpecificationExtension {
+    default?: ResponseObject$1 | ReferenceObject$1;
+    [statuscode: string]: ResponseObject$1 | ReferenceObject$1 | any;
+}
+interface ResponseObject$1 extends ISpecificationExtension {
+    description: string;
+    headers?: HeadersObject$1;
+    content?: ContentObject$1;
+    links?: LinksObject$1;
+}
+interface CallbacksObject$1 extends ISpecificationExtension {
+    [name: string]: CallbackObject$1 | ReferenceObject$1 | any;
+}
+interface CallbackObject$1 extends ISpecificationExtension {
+    [name: string]: PathItemObject$1 | any;
+}
+interface HeadersObject$1 {
+    [name: string]: HeaderObject$1 | ReferenceObject$1;
+}
+interface ExampleObject$1 {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+    [property: string]: any;
+}
+interface LinksObject$1 {
+    [name: string]: LinkObject$1 | ReferenceObject$1;
+}
+interface LinkObject$1 extends ISpecificationExtension {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: LinkParametersObject$1;
+    requestBody?: any | string;
+    description?: string;
+    server?: ServerObject;
+    [property: string]: any;
+}
+interface LinkParametersObject$1 {
+    [name: string]: any | string;
+}
+interface HeaderObject$1 extends BaseParameterObject$1 {
+    $ref?: string;
+}
+interface TagObject$1 extends ISpecificationExtension {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject$1;
+    [extension: string]: any;
+}
+interface ExamplesObject$1 {
+    [name: string]: ExampleObject$1 | ReferenceObject$1;
+}
+interface ReferenceObject$1 {
+    $ref: string;
+}
+declare function isReferenceObject$1(obj: any): obj is ReferenceObject$1;
+type SchemaObjectType$1 = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
+type SchemaObjectFormat = 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string;
+interface SchemaObject$2 extends ISpecificationExtension {
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject$1;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XmlObject$1;
+    externalDocs?: ExternalDocumentationObject$1;
+    example?: any;
+    examples?: any[];
+    deprecated?: boolean;
+    type?: SchemaObjectType$1 | SchemaObjectType$1[];
+    format?: SchemaObjectFormat;
+    allOf?: (SchemaObject$2 | ReferenceObject$1)[];
+    oneOf?: (SchemaObject$2 | ReferenceObject$1)[];
+    anyOf?: (SchemaObject$2 | ReferenceObject$1)[];
+    not?: SchemaObject$2 | ReferenceObject$1;
+    items?: SchemaObject$2 | ReferenceObject$1;
+    properties?: {
+        [propertyName: string]: SchemaObject$2 | ReferenceObject$1;
+    };
+    additionalProperties?: SchemaObject$2 | ReferenceObject$1 | 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[];
+}
+declare function isSchemaObject$1(schema: SchemaObject$2 | ReferenceObject$1): schema is SchemaObject$2;
+interface SchemasObject$1 {
+    [schema: string]: SchemaObject$2;
+}
+interface DiscriminatorObject$1 {
+    propertyName: string;
+    mapping?: {
+        [key: string]: string;
+    };
+}
+interface XmlObject$1 extends ISpecificationExtension {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+type SecuritySchemeType$1 = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+interface SecuritySchemeObject$1 extends ISpecificationExtension {
+    type: SecuritySchemeType$1;
+    description?: string;
+    name?: string;
+    in?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OAuthFlowsObject$1;
+    openIdConnectUrl?: string;
+}
+interface OAuthFlowsObject$1 extends ISpecificationExtension {
+    implicit?: OAuthFlowObject$1;
+    password?: OAuthFlowObject$1;
+    clientCredentials?: OAuthFlowObject$1;
+    authorizationCode?: OAuthFlowObject$1;
+}
+interface OAuthFlowObject$1 extends ISpecificationExtension {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: ScopesObject$1;
+}
+interface ScopesObject$1 extends ISpecificationExtension {
+    [scope: string]: any;
+}
+interface SecurityRequirementObject$1 {
+    [name: string]: string[];
+}
+
+declare class OpenApiBuilder$1 {
+    rootDoc: OpenAPIObject$1;
+    static create(doc?: OpenAPIObject$1): OpenApiBuilder$1;
+    constructor(doc?: OpenAPIObject$1);
+    getSpec(): OpenAPIObject$1;
+    getSpecAsJson(replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
+    getSpecAsYaml(): string;
+    private static isValidOpenApiVersion;
+    addOpenApiVersion(openApiVersion: string): OpenApiBuilder$1;
+    addInfo(info: InfoObject$1): OpenApiBuilder$1;
+    addContact(contact: ContactObject$1): OpenApiBuilder$1;
+    addLicense(license: LicenseObject$1): OpenApiBuilder$1;
+    addTitle(title: string): OpenApiBuilder$1;
+    addDescription(description: string): OpenApiBuilder$1;
+    addTermsOfService(termsOfService: string): OpenApiBuilder$1;
+    addVersion(version: string): OpenApiBuilder$1;
+    addPath(path: string, pathItem: PathItemObject$1): OpenApiBuilder$1;
+    addSchema(name: string, schema: SchemaObject$2 | ReferenceObject$1): OpenApiBuilder$1;
+    addResponse(name: string, response: ResponseObject$1 | ReferenceObject$1): OpenApiBuilder$1;
+    addParameter(name: string, parameter: ParameterObject$1 | ReferenceObject$1): OpenApiBuilder$1;
+    addExample(name: string, example: ExampleObject$1 | ReferenceObject$1): OpenApiBuilder$1;
+    addRequestBody(name: string, reqBody: RequestBodyObject$1 | ReferenceObject$1): OpenApiBuilder$1;
+    addHeader(name: string, header: HeaderObject$1 | ReferenceObject$1): OpenApiBuilder$1;
+    addSecurityScheme(name: string, secScheme: SecuritySchemeObject$1 | ReferenceObject$1): OpenApiBuilder$1;
+    addLink(name: string, link: LinkObject$1 | ReferenceObject$1): OpenApiBuilder$1;
+    addCallback(name: string, callback: CallbackObject$1 | ReferenceObject$1): OpenApiBuilder$1;
+    addServer(server: ServerObject): OpenApiBuilder$1;
+    addTag(tag: TagObject$1): OpenApiBuilder$1;
+    addExternalDocs(extDoc: ExternalDocumentationObject$1): OpenApiBuilder$1;
+}
+
+declare class Server implements ServerObject {
+    url: string;
+    description?: string;
+    variables: {
+        [v: string]: ServerVariable;
+    };
+    [k: IExtensionName]: IExtensionType;
+    constructor(url: string, desc?: string);
+    addVariable(name: string, variable: ServerVariable): void;
+}
+declare class ServerVariable implements ServerVariableObject {
+    enum?: string[] | boolean[] | number[];
+    default: string | boolean | number;
+    description?: string;
+    [k: IExtensionName]: IExtensionType;
+    constructor(defaultValue: string | boolean | number, enums?: string[] | boolean[] | number[], description?: string);
+}
+
+type oas30_IExtensionName = IExtensionName;
+type oas30_IExtensionType = IExtensionType;
+type oas30_ISpecificationExtension = ISpecificationExtension;
+type oas30_SchemaObjectFormat = SchemaObjectFormat;
+type oas30_Server = Server;
+declare const oas30_Server: typeof Server;
+type oas30_ServerObject = ServerObject;
+type oas30_ServerVariable = ServerVariable;
+declare const oas30_ServerVariable: typeof ServerVariable;
+type oas30_ServerVariableObject = ServerVariableObject;
+type oas30_SpecificationExtension = SpecificationExtension;
+declare const oas30_SpecificationExtension: typeof SpecificationExtension;
+declare const oas30_addExtension: typeof addExtension;
+declare const oas30_getExtension: typeof getExtension;
+declare namespace oas30 {
+  export { type BaseParameterObject$1 as BaseParameterObject, type CallbackObject$1 as CallbackObject, type CallbacksObject$1 as CallbacksObject, type ComponentsObject$2 as ComponentsObject, type ContactObject$1 as ContactObject, type ContentObject$1 as ContentObject, type DiscriminatorObject$1 as DiscriminatorObject, type EncodingObject$1 as EncodingObject, type EncodingPropertyObject$1 as EncodingPropertyObject, type ExampleObject$1 as ExampleObject, type ExamplesObject$1 as ExamplesObject, type ExternalDocumentationObject$1 as ExternalDocumentationObject, type HeaderObject$1 as HeaderObject, type HeadersObject$1 as HeadersObject, type oas30_IExtensionName as IExtensionName, type oas30_IExtensionType as IExtensionType, type oas30_ISpecificationExtension as ISpecificationExtension, type InfoObject$1 as InfoObject, type LicenseObject$1 as LicenseObject, type LinkObject$1 as LinkObject, type LinkParametersObject$1 as LinkParametersObject, type LinksObject$1 as LinksObject, type MediaTypeObject$1 as MediaTypeObject, type OAuthFlowObject$1 as OAuthFlowObject, type OAuthFlowsObject$1 as OAuthFlowsObject, type OpenAPIObject$1 as OpenAPIObject, OpenApiBuilder$1 as OpenApiBuilder, type OperationObject$1 as OperationObject, type ParameterLocation$1 as ParameterLocation, type ParameterObject$1 as ParameterObject, type ParameterStyle$1 as ParameterStyle, type PathItemObject$1 as PathItemObject, type PathObject$1 as PathObject, type PathsObject$1 as PathsObject, type ReferenceObject$1 as ReferenceObject, type RequestBodyObject$1 as RequestBodyObject, type ResponseObject$1 as ResponseObject, type ResponsesObject$1 as ResponsesObject, type SchemaObject$2 as SchemaObject, type oas30_SchemaObjectFormat as SchemaObjectFormat, type SchemaObjectType$1 as SchemaObjectType, type SchemasObject$1 as SchemasObject, type ScopesObject$1 as ScopesObject, type SecurityRequirementObject$1 as SecurityRequirementObject, type SecuritySchemeObject$1 as SecuritySchemeObject, type SecuritySchemeType$1 as SecuritySchemeType, oas30_Server as Server, type oas30_ServerObject as ServerObject, oas30_ServerVariable as ServerVariable, type oas30_ServerVariableObject as ServerVariableObject, oas30_SpecificationExtension as SpecificationExtension, type TagObject$1 as TagObject, type XmlObject$1 as XmlObject, oas30_addExtension as addExtension, oas30_getExtension as getExtension, getPath$1 as getPath, isReferenceObject$1 as isReferenceObject, isSchemaObject$1 as isSchemaObject };
+}
+
+interface OpenAPIObject extends ISpecificationExtension {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths?: PathsObject;
+    components?: ComponentsObject$1;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    webhooks?: PathsObject;
+}
+interface InfoObject extends ISpecificationExtension {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+interface ContactObject extends ISpecificationExtension {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+interface LicenseObject extends ISpecificationExtension {
+    name: string;
+    identifier?: string;
+    url?: string;
+}
+interface ComponentsObject$1 extends ISpecificationExtension {
+    schemas?: {
+        [schema: string]: SchemaObject$1 | 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;
+    };
+}
+interface PathsObject extends ISpecificationExtension {
+    [path: string]: PathItemObject;
+}
+type PathObject = PathsObject;
+declare function getPath(pathsObject: PathsObject | undefined, path: string): PathItemObject | undefined;
+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)[];
+}
+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[];
+}
+interface ExternalDocumentationObject extends ISpecificationExtension {
+    description?: string;
+    url: string;
+}
+type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+interface BaseParameterObject extends ISpecificationExtension {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: SchemaObject$1 | ReferenceObject;
+    examples?: {
+        [param: string]: ExampleObject | ReferenceObject;
+    };
+    example?: any;
+    content?: ContentObject;
+}
+interface ParameterObject extends BaseParameterObject {
+    name: string;
+    in: ParameterLocation;
+}
+interface RequestBodyObject extends ISpecificationExtension {
+    description?: string;
+    content: ContentObject;
+    required?: boolean;
+}
+interface ContentObject {
+    [mediatype: string]: MediaTypeObject;
+}
+interface MediaTypeObject extends ISpecificationExtension {
+    schema?: SchemaObject$1 | ReferenceObject;
+    examples?: ExamplesObject;
+    example?: any;
+    encoding?: EncodingObject;
+}
+interface EncodingObject extends ISpecificationExtension {
+    [property: string]: EncodingPropertyObject | any;
+}
+interface EncodingPropertyObject {
+    contentType?: string;
+    headers?: {
+        [key: string]: HeaderObject | ReferenceObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    [key: string]: any;
+}
+interface ResponsesObject extends ISpecificationExtension {
+    default?: ResponseObject | ReferenceObject;
+    [statuscode: string]: ResponseObject | ReferenceObject | any;
+}
+interface ResponseObject extends ISpecificationExtension {
+    description: string;
+    headers?: HeadersObject;
+    content?: ContentObject;
+    links?: LinksObject;
+}
+interface CallbacksObject extends ISpecificationExtension {
+    [name: string]: CallbackObject | ReferenceObject | any;
+}
+interface CallbackObject extends ISpecificationExtension {
+    [name: string]: PathItemObject | any;
+}
+interface HeadersObject {
+    [name: string]: HeaderObject | ReferenceObject;
+}
+interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+    [property: string]: any;
+}
+interface LinksObject {
+    [name: string]: LinkObject | ReferenceObject;
+}
+interface LinkObject extends ISpecificationExtension {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: LinkParametersObject;
+    requestBody?: any | string;
+    description?: string;
+    server?: ServerObject;
+    [property: string]: any;
+}
+interface LinkParametersObject {
+    [name: string]: any | string;
+}
+interface HeaderObject extends BaseParameterObject {
+    $ref?: string;
+}
+interface TagObject extends ISpecificationExtension {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    [extension: string]: any;
+}
+interface ExamplesObject {
+    [name: string]: ExampleObject | ReferenceObject;
+}
+interface ReferenceObject {
+    $ref: string;
+    summary?: string;
+    description?: string;
+}
+declare function isReferenceObject(obj: any): obj is ReferenceObject;
+type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
+interface SchemaObject$1 extends ISpecificationExtension {
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XmlObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    examples?: any[];
+    deprecated?: boolean;
+    type?: SchemaObjectType | SchemaObjectType[];
+    format?: 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string;
+    allOf?: (SchemaObject$1 | ReferenceObject)[];
+    oneOf?: (SchemaObject$1 | ReferenceObject)[];
+    anyOf?: (SchemaObject$1 | ReferenceObject)[];
+    not?: SchemaObject$1 | ReferenceObject;
+    items?: SchemaObject$1 | ReferenceObject;
+    properties?: {
+        [propertyName: string]: SchemaObject$1 | ReferenceObject;
+    };
+    additionalProperties?: SchemaObject$1 | ReferenceObject | boolean;
+    propertyNames?: SchemaObject$1 | ReferenceObject;
+    description?: string;
+    default?: any;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    const?: any;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    prefixItems?: (SchemaObject$1 | ReferenceObject)[];
+    contentMediaType?: string;
+    contentEncoding?: string;
+}
+declare function isSchemaObject(schema: SchemaObject$1 | ReferenceObject): schema is SchemaObject$1;
+interface SchemasObject {
+    [schema: string]: SchemaObject$1;
+}
+interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+        [key: string]: string;
+    };
+}
+interface XmlObject extends ISpecificationExtension {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+interface SecuritySchemeObject extends ISpecificationExtension {
+    type: SecuritySchemeType;
+    description?: string;
+    name?: string;
+    in?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OAuthFlowsObject;
+    openIdConnectUrl?: string;
+}
+interface OAuthFlowsObject extends ISpecificationExtension {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+}
+interface OAuthFlowObject extends ISpecificationExtension {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: ScopesObject;
+}
+interface ScopesObject extends ISpecificationExtension {
+    [scope: string]: any;
+}
+interface SecurityRequirementObject {
+    [name: string]: string[];
+}
+
+declare class OpenApiBuilder {
+    rootDoc: OpenAPIObject;
+    static create(doc?: OpenAPIObject): OpenApiBuilder;
+    constructor(doc?: OpenAPIObject);
+    getSpec(): OpenAPIObject;
+    getSpecAsJson(replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
+    getSpecAsYaml(): string;
+    private static isValidOpenApiVersion;
+    addOpenApiVersion(openApiVersion: string): OpenApiBuilder;
+    addInfo(info: InfoObject): OpenApiBuilder;
+    addContact(contact: ContactObject): OpenApiBuilder;
+    addLicense(license: LicenseObject): OpenApiBuilder;
+    addTitle(title: string): OpenApiBuilder;
+    addDescription(description: string): OpenApiBuilder;
+    addTermsOfService(termsOfService: string): OpenApiBuilder;
+    addVersion(version: string): OpenApiBuilder;
+    addPath(path: string, pathItem: PathItemObject): OpenApiBuilder;
+    addSchema(name: string, schema: SchemaObject$1 | ReferenceObject): OpenApiBuilder;
+    addResponse(name: string, response: ResponseObject | ReferenceObject): OpenApiBuilder;
+    addParameter(name: string, parameter: ParameterObject | ReferenceObject): OpenApiBuilder;
+    addExample(name: string, example: ExampleObject | ReferenceObject): OpenApiBuilder;
+    addRequestBody(name: string, reqBody: RequestBodyObject | ReferenceObject): OpenApiBuilder;
+    addHeader(name: string, header: HeaderObject | ReferenceObject): OpenApiBuilder;
+    addSecurityScheme(name: string, secScheme: SecuritySchemeObject | ReferenceObject): OpenApiBuilder;
+    addLink(name: string, link: LinkObject | ReferenceObject): OpenApiBuilder;
+    addCallback(name: string, callback: CallbackObject | ReferenceObject): OpenApiBuilder;
+    addServer(server: ServerObject): OpenApiBuilder;
+    addTag(tag: TagObject): OpenApiBuilder;
+    addExternalDocs(extDoc: ExternalDocumentationObject): OpenApiBuilder;
+    addWebhook(webhook: string, webhookItem: PathItemObject): OpenApiBuilder;
+}
+
+type oas31_BaseParameterObject = BaseParameterObject;
+type oas31_CallbackObject = CallbackObject;
+type oas31_CallbacksObject = CallbacksObject;
+type oas31_ContactObject = ContactObject;
+type oas31_ContentObject = ContentObject;
+type oas31_DiscriminatorObject = DiscriminatorObject;
+type oas31_EncodingObject = EncodingObject;
+type oas31_EncodingPropertyObject = EncodingPropertyObject;
+type oas31_ExampleObject = ExampleObject;
+type oas31_ExamplesObject = ExamplesObject;
+type oas31_ExternalDocumentationObject = ExternalDocumentationObject;
+type oas31_HeaderObject = HeaderObject;
+type oas31_HeadersObject = HeadersObject;
+type oas31_IExtensionName = IExtensionName;
+type oas31_IExtensionType = IExtensionType;
+type oas31_ISpecificationExtension = ISpecificationExtension;
+type oas31_InfoObject = InfoObject;
+type oas31_LicenseObject = LicenseObject;
+type oas31_LinkObject = LinkObject;
+type oas31_LinkParametersObject = LinkParametersObject;
+type oas31_LinksObject = LinksObject;
+type oas31_MediaTypeObject = MediaTypeObject;
+type oas31_OAuthFlowObject = OAuthFlowObject;
+type oas31_OAuthFlowsObject = OAuthFlowsObject;
+type oas31_OpenAPIObject = OpenAPIObject;
+type oas31_OpenApiBuilder = OpenApiBuilder;
+declare const oas31_OpenApiBuilder: typeof OpenApiBuilder;
+type oas31_OperationObject = OperationObject;
+type oas31_ParameterLocation = ParameterLocation;
+type oas31_ParameterObject = ParameterObject;
+type oas31_ParameterStyle = ParameterStyle;
+type oas31_PathItemObject = PathItemObject;
+type oas31_PathObject = PathObject;
+type oas31_PathsObject = PathsObject;
+type oas31_ReferenceObject = ReferenceObject;
+type oas31_RequestBodyObject = RequestBodyObject;
+type oas31_ResponseObject = ResponseObject;
+type oas31_ResponsesObject = ResponsesObject;
+type oas31_SchemaObjectType = SchemaObjectType;
+type oas31_SchemasObject = SchemasObject;
+type oas31_ScopesObject = ScopesObject;
+type oas31_SecurityRequirementObject = SecurityRequirementObject;
+type oas31_SecuritySchemeObject = SecuritySchemeObject;
+type oas31_SecuritySchemeType = SecuritySchemeType;
+type oas31_Server = Server;
+declare const oas31_Server: typeof Server;
+type oas31_ServerObject = ServerObject;
+type oas31_ServerVariable = ServerVariable;
+declare const oas31_ServerVariable: typeof ServerVariable;
+type oas31_ServerVariableObject = ServerVariableObject;
+type oas31_SpecificationExtension = SpecificationExtension;
+declare const oas31_SpecificationExtension: typeof SpecificationExtension;
+type oas31_TagObject = TagObject;
+type oas31_XmlObject = XmlObject;
+declare const oas31_addExtension: typeof addExtension;
+declare const oas31_getExtension: typeof getExtension;
+declare const oas31_getPath: typeof getPath;
+declare const oas31_isReferenceObject: typeof isReferenceObject;
+declare const oas31_isSchemaObject: typeof isSchemaObject;
+declare namespace oas31 {
+  export { type oas31_BaseParameterObject as BaseParameterObject, type oas31_CallbackObject as CallbackObject, type oas31_CallbacksObject as CallbacksObject, type ComponentsObject$1 as ComponentsObject, type oas31_ContactObject as ContactObject, type oas31_ContentObject as ContentObject, type oas31_DiscriminatorObject as DiscriminatorObject, type oas31_EncodingObject as EncodingObject, type oas31_EncodingPropertyObject as EncodingPropertyObject, type oas31_ExampleObject as ExampleObject, type oas31_ExamplesObject as ExamplesObject, type oas31_ExternalDocumentationObject as ExternalDocumentationObject, type oas31_HeaderObject as HeaderObject, type oas31_HeadersObject as HeadersObject, type oas31_IExtensionName as IExtensionName, type oas31_IExtensionType as IExtensionType, type oas31_ISpecificationExtension as ISpecificationExtension, type oas31_InfoObject as InfoObject, type oas31_LicenseObject as LicenseObject, type oas31_LinkObject as LinkObject, type oas31_LinkParametersObject as LinkParametersObject, type oas31_LinksObject as LinksObject, type oas31_MediaTypeObject as MediaTypeObject, type oas31_OAuthFlowObject as OAuthFlowObject, type oas31_OAuthFlowsObject as OAuthFlowsObject, type oas31_OpenAPIObject as OpenAPIObject, oas31_OpenApiBuilder as OpenApiBuilder, type oas31_OperationObject as OperationObject, type oas31_ParameterLocation as ParameterLocation, type oas31_ParameterObject as ParameterObject, type oas31_ParameterStyle as ParameterStyle, type oas31_PathItemObject as PathItemObject, type oas31_PathObject as PathObject, type oas31_PathsObject as PathsObject, type oas31_ReferenceObject as ReferenceObject, type oas31_RequestBodyObject as RequestBodyObject, type oas31_ResponseObject as ResponseObject, type oas31_ResponsesObject as ResponsesObject, type SchemaObject$1 as SchemaObject, type oas31_SchemaObjectType as SchemaObjectType, type oas31_SchemasObject as SchemasObject, type oas31_ScopesObject as ScopesObject, type oas31_SecurityRequirementObject as SecurityRequirementObject, type oas31_SecuritySchemeObject as SecuritySchemeObject, type oas31_SecuritySchemeType as SecuritySchemeType, oas31_Server as Server, type oas31_ServerObject as ServerObject, oas31_ServerVariable as ServerVariable, type oas31_ServerVariableObject as ServerVariableObject, oas31_SpecificationExtension as SpecificationExtension, type oas31_TagObject as TagObject, type oas31_XmlObject as XmlObject, oas31_addExtension as addExtension, oas31_getExtension as getExtension, oas31_getPath as getPath, oas31_isReferenceObject as isReferenceObject, oas31_isSchemaObject as isSchemaObject };
+}
+
+declare const openApiVersions: readonly ["3.0.0", "3.0.1", "3.0.2", "3.0.3", "3.1.0"];
+type OpenApiVersion = (typeof openApiVersions)[number];
+
+interface ZodOpenApiMediaTypeObject extends Omit<MediaTypeObject & MediaTypeObject$1, 'schema'> {
+    schema?: ZodType | SchemaObject$1 | ReferenceObject;
+}
+interface ZodOpenApiContentObject {
+    'application/json'?: ZodOpenApiMediaTypeObject;
+    [mediatype: string]: ZodOpenApiMediaTypeObject | undefined;
+}
+interface ZodOpenApiRequestBodyObject extends Omit<RequestBodyObject & RequestBodyObject$1, 'content'> {
+    content: ZodOpenApiContentObject;
+    /** Use this field to auto register this request body as a component */
+    ref?: string;
+}
+interface ZodOpenApiResponseObject extends Omit<ResponseObject & ResponseObject$1, 'content' | 'headers'> {
+    content?: ZodOpenApiContentObject;
+    headers?: AnyZodObject | HeadersObject$1 | HeadersObject;
+    /** Use this field to auto register this response object as a component */
+    ref?: string;
+}
+interface ZodOpenApiResponsesObject extends ISpecificationExtension {
+    default?: ZodOpenApiResponseObject | ReferenceObject | ReferenceObject$1;
+    [statuscode: `${1 | 2 | 3 | 4 | 5}${string}`]: ZodOpenApiResponseObject | ReferenceObject;
+}
+type ZodOpenApiParameters = {
+    [type in ParameterLocation & ParameterLocation$1]?: ZodObjectInputType;
+};
+interface ZodOpenApiCallbacksObject extends ISpecificationExtension {
+    [name: string]: ZodOpenApiCallbackObject;
+}
+interface ZodOpenApiCallbackObject extends ISpecificationExtension {
+    /** Use this field to auto register this callback object as a component */
+    ref?: string;
+    [name: string]: ZodOpenApiPathItemObject | string | undefined;
+}
+interface ZodOpenApiOperationObject extends Omit<OperationObject & OperationObject$1, 'requestBody' | 'responses' | 'parameters' | 'callbacks'> {
+    parameters?: Array<ZodType | ParameterObject | ParameterObject$1 | ReferenceObject | ReferenceObject$1>;
+    requestBody?: ZodOpenApiRequestBodyObject;
+    requestParams?: ZodOpenApiParameters;
+    responses: ZodOpenApiResponsesObject;
+    callbacks?: ZodOpenApiCallbacksObject;
+}
+interface ZodOpenApiPathItemObject extends Omit<PathItemObject & PathItemObject$1, 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'> {
+    get?: ZodOpenApiOperationObject;
+    put?: ZodOpenApiOperationObject;
+    post?: ZodOpenApiOperationObject;
+    delete?: ZodOpenApiOperationObject;
+    options?: ZodOpenApiOperationObject;
+    head?: ZodOpenApiOperationObject;
+    patch?: ZodOpenApiOperationObject;
+    trace?: ZodOpenApiOperationObject;
+}
+interface ZodOpenApiPathsObject extends ISpecificationExtension {
+    [path: string]: ZodOpenApiPathItemObject;
+}
+interface ZodOpenApiComponentsObject extends Omit<ComponentsObject$1 & ComponentsObject$2, 'schemas' | 'responses' | 'requestBodies' | 'headers' | 'parameters'> {
+    parameters?: Record<string, ZodType | ParameterObject | ParameterObject$1 | ReferenceObject | ReferenceObject$1>;
+    schemas?: Record<string, ZodType | SchemaObject$1 | ReferenceObject | SchemaObject$2 | ReferenceObject$1>;
+    requestBodies?: Record<string, ZodOpenApiRequestBodyObject>;
+    headers?: Record<string, ZodType | HeaderObject | HeaderObject$1 | ReferenceObject | ReferenceObject$1>;
+    responses?: Record<string, ZodOpenApiResponseObject>;
+    callbacks?: Record<string, ZodOpenApiCallbackObject>;
+}
+type ZodOpenApiVersion = OpenApiVersion;
+interface ZodOpenApiObject extends Omit<OpenAPIObject, 'openapi' | 'paths' | 'webhooks' | 'components'> {
+    openapi: ZodOpenApiVersion;
+    paths?: ZodOpenApiPathsObject;
+    webhooks?: ZodOpenApiPathsObject;
+    components?: ZodOpenApiComponentsObject;
+}
+type ZodObjectInputType<Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Record<string, unknown>> = ZodType<Output, Def, Input>;
+declare const createDocument: (zodOpenApiObject: ZodOpenApiObject) => OpenAPIObject;
+
+type CreationType = 'input' | 'output';
+type BaseEffect = {
+    zodType: ZodType;
+    path: string[];
+};
+type ComponentEffect = BaseEffect & {
+    type: 'component';
+};
+type SchemaEffect = BaseEffect & {
+    type: 'schema';
+    creationType: CreationType;
+};
+type Effect = ComponentEffect | SchemaEffect;
+type ResolvedEffect = {
+    creationType: CreationType;
+    path: string[];
+    zodType: ZodType;
+    component?: {
+        ref: string;
+        zodType: ZodType;
+        path: string[];
+    };
+};
+interface CompleteSchemaComponent extends BaseSchemaComponent {
+    type: 'complete';
+    schemaObject: SchemaObject$1 | ReferenceObject | SchemaObject$2 | ReferenceObject$1;
+    /** Set when the created schemaObject is specific to a particular effect */
+    effects?: Effect[];
+    resolvedEffect?: ResolvedEffect;
+}
+/**
+ *
+ */
+interface ManualSchemaComponent extends BaseSchemaComponent {
+    type: 'manual';
+}
+interface InProgressSchemaComponent extends BaseSchemaComponent {
+    type: 'in-progress';
+}
+interface BaseSchemaComponent {
+    ref: string;
+}
+type SchemaComponent = CompleteSchemaComponent | ManualSchemaComponent | InProgressSchemaComponent;
+type SchemaComponentMap = Map<ZodType, SchemaComponent>;
+interface CompleteParameterComponent extends BaseParameterComponent {
+    type: 'complete';
+    paramObject: ParameterObject | ReferenceObject | ParameterObject$1 | ReferenceObject$1;
+}
+interface PartialParameterComponent extends BaseParameterComponent {
+    type: 'manual';
+}
+interface BaseParameterComponent {
+    ref: string;
+    in: ParameterLocation;
+    name: string;
+}
+type ParameterComponent = CompleteParameterComponent | PartialParameterComponent;
+type ParameterComponentMap = Map<ZodType, ParameterComponent>;
+interface CompleteHeaderComponent extends BaseHeaderComponent {
+    type: 'complete';
+    headerObject: HeaderObject | ReferenceObject | HeaderObject$1 | ReferenceObject$1;
+}
+interface PartialHeaderComponent extends BaseHeaderComponent {
+    type: 'manual';
+}
+interface BaseHeaderComponent {
+    ref: string;
+}
+type HeaderComponent = CompleteHeaderComponent | PartialHeaderComponent;
+type HeaderComponentMap = Map<ZodType, HeaderComponent>;
+interface BaseResponseComponent {
+    ref: string;
+}
+interface CompleteResponseComponent extends BaseResponseComponent {
+    type: 'complete';
+    responseObject: ResponseObject | ReferenceObject | ResponseObject$1 | ReferenceObject$1;
+}
+interface PartialResponseComponent extends BaseResponseComponent {
+    type: 'manual';
+}
+type ResponseComponent = CompleteResponseComponent | PartialResponseComponent;
+type ResponseComponentMap = Map<ZodOpenApiResponseObject, ResponseComponent>;
+interface BaseRequestBodyComponent {
+    ref: string;
+}
+interface CompleteRequestBodyComponent extends BaseRequestBodyComponent {
+    type: 'complete';
+    requestBodyObject: RequestBodyObject | ReferenceObject | RequestBodyObject$1 | ReferenceObject$1;
+}
+interface PartialRequestBodyComponent extends BaseRequestBodyComponent {
+    type: 'manual';
+}
+type RequestBodyComponent = CompleteRequestBodyComponent | PartialRequestBodyComponent;
+type RequestBodyComponentMap = Map<ZodOpenApiRequestBodyObject, RequestBodyComponent>;
+interface BaseCallbackComponent {
+    ref: string;
+}
+interface CompleteCallbackComponent extends BaseCallbackComponent {
+    type: 'complete';
+    callbackObject: ZodOpenApiCallbackObject | CallbackObject | CallbackObject$1;
+}
+interface PartialCallbackComponent extends BaseCallbackComponent {
+    type: 'manual';
+}
+type CallbackComponent = CompleteCallbackComponent | PartialCallbackComponent;
+type CallbackComponentMap = Map<ZodOpenApiCallbackObject, CallbackComponent>;
+interface ComponentsObject {
+    schemas: SchemaComponentMap;
+    parameters: ParameterComponentMap;
+    headers: HeaderComponentMap;
+    requestBodies: RequestBodyComponentMap;
+    responses: ResponseComponentMap;
+    callbacks: CallbackComponentMap;
+    openapi: ZodOpenApiVersion;
+}
+declare const getDefaultComponents: (componentsObject?: ZodOpenApiComponentsObject, openapi?: ZodOpenApiVersion) => ComponentsObject;
+declare const createComponents: (componentsObject: ZodOpenApiComponentsObject, components: ComponentsObject) => ComponentsObject$1 | undefined;
+
+type SchemaObject = SchemaObject$2 & SchemaObject$1;
+/**
+ * zod-openapi metadata
+ */
+interface ZodOpenApiMetadata<T extends ZodTypeAny, TInferred = z.input<T> | z.output<T>> extends SchemaObject {
+    example?: TInferred;
+    examples?: [TInferred, ...TInferred[]];
+    default?: T extends ZodDate ? string : TInferred;
+    /**
+     * Used to set the output of a ZodUnion to be `oneOf` instead of `allOf`
+     */
+    unionOneOf?: boolean;
+    /**
+     * Used to output this Zod Schema in the components schemas section. Any usage of this Zod Schema will then be transformed into a $ref.
+     */
+    ref?: string;
+    /**
+     * Used when you are manually adding a Zod Schema to the components section. This controls whether this should be rendered as request (`input`) or response (`output`). Defaults to `output`
+     */
+    refType?: CreationType;
+    /**
+     * Used to set the created type of an effect.
+     */
+    effectType?: CreationType | (z.input<T> extends z.output<T> ? z.output<T> extends z.input<T> ? 'same' : never : never);
+    /**
+     * Used to set metadata for a parameter, request header or cookie
+     */
+    param?: Partial<ParameterObject> & {
+        example?: TInferred;
+        examples?: Record<string, (ExampleObject & {
+            value: TInferred;
+        }) | ReferenceObject>;
+        /**
+         * Used to output this Zod Schema in the components parameters section. Any usage of this Zod Schema will then be transformed into a $ref.
+         */
+        ref?: string;
+    };
+    /**
+     * Used to set data for a response header
+     */
+    header?: Partial<HeaderObject & HeaderObject$1> & {
+        /**
+         * Used to output this Zod Schema in the components headers section. Any usage of this Zod Schema will then be transformed into a $ref.
+         */
+        ref?: string;
+    };
+    /**
+     * Used to override the generated type. If this is provided no metadata will be generated.
+     */
+    type?: SchemaObject['type'];
+}
+interface ZodOpenApiExtendMetadata {
+    extends: ZodObject<any, any, any, any, any>;
+}
+declare module 'zod' {
+    interface ZodType {
+        /**
+         * Add OpenAPI metadata to a Zod Type
+         */
+        openapi<T extends ZodTypeAny>(this: T, metadata: ZodOpenApiMetadata<T>): T;
+    }
+    interface ZodTypeDef {
+        /**
+         * OpenAPI metadata
+         */
+        openapi?: ZodOpenApiMetadata<ZodTypeAny>;
+    }
+    interface ZodObjectDef {
+        extendMetadata?: ZodOpenApiExtendMetadata;
+    }
+}
+
+declare function extendZodWithOpenApi(zod: typeof z): void;
+
+declare const createMediaTypeSchema: (schemaObject: ZodType | SchemaObject$1 | ReferenceObject | undefined, components: ComponentsObject, type: CreationType, subpath: string[]) => SchemaObject$1 | ReferenceObject | undefined;
+
+declare const createParamOrRef: (zodSchema: ZodType, components: ComponentsObject, subpath: string[], type?: keyof ZodOpenApiParameters, name?: string) => ParameterObject | ReferenceObject;
+
+type api_ComponentsObject = ComponentsObject;
+declare const api_createComponents: typeof createComponents;
+declare const api_createMediaTypeSchema: typeof createMediaTypeSchema;
+declare const api_createParamOrRef: typeof createParamOrRef;
+declare const api_getDefaultComponents: typeof getDefaultComponents;
+declare namespace api {
+  export { type api_ComponentsObject as ComponentsObject, api_createComponents as createComponents, api_createMediaTypeSchema as createMediaTypeSchema, api_createParamOrRef as createParamOrRef, api_getDefaultComponents as getDefaultComponents };
+}
+
+export { Server, ServerVariable, type ZodObjectInputType, type ZodOpenApiCallbackObject, type ZodOpenApiCallbacksObject, type ZodOpenApiComponentsObject, type ZodOpenApiContentObject, type ZodOpenApiMediaTypeObject, type ZodOpenApiObject, type ZodOpenApiOperationObject, type ZodOpenApiParameters, type ZodOpenApiPathItemObject, type ZodOpenApiPathsObject, type ZodOpenApiRequestBodyObject, type ZodOpenApiResponseObject, type ZodOpenApiResponsesObject, type ZodOpenApiVersion, api, createDocument, extendZodWithOpenApi, oas30, oas31 };