@hey-api/openapi-ts 0.86.12 → 0.87.0

package/dist/index.cjs

@@ -1 +1 @@
-const e=require(`./getSpec-xn4as4li.cjs`),t=require(`./src-DptUs1Ky.cjs`);exports.Logger=t.i,exports.clientDefaultConfig=e.s,exports.clientDefaultMeta=e.c,exports.clientPluginHandler=e.a,exports.compiler=e._,exports.createClient=t.r,exports.defaultPaginationKeywords=e.x,exports.defaultPlugins=e.r,exports.defineConfig=t.t,exports.definePluginConfig=e.b,exports.tsc=e.v,exports.utils=t.n;
+const e=require(`./openApi-BWD76jue.cjs`),t=require(`./src-H1fIt1p4.cjs`);exports.Logger=t.i,exports.clientDefaultConfig=e.c,exports.clientDefaultMeta=e.l,exports.clientPluginHandler=e.o,exports.compiler=e.u,exports.createClient=t.r,exports.defaultPaginationKeywords=e.h,exports.defaultPlugins=e.a,exports.defineConfig=t.t,exports.definePluginConfig=e.m,exports.tsc=e.d,exports.utils=t.n;

package/dist/index.d.cts

@@ -1,13 +1,15 @@
-import { A as Modifier, C as PluginHandler, D as MaybeArray, E as LazyOrAsync, F as ObjectValue, I as SyntaxKindKeyword, L as types_d_exports, M as AccessLevel, N as FunctionParameter, O as Comments, P as FunctionTypeParameter, R as __export, S as Client$2, T as IR, _ as OpenApiSchemaObject, b as Client$7, d as OpenApi, f as OpenApiMetaObject, g as OpenApiResponseObject, h as OpenApiRequestBodyObject, i as UserConfig, j as tsNodeToString, k as ImportExportItemObject, l as Context, m as OpenApiParameterObject, o as DefinePlugin, p as OpenApiOperationObject, s as Plugin, t as LegacyIR, u as Logger, v as TypeTransformer, w as StringCase, x as Operation, y as ExpressionTransformer } from "./types-Dh80P1tV.cjs";
-import * as typescript0 from "typescript";
-import ts from "typescript";
+import { S as MaybeArray, _ as Client$2, a as Plugin, b as IR, c as OpenApiOperationObject, d as OpenApiResponseObject, f as OpenApiSchemaObject, g as ExpressionTransformer, h as TypeTransformer, i as DefinePlugin, l as OpenApiParameterObject, m as Logger, n as UserConfig, o as OpenApi, p as Context, s as OpenApiMetaObject, u as OpenApiRequestBodyObject, v as PluginHandler, x as LazyOrAsync, y as StringCase } from "./config-B2o9ax_a.cjs";
 import { HttpClient, HttpErrorResponse, HttpHeaders, HttpRequest, HttpResponse } from "@angular/common/http";
 import { Injector } from "@angular/core";
 import { AxiosError, AxiosInstance, AxiosRequestHeaders, AxiosResponse, AxiosStatic, CreateAxiosDefaults } from "axios";
 import { AsyncDataOptions, UseFetchOptions, useAsyncData, useFetch, useLazyAsyncData, useLazyFetch } from "nuxt/app";
 import { Ref } from "vue";
 import { FetchOptions, ResponseType, ofetch } from "ofetch";
+import * as typescript0 from "typescript";
+import ts from "typescript";
 
+//#region rolldown:runtime
+//#endregion
 //#region src/plugins/@hey-api/client-core/bundle/auth.d.ts
 type AuthToken = string | undefined;
 interface Auth {
@@ -56,7 +58,7 @@ type QuerySerializerOptions = QuerySerializerOptionsObject & {
 //#endregion
 //#region src/plugins/@hey-api/client-core/bundle/types.d.ts
 type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
-type Client$8<RequestFn$6 = never, Config$7 = unknown, MethodFn$6 = never, BuildUrlFn$6 = never, SseFn$6 = never> = {
+type Client$7<RequestFn$6 = never, Config$7 = unknown, MethodFn$6 = never, BuildUrlFn$6 = never, SseFn$6 = never> = {
   /**
    * Returns the final request URL.
    */
@@ -301,7 +303,7 @@ type BuildUrlFn$5 = <TData extends {
   query?: Record<string, unknown>;
   url: string;
 }>(options: TData & Options$5<TData>) => string;
-type Client = Client$8<RequestFn$5, Config$6, MethodFn$5, BuildUrlFn$5, SseFn$5> & {
+type Client = Client$7<RequestFn$5, Config$6, MethodFn$5, BuildUrlFn$5, SseFn$5> & {
   interceptors: Middleware$3<HttpRequest<unknown>, HttpResponse<unknown>, unknown, ResolvedRequestOptions$3>;
   requestOptions: RequestOptionsFn;
 };
@@ -378,7 +380,7 @@ type BuildUrlFn$4 = <TData extends {
   query?: Record<string, unknown>;
   url: string;
 }>(options: TData & Options$4<TData>) => string;
-type Client$1 = Client$8<RequestFn$4, Config$5, MethodFn$4, BuildUrlFn$4, SseFn$4> & {
+type Client$1 = Client$7<RequestFn$4, Config$5, MethodFn$4, BuildUrlFn$4, SseFn$4> & {
   instance: AxiosInstance;
 };
 interface TDataShape$4 {
@@ -502,7 +504,7 @@ type BuildUrlFn$3 = <TData extends {
   query?: Record<string, unknown>;
   url: string;
 }>(options: TData & Options$3<TData>) => string;
-type Client$3 = Client$8<RequestFn$3, Config$4, MethodFn$3, BuildUrlFn$3, SseFn$3> & {
+type Client$3 = Client$7<RequestFn$3, Config$4, MethodFn$3, BuildUrlFn$3, SseFn$3> & {
   interceptors: Middleware$2<Request, Response, unknown, ResolvedRequestOptions$2>;
 };
 interface TDataShape$3 {
@@ -608,7 +610,7 @@ type BuildUrlFn$2 = <TData extends {
   query?: Record<string, unknown>;
   url: string;
 }>(options: TData & Options$2<TData>) => string;
-type Client$4 = Client$8<RequestFn$2, Config$3, MethodFn$2, BuildUrlFn$2, SseFn$2> & {
+type Client$4 = Client$7<RequestFn$2, Config$3, MethodFn$2, BuildUrlFn$2, SseFn$2> & {
   interceptors: Middleware$1<Response, unknown, ResolvedRequestOptions$1>;
 };
 interface TDataShape$2 {
@@ -684,7 +686,7 @@ interface TDataShape$1 {
 }
 type BuildUrlOptions<TData extends Omit<TDataShape$1, 'headers'> = Omit<TDataShape$1, 'headers'>> = Pick<WithRefs<TData>, 'path' | 'query'> & Pick<TData, 'url'> & Pick<Options$1<'$fetch', TData>, 'baseURL' | 'querySerializer'>;
 type BuildUrlFn$1 = <TData extends Omit<TDataShape$1, 'headers'>>(options: BuildUrlOptions<TData>) => string;
-type Client$5 = Client$8<RequestFn$1, Config$2, MethodFn$1, BuildUrlFn$1, SseFn$1>;
+type Client$5 = Client$7<RequestFn$1, Config$2, MethodFn$1, BuildUrlFn$1, SseFn$1>;
 type OmitKeys$1<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
 type Options$1<TComposable extends Composable = '$fetch', TData extends TDataShape$1 = TDataShape$1, ResT = unknown, DefaultT = undefined> = OmitKeys$1<RequestOptions$1<TComposable, ResT, DefaultT>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : WithRefs<Omit<TData, 'url'>>);
 type FetchOptions$1<TData> = Omit<UseFetchOptions<TData, TData>, keyof AsyncDataOptions<TData>>;
@@ -861,7 +863,7 @@ type BuildUrlFn = <TData extends {
   query?: Record<string, unknown>;
   url: string;
 }>(options: TData & Options<TData>) => string;
-type Client$6 = Client$8<RequestFn, Config$1, MethodFn, BuildUrlFn, SseFn> & {
+type Client$6 = Client$7<RequestFn, Config$1, MethodFn, BuildUrlFn, SseFn> & {
   interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
 };
 interface TDataShape {
@@ -880,7 +882,7 @@ type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean
  *
  * @param userConfig User provided {@link UserConfig} configuration(s).
  */
-declare const createClient: (userConfig?: LazyOrAsync<MaybeArray<UserConfig>>, logger?: Logger) => Promise<ReadonlyArray<Client$7 | Context>>;
+declare const createClient: (userConfig?: LazyOrAsync<MaybeArray<UserConfig>>, logger?: Logger) => Promise<ReadonlyArray<Context>>;
 //#endregion
 //#region src/config/parser.d.ts
 declare const defaultPaginationKeywords: readonly ["after", "before", "cursor", "offset", "page", "start"];
@@ -917,6 +919,435 @@ declare const definePluginConfig: <T extends Plugin.Types>(defaultConfig: Plugin
    */
   name: any;
 };
+declare namespace types_d_exports {
+  export { AccessLevel, FunctionParameter, FunctionTypeParameter, ObjectValue, SyntaxKindKeyword, createAnonymousFunction, createArrayLiteralExpression, createArrowFunction, createAsExpression, createAssignment, createAwaitExpression, createBlock, createConditionalExpression, createEnumDeclaration, createForOfStatement, createFunctionTypeNode, createGetAccessorDeclaration, createIndexedAccessTypeNode, createKeywordTypeNode, createLiteralTypeNode, createMappedTypeNode, createNamespaceDeclaration, createNewExpression, createNull, createObjectType, createParameterDeclaration, createPropertyAccessChain, createPropertyAccessExpression, createPropertyAssignment, createRegularExpressionLiteral, createStringLiteral, createTemplateLiteralType, createTypeAliasDeclaration, createTypeNode, createTypeOfExpression, createTypeOperatorNode, createTypeParameterDeclaration, createTypeParenthesizedNode, createTypeReferenceNode, syntaxKindKeyword, toExpression, toParameterDeclarations, toTypeParameters };
+}
+type AccessLevel = 'private' | 'protected' | 'public';
+type FunctionParameter = {
+  accessLevel?: AccessLevel;
+  default?: any;
+  isReadOnly?: boolean;
+  isRequired?: boolean;
+  name: string;
+  type?: any | ts.TypeNode;
+} | {
+  destructure: ReadonlyArray<FunctionParameter>;
+  type?: any | ts.TypeNode;
+};
+interface FunctionTypeParameter {
+  default?: any;
+  extends?: string | ts.TypeNode;
+  name: string | ts.Identifier;
+}
+declare const createTypeNode: (base: any | ts.TypeNode, args?: (any | ts.TypeNode)[]) => ts.TypeNode;
+declare const createPropertyAccessChain: ({
+  expression,
+  name
+}: {
+  expression: ts.Expression;
+  name: string | ts.MemberName;
+}) => ts.PropertyAccessChain;
+declare const createPropertyAccessExpression: ({
+  expression,
+  isOptional,
+  name
+}: {
+  expression: string | ts.Expression;
+  isOptional?: boolean;
+  name: string | number | ts.MemberName;
+}) => ts.PropertyAccessChain | ts.PropertyAccessExpression | ts.ElementAccessExpression;
+declare const createNull: () => ts.NullLiteral;
+/**
+ * Convert an unknown value to an expression.
+ * @param identifiers - list of keys that are treated as identifiers.
+ * @param shorthand - if shorthand syntax is allowed.
+ * @param unescape - if string should be unescaped.
+ * @param value - the unknown value.
+ * @returns ts.Expression
+ */
+declare const toExpression: <T = unknown>({
+  identifiers,
+  isValueAccess,
+  shorthand,
+  unescape,
+  value
+}: {
+  identifiers?: string[];
+  isValueAccess?: boolean;
+  shorthand?: boolean;
+  unescape?: boolean;
+  value: T;
+}) => ts.Expression | undefined;
+/**
+ * Convert parameters to the declaration array expected by TypeScript
+ * Compiler API.
+ * @param parameters - the parameters to convert to declarations
+ * @returns ts.ParameterDeclaration[]
+ */
+declare const toParameterDeclarations: (parameters: ReadonlyArray<FunctionParameter>) => ts.ParameterDeclaration[];
+type SyntaxKindKeyword = 'any' | 'async' | 'boolean' | 'export' | 'never' | 'number' | 'private' | 'protected' | 'public' | 'readonly' | 'static' | 'string' | 'undefined' | 'unknown' | 'void';
+declare const syntaxKindKeyword: <T extends SyntaxKindKeyword>({
+  keyword
+}: {
+  keyword: T;
+}) => T extends "protected" ? ts.SyntaxKind.ProtectedKeyword : T extends "public" ? ts.SyntaxKind.PublicKeyword : T extends "private" ? ts.SyntaxKind.PrivateKeyword : T extends "export" ? ts.SyntaxKind.ExportKeyword : T extends "async" ? ts.SyntaxKind.ExportKeyword : T extends "readonly" ? ts.SyntaxKind.ExportKeyword : T extends "static" ? ts.SyntaxKind.ExportKeyword : ts.SyntaxKind.AnyKeyword | ts.SyntaxKind.BooleanKeyword | ts.SyntaxKind.NeverKeyword | ts.SyntaxKind.NumberKeyword | ts.SyntaxKind.StringKeyword | ts.SyntaxKind.UndefinedKeyword | ts.SyntaxKind.UnknownKeyword | ts.SyntaxKind.VoidKeyword;
+declare const createKeywordTypeNode: ({
+  keyword
+}: {
+  keyword: Extract<SyntaxKindKeyword, "any" | "boolean" | "never" | "number" | "string" | "undefined" | "unknown" | "void">;
+}) => ts.KeywordTypeNode<ts.SyntaxKind.VoidKeyword | ts.SyntaxKind.AnyKeyword | ts.SyntaxKind.BooleanKeyword | ts.SyntaxKind.NeverKeyword | ts.SyntaxKind.NumberKeyword | ts.SyntaxKind.StringKeyword | ts.SyntaxKind.UndefinedKeyword | ts.SyntaxKind.UnknownKeyword>;
+declare const toTypeParameters: (types: (FunctionTypeParameter | ts.TypeParameterDeclaration)[]) => ts.TypeParameterDeclaration[];
+declare const createTypeOperatorNode: ({
+  operator,
+  type
+}: {
+  operator: "keyof" | "readonly" | "unique";
+  type: ts.TypeNode;
+}) => ts.TypeOperatorNode;
+declare const createTypeParameterDeclaration: ({
+  constraint,
+  defaultType,
+  modifiers,
+  name
+}: {
+  constraint?: ts.TypeNode;
+  defaultType?: ts.TypeNode;
+  modifiers?: Array<ts.Modifier>;
+  name: string | ts.Identifier;
+}) => ts.TypeParameterDeclaration;
+declare const createMappedTypeNode: ({
+  members,
+  nameType,
+  questionToken,
+  readonlyToken,
+  type,
+  typeParameter
+}: {
+  members?: ts.NodeArray<ts.TypeElement>;
+  nameType?: ts.TypeNode;
+  questionToken?: ts.QuestionToken | ts.PlusToken | ts.MinusToken;
+  readonlyToken?: ts.ReadonlyKeyword | ts.PlusToken | ts.MinusToken;
+  type?: ts.TypeNode;
+  typeParameter: ts.TypeParameterDeclaration;
+}) => ts.MappedTypeNode;
+declare const createLiteralTypeNode: ({
+  literal
+}: {
+  literal: ts.LiteralTypeNode["literal"];
+}) => ts.LiteralTypeNode;
+/**
+ * Create arrow function type expression.
+ */
+declare const createArrowFunction: ({
+  async,
+  comment,
+  multiLine,
+  parameters,
+  returnType,
+  statements,
+  types
+}: {
+  async?: boolean;
+  comment?: Comments;
+  multiLine?: boolean;
+  parameters?: ReadonlyArray<FunctionParameter>;
+  returnType?: string | ts.TypeNode;
+  statements?: ts.Statement[] | ts.Expression;
+  types?: FunctionTypeParameter[];
+}) => ts.ArrowFunction;
+/**
+ * Create anonymous function type expression.
+ */
+declare const createAnonymousFunction: ({
+  async,
+  comment,
+  multiLine,
+  parameters,
+  returnType,
+  statements,
+  types
+}: {
+  async?: boolean;
+  comment?: Comments;
+  multiLine?: boolean;
+  parameters?: FunctionParameter[];
+  returnType?: string | ts.TypeNode;
+  statements?: ReadonlyArray<ts.Statement>;
+  types?: FunctionTypeParameter[];
+}) => ts.FunctionExpression;
+/**
+ * Create Array type expression.
+ */
+declare const createArrayLiteralExpression: <T>({
+  elements,
+  multiLine
+}: {
+  /**
+   * The array to create.
+   */
+  elements: T[];
+  /**
+   * Should the array be multi line?
+   *
+   * @default false
+   */
+  multiLine?: boolean;
+}) => ts.ArrayLiteralExpression;
+declare const createAwaitExpression: ({
+  expression
+}: {
+  expression: ts.Expression;
+}) => ts.AwaitExpression;
+declare const createFunctionTypeNode: ({
+  parameters,
+  returnType,
+  typeParameters
+}: {
+  parameters?: ts.ParameterDeclaration[];
+  returnType: ts.TypeNode;
+  typeParameters?: ts.TypeParameterDeclaration[];
+}) => ts.FunctionTypeNode;
+type ObjectValue = {
+  assertion?: 'any' | ts.TypeNode;
+  comments?: Comments;
+  spread: string;
+} | {
+  comments?: Comments;
+  isValueAccess?: boolean;
+  key: string;
+  shorthand?: boolean;
+  value: any;
+};
+/**
+ * Create Object type expression.
+ * @param comments - comments to add to each property.
+ * @param identifier - keys that should be treated as identifiers.
+ * @param multiLine - if the object should be multiline.
+ * @param obj - the object to create expression with.
+ * @param shorthand - if shorthand syntax should be used.
+ * @param unescape - if properties strings should be unescaped.
+ * @returns ts.ObjectLiteralExpression
+ */
+declare const createObjectType: <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;
+}) => ts.ObjectLiteralExpression;
+/**
+ * Create enum declaration. Example `export enum T = { X, Y };`
+ * @param asConst - whether to use const enums.
+ * @param comments - comments to add to each property.
+ * @param leadingComment - leading comment to add to enum.
+ * @param name - the name of the enum.
+ * @param obj - the object representing the enum.
+ * @returns ts.EnumDeclaration
+ */
+declare const createEnumDeclaration: <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 | ts.TypeReferenceNode;
+  obj: T;
+}) => ts.EnumDeclaration;
+/**
+ * Create namespace declaration. Example `export namespace MyNamespace { ... }`
+ * @param name - the name of the namespace.
+ * @param nodes - the nodes in the namespace.
+ * @returns
+ */
+declare const createNamespaceDeclaration: ({
+  name,
+  statements
+}: {
+  name: string;
+  statements: Array<ts.Statement>;
+}) => ts.ModuleDeclaration;
+declare const createIndexedAccessTypeNode: ({
+  indexType,
+  objectType
+}: {
+  indexType: ts.TypeNode;
+  objectType: ts.TypeNode;
+}) => ts.IndexedAccessTypeNode;
+declare const createGetAccessorDeclaration: ({
+  modifiers,
+  name,
+  returnType,
+  statements
+}: {
+  modifiers?: Modifier | ReadonlyArray<Modifier>;
+  name: string | ts.PropertyName;
+  returnType?: string | ts.Identifier;
+  statements: ReadonlyArray<ts.Statement>;
+}) => ts.GetAccessorDeclaration;
+declare const createStringLiteral: ({
+  isSingleQuote,
+  text
+}: {
+  isSingleQuote?: boolean;
+  text: string;
+}) => ts.StringLiteral;
+declare const createConditionalExpression: ({
+  condition,
+  whenFalse,
+  whenTrue
+}: {
+  condition: ts.Expression;
+  whenFalse: ts.Expression;
+  whenTrue: ts.Expression;
+}) => ts.ConditionalExpression;
+declare const createTypeOfExpression: ({
+  text
+}: {
+  text: string | ts.Identifier;
+}) => ts.TypeOfExpression;
+/**
+ * Create a type alias declaration. Example `export type X = Y;`.
+ * @param comment (optional) comments to add
+ * @param name the name of the type
+ * @param type the type
+ * @returns ts.TypeAliasDeclaration
+ */
+declare const createTypeAliasDeclaration: ({
+  comment,
+  exportType,
+  name,
+  type,
+  typeParameters
+}: {
+  comment?: Comments;
+  exportType?: boolean;
+  name: string | ts.TypeReferenceNode;
+  type: string | ts.TypeNode | ts.Identifier;
+  typeParameters?: FunctionTypeParameter[];
+}) => ts.TypeAliasDeclaration;
+declare const createTypeReferenceNode: ({
+  typeArguments,
+  typeName
+}: {
+  typeArguments?: ts.TypeNode[];
+  typeName: string | ts.EntityName;
+}) => ts.TypeReferenceNode;
+declare const createTypeParenthesizedNode: ({
+  type
+}: {
+  type: ts.TypeNode;
+}) => ts.ParenthesizedTypeNode;
+declare const createParameterDeclaration: ({
+  initializer,
+  modifiers,
+  name,
+  required,
+  type
+}: {
+  initializer?: ts.Expression;
+  modifiers?: ReadonlyArray<ts.ModifierLike>;
+  name: string | ts.BindingName;
+  required?: boolean;
+  type?: ts.TypeNode;
+}) => ts.ParameterDeclaration;
+declare const createNewExpression: ({
+  argumentsArray,
+  expression,
+  typeArguments
+}: {
+  argumentsArray?: Array<ts.Expression>;
+  expression: ts.Expression;
+  typeArguments?: Array<ts.TypeNode>;
+}) => ts.NewExpression;
+declare const createForOfStatement: ({
+  awaitModifier,
+  expression,
+  initializer,
+  statement
+}: {
+  awaitModifier?: ts.AwaitKeyword;
+  expression: ts.Expression;
+  initializer: ts.ForInitializer;
+  statement: ts.Statement;
+}) => ts.ForOfStatement;
+declare const createAssignment: ({
+  left,
+  right
+}: {
+  left: ts.Expression;
+  right: ts.Expression;
+}) => ts.AssignmentExpression<ts.EqualsToken>;
+declare const createBlock: ({
+  multiLine,
+  statements
+}: {
+  multiLine?: boolean;
+  statements: ReadonlyArray<ts.Statement>;
+}) => ts.Block;
+declare const createPropertyAssignment: ({
+  initializer,
+  name
+}: {
+  initializer: ts.Expression;
+  name: string | ts.PropertyName;
+}) => ts.PropertyAssignment;
+declare const createRegularExpressionLiteral: ({
+  flags,
+  text
+}: {
+  flags?: ReadonlyArray<"g" | "i" | "m" | "s" | "u" | "y">;
+  text: string;
+}) => ts.RegularExpressionLiteral;
+declare const createAsExpression: ({
+  expression,
+  type
+}: {
+  expression: ts.Expression;
+  type: ts.TypeNode;
+}) => ts.AsExpression;
+declare const createTemplateLiteralType: ({
+  value
+}: {
+  value: ReadonlyArray<string | ts.TypeNode>;
+}) => ts.TemplateLiteralTypeNode;
+//#endregion
+//#region src/tsc/utils.d.ts
+interface ImportExportItemObject<Name extends string | undefined = string | undefined, Alias extends string | undefined = undefined> {
+  alias?: Alias;
+  asType?: boolean;
+  name: Name;
+}
+/**
+ * Print a TypeScript node to a string.
+ * @param node the node to print
+ * @returns string
+ */
+declare function tsNodeToString({
+  node,
+  unescape
+}: {
+  node: ts.Node;
+  unescape?: boolean;
+}): string;
+type Modifier = AccessLevel | 'async' | 'export' | 'readonly' | 'static';
+type CommentLines = Array<string | null | false | undefined>;
+type CommentObject = {
+  jsdoc?: boolean;
+  lines: CommentLines;
+};
+type Comments = CommentLines | Array<CommentObject>;
 declare namespace module_d_exports {
   export { ImportExportItem, createCallExpression, createConstVariable, createExportAllDeclaration, createNamedExportDeclarations, createNamedImportDeclarations };
 }
@@ -2142,5 +2573,5 @@ declare module '@hey-api/codegen-core' {
  */
 declare const defineConfig: <T extends MaybeArray<UserConfig>>(config: LazyOrAsync<T>) => Promise<T>;
 //#endregion
-export { type Client as AngularClient, type Client$1 as AxiosClient, type Client$2 as Client, type DefinePlugin, type ExpressionTransformer, type Client$3 as FetchClient, type IR, type LegacyIR, Logger, type Client$4 as NextClient, type Client$5 as NuxtClient, type Client$6 as OfetchClient, type OpenApi, type OpenApiMetaObject, type OpenApiOperationObject, type OpenApiParameterObject, type OpenApiRequestBodyObject, type OpenApiResponseObject, type OpenApiSchemaObject, type Operation, type Plugin, type TypeTransformer, type UserConfig, clientDefaultConfig, clientDefaultMeta, clientPluginHandler, compiler, createClient, defaultPaginationKeywords, defaultPlugins, defineConfig, definePluginConfig, tsc, utils };
+export { type Client as AngularClient, type Client$1 as AxiosClient, type Client$2 as Client, type DefinePlugin, type ExpressionTransformer, type Client$3 as FetchClient, type IR, Logger, type Client$4 as NextClient, type Client$5 as NuxtClient, type Client$6 as OfetchClient, type OpenApi, type OpenApiMetaObject, type OpenApiOperationObject, type OpenApiParameterObject, type OpenApiRequestBodyObject, type OpenApiResponseObject, type OpenApiSchemaObject, type Plugin, type TypeTransformer, type UserConfig, clientDefaultConfig, clientDefaultMeta, clientPluginHandler, compiler, createClient, defaultPaginationKeywords, defaultPlugins, defineConfig, definePluginConfig, tsc, utils };
 //# sourceMappingURL=index.d.cts.map