jsdevel

openapi-types

    type Document<T extends {} = {}> = OpenAPIV2.Document<T> | OpenAPIV3.Document<T> | OpenAPIV3_1.Document<T>;

    type Operation<T extends {} = {}> = OpenAPIV2.OperationObject<T> | OpenAPIV3.OperationObject<T> | OpenAPIV3_1.OperationObject<T>;

    type Modify<T, R> = Omit<T, keyof R> & R;

    type PathsWebhooksComponents<T extends {} = {}> = {

        webhooks: Record<string, PathItemObject | ReferenceObject>;

    export type Document<T extends {} = {}> = Modify<Omit<OpenAPIV3.Document<T>, 'paths' | 'components'>, {

    } & ((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'>))>;

    export type InfoObject = Modify<OpenAPIV3.InfoObject, {

    export type ContactObject = OpenAPIV3.ContactObject;

    export type LicenseObject = Modify<OpenAPIV3.LicenseObject, {

    export type ServerObject = Modify<OpenAPIV3.ServerObject, {

        variables?: Record<string, ServerVariableObject>;

    export type ServerVariableObject = Modify<OpenAPIV3.ServerVariableObject, {

    export type PathsObject<T extends {} = {}, P extends {} = {}> = Record<string, (PathItemObject<T> & P) | undefined>;

    export type HttpMethods = OpenAPIV3.HttpMethods;

    export type PathItemObject<T extends {} = {}> = Modify<OpenAPIV3.PathItemObject<T>, {

        parameters?: (ReferenceObject | ParameterObject)[];

        [method in HttpMethods]?: OperationObject<T>;

    export type OperationObject<T extends {} = {}> = Modify<OpenAPIV3.OperationObject<T>, {

        requestBody?: ReferenceObject | RequestBodyObject;

        callbacks?: Record<string, ReferenceObject | CallbackObject>;

    export type ExternalDocumentationObject = OpenAPIV3.ExternalDocumentationObject;

    export type ParameterObject = OpenAPIV3.ParameterObject;

    export type HeaderObject = OpenAPIV3.HeaderObject;

    export type ParameterBaseObject = OpenAPIV3.ParameterBaseObject;

    export type NonArraySchemaObjectType = OpenAPIV3.NonArraySchemaObjectType | 'null';

    export 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;

    export interface ArraySchemaObject extends BaseSchemaObject {

        items: ReferenceObject | SchemaObject;

    export interface NonArraySchemaObject extends BaseSchemaObject {

    interface MixedSchemaObject extends BaseSchemaObject {

        type?: (ArraySchemaObjectType | NonArraySchemaObjectType)[];

        items?: ReferenceObject | SchemaObject;

    export type BaseSchemaObject = Modify<Omit<OpenAPIV3.BaseSchemaObject, 'nullable'>, {

        examples?: OpenAPIV3.BaseSchemaObject['example'][];

        exclusiveMinimum?: boolean | number;

        exclusiveMaximum?: boolean | number;

        additionalProperties?: boolean | ReferenceObject | SchemaObject;

            [name: string]: ReferenceObject | SchemaObject;

        allOf?: (ReferenceObject | SchemaObject)[];

        oneOf?: (ReferenceObject | SchemaObject)[];

        anyOf?: (ReferenceObject | SchemaObject)[];

        not?: ReferenceObject | SchemaObject;

        discriminator?: DiscriminatorObject;

        externalDocs?: ExternalDocumentationObject;

    export type DiscriminatorObject = OpenAPIV3.DiscriminatorObject;

    export type XMLObject = OpenAPIV3.XMLObject;

    export type ReferenceObject = Modify<OpenAPIV3.ReferenceObject, {

    export type ExampleObject = OpenAPIV3.ExampleObject;

    export type MediaTypeObject = Modify<OpenAPIV3.MediaTypeObject, {

        schema?: SchemaObject | ReferenceObject;

        examples?: Record<string, ReferenceObject | ExampleObject>;

    export type EncodingObject = OpenAPIV3.EncodingObject;

    export type RequestBodyObject = Modify<OpenAPIV3.RequestBodyObject, {

            [media: string]: MediaTypeObject;

    export type ResponsesObject = Record<string, ReferenceObject | ResponseObject>;

    export type ResponseObject = Modify<OpenAPIV3.ResponseObject, {

            [header: string]: ReferenceObject | HeaderObject;

            [link: string]: ReferenceObject | LinkObject;

    export type LinkObject = Modify<OpenAPIV3.LinkObject, {

    export type CallbackObject = Record<string, PathItemObject | ReferenceObject>;

    export type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject;

    export type ComponentsObject = Modify<OpenAPIV3.ComponentsObject, {

        schemas?: Record<string, SchemaObject>;

        responses?: Record<string, ReferenceObject | ResponseObject>;

        parameters?: Record<string, ReferenceObject | ParameterObject>;

        requestBodies?: Record<string, ReferenceObject | RequestBodyObject>;

        headers?: Record<string, ReferenceObject | HeaderObject>;

        securitySchemes?: Record<string, ReferenceObject | SecuritySchemeObject>;

        links?: Record<string, ReferenceObject | LinkObject>;

        pathItems?: Record<string, ReferenceObject | PathItemObject>;

    export type SecuritySchemeObject = OpenAPIV3.SecuritySchemeObject;

    export type HttpSecurityScheme = OpenAPIV3.HttpSecurityScheme;

    export type ApiKeySecurityScheme = OpenAPIV3.ApiKeySecurityScheme;

    export type OAuth2SecurityScheme = OpenAPIV3.OAuth2SecurityScheme;

    export type OpenIdSecurityScheme = OpenAPIV3.OpenIdSecurityScheme;

    export type TagObject = OpenAPIV3.TagObject;

    interface Document<T extends {} = {}> {

        security?: SecurityRequirementObject[];

        'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];

        'x-express-openapi-validation-strict'?: boolean;

            [variable: string]: ServerVariableObject;

    interface PathsObject<T extends {} = {}, P extends {} = {}> {

        [pattern: string]: (PathItemObject<T> & P) | undefined;

  "description": "Types for OpenAPI documents.",

    "url": "https://github.com/kogosoftwarellc/open-api/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3Aopenapi-types"

  "repository": "https://github.com/kogosoftwarellc/open-api/tree/master/packages/openapi-types",

  "homepage": "https://github.com/kogosoftwarellc/open-api/tree/master/packages/openapi-types#readme",

  "gitHead": "fd3fb1195f9147e4ac7c51e58c33f1c85cce3322"

  "gitHead": "2256840df589723c2fadbde293317b1eb95c9ef9"

		@@ -96,2 +96,3 @@ export declare namespace OpenAPI {
		xml?: XMLObject;
		const?: any;
		}>;
		@@ -98,0 +99,0 @@ export type DiscriminatorObject = OpenAPIV3.DiscriminatorObject;

		{
		"name": "openapi-types",
		"version": "12.0.2",
		"version": "12.1.0",
		"description": "Types for OpenAPI documents.",
		@@ -24,3 +24,3 @@ "main": "./dist/index.js",
		"license": "MIT",
		"gitHead": "fd3fb1195f9147e4ac7c51e58c33f1c85cce3322"
		"gitHead": "2256840df589723c2fadbde293317b1eb95c9ef9"
		}

Improved metrics