fumadocs-openapi 10.10.3 → 11.0.0

package/dist/server/proxy.js

@@ -14,9 +14,7 @@ const methodsWithBody = new Set([
 	"DELETE"
 ]);
 function createProxy(options = {}) {
-	const { allowedOrigins, allowedUrls, filterRequest = (req) => {
-		return !allowedUrls || allowedUrls.some((item) => req.url.startsWith(item));
-	}, overrides } = options;
+	const { allowedOrigins, filterRequest, overrides } = options;
 	const handlers = { handle: handler };
 	async function handler(req) {
 		const searchParams = new URL(req.url).searchParams;
@@ -26,7 +24,7 @@ function createProxy(options = {}) {
 		if (!targetUrl) return Response.json("[Proxy] Invalid `url` parameter value.", { status: 400 });
 		if (allowedOrigins && !allowedOrigins.includes(targetUrl.origin)) return Response.json(`[Proxy] The origin "${targetUrl.origin}" is not allowed.`, { status: 400 });
 		const proxied = await rewriteRequest(req, targetUrl, searchParams.get("cookie"));
-		if (!filterRequest(proxied)) return Response.json("[Proxy] The proxied request is not allowed", { status: 403 });
+		if (filterRequest && !filterRequest(proxied)) return Response.json("[Proxy] The proxied request is not allowed", { status: 403 });
 		try {
 			return rewriteResponse(await fetch(proxied));
 		} catch (err) {

package/dist/{_openapi/types.d.ts → types/openapi.d.ts}

@@ -1,13 +1,7 @@
-//#region src/_openapi/types.d.ts
-/**
- * These types are copied from openapi-types, with two modifications:
- *
- * - all attributes are optional, you can't rely on the specification for user input
- * - extensions (basically any attributes, not only prefixed with an `x-`) are allowed
- *
- * We deal with user input and can't assume they really stick to any official specification.
+//#region src/types/openapi.d.ts
+/** Original copy: https://github.com/scalar/scalar/blob/main/packages/openapi-types/src/openapi-types.ts
+ * - Removed Record<string, unknown> fallbacks
  */
-/** any other attribute, for example x-* extensions */
 declare namespace OpenAPI {
   type Document<T = {}> = OpenAPIV2.Document<T> | OpenAPIV3.Document<T> | OpenAPIV3_1.Document<T> | OpenAPIV3_2.Document<T>;
   type Operation<T = {}> = OpenAPIV2.OperationObject<T> | OpenAPIV3.OperationObject<T> | OpenAPIV3_1.OperationObject<T> | OpenAPIV3_2.OperationObject<T>;
@@ -27,12 +21,12 @@ declare namespace OpenAPI {
 }
 declare namespace OpenAPIV3_2 {
   type Modify<T, R> = Omit<T, keyof R> & R;
-  export type PathsWebhooksComponents<T = {}> = {
+  type PathsWebhooksComponents<T = {}> = {
     paths?: PathsObject<T>;
     webhooks?: Record<string, PathItemObject | ReferenceObject>;
     components?: ComponentsObject;
   };
-  export type Document<T = {}> = Modify<Omit<OpenAPIV3_1.Document<T>, 'paths' | 'components' | 'webhooks' | 'tags'>, {
+  type Document<T = {}> = Modify<Omit<OpenAPIV3_1.Document<T>, 'paths' | 'components' | 'webhooks' | 'tags'>, {
     /**
      * Version of the OpenAPI specification
      * @see https://github.com/OAI/OpenAPI-Specification/tree/main/versions
@@ -43,25 +37,25 @@ declare namespace OpenAPIV3_2 {
     $self?: string;
     tags?: TagObject[];
   } & ((Pick<PathsWebhooksComponents<T>, 'paths'> & Omit<Partial<PathsWebhooksComponents<T>>, 'paths'>) | (Pick<PathsWebhooksComponents<T>, 'webhooks'> & Omit<Partial<PathsWebhooksComponents<T>>, 'webhooks'>) | (Pick<PathsWebhooksComponents<T>, 'components'> & Omit<Partial<PathsWebhooksComponents<T>>, 'components'>)) & T>;
-  export type ServerObject = Modify<OpenAPIV3_1.ServerObject, {
+  type ServerObject = Modify<OpenAPIV3_1.ServerObject, {
     name?: string;
   }>;
-  export type PathsObject<T = {}, P extends {} = {}> = Record<string, (PathItemObject<T> & P) | undefined>;
-  export type HttpMethods = OpenAPIV3_1.HttpMethods | 'query';
-  export type PathItemObject<T = {}> = Modify<OpenAPIV3_1.PathItemObject<T>, { [method in HttpMethods]?: OperationObject<T> }> & {
+  type PathsObject<T = {}, P extends {} = {}> = Record<string, (PathItemObject<T> & P) | undefined>;
+  type HttpMethods = OpenAPIV3_1.HttpMethods | 'query';
+  type PathItemObject<T = {}> = Modify<OpenAPIV3_1.PathItemObject<T>, { [method in HttpMethods]?: OperationObject<T> }> & {
     additionalOperations?: Record<string, OperationObject<T>>;
     parameters?: (ReferenceObject | ParameterObject)[];
   };
-  export type OperationObject<T = {}> = Modify<OpenAPIV3_1.OperationObject<T>, {
+  type OperationObject<T = {}> = Modify<OpenAPIV3_1.OperationObject<T>, {
     parameters?: (ReferenceObject | ParameterObject)[];
     requestBody?: ReferenceObject | RequestBodyObject;
     responses?: ResponsesObject;
     callbacks?: Record<string, ReferenceObject | CallbackObject>;
     servers?: ServerObject[];
   }> & T;
-  export type ParameterStyle = OpenAPIV3_1.ParameterStyle | 'cookie';
-  export type ParameterLocation = OpenAPIV3_1.ParameterLocation | 'querystring';
-  export type ParameterObject = Modify<OpenAPIV3_1.ParameterObject, {
+  type ParameterStyle = OpenAPIV3_1.ParameterStyle | 'cookie';
+  type ParameterLocation = OpenAPIV3_1.ParameterLocation | 'querystring';
+  type ParameterObject = Modify<OpenAPIV3_1.ParameterObject, {
     style?: ParameterStyle;
     in?: ParameterLocation;
     schema?: ReferenceObject | SchemaObject;
@@ -69,49 +63,49 @@ declare namespace OpenAPIV3_2 {
       [media: string]: ReferenceObject | ExampleObject;
     };
   }>;
-  export type HeaderObject = Modify<OpenAPIV3_1.HeaderObject, {
+  type HeaderObject = Modify<OpenAPIV3_1.HeaderObject, {
     content?: {
       [media: string]: ReferenceObject | MediaTypeObject;
     };
     schema?: ReferenceObject | SchemaObject;
   }>;
-  export type NonArraySchemaObjectType = OpenAPIV3_1.NonArraySchemaObjectType;
-  export type ArraySchemaObjectType = OpenAPIV3_1.ArraySchemaObjectType;
+  type NonArraySchemaObjectType = OpenAPIV3_1.NonArraySchemaObjectType;
+  type ArraySchemaObjectType = OpenAPIV3_1.ArraySchemaObjectType;
   /**
    * There is no way to tell typescript to require items when type is either 'array' or array containing 'array' type
    * 'items' will be always visible as optional
    * Casting schema object to ArraySchemaObject or NonArraySchemaObject will work fine
    */
-  export type SchemaObject = ArraySchemaObject | NonArraySchemaObject | MixedSchemaObject | boolean;
-  export type ArraySchemaObject = {
+  type SchemaObject = ArraySchemaObject | NonArraySchemaObject | MixedSchemaObject | boolean;
+  type ArraySchemaObject = {
     type?: ArraySchemaObjectType;
     items?: ReferenceObject | SchemaObject;
   } & BaseSchemaObject;
-  export type NonArraySchemaObject = {
+  type NonArraySchemaObject = {
     type?: NonArraySchemaObjectType;
   } & BaseSchemaObject;
   type MixedSchemaObject = {
     type?: (ArraySchemaObjectType | NonArraySchemaObjectType)[];
     items?: ReferenceObject | SchemaObject;
   } & BaseSchemaObject;
-  export type BaseSchemaObject = Modify<OpenAPIV3_1.BaseSchemaObject, {
+  type BaseSchemaObject = Modify<OpenAPIV3_1.BaseSchemaObject, {
     examples?: ExampleObject[];
     discriminator?: DiscriminatorObject;
     xml?: XMLObject;
   }>;
-  export type DiscriminatorObject = OpenAPIV3_1.DiscriminatorObject & {
+  type DiscriminatorObject = OpenAPIV3_1.DiscriminatorObject & {
     defaultMapping?: string;
   };
-  export type XMLNodeType = 'element' | 'attribute' | 'text' | 'cdata' | 'comment';
-  export type XMLObject = Omit<OpenAPIV3_1.XMLObject, 'wrapped' | 'attribute'> & {
+  type XMLNodeType = 'element' | 'attribute' | 'text' | 'cdata' | 'comment';
+  type XMLObject = Omit<OpenAPIV3_1.XMLObject, 'wrapped' | 'attribute'> & {
     nodeType?: XMLNodeType;
   };
-  export type ReferenceObject = OpenAPIV3_1.ReferenceObject;
-  export type ExampleObject = OpenAPIV3_1.ExampleObject & {
+  type ReferenceObject = OpenAPIV3_1.ReferenceObject;
+  type ExampleObject = OpenAPIV3_1.ExampleObject & {
     dataValue?: any;
     serializedValue?: string;
   };
-  export type MediaTypeObject = Modify<OpenAPIV3_1.MediaTypeObject, {
+  type MediaTypeObject = Modify<OpenAPIV3_1.MediaTypeObject, {
     schema?: ReferenceObject | SchemaObject;
     examples?: Record<string, ReferenceObject | ExampleObject>;
     encoding?: {
@@ -122,7 +116,7 @@ declare namespace OpenAPIV3_2 {
     itemEncoding?: EncodingObject;
     prefixEncoding?: EncodingObject[];
   };
-  export type EncodingObject = Modify<OpenAPIV3_1.EncodingObject, {
+  type EncodingObject = Modify<OpenAPIV3_1.EncodingObject, {
     headers?: {
       [header: string]: ReferenceObject | HeaderObject;
     };
@@ -131,13 +125,13 @@ declare namespace OpenAPIV3_2 {
     prefixEncoding?: EncodingObject[];
     itemEncoding?: EncodingObject;
   };
-  export type RequestBodyObject = Modify<OpenAPIV3_1.RequestBodyObject, {
+  type RequestBodyObject = Modify<OpenAPIV3_1.RequestBodyObject, {
     content?: {
       [media: string]: ReferenceObject | MediaTypeObject;
     };
   }>;
-  export type ResponsesObject = Record<string, ReferenceObject | ResponseObject>;
-  export type ResponseObject = Modify<OpenAPIV3_1.ResponseObject, {
+  type ResponsesObject = Record<string, ReferenceObject | ResponseObject>;
+  type ResponseObject = Modify<OpenAPIV3_1.ResponseObject, {
     headers?: {
       [header: string]: ReferenceObject | HeaderObject;
     };
@@ -150,11 +144,11 @@ declare namespace OpenAPIV3_2 {
   }> & {
     summary?: string;
   };
-  export type LinkObject = Modify<OpenAPIV3_1.LinkObject, {
+  type LinkObject = Modify<OpenAPIV3_1.LinkObject, {
     server?: ServerObject;
   }>;
-  export type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
-  export type ComponentsObject = Modify<OpenAPIV3_1.ComponentsObject, {
+  type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
+  type ComponentsObject = Modify<OpenAPIV3_1.ComponentsObject, {
     schemas?: Record<string, SchemaObject>;
     responses?: Record<string, ReferenceObject | ResponseObject>;
     parameters?: Record<string, ReferenceObject | ParameterObject>;
@@ -167,35 +161,34 @@ declare namespace OpenAPIV3_2 {
     pathItems?: Record<string, ReferenceObject | PathItemObject>;
     mediaTypes?: Record<string, MediaTypeObject | ReferenceObject>;
   }>;
-  export type SecuritySchemeObject = (HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme) & {
+  type SecuritySchemeObject = (HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme) & {
     deprecated?: boolean;
   };
-  export type HttpSecurityScheme = OpenAPIV3_1.HttpSecurityScheme;
-  export type ApiKeySecurityScheme = OpenAPIV3_1.ApiKeySecurityScheme;
-  export type OAuthFlows = OpenAPIV3_1.OAuthFlows & {
+  type HttpSecurityScheme = OpenAPIV3_1.HttpSecurityScheme;
+  type ApiKeySecurityScheme = OpenAPIV3_1.ApiKeySecurityScheme;
+  type OAuthFlows = OpenAPIV3_1.OAuthFlows & {
     deviceAuthorization?: OpenAPIV3.OAuthFlowBase & OpenAPIV3.OAuthFlowTokenUrlTrait & {
       deviceAuthorizationUrl?: string;
     };
   };
-  export type OAuth2SecurityScheme = Modify<OpenAPIV3_1.OAuth2SecurityScheme, {
+  type OAuth2SecurityScheme = Modify<OpenAPIV3_1.OAuth2SecurityScheme, {
     flows?: OAuthFlows;
   }>;
-  export type OpenIdSecurityScheme = OpenAPIV3_1.OpenIdSecurityScheme;
-  export type TagObject = OpenAPIV3_1.TagObject & {
+  type OpenIdSecurityScheme = OpenAPIV3_1.OpenIdSecurityScheme;
+  type TagObject = OpenAPIV3_1.TagObject & {
     summary?: string;
     parent?: string;
     kind?: string;
   };
-  export {};
 }
 declare namespace OpenAPIV3_1 {
   type Modify<T, R> = Omit<T, keyof R> & R;
-  export type PathsWebhooksComponents<T = {}> = {
+  type PathsWebhooksComponents<T = {}> = {
     paths?: PathsObject<T>;
     webhooks?: Record<string, PathItemObject | ReferenceObject>;
     components?: ComponentsObject;
   };
-  export type Document<T = {}> = Modify<Omit<OpenAPIV3.Document<T>, 'paths' | 'components'>, {
+  type Document<T = {}> = Modify<Omit<OpenAPIV3.Document<T>, 'paths' | 'components'>, {
     /**
      * Version of the OpenAPI specification
      * @see https://github.com/OAI/OpenAPI-Specification/tree/main/versions
@@ -206,69 +199,69 @@ declare namespace OpenAPIV3_1 {
     jsonSchemaDialect?: string;
     servers?: ServerObject[];
   } & ((Pick<PathsWebhooksComponents<T>, 'paths'> & Omit<Partial<PathsWebhooksComponents<T>>, 'paths'>) | (Pick<PathsWebhooksComponents<T>, 'webhooks'> & Omit<Partial<PathsWebhooksComponents<T>>, 'webhooks'>) | (Pick<PathsWebhooksComponents<T>, 'components'> & Omit<Partial<PathsWebhooksComponents<T>>, 'components'>)) & T>;
-  export type InfoObject = Modify<OpenAPIV3.InfoObject, {
+  type InfoObject = Modify<OpenAPIV3.InfoObject, {
     summary?: string;
     license?: LicenseObject;
   }>;
-  export type ContactObject = OpenAPIV3.ContactObject;
-  export type LicenseObject = Modify<OpenAPIV3.LicenseObject, {
+  type ContactObject = OpenAPIV3.ContactObject;
+  type LicenseObject = Modify<OpenAPIV3.LicenseObject, {
     identifier?: string;
   }>;
-  export type ServerObject = Modify<OpenAPIV3.ServerObject, {
+  type ServerObject = Modify<OpenAPIV3.ServerObject, {
     url?: string;
     description?: string;
     variables?: Record<string, ServerVariableObject>;
   }>;
-  export type ServerVariableObject = Modify<OpenAPIV3.ServerVariableObject, {
+  type ServerVariableObject = Modify<OpenAPIV3.ServerVariableObject, {
     enum?: [string, ...string[]];
   }>;
-  export type PathsObject<T = {}, P extends {} = {}> = Record<string, (PathItemObject<T> & P) | undefined>;
-  export type HttpMethods = OpenAPIV3.HttpMethods;
-  export type PathItemObject<T = {}> = Modify<OpenAPIV3.PathItemObject<T>, {
+  type PathsObject<T = {}, P extends {} = {}> = Record<string, (PathItemObject<T> & P) | undefined>;
+  type HttpMethods = OpenAPIV3.HttpMethods;
+  type PathItemObject<T = {}> = Modify<OpenAPIV3.PathItemObject<T>, {
     servers?: ServerObject[];
     parameters?: (ReferenceObject | ParameterObject)[];
   }> & { [method in HttpMethods]?: OperationObject<T> };
-  export type OperationObject<T = {}> = Modify<OpenAPIV3.OperationObject<T>, {
+  type OperationObject<T = {}> = Modify<OpenAPIV3.OperationObject<T>, {
     parameters?: (ReferenceObject | ParameterObject)[];
     requestBody?: ReferenceObject | RequestBodyObject;
     responses?: ResponsesObject;
     callbacks?: Record<string, ReferenceObject | CallbackObject>;
     servers?: ServerObject[];
   }> & T;
-  export type ExternalDocumentationObject = OpenAPIV3.ExternalDocumentationObject;
-  export type ParameterStyle = OpenAPIV3.ParameterStyle;
-  export type ParameterLocation = OpenAPIV3.ParameterLocation;
-  export type ParameterObject = OpenAPIV3.ParameterObject;
-  export type HeaderObject = Modify<OpenAPIV3.HeaderObject, {
+  type ExternalDocumentationObject = OpenAPIV3.ExternalDocumentationObject;
+  type ParameterStyle = OpenAPIV3.ParameterStyle;
+  type ParameterLocation = OpenAPIV3.ParameterLocation;
+  type ParameterObject = OpenAPIV3.ParameterObject;
+  type HeaderObject = Modify<OpenAPIV3.HeaderObject, {
     content?: {
       [media: string]: MediaTypeObject;
     };
   }>;
-  export type ParameterBaseObject = Modify<OpenAPIV3.ParameterBaseObject, {
+  type ParameterBaseObject = Modify<OpenAPIV3.ParameterBaseObject, {
     content?: {
       [media: string]: MediaTypeObject;
     };
   }>;
-  export type NonArraySchemaObjectType = OpenAPIV3.NonArraySchemaObjectType | 'null';
-  export type ArraySchemaObjectType = OpenAPIV3.ArraySchemaObjectType;
+  type NonArraySchemaObjectType = OpenAPIV3.NonArraySchemaObjectType | 'null';
+  type ArraySchemaObjectType = OpenAPIV3.ArraySchemaObjectType;
   /**
    * There is no way to tell typescript to require items when type is either 'array' or array containing 'array' type
    * 'items' will be always visible as optional
    * Casting schema object to ArraySchemaObject or NonArraySchemaObject will work fine
    */
-  export type SchemaObject = ArraySchemaObject | NonArraySchemaObject | MixedSchemaObject | boolean;
-  export type ArraySchemaObject = {
+  type SchemaObject = ArraySchemaObject | NonArraySchemaObject | MixedSchemaObject | boolean;
+  type ArraySchemaObject = {
     type?: ArraySchemaObjectType;
     items?: ReferenceObject | SchemaObject;
   } & BaseSchemaObject;
-  export type NonArraySchemaObject = {
+  type NonArraySchemaObject = {
     type?: NonArraySchemaObjectType;
   } & BaseSchemaObject;
   type MixedSchemaObject = {
     type?: (ArraySchemaObjectType | NonArraySchemaObjectType)[];
     items?: ReferenceObject | SchemaObject;
   } & BaseSchemaObject;
-  export type BaseSchemaObject = Modify<Omit<OpenAPIV3.BaseSchemaObject, 'nullable'>, {
+  type BaseSchemaObject = Modify<Omit<OpenAPIV3.BaseSchemaObject, 'nullable'>, {
     examples?: OpenAPIV3.BaseSchemaObject['example'][];
     exclusiveMinimum?: number;
     exclusiveMaximum?: number;
@@ -290,25 +283,25 @@ declare namespace OpenAPIV3_1 {
     xml?: XMLObject;
     const?: any;
   }>;
-  export type DiscriminatorObject = OpenAPIV3.DiscriminatorObject;
-  export type XMLObject = OpenAPIV3.XMLObject;
-  export type ReferenceObject = Modify<OpenAPIV3.ReferenceObject, {
+  type DiscriminatorObject = OpenAPIV3.DiscriminatorObject;
+  type XMLObject = OpenAPIV3.XMLObject;
+  type ReferenceObject = Modify<OpenAPIV3.ReferenceObject, {
     summary?: string;
     description?: string;
   }>;
-  export type ExampleObject = OpenAPIV3.ExampleObject;
-  export type MediaTypeObject = Modify<OpenAPIV3.MediaTypeObject, {
+  type ExampleObject = OpenAPIV3.ExampleObject;
+  type MediaTypeObject = Modify<OpenAPIV3.MediaTypeObject, {
     schema?: SchemaObject | ReferenceObject;
     examples?: Record<string, ReferenceObject | ExampleObject>;
   }>;
-  export type EncodingObject = OpenAPIV3.EncodingObject;
-  export type RequestBodyObject = Modify<OpenAPIV3.RequestBodyObject, {
+  type EncodingObject = OpenAPIV3.EncodingObject;
+  type RequestBodyObject = Modify<OpenAPIV3.RequestBodyObject, {
     content?: {
       [media: string]: MediaTypeObject;
     };
   }>;
-  export type ResponsesObject = Record<string, ReferenceObject | ResponseObject>;
-  export type ResponseObject = Modify<OpenAPIV3.ResponseObject, {
+  type ResponsesObject = Record<string, ReferenceObject | ResponseObject>;
+  type ResponseObject = Modify<OpenAPIV3.ResponseObject, {
     headers?: {
       [header: string]: ReferenceObject | HeaderObject;
     };
@@ -319,12 +312,12 @@ declare namespace OpenAPIV3_1 {
       [link: string]: ReferenceObject | LinkObject;
     };
   }>;
-  export type LinkObject = Modify<OpenAPIV3.LinkObject, {
+  type LinkObject = Modify<OpenAPIV3.LinkObject, {
     server?: ServerObject;
   }>;
-  export type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
-  export type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject;
-  export type ComponentsObject = Modify<OpenAPIV3.ComponentsObject, {
+  type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
+  type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject;
+  type ComponentsObject = Modify<OpenAPIV3.ComponentsObject, {
     schemas?: Record<string, SchemaObject>;
     responses?: Record<string, ReferenceObject | ResponseObject>;
     parameters?: Record<string, ReferenceObject | ParameterObject>;
@@ -336,17 +329,16 @@ declare namespace OpenAPIV3_1 {
     callbacks?: Record<string, ReferenceObject | CallbackObject>;
     pathItems?: Record<string, ReferenceObject | PathItemObject>;
   }>;
-  export type SecuritySchemeObject = OpenAPIV3.SecuritySchemeObject;
-  export type HttpSecurityScheme = OpenAPIV3.HttpSecurityScheme;
-  export type ApiKeySecurityScheme = OpenAPIV3.ApiKeySecurityScheme;
-  export type OAuthFlows = OpenAPIV3.OAuthFlows;
-  export type OAuth2SecurityScheme = OpenAPIV3.OAuth2SecurityScheme;
-  export type OpenIdSecurityScheme = OpenAPIV3.OpenIdSecurityScheme;
-  export type TagObject = OpenAPIV3.TagObject;
-  export {};
+  type SecuritySchemeObject = OpenAPIV3.SecuritySchemeObject;
+  type HttpSecurityScheme = OpenAPIV3.HttpSecurityScheme;
+  type ApiKeySecurityScheme = OpenAPIV3.ApiKeySecurityScheme;
+  type OAuthFlows = OpenAPIV3.OAuthFlows;
+  type OAuth2SecurityScheme = OpenAPIV3.OAuth2SecurityScheme;
+  type OpenIdSecurityScheme = OpenAPIV3.OpenIdSecurityScheme;
+  type TagObject = OpenAPIV3.TagObject;
 }
 declare namespace OpenAPIV3 {
-  export type Document<T = {}> = {
+  type Document<T = {}> = {
     /**
      * Version of the OpenAPI specification
      * @see https://github.com/OAI/OpenAPI-Specification/tree/main/versions
@@ -361,7 +353,7 @@ declare namespace OpenAPIV3 {
     tags?: TagObject[];
     externalDocs?: ExternalDocumentationObject;
   } & T;
-  export type InfoObject = {
+  type InfoObject = {
     title?: string;
     description?: string;
     termsOfService?: string;
@@ -369,39 +361,39 @@ declare namespace OpenAPIV3 {
     license?: LicenseObject;
     version?: string;
   };
-  export type ContactObject = {
+  type ContactObject = {
     name?: string;
     url?: string;
     email?: string;
   };
-  export type LicenseObject = {
+  type LicenseObject = {
     name?: string;
     url?: string;
   };
-  export type ServerObject = {
+  type ServerObject = {
     url?: string;
     description?: string;
     variables?: {
       [variable: string]: ServerVariableObject;
     };
   };
-  export type ServerVariableObject = {
+  type ServerVariableObject = {
     enum?: string[] | number[];
     default?: string | number;
     description?: string;
   };
-  export type PathsObject<T = {}, P extends {} = {}> = {
+  type PathsObject<T = {}, P extends {} = {}> = {
     [pattern: string]: (PathItemObject<T> & P) | undefined;
   };
-  export type HttpMethods = OpenAPIV2.HttpMethods | 'trace';
-  export type PathItemObject<T = {}> = {
+  type HttpMethods = OpenAPIV2.HttpMethods | 'trace';
+  type PathItemObject<T = {}> = {
     $ref?: string;
     summary?: string;
     description?: string;
     servers?: ServerObject[];
     parameters?: (ReferenceObject | ParameterObject)[];
   } & { [method in HttpMethods]?: OperationObject<T> } & T;
-  export type OperationObject<T = {}> = {
+  type OperationObject<T = {}> = {
     tags?: string[];
     summary?: string;
     description?: string;
@@ -417,18 +409,18 @@ declare namespace OpenAPIV3 {
     security?: SecurityRequirementObject[];
     servers?: ServerObject[];
   } & T;
-  export type ExternalDocumentationObject = {
+  type ExternalDocumentationObject = {
     description?: string;
     url?: string;
   };
-  export type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
-  export type ParameterObject = {
+  type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+  type ParameterObject = {
     name?: string;
     in?: ParameterLocation;
   } & ParameterBaseObject;
-  export type HeaderObject = {} & ParameterBaseObject;
-  export type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
-  export type ParameterBaseObject = {
+  type HeaderObject = {} & ParameterBaseObject;
+  type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+  type ParameterBaseObject = {
     description?: string;
     required?: boolean;
     deprecated?: boolean;
@@ -445,17 +437,17 @@ declare namespace OpenAPIV3 {
       [media: string]: MediaTypeObject;
     };
   };
-  export type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
-  export type ArraySchemaObjectType = 'array';
-  export type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
-  export type ArraySchemaObject = {
+  type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+  type ArraySchemaObjectType = 'array';
+  type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+  type ArraySchemaObject = {
     type?: ArraySchemaObjectType;
     items?: ReferenceObject | SchemaObject;
   } & BaseSchemaObject;
-  export type NonArraySchemaObject = {
+  type NonArraySchemaObject = {
     type?: NonArraySchemaObjectType;
   } & BaseSchemaObject;
-  export type BaseSchemaObject = {
+  type BaseSchemaObject = {
     title?: string;
     description?: string;
     format?: string;
@@ -495,29 +487,29 @@ declare namespace OpenAPIV3 {
     example?: any;
     deprecated?: boolean;
   };
-  export type DiscriminatorObject = {
+  type DiscriminatorObject = {
     propertyName?: string;
     mapping?: {
       [value: string]: string;
     };
   };
-  export type XMLObject = {
+  type XMLObject = {
     name?: string;
     namespace?: string;
     prefix?: string;
     attribute?: boolean;
     wrapped?: boolean;
   };
-  export type ReferenceObject = {
+  type ReferenceObject = {
     $ref: string;
   };
-  export type ExampleObject = {
+  type ExampleObject = {
     summary?: string;
     description?: string;
     value?: any;
     externalValue?: string;
   };
-  export type MediaTypeObject = {
+  type MediaTypeObject = {
     schema?: ReferenceObject | SchemaObject;
     example?: any;
     examples?: {
@@ -527,7 +519,7 @@ declare namespace OpenAPIV3 {
       [media: string]: EncodingObject;
     };
   };
-  export type EncodingObject = {
+  type EncodingObject = {
     contentType?: string;
     headers?: {
       [header: string]: ReferenceObject | HeaderObject;
@@ -536,17 +528,17 @@ declare namespace OpenAPIV3 {
     explode?: boolean;
     allowReserved?: boolean;
   };
-  export type RequestBodyObject = {
+  type RequestBodyObject = {
     description?: string;
     content?: {
       [media: string]: MediaTypeObject;
     };
     required?: boolean;
   };
-  export type ResponsesObject = {
+  type ResponsesObject = {
     [code: string]: ReferenceObject | ResponseObject;
   };
-  export type ResponseObject = {
+  type ResponseObject = {
     description?: string;
     headers?: {
       [header: string]: ReferenceObject | HeaderObject;
@@ -558,7 +550,7 @@ declare namespace OpenAPIV3 {
       [link: string]: ReferenceObject | LinkObject;
     };
   };
-  export type LinkObject = {
+  type LinkObject = {
     operationRef?: string;
     operationId?: string;
     parameters?: {
@@ -568,13 +560,13 @@ declare namespace OpenAPIV3 {
     description?: string;
     server?: ServerObject;
   };
-  export type CallbackObject = {
+  type CallbackObject = {
     [url: string]: PathItemObject;
   };
-  export type SecurityRequirementObject = {
+  type SecurityRequirementObject = {
     [name: string]: string[];
   };
-  export type ComponentsObject = {
+  type ComponentsObject = {
     schemas?: {
       [key: string]: ReferenceObject | SchemaObject;
     };
@@ -603,20 +595,20 @@ declare namespace OpenAPIV3 {
       [key: string]: ReferenceObject | CallbackObject;
     };
   };
-  export type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
-  export type HttpSecurityScheme = {
+  type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+  type HttpSecurityScheme = {
     type?: 'http';
     description?: string;
     scheme?: string;
     bearerFormat?: string;
   };
-  export type ApiKeySecurityScheme = {
+  type ApiKeySecurityScheme = {
     type?: 'apiKey';
     description?: string;
     name?: string;
     in?: string;
   };
-  export type OAuthFlowBase = {
+  type OAuthFlowBase = {
     scopes?: {
       [scope: string]: string;
     };
@@ -625,31 +617,30 @@ declare namespace OpenAPIV3 {
   type OAuthFlowAuthorizationUrlTrait = {
     authorizationUrl?: string;
   };
-  export type OAuthFlowTokenUrlTrait = {
+  type OAuthFlowTokenUrlTrait = {
     tokenUrl?: string;
   };
-  export type OAuthFlows = {
+  type OAuthFlows = {
     implicit?: OAuthFlowBase & OAuthFlowAuthorizationUrlTrait;
     password?: OAuthFlowBase & OAuthFlowTokenUrlTrait;
     clientCredentials?: OAuthFlowBase & OAuthFlowTokenUrlTrait;
     authorizationCode?: OAuthFlowBase & OAuthFlowAuthorizationUrlTrait & OAuthFlowTokenUrlTrait;
   };
-  export type OAuth2SecurityScheme = {
+  type OAuth2SecurityScheme = {
     type?: 'oauth2';
     description?: string;
     flows?: OAuthFlows;
   };
-  export type OpenIdSecurityScheme = {
+  type OpenIdSecurityScheme = {
     type?: 'openIdConnect';
     description?: string;
     openIdConnectUrl?: string;
   };
-  export type TagObject = {
+  type TagObject = {
     name?: string;
     description?: string;
     externalDocs?: ExternalDocumentationObject;
   };
-  export {};
 }
 declare namespace OpenAPIV2 {
   type Document<T = {}> = {