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