oazapfts 6.0.3 → 6.0.5

package/cli.d.ts

@@ -1,2 +1 @@
-#!/usr/bin/env node
-export {};
+export { }

package/generate.d.ts

@@ -1,155 +1,358 @@
-import ts from "typescript";
-import { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
-import { Opts } from ".";
-export * from "./tscodegen";
-export * from "./generateServers";
-export declare const verbs: string[];
-type ContentType = "json" | "form" | "multipart";
-type OnlyMode = "readOnly" | "writeOnly";
-type OnlyModes = Record<OnlyMode, boolean>;
-type OpenAPISchemaObject = OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject;
-type OpenAPIReferenceObject = OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject;
-type OpenAPIParameterObject = OpenAPIV3.ParameterObject | OpenAPIV3_1.ParameterObject;
-type OpenAPIDocument = OpenAPIV3.Document | OpenAPIV3_1.Document;
-type OpenAPIDiscriminatorObject = OpenAPIV3.DiscriminatorObject | OpenAPIV3_1.DiscriminatorObject;
-type OpenAPIResponseObject = OpenAPIV3.ResponseObject | OpenAPIV3_1.ResponseObject;
-type OpenAPIResponsesObject = OpenAPIV3.ResponsesObject | OpenAPIV3_1.ResponsesObject;
-type OpenAPIRequestBodyObject = OpenAPIV3.RequestBodyObject | OpenAPIV3_1.RequestBodyObject;
-type OpenAPIMediaTypeObject = OpenAPIV3.MediaTypeObject | OpenAPIV3_1.MediaTypeObject;
-export declare function isMimeType(s: unknown): boolean;
-export declare function isJsonMimeType(mime: string): boolean;
-export declare function getBodyFormatter(body?: OpenAPIRequestBodyObject): ContentType | undefined;
-type SchemaObject = OpenAPISchemaObject & {
-    const?: unknown;
-    "x-enumNames"?: string[];
-    "x-enum-varnames"?: string[];
-    "x-component-ref-path"?: string;
-    prefixItems?: (OpenAPIReferenceObject | SchemaObject)[];
-};
-/**
- * Get the name of a formatter function for a given parameter.
- */
-export declare function getFormatter({ style, explode, content, }: OpenAPIParameterObject): "json" | "form" | "deep" | "explode" | "space" | "pipe";
-export declare function getOperationIdentifier(id?: string): string | undefined;
-/**
- * Create a method name for a given operation, either from its operationId or
- * the HTTP verb and path.
- */
-export declare function getOperationName(verb: string, path: string, operationId?: string): string;
-export declare function isNullable(schema?: SchemaObject | OpenAPIReferenceObject): boolean | undefined;
-export declare function isReference(obj: unknown): obj is OpenAPIReferenceObject;
-/**
- * Converts a local reference path into an array of property names.
- */
-export declare function refPathToPropertyPath(ref: string): string[];
-/**
- * If the given object is a ReferenceObject, return the last part of its path.
- */
-export declare function getReferenceName(obj: unknown): string | undefined;
-export declare function toIdentifier(s: string, upperFirst?: boolean, onlyMode?: OnlyMode): string;
-/**
- * Create a template string literal from the given OpenAPI urlTemplate.
- * Curly braces in the path are turned into identifier expressions,
- * which are read from the local scope during runtime.
- */
-export declare function createUrlExpression(path: string, qs?: ts.Expression): ts.StringLiteral | ts.TemplateExpression;
-/**
- * Create a call expression for one of the QS runtime functions.
- */
-export declare function callQsFunction(name: string, args: ts.Expression[]): ts.CallExpression;
-/**
- * Create a call expression for one of the oazapfts runtime functions.
- */
-export declare function callOazapftsFunction(name: string, args: ts.Expression[], typeArgs?: ts.TypeNode[]): ts.CallExpression;
-/**
- * Despite its name, OpenApi's `deepObject` serialization does not support
- * deeply nested objects. As a workaround we detect parameters that contain
- * square brackets and merge them into a single object.
- */
-export declare function supportDeepObjects(params: OpenAPIParameterObject[]): OpenAPIV3.ParameterObject[];
-/**
- * Main entry point that generates TypeScript code from a given API spec.
- */
-export default class ApiGenerator {
-    readonly spec: OpenAPIDocument;
-    readonly opts: Opts;
-    /** Indicates if the document was converted from an older version of the OpenAPI specification. */
-    readonly isConverted: boolean;
-    constructor(spec: OpenAPIDocument, opts?: Opts, 
-    /** Indicates if the document was converted from an older version of the OpenAPI specification. */
-    isConverted?: boolean);
-    discriminatingSchemas: Set<string>;
-    aliases: (ts.TypeAliasDeclaration | ts.InterfaceDeclaration)[];
-    enumAliases: ts.Statement[];
-    enumRefs: Record<string, {
-        values: string;
-        type: ts.TypeReferenceNode;
-    }>;
-    refs: Record<string, {
-        base: ts.TypeReferenceNode;
-        readOnly?: ts.TypeReferenceNode;
-        writeOnly?: ts.TypeReferenceNode;
-    }>;
-    refsOnlyMode: Map<string, OnlyModes>;
-    typeAliases: Record<string, number>;
-    reset(): void;
-    resolve<T>(obj: T | OpenAPIReferenceObject): T;
-    resolveArray<T>(array?: Array<T | OpenAPIReferenceObject>): T[];
-    skip(tags?: string[]): boolean;
-    findAvailableRef(ref: string): string;
-    getUniqueAlias(name: string): string;
-    getEnumUniqueAlias(name: string, values: string): string;
-    /**
-     * Create a type alias for the schema referenced by the given ReferenceObject
-     */
-    getRefAlias(obj: OpenAPIReferenceObject, onlyMode?: OnlyMode, ignoreDiscriminator?: boolean): ts.TypeNode;
-    getUnionType(variants: (OpenAPIReferenceObject | SchemaObject)[], discriminator?: OpenAPIDiscriminatorObject, onlyMode?: OnlyMode): ts.UnionTypeNode;
-    /**
-     * Creates a type node from a given schema.
-     * Delegates to getBaseTypeFromSchema internally and
-     * optionally adds a union with null.
-     */
-    getTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): ts.TypeNode;
-    /**
-     * This is the very core of the OpenAPI to TS conversion - it takes a
-     * schema and returns the appropriate type.
-     */
-    getBaseTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): ts.TypeNode;
-    isTrueEnum(schema: SchemaObject, name?: string): name is string;
-    /**
-     * Creates literal type (or union) from an array of values
-     */
-    getTypeFromEnum(values: unknown[]): ts.LiteralTypeNode | ts.UnionTypeNode;
-    getEnumValuesString(values: string[]): string;
-    getTrueEnum(schema: SchemaObject, propName: string): ts.TypeReferenceNode;
-    /**
-     * Checks if readOnly/writeOnly properties are present in the given schema.
-     * Returns a tuple of booleans; the first one is about readOnly, the second
-     * one is about writeOnly.
-     */
-    checkSchemaOnlyMode(schema: SchemaObject | OpenAPIReferenceObject, resolveRefs?: boolean): OnlyModes;
-    /**
-     * Recursively creates a type literal with the given props.
-     */
-    getTypeFromProperties(props: {
-        [prop: string]: SchemaObject | OpenAPIReferenceObject;
-    }, required?: string[], additionalProperties?: boolean | OpenAPISchemaObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): ts.TypeLiteralNode;
-    getTypeFromResponses(responses: OpenAPIResponsesObject, onlyMode?: OnlyMode): ts.UnionTypeNode;
-    getTypeFromResponse(resOrRef: OpenAPIResponseObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): ts.TypeNode;
-    getResponseType(responses?: OpenAPIResponsesObject): "json" | "text" | "blob";
-    getSchemaFromContent(content: Record<string, OpenAPIMediaTypeObject>): OpenAPISchemaObject | OpenAPIReferenceObject;
-    getTypeFromParameter(p: OpenAPIParameterObject): ts.TypeNode;
-    wrapResult(ex: ts.Expression): ts.Expression;
-    /**
-     * Does three things:
-     * 1. Add a `x-component-ref-path` property.
-     * 2. Record discriminating schemas in `this.discriminatingSchemas`. A discriminating schema
-     *    refers to a schema that has a `discriminator` property which is neither used in conjunction
-     *    with `oneOf` nor `anyOf`.
-     * 3. Make all mappings of discriminating schemas explicit to generate types immediately.
-     */
-    preprocessComponents(schemas: {
-        [key: string]: OpenAPIReferenceObject | SchemaObject;
-    }): void;
-    generateApi(): ts.SourceFile;
-}
+import { default as default_2 } from 'typescript';
+import { OpenAPIV3 } from 'openapi-types';
+import { OpenAPIV3_1 } from 'openapi-types';
+
+export declare function addComment<T extends default_2.Node>(node: T, comment?: string): T;
+
+/**
+ * Main entry point that generates TypeScript code from a given API spec.
+ */
+declare class ApiGenerator {
+    readonly spec: OpenAPIDocument;
+    readonly opts: Opts;
+    /** Indicates if the document was converted from an older version of the OpenAPI specification. */
+    readonly isConverted: boolean;
+    constructor(spec: OpenAPIDocument, opts?: Opts, 
+    /** Indicates if the document was converted from an older version of the OpenAPI specification. */
+    isConverted?: boolean);
+    discriminatingSchemas: Set<string>;
+    aliases: (default_2.TypeAliasDeclaration | default_2.InterfaceDeclaration)[];
+    enumAliases: default_2.Statement[];
+    enumRefs: Record<string, {
+        values: string;
+        type: default_2.TypeReferenceNode;
+    }>;
+    refs: Record<string, {
+        base: default_2.TypeReferenceNode;
+        readOnly?: default_2.TypeReferenceNode;
+        writeOnly?: default_2.TypeReferenceNode;
+    }>;
+    refsOnlyMode: Map<string, OnlyModes>;
+    typeAliases: Record<string, number>;
+    reset(): void;
+    resolve<T>(obj: T | OpenAPIReferenceObject): T;
+    resolveArray<T>(array?: Array<T | OpenAPIReferenceObject>): T[];
+    skip(tags?: string[]): boolean;
+    findAvailableRef(ref: string): string;
+    getUniqueAlias(name: string): string;
+    getEnumUniqueAlias(name: string, values: string): string;
+    /**
+     * Create a type alias for the schema referenced by the given ReferenceObject
+     */
+    getRefAlias(obj: OpenAPIReferenceObject, onlyMode?: OnlyMode, ignoreDiscriminator?: boolean): default_2.TypeNode;
+    getUnionType(variants: (OpenAPIReferenceObject | SchemaObject)[], discriminator?: OpenAPIDiscriminatorObject, onlyMode?: OnlyMode): default_2.UnionTypeNode;
+    /**
+     * Creates a type node from a given schema.
+     * Delegates to getBaseTypeFromSchema internally and
+     * optionally adds a union with null.
+     */
+    getTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): default_2.TypeNode;
+    /**
+     * This is the very core of the OpenAPI to TS conversion - it takes a
+     * schema and returns the appropriate type.
+     */
+    getBaseTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): default_2.TypeNode;
+    isTrueEnum(schema: SchemaObject, name?: string): name is string;
+    /**
+     * Creates literal type (or union) from an array of values
+     */
+    getTypeFromEnum(values: unknown[]): default_2.LiteralTypeNode | default_2.UnionTypeNode;
+    getEnumValuesString(values: string[]): string;
+    getTrueEnum(schema: SchemaObject, propName: string): default_2.TypeReferenceNode;
+    /**
+     * Checks if readOnly/writeOnly properties are present in the given schema.
+     * Returns a tuple of booleans; the first one is about readOnly, the second
+     * one is about writeOnly.
+     */
+    checkSchemaOnlyMode(schema: SchemaObject | OpenAPIReferenceObject, resolveRefs?: boolean): OnlyModes;
+    /**
+     * Recursively creates a type literal with the given props.
+     */
+    getTypeFromProperties(props: {
+        [prop: string]: SchemaObject | OpenAPIReferenceObject;
+    }, required?: string[], additionalProperties?: boolean | OpenAPISchemaObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): default_2.TypeLiteralNode;
+    getTypeFromResponses(responses: OpenAPIResponsesObject, onlyMode?: OnlyMode): default_2.UnionTypeNode;
+    getTypeFromResponse(resOrRef: OpenAPIResponseObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): default_2.TypeNode;
+    getResponseType(responses?: OpenAPIResponsesObject): "json" | "text" | "blob";
+    getSchemaFromContent(content: Record<string, OpenAPIMediaTypeObject>): OpenAPISchemaObject | OpenAPIReferenceObject;
+    getTypeFromParameter(p: OpenAPIParameterObject): default_2.TypeNode;
+    wrapResult(ex: default_2.Expression): default_2.Expression;
+    /**
+     * Does three things:
+     * 1. Add a `x-component-ref-path` property.
+     * 2. Record discriminating schemas in `this.discriminatingSchemas`. A discriminating schema
+     *    refers to a schema that has a `discriminator` property which is neither used in conjunction
+     *    with `oneOf` nor `anyOf`.
+     * 3. Make all mappings of discriminating schemas explicit to generate types immediately.
+     */
+    preprocessComponents(schemas: {
+        [key: string]: OpenAPIReferenceObject | SchemaObject;
+    }): void;
+    generateApi(): default_2.SourceFile;
+}
+export default ApiGenerator;
+
+export declare function appendNodes<T extends default_2.Node>(array: default_2.NodeArray<T>, ...nodes: T[]): default_2.NodeArray<T>;
+
+export declare function block(...statements: default_2.Statement[]): default_2.Block;
+
+/**
+ * Create a call expression for one of the oazapfts runtime functions.
+ */
+export declare function callOazapftsFunction(name: string, args: default_2.Expression[], typeArgs?: default_2.TypeNode[]): default_2.CallExpression;
+
+/**
+ * Create a call expression for one of the QS runtime functions.
+ */
+export declare function callQsFunction(name: string, args: default_2.Expression[]): default_2.CallExpression;
+
+export declare function changePropertyValue(o: default_2.ObjectLiteralExpression, property: string, value: default_2.Expression): void;
+
+declare type ContentType = "json" | "form" | "multipart";
+
+export declare function createArrowFunction(parameters: default_2.ParameterDeclaration[], body: default_2.ConciseBody, { modifiers, typeParameters, type, equalsGreaterThanToken, }?: {
+    modifiers?: default_2.Modifier[];
+    typeParameters?: default_2.TypeParameterDeclaration[];
+    type?: default_2.TypeNode;
+    equalsGreaterThanToken?: default_2.EqualsGreaterThanToken;
+}): default_2.ArrowFunction;
+
+export declare function createCall(expression: default_2.Expression | string, { typeArgs, args, }?: {
+    typeArgs?: Array<default_2.TypeNode>;
+    args?: Array<default_2.Expression>;
+}): default_2.CallExpression;
+
+export declare function createClassDeclaration({ modifiers, name, typeParameters, heritageClauses, members, }: {
+    modifiers?: Array<default_2.Modifier>;
+    name?: string | default_2.Identifier;
+    typeParameters?: Array<default_2.TypeParameterDeclaration>;
+    heritageClauses?: Array<default_2.HeritageClause>;
+    members: Array<default_2.ClassElement>;
+}): default_2.ClassDeclaration;
+
+export declare function createConstructor({ modifiers, parameters, body, }: {
+    modifiers?: Array<default_2.Modifier>;
+    parameters: Array<default_2.ParameterDeclaration>;
+    body?: default_2.Block;
+}): default_2.ConstructorDeclaration;
+
+export declare function createEnumTypeNode(values: Array<string | boolean | number>): default_2.LiteralTypeNode | default_2.UnionTypeNode;
+
+export declare function createFunctionDeclaration(name: string | default_2.Identifier | undefined, { modifiers, asteriskToken, typeParameters, type, }: {
+    modifiers?: default_2.Modifier[];
+    asteriskToken?: default_2.AsteriskToken;
+    typeParameters?: default_2.TypeParameterDeclaration[];
+    type?: default_2.TypeNode;
+}, parameters: default_2.ParameterDeclaration[], body?: default_2.Block): default_2.FunctionDeclaration;
+
+export declare function createIndexSignature(type: default_2.TypeNode, { modifiers, indexName, indexType, }?: {
+    indexName?: string;
+    indexType?: default_2.TypeNode;
+    modifiers?: Array<default_2.Modifier>;
+}): default_2.IndexSignatureDeclaration;
+
+export declare function createInterfaceAliasDeclaration({ modifiers, name, typeParameters, type, inheritedNodeNames, }: {
+    modifiers?: Array<default_2.Modifier>;
+    name: string | default_2.Identifier;
+    typeParameters?: Array<default_2.TypeParameterDeclaration>;
+    type: default_2.TypeNode;
+    inheritedNodeNames?: (string | default_2.Identifier)[];
+}): default_2.InterfaceDeclaration;
+
+export declare function createKeywordType(type: KeywordTypeName): default_2.KeywordTypeNode<default_2.SyntaxKind.AnyKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.NumberKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.ObjectKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.StringKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.BooleanKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.UndefinedKeyword> | default_2.KeywordTypeNode<default_2.SyntaxKind.VoidKeyword> | default_2.LiteralTypeNode;
+
+export declare function createLiteral(v: string | boolean | number): default_2.StringLiteral | default_2.TrueLiteral | default_2.FalseLiteral | default_2.NumericLiteral;
+
+export declare function createMethod(name: string | default_2.Identifier | default_2.StringLiteral | default_2.NumericLiteral | default_2.ComputedPropertyName, { modifiers, asteriskToken, questionToken, typeParameters, type, }?: {
+    modifiers?: default_2.Modifier[];
+    asteriskToken?: default_2.AsteriskToken;
+    questionToken?: default_2.QuestionToken | boolean;
+    typeParameters?: default_2.TypeParameterDeclaration[];
+    type?: default_2.TypeNode;
+}, parameters?: default_2.ParameterDeclaration[], body?: default_2.Block): default_2.MethodDeclaration;
+
+export declare function createMethodCall(method: string, opts: {
+    typeArgs?: Array<default_2.TypeNode>;
+    args?: Array<default_2.Expression>;
+}): default_2.CallExpression;
+
+export declare function createObjectBinding(elements: Array<{
+    name: string | default_2.BindingName;
+    dotDotDotToken?: default_2.DotDotDotToken;
+    propertyName?: string | default_2.PropertyName;
+    initializer?: default_2.Expression;
+}>): default_2.ObjectBindingPattern;
+
+export declare function createObjectLiteral(props: [string, string | default_2.Expression][]): default_2.ObjectLiteralExpression;
+
+export declare function createParameter(name: string | default_2.BindingName, { modifiers, dotDotDotToken, questionToken, type, initializer, }: {
+    modifiers?: Array<default_2.Modifier>;
+    dotDotDotToken?: default_2.DotDotDotToken;
+    questionToken?: default_2.QuestionToken | boolean;
+    type?: default_2.TypeNode;
+    initializer?: default_2.Expression;
+}): default_2.ParameterDeclaration;
+
+export declare function createPropertyAssignment(name: string, expression: default_2.Expression): default_2.PropertyAssignment | default_2.ShorthandPropertyAssignment;
+
+export declare function createPropertySignature({ modifiers, name, questionToken, type, }: {
+    modifiers?: Array<default_2.Modifier>;
+    name: default_2.PropertyName | string;
+    questionToken?: default_2.QuestionToken | boolean;
+    type?: default_2.TypeNode;
+}): default_2.PropertySignature;
+
+export declare function createQuestionToken(token?: boolean | default_2.QuestionToken): default_2.QuestionToken | undefined;
+
+export declare function createTemplateString(head: string, spans: Array<{
+    literal: string;
+    expression: default_2.Expression;
+}>): default_2.StringLiteral | default_2.TemplateExpression;
+
+export declare function createTypeAliasDeclaration({ modifiers, name, typeParameters, type, }: {
+    modifiers?: Array<default_2.Modifier>;
+    name: string | default_2.Identifier;
+    typeParameters?: Array<default_2.TypeParameterDeclaration>;
+    type: default_2.TypeNode;
+}): default_2.TypeAliasDeclaration;
+
+/**
+ * Create a template string literal from the given OpenAPI urlTemplate.
+ * Curly braces in the path are turned into identifier expressions,
+ * which are read from the local scope during runtime.
+ */
+export declare function createUrlExpression(path: string, qs?: default_2.Expression): default_2.StringLiteral | default_2.TemplateExpression;
+
+export declare function defaultBaseUrl(servers: OpenAPIV3.ServerObject[]): default_2.StringLiteral;
+
+export declare function findFirstVariableDeclaration(nodes: default_2.NodeArray<default_2.Node>, name: string): default_2.VariableDeclaration;
+
+export declare function findNode<T extends default_2.Node>(nodes: default_2.NodeArray<default_2.Node>, kind: T extends {
+    kind: infer K;
+} ? K : never, test?: (node: T) => boolean | undefined): T;
+
+export declare function getBodyFormatter(body?: OpenAPIRequestBodyObject): ContentType | undefined;
+
+export declare function getFirstDeclarationName(n: default_2.VariableStatement): string | (void & {
+    __escapedIdentifier: void;
+});
+
+/**
+ * Get the name of a formatter function for a given parameter.
+ */
+export declare function getFormatter({ style, explode, content, }: OpenAPIParameterObject): "json" | "form" | "deep" | "explode" | "space" | "pipe";
+
+export declare function getName(name: default_2.Node): string | (void & {
+    __escapedIdentifier: void;
+});
+
+export declare function getOperationIdentifier(id?: string): string | undefined;
+
+/**
+ * Create a method name for a given operation, either from its operationId or
+ * the HTTP verb and path.
+ */
+export declare function getOperationName(verb: string, path: string, operationId?: string): string;
+
+/**
+ * If the given object is a ReferenceObject, return the last part of its path.
+ */
+export declare function getReferenceName(obj: unknown): string | undefined;
+
+export declare function isJsonMimeType(mime: string): boolean;
+
+export declare function isMimeType(s: unknown): boolean;
+
+export declare function isNullable(schema?: SchemaObject | OpenAPIReferenceObject): boolean | undefined;
+
+export declare function isReference(obj: unknown): obj is OpenAPIReferenceObject;
+
+export declare function isValidIdentifier(str: string): boolean;
+
+export declare const keywordType: {
+    any: default_2.KeywordTypeNode<default_2.SyntaxKind.AnyKeyword>;
+    number: default_2.KeywordTypeNode<default_2.SyntaxKind.NumberKeyword>;
+    object: default_2.KeywordTypeNode<default_2.SyntaxKind.ObjectKeyword>;
+    string: default_2.KeywordTypeNode<default_2.SyntaxKind.StringKeyword>;
+    boolean: default_2.KeywordTypeNode<default_2.SyntaxKind.BooleanKeyword>;
+    undefined: default_2.KeywordTypeNode<default_2.SyntaxKind.UndefinedKeyword>;
+    void: default_2.KeywordTypeNode<default_2.SyntaxKind.VoidKeyword>;
+    null: default_2.LiteralTypeNode;
+};
+
+declare type KeywordTypeName = keyof typeof keywordType;
+
+export declare const modifier: {
+    async: default_2.ModifierToken<default_2.SyntaxKind.AsyncKeyword>;
+    export: default_2.ModifierToken<default_2.SyntaxKind.ExportKeyword>;
+};
+
+declare type OnlyMode = "readOnly" | "writeOnly";
+
+declare type OnlyModes = Record<OnlyMode, boolean>;
+
+declare type OpenAPIDiscriminatorObject = OpenAPIV3.DiscriminatorObject | OpenAPIV3_1.DiscriminatorObject;
+
+declare type OpenAPIDocument = OpenAPIV3.Document | OpenAPIV3_1.Document;
+
+declare type OpenAPIMediaTypeObject = OpenAPIV3.MediaTypeObject | OpenAPIV3_1.MediaTypeObject;
+
+declare type OpenAPIParameterObject = OpenAPIV3.ParameterObject | OpenAPIV3_1.ParameterObject;
+
+declare type OpenAPIReferenceObject = OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject;
+
+declare type OpenAPIRequestBodyObject = OpenAPIV3.RequestBodyObject | OpenAPIV3_1.RequestBodyObject;
+
+declare type OpenAPIResponseObject = OpenAPIV3.ResponseObject | OpenAPIV3_1.ResponseObject;
+
+declare type OpenAPIResponsesObject = OpenAPIV3.ResponsesObject | OpenAPIV3_1.ResponsesObject;
+
+declare type OpenAPISchemaObject = OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject;
+
+declare type Opts = {
+    include?: string[];
+    exclude?: string[];
+    optimistic?: boolean;
+    unionUndefined?: boolean;
+    useEnumType?: boolean;
+    mergeReadWriteOnly?: boolean;
+    argumentStyle?: (typeof optsArgumentStyles)[number];
+};
+
+declare const optsArgumentStyles: string[];
+
+export declare function printFile(sourceFile: default_2.SourceFile): string;
+
+export declare function printNode(node: default_2.Node): string;
+
+export declare function printNodes(nodes: default_2.Node[]): string;
+
+export declare const questionToken: default_2.PunctuationToken<default_2.SyntaxKind.QuestionToken>;
+
+/**
+ * Converts a local reference path into an array of property names.
+ */
+export declare function refPathToPropertyPath(ref: string): string[];
+
+export declare type SchemaObject = OpenAPISchemaObject & {
+    const?: unknown;
+    "x-enumNames"?: string[];
+    "x-enum-varnames"?: string[];
+    "x-component-ref-path"?: string;
+    prefixItems?: (OpenAPIReferenceObject | SchemaObject)[];
+};
+
+/**
+ * Despite its name, OpenApi's `deepObject` serialization does not support
+ * deeply nested objects. As a workaround we detect parameters that contain
+ * square brackets and merge them into a single object.
+ */
+export declare function supportDeepObjects(params: OpenAPIParameterObject[]): OpenAPIV3.ParameterObject[];
+
+export declare function toExpression(ex: default_2.Expression | string): default_2.Expression;
+
+export declare function toIdentifier(s: string, upperFirst?: boolean, onlyMode?: OnlyMode): string;
+
+export declare const verbs: string[];
+
+export { }