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;

        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, {

                authorizationUrl: string;

                    [scope: string]: string;

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

        parameters?: ParametersDefinitionsObject;

        responses?: ResponsesDefinitionsObject;

        security?: SecurityRequirementObject[];

        securityDefinitions?: SecurityDefinitionsObject;

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

        type: 'basic' | 'apiKey' | 'oauth2';

    interface SecuritySchemeBasic extends SecuritySchemeObjectBase {

    interface SecuritySchemeApiKey extends SecuritySchemeObjectBase {

    type SecuritySchemeOauth2 = SecuritySchemeOauth2Implicit | SecuritySchemeOauth2AccessCode | SecuritySchemeOauth2Password | SecuritySchemeOauth2Application;

    interface SecuritySchemeOauth2Base extends SecuritySchemeObjectBase {

        flow: 'implicit' | 'password' | 'application' | 'accessCode';

    interface SecuritySchemeOauth2Implicit extends SecuritySchemeOauth2Base {

    interface SecuritySchemeOauth2AccessCode extends SecuritySchemeOauth2Base {

    interface SecuritySchemeOauth2Password extends SecuritySchemeOauth2Base {

  "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": "2cce544746b8dcf8a098c3cc8560650588011755"

  "gitHead": "da3416820b46fa916a75d3388b09444876873d01"

		@@ -428,2 +428,3 @@ export declare namespace OpenAPI {
		type: 'oauth2';
		description?: string;
		flows: {
		@@ -430,0 +431,0 @@ implicit?: {

		{
		"name": "openapi-types",
		"version": "11.0.1",
		"version": "11.1.0",
		"description": "Types for OpenAPI documents.",
		@@ -24,3 +24,3 @@ "main": "./dist/index.js",
		"license": "MIT",
		"gitHead": "2cce544746b8dcf8a098c3cc8560650588011755"
		"gitHead": "da3416820b46fa916a75d3388b09444876873d01"
		}

Improved metrics