@depup/openapi-typescript 7.13.0-depup.0

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/index.ts"],"sourcesContent":["import { performance } from \"node:perf_hooks\";\nimport type { Readable } from \"node:stream\";\nimport { createConfig } from \"@redocly/openapi-core\";\nimport type ts from \"typescript\";\nimport { validateAndBundle } from \"./lib/redoc.js\";\nimport { debug, resolveRef, scanDiscriminators } from \"./lib/utils.js\";\nimport transformSchema from \"./transform/index.js\";\nimport type { GlobalContext, OpenAPI3, OpenAPITSOptions } from \"./types.js\";\n\nexport * from \"./lib/ts.js\";\nexport * from \"./lib/utils.js\";\nexport { default as transformComponentsObject } from \"./transform/components-object.js\";\nexport { default as transformHeaderObject } from \"./transform/header-object.js\";\nexport { default as transformSchema } from \"./transform/index.js\";\nexport { default as transformMediaTypeObject } from \"./transform/media-type-object.js\";\nexport * from \"./transform/operation-object.js\";\nexport { default as transformOperationObject } from \"./transform/operation-object.js\";\nexport { default as transformParameterObject } from \"./transform/parameter-object.js\";\nexport * from \"./transform/path-item-object.js\";\nexport { default as transformPathItemObject } from \"./transform/path-item-object.js\";\nexport { default as transformPathsObject } from \"./transform/paths-object.js\";\nexport { default as transformRequestBodyObject } from \"./transform/request-body-object.js\";\nexport { default as transformResponseObject } from \"./transform/response-object.js\";\nexport { default as transformResponsesObject } from \"./transform/responses-object.js\";\nexport * from \"./transform/schema-object.js\";\nexport { default as transformSchemaObject } from \"./transform/schema-object.js\";\nexport * from \"./types.js\";\n\nexport const COMMENT_HEADER = `/**\n * This file was auto-generated by openapi-typescript.\n * Do not make direct changes to the file.\n */\n\n`;\n\n/**\n * Convert an OpenAPI schema to TypesScript AST\n * @param {string|URL|object|Readable} source OpenAPI schema source:\n *   - YAML: string\n *   - JSON: parsed object\n *   - URL: URL to a YAML or JSON file (local or remote)\n *   - Readable: Readable stream of YAML or JSON\n */\nexport default async function openapiTS(\n  source: string | URL | OpenAPI3 | Buffer | Readable,\n  options: OpenAPITSOptions = {} as Partial<OpenAPITSOptions>,\n): Promise<ts.Node[]> {\n  if (!source) {\n    throw new Error(\"Empty schema. Please specify a URL, file path, or Redocly Config\");\n  }\n\n  const redoc =\n    options.redocly ??\n    (await createConfig(\n      {\n        rules: {\n          \"operation-operationId-unique\": { severity: \"error\" }, // throw error on duplicate operationIDs\n        },\n      },\n      { extends: [\"minimal\"] },\n    ));\n\n  const schema = await validateAndBundle(source, {\n    redoc,\n    cwd: options.cwd instanceof URL ? options.cwd : new URL(`file://${options.cwd ?? process.cwd()}/`),\n    silent: options.silent ?? false,\n  });\n\n  const ctx: GlobalContext = {\n    additionalProperties: options.additionalProperties ?? false,\n    alphabetize: options.alphabetize ?? false,\n    arrayLength: options.arrayLength ?? false,\n    defaultNonNullable: options.defaultNonNullable ?? true,\n    discriminators: scanDiscriminators(schema, options),\n    emptyObjectsUnknown: options.emptyObjectsUnknown ?? false,\n    enum: options.enum ?? false,\n    enumValues: options.enumValues ?? false,\n    conditionalEnums: options.conditionalEnums ?? false,\n    dedupeEnums: options.dedupeEnums ?? false,\n    excludeDeprecated: options.excludeDeprecated ?? false,\n    exportType: options.exportType ?? false,\n    immutable: options.immutable ?? false,\n    rootTypes: options.rootTypes ?? false,\n    rootTypesNoSchemaPrefix: options.rootTypesNoSchemaPrefix ?? false,\n    rootTypesKeepCasing: options.rootTypesKeepCasing ?? false,\n    injectFooter: [],\n    pathParamsAsTypes: options.pathParamsAsTypes ?? false,\n    postTransform: typeof options.postTransform === \"function\" ? options.postTransform : undefined,\n    propertiesRequiredByDefault: options.propertiesRequiredByDefault ?? false,\n    redoc,\n    silent: options.silent ?? false,\n    inject: options.inject ?? undefined,\n    transform: typeof options.transform === \"function\" ? options.transform : undefined,\n    transformProperty: typeof options.transformProperty === \"function\" ? options.transformProperty : undefined,\n    makePathsEnum: options.makePathsEnum ?? false,\n    generatePathParams: options.generatePathParams ?? false,\n    readWriteMarkers: options.readWriteMarkers ?? false,\n    resolve($ref) {\n      return resolveRef(schema, $ref, { silent: options.silent ?? false });\n    },\n  };\n\n  const transformT = performance.now();\n  const result = transformSchema(schema, ctx);\n  debug(\"Completed AST transformation for entire document\", \"ts\", performance.now() - transformT);\n\n  return result;\n}\n"],"names":["redoc","createConfig","validateAndBundle","scanDiscriminators","resolveRef","performance","transformSchema","debug"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,517 @@
+import { Readable } from 'node:stream';
+import ts from 'typescript';
+import { PathLike } from 'node:fs';
+import { Config, Referenced } from '@redocly/openapi-core';
+export { default as c } from 'ansi-colors';
+
+interface Extensable {
+    [key: `x-${string}`]: any;
+}
+interface OpenAPI3 extends Extensable {
+    openapi: string;
+    info: InfoObject;
+    jsonSchemaDialect?: string;
+    servers?: ServerObject[];
+    paths?: PathsObject;
+    webhooks?: {
+        [id: string]: PathItemObject | ReferenceObject;
+    };
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    $defs?: $defs;
+}
+interface InfoObject extends Extensable {
+    title: string;
+    summary?: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+interface ContactObject extends Extensable {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+interface LicenseObject extends Extensable {
+    name: string;
+    identifier: string;
+    url: string;
+}
+interface ServerObject extends Extensable {
+    url: string;
+    description: string;
+    variables: {
+        [name: string]: ServerVariableObject;
+    };
+}
+interface ServerVariableObject extends Extensable {
+    enum?: string[];
+    default: string;
+    description?: string;
+}
+interface ComponentsObject extends Extensable {
+    schemas?: Record<string, SchemaObject>;
+    responses?: Record<string, ResponseObject | ReferenceObject>;
+    parameters?: Record<string, ParameterObject | ReferenceObject>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    requestBodies?: Record<string, RequestBodyObject | ReferenceObject>;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+    callbacks?: Record<string, CallbackObject | ReferenceObject>;
+    pathItems?: Record<string, PathItemObject | ReferenceObject>;
+}
+interface PathsObject {
+    [pathname: string]: PathItemObject | ReferenceObject;
+}
+interface WebhooksObject {
+    [name: string]: PathItemObject;
+}
+interface PathItemObject extends Extensable {
+    get?: OperationObject | ReferenceObject;
+    put?: OperationObject | ReferenceObject;
+    post?: OperationObject | ReferenceObject;
+    delete?: OperationObject | ReferenceObject;
+    options?: OperationObject | ReferenceObject;
+    head?: OperationObject | ReferenceObject;
+    patch?: OperationObject | ReferenceObject;
+    trace?: OperationObject | ReferenceObject;
+    servers?: ServerObject[];
+    parameters?: (ParameterObject | ReferenceObject)[];
+}
+interface OperationObject extends Extensable {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses?: ResponsesObject;
+    callbacks?: Record<string, CallbackObject | ReferenceObject>;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+}
+interface ExternalDocumentationObject extends Extensable {
+    description?: string;
+    url: string;
+}
+interface ParameterObject extends Extensable {
+    name: string;
+    in: "query" | "header" | "path" | "cookie";
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: SchemaObject;
+    example?: any;
+    examples?: {
+        [name: string]: ExampleObject | ReferenceObject;
+    };
+    content?: {
+        [contentType: string]: MediaTypeObject | ReferenceObject;
+    };
+}
+interface RequestBodyObject extends Extensable {
+    description?: string;
+    content: {
+        [contentType: string]: MediaTypeObject | ReferenceObject;
+    };
+    required?: boolean;
+}
+interface MediaTypeObject extends Extensable {
+    schema?: SchemaObject | ReferenceObject;
+    example?: any;
+    examples?: {
+        [name: string]: ExampleObject | ReferenceObject;
+    };
+    encoding?: {
+        [propertyName: string]: EncodingObject;
+    };
+}
+interface EncodingObject extends Extensable {
+    contentType?: string;
+    headers?: {
+        [name: string]: HeaderObject | ReferenceObject;
+    };
+    style?: string;
+    explode?: string;
+    allowReserved?: string;
+}
+type ResponsesObject = {
+    [responseCode: string]: ResponseObject | ReferenceObject;
+} & {
+    default?: ResponseObject | ReferenceObject;
+};
+interface ResponseObject extends Extensable {
+    description: string;
+    headers?: {
+        [name: string]: HeaderObject | ReferenceObject;
+    };
+    content?: {
+        [contentType: string]: MediaTypeObject;
+    };
+    links?: {
+        [name: string]: LinkObject | ReferenceObject;
+    };
+}
+type CallbackObject = Record<string, PathItemObject>;
+interface ExampleObject extends Extensable {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+interface LinkObject extends Extensable {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+        [name: string]: `$${string}`;
+    };
+    requestBody?: `$${string}`;
+    description?: string;
+    server?: ServerObject;
+}
+type HeaderObject = Omit<ParameterObject, "name" | "in">;
+interface TagObject extends Extensable {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+}
+interface ReferenceObject extends Extensable {
+    $ref: string;
+    summary?: string;
+    description?: string;
+}
+type SchemaObject = {
+    discriminator?: DiscriminatorObject;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    title?: string;
+    description?: string;
+    $comment?: string;
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    enum?: unknown[];
+    const?: unknown;
+    default?: unknown;
+    format?: string;
+    nullable?: boolean;
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    allOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    required?: string[];
+    [key: `x-${string}`]: any;
+} & (StringSubtype | NumberSubtype | IntegerSubtype | ArraySubtype | BooleanSubtype | NullSubtype | ObjectSubtype | {
+    type: ("string" | "number" | "integer" | "array" | "boolean" | "null" | "object")[];
+});
+interface TransformObject {
+    schema: ts.TypeNode;
+    questionToken: boolean;
+}
+interface StringSubtype {
+    type: "string" | ["string", "null"];
+    enum?: (string | ReferenceObject)[];
+}
+interface NumberSubtype {
+    type: "number" | ["number", "null"];
+    minimum?: number;
+    maximum?: number;
+    enum?: (number | ReferenceObject)[];
+}
+interface IntegerSubtype {
+    type: "integer" | ["integer", "null"];
+    minimum?: number;
+    maximum?: number;
+    enum?: (number | ReferenceObject)[];
+}
+interface ArraySubtype {
+    type: "array" | ["array", "null"];
+    prefixItems?: (SchemaObject | ReferenceObject)[];
+    items?: SchemaObject | ReferenceObject | (SchemaObject | ReferenceObject)[];
+    minItems?: number;
+    maxItems?: number;
+    enum?: (SchemaObject | ReferenceObject)[];
+}
+interface BooleanSubtype {
+    type: "boolean" | ["boolean", "null"];
+    enum?: (boolean | ReferenceObject)[];
+}
+interface NullSubtype {
+    type: "null";
+}
+interface ObjectSubtype {
+    type: "object" | ["object", "null"];
+    properties?: {
+        [name: string]: SchemaObject | ReferenceObject;
+    };
+    additionalProperties?: boolean | Record<string, never> | SchemaObject | ReferenceObject;
+    patternProperties?: Record<string, SchemaObject | ReferenceObject>;
+    required?: string[];
+    allOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    enum?: (SchemaObject | ReferenceObject)[];
+    $defs?: $defs;
+}
+interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: Record<string, string>;
+    oneOf?: string[];
+}
+interface XMLObject extends Extensable {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+type SecuritySchemeObject = {
+    description?: string;
+    [key: `x-${string}`]: any;
+} & ({
+    type: "apiKey";
+    name: string;
+    in: "query" | "header" | "cookie";
+} | {
+    type: "http";
+    scheme: string;
+    bearer?: string;
+} | {
+    type: "mutualTLS";
+} | {
+    type: "oauth2";
+    flows: OAuthFlowsObject;
+} | {
+    type: "openIdConnect";
+    openIdConnectUrl: string;
+});
+interface OAuthFlowsObject extends Extensable {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+}
+interface OAuthFlowObject extends Extensable {
+    authorizationUrl: string;
+    tokenUrl: string;
+    refreshUrl: string;
+    scopes: {
+        [name: string]: string;
+    };
+}
+type SecurityRequirementObject = {
+    [P in keyof ComponentsObject["securitySchemes"]]?: string[];
+};
+interface OpenAPITSOptions {
+    additionalProperties?: boolean;
+    alphabetize?: boolean;
+    arrayLength?: boolean;
+    emptyObjectsUnknown?: boolean;
+    cwd?: PathLike;
+    defaultNonNullable?: boolean;
+    excludeDeprecated?: boolean;
+    transform?: (schemaObject: SchemaObject, options: TransformNodeOptions) => ts.TypeNode | TransformObject | undefined;
+    postTransform?: (type: ts.TypeNode, options: TransformNodeOptions) => ts.TypeNode | undefined;
+    transformProperty?: (property: ts.PropertySignature, schemaObject: SchemaObject, options: TransformNodeOptions) => ts.PropertySignature | undefined;
+    immutable?: boolean;
+    silent?: boolean;
+    version?: number;
+    exportType?: boolean;
+    enum?: boolean;
+    enumValues?: boolean;
+    conditionalEnums?: boolean;
+    dedupeEnums?: boolean;
+    pathParamsAsTypes?: boolean;
+    propertiesRequiredByDefault?: boolean;
+    rootTypes?: boolean;
+    rootTypesNoSchemaPrefix?: boolean;
+    rootTypesKeepCasing?: boolean;
+    redocly?: Config;
+    inject?: string;
+    makePathsEnum?: boolean;
+    generatePathParams?: boolean;
+    readWriteMarkers?: boolean;
+}
+interface GlobalContext {
+    additionalProperties: boolean;
+    alphabetize: boolean;
+    arrayLength: boolean;
+    defaultNonNullable: boolean;
+    discriminators: {
+        objects: Record<string, DiscriminatorObject>;
+        refsHandled: string[];
+    };
+    emptyObjectsUnknown: boolean;
+    enum: boolean;
+    enumValues: boolean;
+    conditionalEnums: boolean;
+    dedupeEnums: boolean;
+    excludeDeprecated: boolean;
+    exportType: boolean;
+    immutable: boolean;
+    injectFooter: ts.Node[];
+    pathParamsAsTypes: boolean;
+    postTransform: OpenAPITSOptions["postTransform"];
+    propertiesRequiredByDefault: boolean;
+    rootTypes: boolean;
+    rootTypesNoSchemaPrefix: boolean;
+    rootTypesKeepCasing: boolean;
+    redoc: Config;
+    silent: boolean;
+    transform: OpenAPITSOptions["transform"];
+    transformProperty: OpenAPITSOptions["transformProperty"];
+    resolve<T>($ref: string): T | undefined;
+    inject?: string;
+    makePathsEnum: boolean;
+    generatePathParams: boolean;
+    readWriteMarkers: boolean;
+}
+type $defs = Record<string, SchemaObject>;
+interface TransformNodeOptions {
+    path?: string;
+    schema?: SchemaObject | ReferenceObject;
+    ctx: GlobalContext;
+}
+
+declare const JS_PROPERTY_INDEX_RE: RegExp;
+declare const JS_ENUM_INVALID_CHARS_RE: RegExp;
+declare const JS_PROPERTY_INDEX_INVALID_CHARS_RE: RegExp;
+declare const SPECIAL_CHARACTER_MAP: Record<string, string>;
+declare const BOOLEAN: ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword>;
+declare const FALSE: ts.LiteralTypeNode;
+declare const NEVER: ts.KeywordTypeNode<ts.SyntaxKind.NeverKeyword>;
+declare const NULL: ts.LiteralTypeNode;
+declare const NUMBER: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
+declare const QUESTION_TOKEN: ts.PunctuationToken<ts.SyntaxKind.QuestionToken>;
+declare const STRING: ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword>;
+declare const TRUE: ts.LiteralTypeNode;
+declare const UNDEFINED: ts.KeywordTypeNode<ts.SyntaxKind.UndefinedKeyword>;
+declare const UNKNOWN: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+interface AnnotatedSchemaObject {
+    const?: unknown;
+    default?: unknown;
+    deprecated?: boolean;
+    description?: string;
+    enum?: unknown[];
+    example?: string;
+    examples?: unknown;
+    format?: string;
+    nullable?: boolean;
+    summary?: string;
+    title?: string;
+    type?: string | string[];
+}
+declare function addJSDocComment(schemaObject: AnnotatedSchemaObject, node: ts.PropertySignature): void;
+type OapiRefResolved = Referenced<ParameterObject>;
+interface OapiRefOptions {
+    deep?: boolean;
+    extractProperties?: string[];
+}
+declare function oapiRef(path: string, resolved?: OapiRefResolved, options?: OapiRefOptions): ts.TypeNode;
+interface AstToStringOptions {
+    fileName?: string;
+    sourceText?: string;
+    formatOptions?: ts.PrinterOptions;
+}
+declare function astToString(ast: ts.Node | ts.Node[] | ts.TypeElement | ts.TypeElement[], options?: AstToStringOptions): string;
+declare function stringToAST(source: string): unknown[];
+declare function tsDedupe(types: ts.TypeNode[]): ts.TypeNode[];
+declare const enumCache: Map<string, ts.EnumDeclaration>;
+declare function tsEnum(name: string, members: (string | number)[], metadata?: {
+    name?: string;
+    description?: string | null;
+}[], options?: {
+    export?: boolean;
+    shouldCache?: boolean;
+}): ts.EnumDeclaration;
+declare function tsArrayLiteralExpression(name: string, elementType: ts.TypeNode, values: (string | number)[], options?: {
+    export?: boolean;
+    readonly?: boolean;
+    injectFooter?: ts.Node[];
+}): ts.VariableStatement;
+declare function tsEnumMember(value: string | number, metadata?: {
+    name?: string;
+    description?: string | null;
+}): ts.EnumMember;
+declare function tsIntersection(types: ts.TypeNode[]): ts.TypeNode;
+declare function tsIsPrimitive(type: ts.TypeNode): boolean;
+declare function tsLiteral(value: unknown): ts.TypeNode;
+declare function tsModifiers(modifiers: {
+    readonly?: boolean;
+    export?: boolean;
+}): ts.Modifier[];
+declare function tsNullable(types: ts.TypeNode[]): ts.TypeNode;
+declare function tsOmit(type: ts.TypeNode, keys: string[]): ts.TypeNode;
+declare function tsRecord(key: ts.TypeNode, value: ts.TypeNode): ts.TypeReferenceNode;
+declare function tsPropertyIndex(index: string | number): ts.Identifier | ts.NumericLiteral | ts.StringLiteral;
+declare function tsUnion(types: ts.TypeNode[]): ts.TypeNode;
+declare function tsWithRequired(type: ts.TypeNode, keys: string[], injectFooter: ts.Node[]): ts.TypeNode;
+declare function tsReadonlyArray(type: ts.TypeNode, injectFooter?: ts.Node[]): ts.TypeNode;
+
+declare function createDiscriminatorProperty(discriminator: DiscriminatorObject, { path, readonly }: {
+    path: string;
+    readonly?: boolean;
+}): ts.TypeElement;
+declare function createRef(parts: (number | string | undefined | null)[]): string;
+declare function debug(msg: string, group?: string, time?: number): void;
+declare function error(msg: string): void;
+declare function formatTime(t: number): string;
+declare function getEntries<T>(obj: ArrayLike<T> | Record<string, T>, options?: {
+    alphabetize?: boolean;
+    excludeDeprecated?: boolean;
+}): [string, T][];
+declare function resolveRef<T>(schema: any, $ref: string, { silent, visited }: {
+    silent: boolean;
+    visited?: string[];
+}): T | undefined;
+declare function scanDiscriminators(schema: OpenAPI3, options: OpenAPITSOptions): {
+    objects: Record<string, DiscriminatorObject>;
+    refsHandled: string[];
+};
+declare function walk(obj: unknown, cb: (value: Record<string, unknown>, path: (string | number)[]) => void, path?: (string | number)[]): void;
+declare function warn(msg: string, silent?: boolean): void;
+
+declare function transformComponentsObject(componentsObject: ComponentsObject, ctx: GlobalContext): ts.Node[];
+
+declare function transformHeaderObject(headerObject: HeaderObject, options: TransformNodeOptions): ts.TypeNode;
+
+declare function transformSchema(schema: OpenAPI3, ctx: GlobalContext): ts.Node[];
+
+declare function transformMediaTypeObject(mediaTypeObject: MediaTypeObject, options: TransformNodeOptions): ts.TypeNode;
+
+declare function transformOperationObject(operationObject: OperationObject, options: TransformNodeOptions): ts.TypeElement[];
+declare function injectOperationObject(operationId: string, operationObject: OperationObject, options: TransformNodeOptions): void;
+
+declare function transformParameterObject(parameterObject: ParameterObject, options: TransformNodeOptions): ts.TypeNode;
+
+type Method = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+declare function transformPathItemObject(pathItem: PathItemObject, options: TransformNodeOptions): ts.TypeNode;
+
+declare function transformPathsObject(pathsObject: PathsObject, ctx: GlobalContext): ts.TypeNode;
+
+declare function transformRequestBodyObject(requestBodyObject: RequestBodyObject, options: TransformNodeOptions): ts.TypeNode;
+
+declare function transformResponseObject(responseObject: ResponseObject, options: TransformNodeOptions): ts.TypeNode;
+
+declare function transformResponsesObject(responsesObject: ResponsesObject, options: TransformNodeOptions): ts.TypeNode;
+
+declare function transformSchemaObject(schemaObject: SchemaObject | ReferenceObject, options: TransformNodeOptions, fromAdditionalProperties?: boolean): ts.TypeNode;
+declare function transformSchemaObjectWithComposition(schemaObject: SchemaObject | ReferenceObject, options: TransformNodeOptions, fromAdditionalProperties?: boolean): ts.TypeNode;
+
+declare const COMMENT_HEADER = "/**\n * This file was auto-generated by openapi-typescript.\n * Do not make direct changes to the file.\n */\n\n";
+declare function openapiTS(source: string | URL | OpenAPI3 | Buffer | Readable, options?: OpenAPITSOptions): Promise<ts.Node[]>;
+
+// @ts-ignore
+export = openapiTS;
+export { BOOLEAN, COMMENT_HEADER, FALSE, JS_ENUM_INVALID_CHARS_RE, JS_PROPERTY_INDEX_INVALID_CHARS_RE, JS_PROPERTY_INDEX_RE, NEVER, NULL, NUMBER, QUESTION_TOKEN, SPECIAL_CHARACTER_MAP, STRING, TRUE, UNDEFINED, UNKNOWN, addJSDocComment, astToString, createDiscriminatorProperty, createRef, debug, enumCache, error, formatTime, getEntries, injectOperationObject, oapiRef, resolveRef, scanDiscriminators, stringToAST, transformComponentsObject, transformHeaderObject, transformMediaTypeObject, transformOperationObject, transformParameterObject, transformPathItemObject, transformPathsObject, transformRequestBodyObject, transformResponseObject, transformResponsesObject, transformSchema, transformSchemaObject, transformSchemaObjectWithComposition, tsArrayLiteralExpression, tsDedupe, tsEnum, tsEnumMember, tsIntersection, tsIsPrimitive, tsLiteral, tsModifiers, tsNullable, tsOmit, tsPropertyIndex, tsReadonlyArray, tsRecord, tsUnion, tsWithRequired, walk, warn };
+export type { $defs, AnnotatedSchemaObject, ArraySubtype, AstToStringOptions, BooleanSubtype, CallbackObject, ComponentsObject, ContactObject, DiscriminatorObject, EncodingObject, ExampleObject, Extensable, ExternalDocumentationObject, GlobalContext, HeaderObject, InfoObject, IntegerSubtype, LicenseObject, LinkObject, MediaTypeObject, Method, NullSubtype, NumberSubtype, OAuthFlowObject, OAuthFlowsObject, OapiRefOptions, ObjectSubtype, OpenAPI3, OpenAPITSOptions, OperationObject, ParameterObject, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SecurityRequirementObject, SecuritySchemeObject, ServerObject, ServerVariableObject, StringSubtype, TagObject, TransformNodeOptions, TransformObject, WebhooksObject, XMLObject };