openapi-typesafe 0.0.0 → 1.0.0-rc.1

package/dist/index.d.mts

@@ -0,0 +1,841 @@
+import { PathLike } from 'node:fs';
+import { Readable } from 'node:stream';
+import { Config } from '@redocly/openapi-core';
+import ts from 'typescript';
+import colors from 'ansi-colors';
+
+type IrKeyword = "string" | "number" | "boolean" | "null" | "undefined" | "unknown" | "never";
+type IrStringEncoding = "json" | "escaped";
+interface IrKeywordType {
+    readonly kind: "keyword";
+    readonly keyword: IrKeyword;
+}
+interface IrStringLiteralType {
+    readonly kind: "stringLiteral";
+    readonly value: string;
+    readonly encoding: IrStringEncoding;
+}
+interface IrNumberLiteralType {
+    readonly kind: "numberLiteral";
+    readonly value: number;
+}
+interface IrBooleanLiteralType {
+    readonly kind: "booleanLiteral";
+    readonly value: boolean;
+}
+interface IrReferenceType {
+    readonly kind: "reference";
+    readonly name: string;
+    readonly typeArguments: readonly IrType[];
+}
+interface IrArrayType {
+    readonly kind: "array";
+    readonly element: IrType;
+}
+interface IrTupleElement {
+    readonly type: IrType;
+    readonly isRest: boolean;
+    readonly isOptional: boolean;
+}
+interface IrTupleType {
+    readonly kind: "tuple";
+    readonly elements: readonly IrTupleElement[];
+}
+interface IrUnionType {
+    readonly kind: "union";
+    readonly types: readonly IrType[];
+}
+interface IrIntersectionType {
+    readonly kind: "intersection";
+    readonly types: readonly IrType[];
+}
+interface IrObjectType {
+    readonly kind: "object";
+    readonly members: readonly IrMember[];
+}
+interface IrIndexedAccessType {
+    readonly kind: "indexedAccess";
+    readonly object: IrType;
+    readonly index: IrType;
+}
+interface IrReadonlyType {
+    readonly kind: "readonly";
+    readonly type: IrType;
+}
+interface IrRawType {
+    readonly kind: "raw";
+    readonly text: string;
+    readonly origin?: unknown;
+}
+type IrType = IrKeywordType | IrStringLiteralType | IrNumberLiteralType | IrBooleanLiteralType | IrReferenceType | IrArrayType | IrTupleType | IrUnionType | IrIntersectionType | IrObjectType | IrIndexedAccessType | IrReadonlyType | IrRawType;
+type IrComment = {
+    readonly kind: "block";
+    readonly text: string;
+} | {
+    readonly kind: "line";
+    readonly text: string;
+};
+type IrPropertyName = {
+    readonly kind: "identifier";
+    readonly text: string;
+} | {
+    readonly kind: "string";
+    readonly value: string;
+} | {
+    readonly kind: "number";
+    readonly text: string;
+};
+interface IrPropertySignature {
+    readonly kind: "property";
+    readonly name: IrPropertyName;
+    readonly type: IrType;
+    readonly isOptional: boolean;
+    readonly isReadonly: boolean;
+    readonly comments: readonly IrComment[];
+}
+interface IrIndexSignature {
+    readonly kind: "indexSignature";
+    readonly parameterName: string;
+    readonly parameterType: IrType;
+    readonly type: IrType;
+    readonly isReadonly: boolean;
+    readonly comments: readonly IrComment[];
+}
+type IrMember = IrPropertySignature | IrIndexSignature;
+interface IrInterfaceDeclaration {
+    readonly kind: "interface";
+    readonly name: string;
+    readonly isExported: boolean;
+    readonly members: readonly IrMember[];
+    readonly comments: readonly IrComment[];
+}
+interface IrTypeAliasDeclaration {
+    readonly kind: "typeAlias";
+    readonly name: string;
+    readonly isExported: boolean;
+    readonly type: IrType;
+    readonly comments: readonly IrComment[];
+}
+interface IrEnumMember {
+    readonly name: string;
+    readonly value: string | number;
+    readonly comments: readonly IrComment[];
+}
+interface IrEnumDeclaration {
+    readonly kind: "enum";
+    readonly name: string;
+    readonly isExported: boolean;
+    readonly members: readonly IrEnumMember[];
+    readonly comments: readonly IrComment[];
+}
+interface IrConstArrayDeclaration {
+    readonly kind: "constArray";
+    readonly name: string;
+    readonly isExported: boolean;
+    readonly type: IrType;
+    readonly values: readonly (string | number)[];
+    readonly comments: readonly IrComment[];
+}
+interface IrRawDeclaration {
+    readonly kind: "rawDeclaration";
+    readonly text: string;
+    readonly name?: string;
+}
+type IrDeclaration = IrInterfaceDeclaration | IrTypeAliasDeclaration | IrEnumDeclaration | IrConstArrayDeclaration | IrRawDeclaration;
+
+type FooterEntry = IrDeclaration | ts.Node;
+
+type DebugGroup = "redoc" | "lint" | "bundle" | "ts";
+interface Logger {
+    debug(message: string, group?: DebugGroup, durationMs?: number): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+
+declare const OutputFix: {
+    readonly ALLOF_DISCRIMINATED_UNION: "allof-discriminated-union";
+    readonly ALLOF_REQUIRED: "allof-required";
+    readonly ANYOF_ONEOF_DESCRIPTIONS: "anyof-oneof-descriptions";
+    readonly ANYOF_ONEOF_REQUIRED: "anyof-oneof-required";
+    readonly ANYOF_PROPERTIES: "anyof-properties";
+    readonly ARRAY_LENGTH_TUPLES: "array-length-tuples";
+    readonly DEDUPE_ENUM_NAMES: "dedupe-enum-names";
+    readonly DISCRIMINATOR_MEMBER_REQUIRED: "discriminator-member-required";
+    readonly DISCRIMINATOR_VALUES: "discriminator-values";
+    readonly EXPLODED_QUERY_OBJECTS: "exploded-query-objects";
+    readonly NULLABLE_ENUMS: "nullable-enums";
+    readonly PATH_PARAM_TYPE_NAMES: "path-param-type-names";
+    readonly PREFIX_ITEMS: "prefix-items";
+    readonly READ_WRITE_REFS: "read-write-refs";
+    readonly REF_POINTERS: "ref-pointers";
+    readonly ROOT_TYPE_NUMBERING: "root-type-numbering";
+    readonly UNEVALUATED_PROPERTIES: "unevaluated-properties";
+};
+type OutputFix = (typeof OutputFix)[keyof typeof OutputFix];
+declare const OUTPUT_FIXES: readonly OutputFix[];
+declare const ALL_OUTPUT_FIXES = "all";
+type OutputFixName = OutputFix | typeof ALL_OUTPUT_FIXES;
+
+interface EnumMemberMetadata {
+    readonly name: string | undefined;
+    readonly description: string | undefined;
+}
+interface EnumDeclarationRequest {
+    readonly name: string;
+    readonly isComponentSchema: boolean;
+    readonly values: readonly (string | number)[];
+    readonly metadata: readonly EnumMemberMetadata[];
+    readonly isOwnerReference?: boolean;
+}
+interface EnumValuesRequest {
+    readonly name: string;
+    readonly type: IrType;
+    readonly values: readonly (string | number)[];
+}
+interface FooterDeclarations {
+    addEnum(request: EnumDeclarationRequest): string;
+    enumMembers(name: string): ReadonlyMap<string | number, string>;
+    addEnumValues(request: EnumValuesRequest): void;
+    requireWithRequired(): void;
+    requirePropertyValues(): void;
+}
+
+interface DocumentFooter extends FooterDeclarations {
+    addOperation(build: () => IrPropertySignature): void;
+}
+
+interface Extensable {
+    [key: `x-${string}`]: any;
+}
+interface ServerObject extends Extensable {
+    url: string;
+    description: string;
+    variables: {
+        [name: string]: ServerVariableObject;
+    };
+}
+interface ServerVariableObject extends Extensable {
+    enum?: string[];
+    default: string;
+    description?: string;
+}
+interface ExternalDocumentationObject extends Extensable {
+    description?: string;
+    url: string;
+}
+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;
+    contentMediaType?: string;
+    contentEncoding?: string;
+    additionalProperties?: boolean | Record<string, never> | SchemaObject | ReferenceObject;
+    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 StringSubtype {
+    type: "string" | ["string", "null"];
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    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>;
+    defaultMapping?: string;
+    oneOf?: string[];
+}
+interface XMLObject extends Extensable {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+type $defs = Record<string, SchemaObject>;
+
+interface ParameterObject extends Extensable {
+    name: string;
+    in: "query" | "header" | "path" | "cookie" | "querystring";
+    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;
+    itemSchema?: 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;
+}
+interface ExampleObject extends Extensable {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+type HeaderObject = Omit<ParameterObject, "name" | "in">;
+
+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;
+    };
+}
+interface LinkObject extends Extensable {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+        [name: string]: `$${string}`;
+    };
+    requestBody?: `$${string}`;
+    description?: string;
+    server?: ServerObject;
+}
+
+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 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;
+    query?: OperationObject | ReferenceObject;
+    additionalOperations?: Record<string, 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[];
+}
+type CallbackObject = Record<string, PathItemObject>;
+
+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 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>;
+    mediaTypes?: Record<string, MediaTypeObject | ReferenceObject>;
+}
+interface PathsObject {
+    [pathname: string]: PathItemObject | ReferenceObject;
+}
+interface WebhooksObject {
+    [name: string]: PathItemObject;
+}
+interface TagObject extends Extensable {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+}
+
+interface TransformObject {
+    schema: IrType | ts.TypeNode;
+    questionToken: boolean;
+}
+type SchemaSource = string | URL | OpenAPI3 | Buffer | Readable;
+interface OpenAPITSBaseOptions {
+    additionalProperties?: boolean;
+    alphabetize?: boolean;
+    arrayLength?: boolean;
+    binaryAsBlob?: boolean;
+    emptyObjectsUnknown?: boolean;
+    cwd?: PathLike;
+    localRefRoot?: string | URL;
+    remoteRefHosts?: readonly string[];
+    defaultNonNullable?: boolean;
+    excludeDeprecated?: boolean;
+    fix?: readonly OutputFixName[];
+    immutable?: boolean;
+    lint?: 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 LegacyCallbackOptions {
+    irCallbacks?: false;
+    transform?: (schemaObject: SchemaObject, options: TransformNodeOptions) => IrType | ts.TypeNode | TransformObject | undefined;
+    postTransform?: (type: ts.TypeNode, options: TransformNodeOptions) => IrType | ts.TypeNode | undefined;
+    transformProperty?: (property: ts.PropertySignature, schemaObject: SchemaObject, options: TransformNodeOptions) => IrPropertySignature | ts.PropertySignature | undefined;
+}
+type LegacyCallbackName = "transform" | "postTransform" | "transformProperty";
+type IrCallbackType = IrType | string;
+interface IrTransformObject {
+    schema: IrCallbackType;
+    questionToken: boolean;
+}
+type IrTransform = (schemaObject: SchemaObject, options: TransformNodeOptions) => IrCallbackType | IrTransformObject | undefined;
+type IrPostTransform = (type: IrType, options: TransformNodeOptions) => IrCallbackType | undefined;
+type IrTransformProperty = (property: IrPropertySignature, schemaObject: SchemaObject, options: TransformNodeOptions) => IrPropertySignature | undefined;
+interface IrCallbackOptions {
+    irCallbacks: true;
+    transform?: IrTransform;
+    postTransform?: IrPostTransform;
+    transformProperty?: IrTransformProperty;
+}
+interface OpenAPITSOptions extends OpenAPITSBaseOptions, LegacyCallbackOptions {
+}
+interface OpenAPITSIrOptions extends OpenAPITSBaseOptions, IrCallbackOptions {
+}
+type GeneratorOptions = OpenAPITSOptions | OpenAPITSIrOptions;
+interface GlobalContext {
+    additionalProperties: boolean;
+    alphabetize: boolean;
+    arrayLength: boolean;
+    binaryAsBlob: boolean;
+    defaultNonNullable: boolean;
+    discriminators: {
+        objects: Record<string, DiscriminatorObject>;
+        refsHandled: string[];
+        enumParents?: ReadonlyMap<object, {
+            readonly schema: SchemaObject;
+            readonly path: string;
+        }>;
+        otherProperties?: Readonly<Record<string, readonly string[]>>;
+    };
+    emptyObjectsUnknown: boolean;
+    enum: boolean;
+    enumValues: boolean;
+    conditionalEnums: boolean;
+    dedupeEnums: boolean;
+    excludeDeprecated: boolean;
+    exportType: boolean;
+    fix?: readonly OutputFix[];
+    immutable: boolean;
+    injectFooter: FooterEntry[];
+    runFooter?: DocumentFooter;
+    legacyCallbackWarnings?: Set<LegacyCallbackName>;
+    logger?: Logger;
+    pathParamsAsTypes: boolean;
+    irCallbacks: boolean;
+    postTransform: GeneratorOptions["postTransform"];
+    propertiesRequiredByDefault: boolean;
+    rootTypes: boolean;
+    rootTypesNoSchemaPrefix: boolean;
+    rootTypesKeepCasing: boolean;
+    redoc: Config;
+    silent: boolean;
+    transform: GeneratorOptions["transform"];
+    transformProperty: GeneratorOptions["transformProperty"];
+    resolve<T>($ref: string): T | undefined;
+    inject?: string;
+    makePathsEnum: boolean;
+    generatePathParams: boolean;
+    readWriteMarkers: boolean;
+}
+interface TransformNodeOptions {
+    path?: string;
+    schema?: SchemaObject | ReferenceObject;
+    ctx: GlobalContext;
+}
+
+declare function openapiTS(source: SchemaSource, options?: GeneratorOptions): Promise<IrDeclaration[]>;
+
+declare const ERROR_CODES: {
+    readonly SCHEMA_SOURCE_EMPTY: "SCHEMA_SOURCE_EMPTY";
+    readonly SCHEMA_SOURCE_INVALID: "SCHEMA_SOURCE_INVALID";
+    readonly SCHEMA_LOAD_FAILED: "SCHEMA_LOAD_FAILED";
+    readonly SCHEMA_PARSE_FAILED: "SCHEMA_PARSE_FAILED";
+    readonly SCHEMA_VERSION_UNSUPPORTED: "SCHEMA_VERSION_UNSUPPORTED";
+    readonly SCHEMA_INVALID: "SCHEMA_INVALID";
+    readonly SCHEMA_REF_INVALID: "SCHEMA_REF_INVALID";
+    readonly SCHEMA_REF_FORBIDDEN: "SCHEMA_REF_FORBIDDEN";
+    readonly SCHEMA_OBJECT_INVALID: "SCHEMA_OBJECT_INVALID";
+    readonly SCHEMA_PROPERTY_INVALID: "SCHEMA_PROPERTY_INVALID";
+    readonly SCHEMA_TOO_DEEP: "SCHEMA_TOO_DEEP";
+    readonly SCHEMA_KEY_UNSUPPORTED: "SCHEMA_KEY_UNSUPPORTED";
+    readonly ENUM_NAME_EMPTY: "ENUM_NAME_EMPTY";
+    readonly CALLBACK_RESULT_UNREADABLE: "CALLBACK_RESULT_UNREADABLE";
+    readonly OPTION_FIX_UNKNOWN: "OPTION_FIX_UNKNOWN";
+    readonly TYPESCRIPT_NOT_FOUND: "TYPESCRIPT_NOT_FOUND";
+    readonly CLI_FLAG_REMOVED: "CLI_FLAG_REMOVED";
+    readonly CLI_GLOB_UNSUPPORTED: "CLI_GLOB_UNSUPPORTED";
+    readonly CLI_CONFIG_NOT_FOUND: "CLI_CONFIG_NOT_FOUND";
+    readonly CLI_CONFIG_INVALID: "CLI_CONFIG_INVALID";
+    readonly CLI_CONFIG_OUTPUT_MISSING: "CLI_CONFIG_OUTPUT_MISSING";
+    readonly CLI_CHECK_OUTPUT_MISSING: "CLI_CHECK_OUTPUT_MISSING";
+    readonly CLI_INPUT_MISSING: "CLI_INPUT_MISSING";
+    readonly OUTPUT_STALE: "OUTPUT_STALE";
+    readonly OUTPUT_READ_FAILED: "OUTPUT_READ_FAILED";
+    readonly OUTPUT_WRITE_FAILED: "OUTPUT_WRITE_FAILED";
+};
+type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+type ErrorDetails = Readonly<Record<string, unknown>>;
+interface OpenAPITypesafeErrorInit {
+    readonly code: ErrorCode;
+    readonly message: string;
+    readonly details?: ErrorDetails;
+    readonly cause?: unknown;
+}
+declare class OpenAPITypesafeError extends Error {
+    readonly code: ErrorCode;
+    readonly details: ErrorDetails;
+    constructor(init: OpenAPITypesafeErrorInit);
+}
+declare function isOpenAPITypesafeError(value: unknown): value is OpenAPITypesafeError;
+
+interface AstToStringOptions {
+    fileName?: string;
+    sourceText?: string;
+    formatOptions?: ts.PrinterOptions;
+}
+
+type IrPrintable = IrDeclaration | IrMember | IrType;
+
+type AstToStringInput = IrPrintable | ts.Node | readonly (IrPrintable | ts.Node)[];
+declare function astToString(ast: AstToStringInput, options?: AstToStringOptions): string;
+
+declare const COMMENT_HEADER = "/**\n * This file was auto-generated by openapi-typesafe.\n * Do not make direct changes to the file.\n */\n\n";
+
+interface EnumParent {
+    readonly schema: SchemaObject;
+    readonly path: string;
+}
+
+interface DiscriminatorScan {
+    objects: Record<string, DiscriminatorObject>;
+    refsHandled: string[];
+    enumParents: ReadonlyMap<object, EnumParent>;
+    otherProperties: Readonly<Record<string, readonly string[]>>;
+}
+declare function scanDiscriminators(schema: OpenAPI3, options: GeneratorOptions, logger?: Logger): DiscriminatorScan;
+
+type TypeInput = IrType | ts.TypeNode;
+declare const BOOLEAN: IrType;
+declare const FALSE: IrType;
+declare const NEVER: IrType;
+declare const NULL: IrType;
+declare const NUMBER: IrType;
+declare const STRING: IrType;
+declare const TRUE: IrType;
+declare const UNDEFINED: IrType;
+declare const UNKNOWN: IrType;
+declare function tsUnion(types: readonly TypeInput[]): IrType;
+declare function tsIntersection(types: readonly TypeInput[]): IrType;
+declare function tsNullable(types: readonly TypeInput[]): IrType;
+declare function tsOmit(type: TypeInput, keys: readonly string[]): IrType;
+declare function tsRecord(key: TypeInput, value: TypeInput): IrType;
+declare function tsLiteral(value: unknown): IrType;
+declare function tsWithRequired(type: TypeInput, keys: readonly string[], injectFooter: FooterEntry[]): IrType;
+interface OapiRefOptions {
+    deep?: boolean;
+    extractProperties?: string[];
+}
+declare function oapiRef(path: string, resolved?: ParameterObject | ReferenceObject, options?: OapiRefOptions): IrType;
+
+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 QUESTION_TOKEN: ts.QuestionToken;
+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;
+declare function tsDedupe(types: TypeInput[]): 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: TypeInput, values: (string | number)[], options?: {
+    export?: boolean;
+    readonly?: boolean;
+    injectFooter?: FooterEntry[];
+}): ts.VariableStatement;
+declare function tsEnumMember(value: string | number, metadata?: {
+    name?: string;
+    description?: string | null;
+}): ts.EnumMember;
+declare function tsIsPrimitive(input: TypeInput): boolean;
+declare function tsModifiers(modifiers: {
+    readonly?: boolean;
+    export?: boolean;
+}): ts.Modifier[];
+declare function tsPropertyIndex(index: string | number): ts.Identifier | ts.NumericLiteral | ts.StringLiteral;
+declare function tsReadonlyArray(type: TypeInput, injectFooter?: FooterEntry[]): ts.TypeNode;
+
+interface ResolveRefOptions {
+    silent: boolean;
+    visited?: string[];
+    logger?: Logger;
+}
+
+declare const c: typeof colors;
+declare function createDiscriminatorProperty(discriminator: DiscriminatorObject, { path, readonly }: {
+    path: string;
+    readonly?: boolean;
+}): IrPropertySignature;
+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, options: ResolveRefOptions): T | undefined;
+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 const STRING_TO_AST_DEPRECATION_CODE = "OPENAPI_TYPESAFE_DEP_STRING_TO_AST";
+declare const stringToAST: (source: string) => unknown[];
+
+declare function transformSchema(schema: OpenAPI3, ctx: GlobalContext): IrDeclaration[];
+
+declare function transformComponentsObject(componentsObject: ComponentsObject, ctx: GlobalContext): (IrType | IrTypeAliasDeclaration)[];
+
+declare function transformHeaderObject(headerObject: HeaderObject, options: TransformNodeOptions): IrType;
+
+declare function transformMediaTypeObject(mediaTypeObject: MediaTypeObject, options: TransformNodeOptions): IrType;
+
+declare function transformOperationObject(operationObject: OperationObject, options: TransformNodeOptions): IrMember[];
+declare function injectOperationObject(operationId: string, operationObject: OperationObject, options: TransformNodeOptions): void;
+
+declare function transformParameterObject(parameterObject: ParameterObject, options: TransformNodeOptions): IrType;
+
+type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+
+type Method = HttpMethod;
+declare function transformPathItemObject(pathItem: PathItemObject, options: TransformNodeOptions): IrType;
+
+declare function transformPathsObject(pathsObject: PathsObject, ctx: GlobalContext): IrType;
+
+declare function transformRequestBodyObject(requestBodyObject: RequestBodyObject, options: TransformNodeOptions): IrType;
+
+declare function transformResponseObject(responseObject: ResponseObject, options: TransformNodeOptions): IrType;
+
+declare function transformResponsesObject(responsesObject: ResponsesObject, options: TransformNodeOptions): IrType;
+
+declare function transformSchemaObject(schemaObject: SchemaObject | ReferenceObject, options: TransformNodeOptions, fromAdditionalProperties?: boolean): IrType;
+declare function transformSchemaObjectWithComposition(schemaObject: SchemaObject | ReferenceObject, options: TransformNodeOptions, fromAdditionalProperties?: boolean): IrType;
+
+export { ALL_OUTPUT_FIXES, BOOLEAN, COMMENT_HEADER, ERROR_CODES, FALSE, JS_ENUM_INVALID_CHARS_RE, JS_PROPERTY_INDEX_INVALID_CHARS_RE, JS_PROPERTY_INDEX_RE, NEVER, NULL, NUMBER, OUTPUT_FIXES, OpenAPITypesafeError, OutputFix, QUESTION_TOKEN, SPECIAL_CHARACTER_MAP, STRING, STRING_TO_AST_DEPRECATION_CODE, TRUE, UNDEFINED, UNKNOWN, addJSDocComment, astToString, c, createDiscriminatorProperty, createRef, debug, openapiTS as default, enumCache, error, formatTime, getEntries, injectOperationObject, isOpenAPITypesafeError, 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, AstToStringInput, AstToStringOptions, BooleanSubtype, CallbackObject, ComponentsObject, ContactObject, DiscriminatorObject, EncodingObject, ErrorCode, ErrorDetails, ExampleObject, Extensable, ExternalDocumentationObject, FooterEntry, GeneratorOptions, GlobalContext, HeaderObject, InfoObject, IntegerSubtype, IrArrayType, IrBooleanLiteralType, IrCallbackOptions, IrCallbackType, IrComment, IrConstArrayDeclaration, IrDeclaration, IrEnumDeclaration, IrEnumMember, IrIndexSignature, IrIndexedAccessType, IrInterfaceDeclaration, IrIntersectionType, IrKeyword, IrKeywordType, IrMember, IrNumberLiteralType, IrObjectType, IrPostTransform, IrPropertyName, IrPropertySignature, IrRawDeclaration, IrRawType, IrReadonlyType, IrReferenceType, IrStringEncoding, IrStringLiteralType, IrTransform, IrTransformObject, IrTransformProperty, IrTupleElement, IrTupleType, IrType, IrTypeAliasDeclaration, IrUnionType, LegacyCallbackName, LegacyCallbackOptions, LicenseObject, LinkObject, MediaTypeObject, Method, NullSubtype, NumberSubtype, OAuthFlowObject, OAuthFlowsObject, OapiRefOptions, ObjectSubtype, OpenAPI3, OpenAPITSBaseOptions, OpenAPITSIrOptions, OpenAPITSOptions, OperationObject, OutputFixName, ParameterObject, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResolveRefOptions, ResponseObject, ResponsesObject, SchemaObject, SchemaSource, SecurityRequirementObject, SecuritySchemeObject, ServerObject, ServerVariableObject, StringSubtype, TagObject, TransformNodeOptions, TransformObject, TypeInput, WebhooksObject, XMLObject };