@hey-api/openapi-ts 0.86.3 → 0.86.5

package/dist/index.d.cts

@@ -1,4 +1,6 @@
-import { C as OpenApiSchemaObject, D as MaybeArray, E as LazyOrAsync, S as OpenApiResponseObject, _ as OpenApi, a as ExpressionTransformer, b as OpenApiParameterObject, c as Client$2, d as Plugin, f as Client$7, g as UserConfig, i as TypeTransformer, l as PluginHandler, m as Logger, o as compiler, r as IR, s as tsc, t as LegacyIR, u as DefinePlugin, v as OpenApiMetaObject, w as StringCase, x as OpenApiRequestBodyObject, y as OpenApiOperationObject } from "./types-CBGf9bNY.cjs";
+import { A as FunctionParameter, C as StringCase, D as ImportExportItemObject, E as Comments, F as __export, M as ObjectValue, N as SyntaxKindKeyword, O as tsNodeToString, P as types_d_exports, S as PluginHandler, T as MaybeArray, _ as OpenApiResponseObject, b as Logger, c as ExpressionTransformer, d as Client$7, f as OpenApi, g as OpenApiRequestBodyObject, h as OpenApiParameterObject, i as UserConfig, j as FunctionTypeParameter, k as AccessLevel, l as DefinePlugin, m as OpenApiOperationObject, o as IR, p as OpenApiMetaObject, s as TypeTransformer, t as LegacyIR, u as Plugin, v as OpenApiSchemaObject, w as LazyOrAsync, x as Client$2 } from "./types-ComCm5zo.cjs";
+import * as typescript0 from "typescript";
+import ts from "typescript";
 import { HttpClient, HttpErrorResponse, HttpHeaders, HttpRequest, HttpResponse } from "@angular/common/http";
 import { Injector } from "@angular/core";
 import { AxiosError, AxiosInstance, AxiosRequestHeaders, AxiosResponse, AxiosStatic, CreateAxiosDefaults } from "axios";
@@ -39,11 +41,18 @@ type ObjectStyle = 'form' | 'deepObject';
 //#region src/plugins/@hey-api/client-core/bundle/bodySerializer.d.ts
 type QuerySerializer$1 = (query: Record<string, unknown>) => string;
 type BodySerializer = (body: any) => any;
-interface QuerySerializerOptions {
+type QuerySerializerOptionsObject = {
   allowReserved?: boolean;
-  array?: SerializerOptions<ArrayStyle>;
-  object?: SerializerOptions<ObjectStyle>;
-}
+  array?: Partial<SerializerOptions<ArrayStyle>>;
+  object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+  /**
+   * Per-parameter serialization overrides. When provided, these settings
+   * override the global array/object settings for specific parameter names.
+   */
+  parameters?: Record<string, QuerySerializerOptionsObject>;
+};
 //#endregion
 //#region src/plugins/@hey-api/client-core/bundle/types.d.ts
 type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
@@ -865,6 +874,14 @@ interface TDataShape {
 type OmitKeys<T$1, K$1> = Pick<T$1, Exclude<keyof T$1, K$1>>;
 type Options$1<TData$1 extends TDataShape = TDataShape, ThrowOnError$1 extends boolean = boolean, TResponse = unknown, TResponseStyle$1 extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle$1, ThrowOnError$1>, 'body' | 'path' | 'query' | 'url'> & Omit<TData$1, 'url'>;
 //#endregion
+//#region src/generate.d.ts
+/**
+ * Generate a client from the provided configuration.
+ *
+ * @param userConfig User provided {@link UserConfig} configuration(s).
+ */
+declare const createClient: (userConfig?: LazyOrAsync<MaybeArray<UserConfig>>, logger?: Logger) => Promise<ReadonlyArray<Client$7 | IR.Context>>;
+//#endregion
 //#region src/config/parser.d.ts
 declare const defaultPaginationKeywords: readonly ["after", "before", "cursor", "offset", "page", "start"];
 //#endregion
@@ -900,6 +917,1175 @@ declare const definePluginConfig: <T extends Plugin.Types>(defaultConfig: Plugin
    */
   name: any;
 };
+declare namespace module_d_exports {
+  export { ImportExportItem, createCallExpression, createConstVariable, createExportAllDeclaration, createNamedExportDeclarations, createNamedImportDeclarations };
+}
+/**
+ * Create export all declaration. Example: `export * from './y'`.
+ * @param module - module containing exports
+ * @returns ts.ExportDeclaration
+ */
+declare const createExportAllDeclaration: ({
+  module,
+  shouldAppendJs
+}: {
+  module: string;
+  shouldAppendJs?: boolean;
+}) => ts.ExportDeclaration;
+type ImportExportItem = ImportExportItemObject | string;
+declare const createCallExpression: ({
+  functionName,
+  parameters,
+  types
+}: {
+  functionName: string | ts.PropertyAccessExpression | ts.PropertyAccessChain | ts.ElementAccessExpression | ts.Expression;
+  parameters?: Array<string | ts.Expression | undefined>;
+  types?: ReadonlyArray<ts.TypeNode>;
+}) => ts.CallExpression;
+/**
+ * Create a named export declaration. Example: `export { X } from './y'`.
+ * @param exports - named imports to export
+ * @param module - module containing exports
+ * @returns ts.ExportDeclaration
+ */
+declare const createNamedExportDeclarations: ({
+  exports,
+  module
+}: {
+  exports: Array<ImportExportItem> | ImportExportItem;
+  module: string;
+}) => ts.ExportDeclaration;
+/**
+ * Create a const variable. Optionally, it can use const assertion or export
+ * statement. Example: `export x = {} as const`.
+ * @param assertion use const assertion?
+ * @param exportConst export created variable?
+ * @param expression expression for the variable.
+ * @param name name of the variable.
+ * @returns ts.VariableStatement
+ */
+declare const createConstVariable: ({
+  assertion,
+  comment,
+  destructure,
+  exportConst,
+  expression,
+  name,
+  typeName
+}: {
+  assertion?: "const" | ts.TypeNode;
+  comment?: Comments;
+  destructure?: boolean;
+  exportConst?: boolean;
+  expression: ts.Expression;
+  name: string | ts.TypeReferenceNode;
+  typeName?: string | ts.IndexedAccessTypeNode | ts.TypeNode;
+}) => ts.VariableStatement;
+/**
+ * Create a named import declaration. Example: `import { X } from './y'`.
+ * @param imports - named exports to import
+ * @param module - module containing imports
+ * @returns ts.ImportDeclaration
+ */
+declare const createNamedImportDeclarations: ({
+  imports,
+  module
+}: {
+  imports: Array<ImportExportItem> | ImportExportItem;
+  module: string;
+}) => ts.ImportDeclaration;
+//#endregion
+//#region src/tsc/typedef.d.ts
+type Property = {
+  comment?: Comments;
+  isReadOnly?: boolean;
+  isRequired?: boolean;
+  name: string | ts.PropertyName;
+  type: any | ts.TypeNode;
+};
+//#endregion
+//#region src/tsc/index.d.ts
+declare const tsc: {
+  anonymousFunction: ({
+    async,
+    comment,
+    multiLine,
+    parameters,
+    returnType,
+    statements,
+    types: types_d_exports
+  }: {
+    async?: boolean;
+    comment?: Comments;
+    multiLine?: boolean;
+    parameters?: FunctionParameter[];
+    returnType?: string | typescript0.TypeNode;
+    statements?: ReadonlyArray<typescript0.Statement>;
+    types?: FunctionTypeParameter[];
+  }) => typescript0.FunctionExpression;
+  arrayLiteralExpression: <T>({
+    elements,
+    multiLine
+  }: {
+    elements: T[];
+    multiLine?: boolean;
+  }) => typescript0.ArrayLiteralExpression;
+  arrowFunction: ({
+    async,
+    comment,
+    multiLine,
+    parameters,
+    returnType,
+    statements,
+    types: types_d_exports
+  }: {
+    async?: boolean;
+    comment?: Comments;
+    multiLine?: boolean;
+    parameters?: ReadonlyArray<FunctionParameter>;
+    returnType?: string | typescript0.TypeNode;
+    statements?: typescript0.Statement[] | typescript0.Expression;
+    types?: FunctionTypeParameter[];
+  }) => typescript0.ArrowFunction;
+  asExpression: ({
+    expression,
+    type
+  }: {
+    expression: typescript0.Expression;
+    type: typescript0.TypeNode;
+  }) => typescript0.AsExpression;
+  assignment: ({
+    left,
+    right
+  }: {
+    left: typescript0.Expression;
+    right: typescript0.Expression;
+  }) => typescript0.AssignmentExpression<typescript0.EqualsToken>;
+  awaitExpression: ({
+    expression
+  }: {
+    expression: typescript0.Expression;
+  }) => typescript0.AwaitExpression;
+  binaryExpression: ({
+    left,
+    operator,
+    right
+  }: {
+    left: typescript0.Expression;
+    operator?: "=" | "===" | "!==" | "in" | "??";
+    right: typescript0.Expression | string;
+  }) => typescript0.BinaryExpression;
+  block: ({
+    multiLine,
+    statements
+  }: {
+    multiLine?: boolean;
+    statements: ReadonlyArray<typescript0.Statement>;
+  }) => typescript0.Block;
+  callExpression: ({
+    functionName,
+    parameters,
+    types: types_d_exports
+  }: {
+    functionName: string | typescript0.PropertyAccessExpression | typescript0.PropertyAccessChain | typescript0.ElementAccessExpression | typescript0.Expression;
+    parameters?: Array<string | typescript0.Expression | undefined>;
+    types?: ReadonlyArray<typescript0.TypeNode>;
+  }) => typescript0.CallExpression;
+  classDeclaration: ({
+    decorator,
+    exportClass,
+    extendedClasses,
+    name,
+    nodes
+  }: {
+    decorator?: {
+      args: any[];
+      name: string;
+    };
+    exportClass?: boolean;
+    extendedClasses?: ReadonlyArray<string>;
+    name: string;
+    nodes: ReadonlyArray<typescript0.ClassElement>;
+  }) => typescript0.ClassDeclaration;
+  conditionalExpression: ({
+    condition,
+    whenFalse,
+    whenTrue
+  }: {
+    condition: typescript0.Expression;
+    whenFalse: typescript0.Expression;
+    whenTrue: typescript0.Expression;
+  }) => typescript0.ConditionalExpression;
+  constVariable: ({
+    assertion,
+    comment,
+    destructure,
+    exportConst,
+    expression,
+    name,
+    typeName
+  }: {
+    assertion?: "const" | typescript0.TypeNode;
+    comment?: Comments;
+    destructure?: boolean;
+    exportConst?: boolean;
+    expression: typescript0.Expression;
+    name: string | typescript0.TypeReferenceNode;
+    typeName?: string | typescript0.IndexedAccessTypeNode | typescript0.TypeNode;
+  }) => typescript0.VariableStatement;
+  constructorDeclaration: ({
+    accessLevel,
+    comment,
+    multiLine,
+    parameters,
+    statements
+  }: {
+    accessLevel?: AccessLevel;
+    comment?: Comments;
+    multiLine?: boolean;
+    parameters?: FunctionParameter[];
+    statements?: typescript0.Statement[];
+  }) => typescript0.ConstructorDeclaration;
+  enumDeclaration: <T extends Record<string, any> | Array<ObjectValue>>({
+    asConst,
+    comments: enumMemberComments,
+    leadingComment: comments,
+    name,
+    obj
+  }: {
+    asConst: boolean;
+    comments?: Record<string | number, Comments>;
+    leadingComment?: Comments;
+    name: string | typescript0.TypeReferenceNode;
+    obj: T;
+  }) => typescript0.EnumDeclaration;
+  exportAllDeclaration: ({
+    module: module_d_exports,
+    shouldAppendJs
+  }: {
+    module: string;
+    shouldAppendJs?: boolean;
+  }) => typescript0.ExportDeclaration;
+  exportNamedDeclaration: ({
+    exports,
+    module: module_d_exports
+  }: {
+    exports: Array<ImportExportItem> | ImportExportItem;
+    module: string;
+  }) => typescript0.ExportDeclaration;
+  expressionToStatement: ({
+    expression
+  }: {
+    expression: typescript0.Expression;
+  }) => typescript0.ExpressionStatement;
+  forOfStatement: ({
+    awaitModifier,
+    expression,
+    initializer,
+    statement
+  }: {
+    awaitModifier?: typescript0.AwaitKeyword;
+    expression: typescript0.Expression;
+    initializer: typescript0.ForInitializer;
+    statement: typescript0.Statement;
+  }) => typescript0.ForOfStatement;
+  functionTypeNode: ({
+    parameters,
+    returnType,
+    typeParameters
+  }: {
+    parameters?: typescript0.ParameterDeclaration[];
+    returnType: typescript0.TypeNode;
+    typeParameters?: typescript0.TypeParameterDeclaration[];
+  }) => typescript0.FunctionTypeNode;
+  getAccessorDeclaration: ({
+    name,
+    returnType,
+    statements
+  }: {
+    name: string | typescript0.PropertyName;
+    returnType?: string | typescript0.Identifier;
+    statements: ReadonlyArray<typescript0.Statement>;
+  }) => typescript0.GetAccessorDeclaration;
+  identifier: ({
+    text
+  }: {
+    text: string;
+  }) => typescript0.Identifier;
+  ifStatement: ({
+    elseStatement,
+    expression,
+    thenStatement
+  }: {
+    elseStatement?: typescript0.Statement;
+    expression: typescript0.Expression;
+    thenStatement: typescript0.Statement;
+  }) => typescript0.IfStatement;
+  indexedAccessTypeNode: ({
+    indexType,
+    objectType
+  }: {
+    indexType: typescript0.TypeNode;
+    objectType: typescript0.TypeNode;
+  }) => typescript0.IndexedAccessTypeNode;
+  isTsNode: (node: any) => node is typescript0.Expression;
+  keywordTypeNode: ({
+    keyword
+  }: {
+    keyword: Extract<SyntaxKindKeyword, "any" | "boolean" | "never" | "number" | "string" | "undefined" | "unknown" | "void">;
+  }) => typescript0.KeywordTypeNode<typescript0.SyntaxKind.VoidKeyword | typescript0.SyntaxKind.AnyKeyword | typescript0.SyntaxKind.BooleanKeyword | typescript0.SyntaxKind.NeverKeyword | typescript0.SyntaxKind.NumberKeyword | typescript0.SyntaxKind.StringKeyword | typescript0.SyntaxKind.UndefinedKeyword | typescript0.SyntaxKind.UnknownKeyword>;
+  literalTypeNode: ({
+    literal
+  }: {
+    literal: typescript0.LiteralTypeNode["literal"];
+  }) => typescript0.LiteralTypeNode;
+  mappedTypeNode: ({
+    members,
+    nameType,
+    questionToken,
+    readonlyToken,
+    type,
+    typeParameter
+  }: {
+    members?: typescript0.NodeArray<typescript0.TypeElement>;
+    nameType?: typescript0.TypeNode;
+    questionToken?: typescript0.QuestionToken | typescript0.PlusToken | typescript0.MinusToken;
+    readonlyToken?: typescript0.ReadonlyKeyword | typescript0.PlusToken | typescript0.MinusToken;
+    type?: typescript0.TypeNode;
+    typeParameter: typescript0.TypeParameterDeclaration;
+  }) => typescript0.MappedTypeNode;
+  methodDeclaration: ({
+    accessLevel,
+    comment,
+    isStatic,
+    multiLine,
+    name,
+    parameters,
+    returnType,
+    statements,
+    types: types_d_exports
+  }: {
+    accessLevel?: AccessLevel;
+    comment?: Comments;
+    isStatic?: boolean;
+    multiLine?: boolean;
+    name: string;
+    parameters?: ReadonlyArray<FunctionParameter>;
+    returnType?: string | typescript0.TypeNode;
+    statements?: typescript0.Statement[];
+    types?: FunctionTypeParameter[];
+  }) => typescript0.MethodDeclaration;
+  namedImportDeclarations: ({
+    imports,
+    module: module_d_exports
+  }: {
+    imports: Array<ImportExportItem> | ImportExportItem;
+    module: string;
+  }) => typescript0.ImportDeclaration;
+  namespaceDeclaration: ({
+    name,
+    statements
+  }: {
+    name: string;
+    statements: Array<typescript0.Statement>;
+  }) => typescript0.ModuleDeclaration;
+  newExpression: ({
+    argumentsArray,
+    expression,
+    typeArguments
+  }: {
+    argumentsArray?: Array<typescript0.Expression>;
+    expression: typescript0.Expression;
+    typeArguments?: Array<typescript0.TypeNode>;
+  }) => typescript0.NewExpression;
+  nodeToString: typeof tsNodeToString;
+  null: () => typescript0.NullLiteral;
+  objectExpression: <T extends Record<string, any> | Array<ObjectValue>>({
+    comments,
+    identifiers,
+    multiLine,
+    obj,
+    shorthand,
+    unescape
+  }: {
+    comments?: Comments;
+    identifiers?: string[];
+    multiLine?: boolean;
+    obj: T;
+    shorthand?: boolean;
+    unescape?: boolean;
+  }) => typescript0.ObjectLiteralExpression;
+  ots: {
+    boolean: (value: boolean) => typescript0.TrueLiteral | typescript0.FalseLiteral;
+    export: ({
+      alias,
+      asType,
+      name
+    }: ImportExportItemObject) => typescript0.ExportSpecifier;
+    import: ({
+      alias,
+      asType,
+      name
+    }: ImportExportItemObject) => typescript0.ImportSpecifier;
+    number: (value: number) => typescript0.NumericLiteral | typescript0.PrefixUnaryExpression;
+    string: (value: string, unescape?: boolean) => typescript0.Identifier | typescript0.StringLiteral;
+  };
+  parameterDeclaration: ({
+    initializer,
+    modifiers,
+    name,
+    required,
+    type
+  }: {
+    initializer?: typescript0.Expression;
+    modifiers?: ReadonlyArray<typescript0.ModifierLike>;
+    name: string | typescript0.BindingName;
+    required?: boolean;
+    type?: typescript0.TypeNode;
+  }) => typescript0.ParameterDeclaration;
+  propertyAccessExpression: ({
+    expression,
+    isOptional,
+    name
+  }: {
+    expression: string | typescript0.Expression;
+    isOptional?: boolean;
+    name: string | number | typescript0.MemberName;
+  }) => typescript0.PropertyAccessChain | typescript0.PropertyAccessExpression | typescript0.ElementAccessExpression;
+  propertyAccessExpressions: ({
+    expressions
+  }: {
+    expressions: Array<string | typescript0.Expression | typescript0.MemberName>;
+  }) => typescript0.PropertyAccessExpression;
+  propertyAssignment: ({
+    initializer,
+    name
+  }: {
+    initializer: typescript0.Expression;
+    name: string | typescript0.PropertyName;
+  }) => typescript0.PropertyAssignment;
+  propertyDeclaration: ({
+    initializer,
+    modifier,
+    name,
+    type
+  }: {
+    initializer?: typescript0.Expression;
+    modifier?: "async" | AccessLevel | "export" | "readonly" | "static";
+    name: string | typescript0.PropertyName;
+    type?: typescript0.TypeNode;
+  }) => typescript0.PropertyDeclaration;
+  regularExpressionLiteral: ({
+    flags,
+    text
+  }: {
+    flags?: ReadonlyArray<"g" | "i" | "m" | "s" | "u" | "y">;
+    text: string;
+  }) => typescript0.RegularExpressionLiteral;
+  returnFunctionCall: ({
+    args,
+    name,
+    types: types_d_exports
+  }: {
+    args: any[];
+    name: string | typescript0.Expression;
+    types?: ReadonlyArray<string | typescript0.StringLiteral>;
+  }) => typescript0.ReturnStatement;
+  returnStatement: ({
+    expression
+  }: {
+    expression?: typescript0.Expression;
+  }) => typescript0.ReturnStatement;
+  returnVariable: ({
+    expression
+  }: {
+    expression: string | typescript0.Expression;
+  }) => typescript0.ReturnStatement;
+  safeAccessExpression: (path: string[]) => typescript0.Expression;
+  stringLiteral: ({
+    isSingleQuote,
+    text
+  }: {
+    isSingleQuote?: boolean;
+    text: string;
+  }) => typescript0.StringLiteral;
+  templateLiteralType: ({
+    value
+  }: {
+    value: ReadonlyArray<string | typescript0.TypeNode>;
+  }) => typescript0.TemplateLiteralTypeNode;
+  this: () => typescript0.ThisExpression;
+  transformArrayMap: ({
+    path,
+    transformExpression
+  }: {
+    path: string[];
+    transformExpression: typescript0.Expression;
+  }) => typescript0.IfStatement;
+  transformArrayMutation: ({
+    path,
+    transformerName
+  }: {
+    path: string[];
+    transformerName: string;
+  }) => typescript0.Statement;
+  transformDateMutation: ({
+    path
+  }: {
+    path: string[];
+  }) => typescript0.Statement;
+  transformFunctionMutation: ({
+    path,
+    transformerName
+  }: {
+    path: string[];
+    transformerName: string;
+  }) => typescript0.IfStatement[];
+  transformNewDate: ({
+    parameterName
+  }: {
+    parameterName: string;
+  }) => typescript0.NewExpression;
+  typeAliasDeclaration: ({
+    comment,
+    exportType,
+    name,
+    type,
+    typeParameters
+  }: {
+    comment?: Comments;
+    exportType?: boolean;
+    name: string | typescript0.TypeReferenceNode;
+    type: string | typescript0.TypeNode | typescript0.Identifier;
+    typeParameters?: FunctionTypeParameter[];
+  }) => typescript0.TypeAliasDeclaration;
+  typeArrayNode: (types: ReadonlyArray<any | typescript0.TypeNode> | typescript0.TypeNode | typescript0.Identifier | string, isNullable?: boolean) => typescript0.TypeNode;
+  typeInterfaceNode: ({
+    indexKey,
+    indexProperty,
+    isNullable,
+    properties,
+    useLegacyResolution
+  }: {
+    indexKey?: typescript0.TypeReferenceNode;
+    indexProperty?: Property;
+    isNullable?: boolean;
+    properties: Property[];
+    useLegacyResolution: boolean;
+  }) => typescript0.TypeNode;
+  typeIntersectionNode: ({
+    isNullable,
+    types: types_d_exports
+  }: {
+    isNullable?: boolean;
+    types: (any | typescript0.TypeNode)[];
+  }) => typescript0.TypeNode;
+  typeNode: (base: any | typescript0.TypeNode, args?: (any | typescript0.TypeNode)[]) => typescript0.TypeNode;
+  typeOfExpression: ({
+    text
+  }: {
+    text: string | typescript0.Identifier;
+  }) => typescript0.TypeOfExpression;
+  typeOperatorNode: ({
+    operator,
+    type
+  }: {
+    operator: "keyof" | "readonly" | "unique";
+    type: typescript0.TypeNode;
+  }) => typescript0.TypeOperatorNode;
+  typeParameterDeclaration: ({
+    constraint,
+    defaultType,
+    modifiers,
+    name
+  }: {
+    constraint?: typescript0.TypeNode;
+    defaultType?: typescript0.TypeNode;
+    modifiers?: Array<typescript0.Modifier>;
+    name: string | typescript0.Identifier;
+  }) => typescript0.TypeParameterDeclaration;
+  typeParenthesizedNode: ({
+    type
+  }: {
+    type: typescript0.TypeNode;
+  }) => typescript0.ParenthesizedTypeNode;
+  typeRecordNode: (keys: (any | typescript0.TypeNode)[], values: (any | typescript0.TypeNode)[], isNullable?: boolean, useLegacyResolution?: boolean) => typescript0.TypeNode;
+  typeReferenceNode: ({
+    typeArguments,
+    typeName
+  }: {
+    typeArguments?: typescript0.TypeNode[];
+    typeName: string | typescript0.EntityName;
+  }) => typescript0.TypeReferenceNode;
+  typeTupleNode: ({
+    isNullable,
+    types: types_d_exports
+  }: {
+    isNullable?: boolean;
+    types: Array<any | typescript0.TypeNode>;
+  }) => typescript0.TypeNode;
+  typeUnionNode: ({
+    isNullable,
+    types: types_d_exports
+  }: {
+    isNullable?: boolean;
+    types: ReadonlyArray<any | typescript0.TypeNode>;
+  }) => typescript0.TypeNode;
+  valueToExpression: <T = unknown>({
+    identifiers,
+    isValueAccess,
+    shorthand,
+    unescape,
+    value
+  }: {
+    identifiers?: string[];
+    isValueAccess?: boolean;
+    shorthand?: boolean;
+    unescape?: boolean;
+    value: T;
+  }) => typescript0.Expression | undefined;
+};
+/** @deprecated use tsc */
+declare const compiler: {
+  anonymousFunction: ({
+    async,
+    comment,
+    multiLine,
+    parameters,
+    returnType,
+    statements,
+    types: types_d_exports
+  }: {
+    async?: boolean;
+    comment?: Comments;
+    multiLine?: boolean;
+    parameters?: FunctionParameter[];
+    returnType?: string | typescript0.TypeNode;
+    statements?: ReadonlyArray<typescript0.Statement>;
+    types?: FunctionTypeParameter[];
+  }) => typescript0.FunctionExpression;
+  arrayLiteralExpression: <T>({
+    elements,
+    multiLine
+  }: {
+    elements: T[];
+    multiLine?: boolean;
+  }) => typescript0.ArrayLiteralExpression;
+  arrowFunction: ({
+    async,
+    comment,
+    multiLine,
+    parameters,
+    returnType,
+    statements,
+    types: types_d_exports
+  }: {
+    async?: boolean;
+    comment?: Comments;
+    multiLine?: boolean;
+    parameters?: ReadonlyArray<FunctionParameter>;
+    returnType?: string | typescript0.TypeNode;
+    statements?: typescript0.Statement[] | typescript0.Expression;
+    types?: FunctionTypeParameter[];
+  }) => typescript0.ArrowFunction;
+  asExpression: ({
+    expression,
+    type
+  }: {
+    expression: typescript0.Expression;
+    type: typescript0.TypeNode;
+  }) => typescript0.AsExpression;
+  assignment: ({
+    left,
+    right
+  }: {
+    left: typescript0.Expression;
+    right: typescript0.Expression;
+  }) => typescript0.AssignmentExpression<typescript0.EqualsToken>;
+  awaitExpression: ({
+    expression
+  }: {
+    expression: typescript0.Expression;
+  }) => typescript0.AwaitExpression;
+  binaryExpression: ({
+    left,
+    operator,
+    right
+  }: {
+    left: typescript0.Expression;
+    operator?: "=" | "===" | "!==" | "in" | "??";
+    right: typescript0.Expression | string;
+  }) => typescript0.BinaryExpression;
+  block: ({
+    multiLine,
+    statements
+  }: {
+    multiLine?: boolean;
+    statements: ReadonlyArray<typescript0.Statement>;
+  }) => typescript0.Block;
+  callExpression: ({
+    functionName,
+    parameters,
+    types: types_d_exports
+  }: {
+    functionName: string | typescript0.PropertyAccessExpression | typescript0.PropertyAccessChain | typescript0.ElementAccessExpression | typescript0.Expression;
+    parameters?: Array<string | typescript0.Expression | undefined>;
+    types?: ReadonlyArray<typescript0.TypeNode>;
+  }) => typescript0.CallExpression;
+  classDeclaration: ({
+    decorator,
+    exportClass,
+    extendedClasses,
+    name,
+    nodes
+  }: {
+    decorator?: {
+      args: any[];
+      name: string;
+    };
+    exportClass?: boolean;
+    extendedClasses?: ReadonlyArray<string>;
+    name: string;
+    nodes: ReadonlyArray<typescript0.ClassElement>;
+  }) => typescript0.ClassDeclaration;
+  conditionalExpression: ({
+    condition,
+    whenFalse,
+    whenTrue
+  }: {
+    condition: typescript0.Expression;
+    whenFalse: typescript0.Expression;
+    whenTrue: typescript0.Expression;
+  }) => typescript0.ConditionalExpression;
+  constVariable: ({
+    assertion,
+    comment,
+    destructure,
+    exportConst,
+    expression,
+    name,
+    typeName
+  }: {
+    assertion?: "const" | typescript0.TypeNode;
+    comment?: Comments;
+    destructure?: boolean;
+    exportConst?: boolean;
+    expression: typescript0.Expression;
+    name: string | typescript0.TypeReferenceNode;
+    typeName?: string | typescript0.IndexedAccessTypeNode | typescript0.TypeNode;
+  }) => typescript0.VariableStatement;
+  constructorDeclaration: ({
+    accessLevel,
+    comment,
+    multiLine,
+    parameters,
+    statements
+  }: {
+    accessLevel?: AccessLevel;
+    comment?: Comments;
+    multiLine?: boolean;
+    parameters?: FunctionParameter[];
+    statements?: typescript0.Statement[];
+  }) => typescript0.ConstructorDeclaration;
+  enumDeclaration: <T extends Record<string, any> | Array<ObjectValue>>({
+    asConst,
+    comments: enumMemberComments,
+    leadingComment: comments,
+    name,
+    obj
+  }: {
+    asConst: boolean;
+    comments?: Record<string | number, Comments>;
+    leadingComment?: Comments;
+    name: string | typescript0.TypeReferenceNode;
+    obj: T;
+  }) => typescript0.EnumDeclaration;
+  exportAllDeclaration: ({
+    module: module_d_exports,
+    shouldAppendJs
+  }: {
+    module: string;
+    shouldAppendJs?: boolean;
+  }) => typescript0.ExportDeclaration;
+  exportNamedDeclaration: ({
+    exports,
+    module: module_d_exports
+  }: {
+    exports: Array<ImportExportItem> | ImportExportItem;
+    module: string;
+  }) => typescript0.ExportDeclaration;
+  expressionToStatement: ({
+    expression
+  }: {
+    expression: typescript0.Expression;
+  }) => typescript0.ExpressionStatement;
+  forOfStatement: ({
+    awaitModifier,
+    expression,
+    initializer,
+    statement
+  }: {
+    awaitModifier?: typescript0.AwaitKeyword;
+    expression: typescript0.Expression;
+    initializer: typescript0.ForInitializer;
+    statement: typescript0.Statement;
+  }) => typescript0.ForOfStatement;
+  functionTypeNode: ({
+    parameters,
+    returnType,
+    typeParameters
+  }: {
+    parameters?: typescript0.ParameterDeclaration[];
+    returnType: typescript0.TypeNode;
+    typeParameters?: typescript0.TypeParameterDeclaration[];
+  }) => typescript0.FunctionTypeNode;
+  getAccessorDeclaration: ({
+    name,
+    returnType,
+    statements
+  }: {
+    name: string | typescript0.PropertyName;
+    returnType?: string | typescript0.Identifier;
+    statements: ReadonlyArray<typescript0.Statement>;
+  }) => typescript0.GetAccessorDeclaration;
+  identifier: ({
+    text
+  }: {
+    text: string;
+  }) => typescript0.Identifier;
+  ifStatement: ({
+    elseStatement,
+    expression,
+    thenStatement
+  }: {
+    elseStatement?: typescript0.Statement;
+    expression: typescript0.Expression;
+    thenStatement: typescript0.Statement;
+  }) => typescript0.IfStatement;
+  indexedAccessTypeNode: ({
+    indexType,
+    objectType
+  }: {
+    indexType: typescript0.TypeNode;
+    objectType: typescript0.TypeNode;
+  }) => typescript0.IndexedAccessTypeNode;
+  isTsNode: (node: any) => node is typescript0.Expression;
+  keywordTypeNode: ({
+    keyword
+  }: {
+    keyword: Extract<SyntaxKindKeyword, "any" | "boolean" | "never" | "number" | "string" | "undefined" | "unknown" | "void">;
+  }) => typescript0.KeywordTypeNode<typescript0.SyntaxKind.VoidKeyword | typescript0.SyntaxKind.AnyKeyword | typescript0.SyntaxKind.BooleanKeyword | typescript0.SyntaxKind.NeverKeyword | typescript0.SyntaxKind.NumberKeyword | typescript0.SyntaxKind.StringKeyword | typescript0.SyntaxKind.UndefinedKeyword | typescript0.SyntaxKind.UnknownKeyword>;
+  literalTypeNode: ({
+    literal
+  }: {
+    literal: typescript0.LiteralTypeNode["literal"];
+  }) => typescript0.LiteralTypeNode;
+  mappedTypeNode: ({
+    members,
+    nameType,
+    questionToken,
+    readonlyToken,
+    type,
+    typeParameter
+  }: {
+    members?: typescript0.NodeArray<typescript0.TypeElement>;
+    nameType?: typescript0.TypeNode;
+    questionToken?: typescript0.QuestionToken | typescript0.PlusToken | typescript0.MinusToken;
+    readonlyToken?: typescript0.ReadonlyKeyword | typescript0.PlusToken | typescript0.MinusToken;
+    type?: typescript0.TypeNode;
+    typeParameter: typescript0.TypeParameterDeclaration;
+  }) => typescript0.MappedTypeNode;
+  methodDeclaration: ({
+    accessLevel,
+    comment,
+    isStatic,
+    multiLine,
+    name,
+    parameters,
+    returnType,
+    statements,
+    types: types_d_exports
+  }: {
+    accessLevel?: AccessLevel;
+    comment?: Comments;
+    isStatic?: boolean;
+    multiLine?: boolean;
+    name: string;
+    parameters?: ReadonlyArray<FunctionParameter>;
+    returnType?: string | typescript0.TypeNode;
+    statements?: typescript0.Statement[];
+    types?: FunctionTypeParameter[];
+  }) => typescript0.MethodDeclaration;
+  namedImportDeclarations: ({
+    imports,
+    module: module_d_exports
+  }: {
+    imports: Array<ImportExportItem> | ImportExportItem;
+    module: string;
+  }) => typescript0.ImportDeclaration;
+  namespaceDeclaration: ({
+    name,
+    statements
+  }: {
+    name: string;
+    statements: Array<typescript0.Statement>;
+  }) => typescript0.ModuleDeclaration;
+  newExpression: ({
+    argumentsArray,
+    expression,
+    typeArguments
+  }: {
+    argumentsArray?: Array<typescript0.Expression>;
+    expression: typescript0.Expression;
+    typeArguments?: Array<typescript0.TypeNode>;
+  }) => typescript0.NewExpression;
+  nodeToString: typeof tsNodeToString;
+  null: () => typescript0.NullLiteral;
+  objectExpression: <T extends Record<string, any> | Array<ObjectValue>>({
+    comments,
+    identifiers,
+    multiLine,
+    obj,
+    shorthand,
+    unescape
+  }: {
+    comments?: Comments;
+    identifiers?: string[];
+    multiLine?: boolean;
+    obj: T;
+    shorthand?: boolean;
+    unescape?: boolean;
+  }) => typescript0.ObjectLiteralExpression;
+  ots: {
+    boolean: (value: boolean) => typescript0.TrueLiteral | typescript0.FalseLiteral;
+    export: ({
+      alias,
+      asType,
+      name
+    }: ImportExportItemObject) => typescript0.ExportSpecifier;
+    import: ({
+      alias,
+      asType,
+      name
+    }: ImportExportItemObject) => typescript0.ImportSpecifier;
+    number: (value: number) => typescript0.NumericLiteral | typescript0.PrefixUnaryExpression;
+    string: (value: string, unescape?: boolean) => typescript0.Identifier | typescript0.StringLiteral;
+  };
+  parameterDeclaration: ({
+    initializer,
+    modifiers,
+    name,
+    required,
+    type
+  }: {
+    initializer?: typescript0.Expression;
+    modifiers?: ReadonlyArray<typescript0.ModifierLike>;
+    name: string | typescript0.BindingName;
+    required?: boolean;
+    type?: typescript0.TypeNode;
+  }) => typescript0.ParameterDeclaration;
+  propertyAccessExpression: ({
+    expression,
+    isOptional,
+    name
+  }: {
+    expression: string | typescript0.Expression;
+    isOptional?: boolean;
+    name: string | number | typescript0.MemberName;
+  }) => typescript0.PropertyAccessChain | typescript0.PropertyAccessExpression | typescript0.ElementAccessExpression;
+  propertyAccessExpressions: ({
+    expressions
+  }: {
+    expressions: Array<string | typescript0.Expression | typescript0.MemberName>;
+  }) => typescript0.PropertyAccessExpression;
+  propertyAssignment: ({
+    initializer,
+    name
+  }: {
+    initializer: typescript0.Expression;
+    name: string | typescript0.PropertyName;
+  }) => typescript0.PropertyAssignment;
+  propertyDeclaration: ({
+    initializer,
+    modifier,
+    name,
+    type
+  }: {
+    initializer?: typescript0.Expression;
+    modifier?: "async" | AccessLevel | "export" | "readonly" | "static";
+    name: string | typescript0.PropertyName;
+    type?: typescript0.TypeNode;
+  }) => typescript0.PropertyDeclaration;
+  regularExpressionLiteral: ({
+    flags,
+    text
+  }: {
+    flags?: ReadonlyArray<"g" | "i" | "m" | "s" | "u" | "y">;
+    text: string;
+  }) => typescript0.RegularExpressionLiteral;
+  returnFunctionCall: ({
+    args,
+    name,
+    types: types_d_exports
+  }: {
+    args: any[];
+    name: string | typescript0.Expression;
+    types?: ReadonlyArray<string | typescript0.StringLiteral>;
+  }) => typescript0.ReturnStatement;
+  returnStatement: ({
+    expression
+  }: {
+    expression?: typescript0.Expression;
+  }) => typescript0.ReturnStatement;
+  returnVariable: ({
+    expression
+  }: {
+    expression: string | typescript0.Expression;
+  }) => typescript0.ReturnStatement;
+  safeAccessExpression: (path: string[]) => typescript0.Expression;
+  stringLiteral: ({
+    isSingleQuote,
+    text
+  }: {
+    isSingleQuote?: boolean;
+    text: string;
+  }) => typescript0.StringLiteral;
+  templateLiteralType: ({
+    value
+  }: {
+    value: ReadonlyArray<string | typescript0.TypeNode>;
+  }) => typescript0.TemplateLiteralTypeNode;
+  this: () => typescript0.ThisExpression;
+  transformArrayMap: ({
+    path,
+    transformExpression
+  }: {
+    path: string[];
+    transformExpression: typescript0.Expression;
+  }) => typescript0.IfStatement;
+  transformArrayMutation: ({
+    path,
+    transformerName
+  }: {
+    path: string[];
+    transformerName: string;
+  }) => typescript0.Statement;
+  transformDateMutation: ({
+    path
+  }: {
+    path: string[];
+  }) => typescript0.Statement;
+  transformFunctionMutation: ({
+    path,
+    transformerName
+  }: {
+    path: string[];
+    transformerName: string;
+  }) => typescript0.IfStatement[];
+  transformNewDate: ({
+    parameterName
+  }: {
+    parameterName: string;
+  }) => typescript0.NewExpression;
+  typeAliasDeclaration: ({
+    comment,
+    exportType,
+    name,
+    type,
+    typeParameters
+  }: {
+    comment?: Comments;
+    exportType?: boolean;
+    name: string | typescript0.TypeReferenceNode;
+    type: string | typescript0.TypeNode | typescript0.Identifier;
+    typeParameters?: FunctionTypeParameter[];
+  }) => typescript0.TypeAliasDeclaration;
+  typeArrayNode: (types: ReadonlyArray<any | typescript0.TypeNode> | typescript0.TypeNode | typescript0.Identifier | string, isNullable?: boolean) => typescript0.TypeNode;
+  typeInterfaceNode: ({
+    indexKey,
+    indexProperty,
+    isNullable,
+    properties,
+    useLegacyResolution
+  }: {
+    indexKey?: typescript0.TypeReferenceNode;
+    indexProperty?: Property;
+    isNullable?: boolean;
+    properties: Property[];
+    useLegacyResolution: boolean;
+  }) => typescript0.TypeNode;
+  typeIntersectionNode: ({
+    isNullable,
+    types: types_d_exports
+  }: {
+    isNullable?: boolean;
+    types: (any | typescript0.TypeNode)[];
+  }) => typescript0.TypeNode;
+  typeNode: (base: any | typescript0.TypeNode, args?: (any | typescript0.TypeNode)[]) => typescript0.TypeNode;
+  typeOfExpression: ({
+    text
+  }: {
+    text: string | typescript0.Identifier;
+  }) => typescript0.TypeOfExpression;
+  typeOperatorNode: ({
+    operator,
+    type
+  }: {
+    operator: "keyof" | "readonly" | "unique";
+    type: typescript0.TypeNode;
+  }) => typescript0.TypeOperatorNode;
+  typeParameterDeclaration: ({
+    constraint,
+    defaultType,
+    modifiers,
+    name
+  }: {
+    constraint?: typescript0.TypeNode;
+    defaultType?: typescript0.TypeNode;
+    modifiers?: Array<typescript0.Modifier>;
+    name: string | typescript0.Identifier;
+  }) => typescript0.TypeParameterDeclaration;
+  typeParenthesizedNode: ({
+    type
+  }: {
+    type: typescript0.TypeNode;
+  }) => typescript0.ParenthesizedTypeNode;
+  typeRecordNode: (keys: (any | typescript0.TypeNode)[], values: (any | typescript0.TypeNode)[], isNullable?: boolean, useLegacyResolution?: boolean) => typescript0.TypeNode;
+  typeReferenceNode: ({
+    typeArguments,
+    typeName
+  }: {
+    typeArguments?: typescript0.TypeNode[];
+    typeName: string | typescript0.EntityName;
+  }) => typescript0.TypeReferenceNode;
+  typeTupleNode: ({
+    isNullable,
+    types: types_d_exports
+  }: {
+    isNullable?: boolean;
+    types: Array<any | typescript0.TypeNode>;
+  }) => typescript0.TypeNode;
+  typeUnionNode: ({
+    isNullable,
+    types: types_d_exports
+  }: {
+    isNullable?: boolean;
+    types: ReadonlyArray<any | typescript0.TypeNode>;
+  }) => typescript0.TypeNode;
+  valueToExpression: <T = unknown>({
+    identifiers,
+    isValueAccess,
+    shorthand,
+    unescape,
+    value
+  }: {
+    identifiers?: string[];
+    isValueAccess?: boolean;
+    shorthand?: boolean;
+    unescape?: boolean;
+    value: T;
+  }) => typescript0.Expression | undefined;
+};
 //#endregion
 //#region src/utils/exports.d.ts
 declare const utils: {
@@ -915,12 +2101,32 @@ declare const utils: {
 };
 //#endregion
 //#region src/index.d.ts
-/**
- * Generate a client from the provided configuration.
- *
- * @param userConfig User provided {@link UserConfig} configuration(s).
- */
-declare const createClient: (userConfig?: LazyOrAsync<MaybeArray<UserConfig>>, logger?: Logger) => Promise<ReadonlyArray<Client$7 | IR.Context>>;
+declare module '@hey-api/codegen-core' {
+  interface ProjectRenderMeta {
+    /**
+     * If specified, this will be the file extension used when importing
+     * other modules. By default, we don't add a file extension and let the
+     * runtime resolve it.
+     *
+     * @default null
+     */
+    importFileExtension?: (string & {}) | null;
+  }
+  interface SymbolMeta {
+    /**
+     * Path to the resource this symbol represents.
+     */
+    path?: ReadonlyArray<string | number>;
+    /**
+     * Name of the plugin that registered this symbol.
+     */
+    pluginName?: string;
+    /**
+     * Tags associated with this symbol.
+     */
+    tags?: Set<string>;
+  }
+}
 /**
  * Type helper for openapi-ts.config.ts, returns {@link MaybeArray<UserConfig>} object(s)
  */