@hey-api/openapi-ts 0.86.12 → 0.87.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { A as StringCase, B as FunctionTypeParameter, C as PluginHandler, D as Client$3, E as Client$4, F as ImportExportItemObject, H as SyntaxKindKeyword, I as Modifier, L as tsNodeToString, M as LazyOrAsync, N as MaybeArray, O as Client$1, P as Comments, R as AccessLevel, S as Client$2, T as Client$5, U as types_d_exports, V as ObjectValue, _ as OpenApiSchemaObject, b as Client$7, d as OpenApi, f as OpenApiMetaObject, g as OpenApiResponseObject, h as OpenApiRequestBodyObject, i as UserConfig, j as IR, k as Client, 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 Client$6, x as Operation, y as ExpressionTransformer, z as FunctionParameter } from "./types-BRmx9r9T.js";
+import { C as Client$1, D as LazyOrAsync, E as IR, O as MaybeArray, S as Client$3, T as StringCase, _ as Client$2, a as Plugin, b as Client$5, 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, w as Client, x as Client$4, y as Client$6 } from "./config-CNi83ZTD.js";
 import "@hey-api/codegen-core";
 import * as typescript0 from "typescript";
 import ts from "typescript";
@@ -10,7 +10,7 @@ import ts from "typescript";
  *
  * @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"];
@@ -38,7 +38,7 @@ declare const clientPluginHandler: ({
 }: Parameters<PluginHandler>[0]) => void;
 //#endregion
 //#region src/plugins/shared/utils/config.d.ts
-declare const definePluginConfig: <T extends Plugin.Types>(defaultConfig: Plugin.Config<T>) => (userConfig?: Omit<Plugin.UserConfig<T["config"]>, "name">) => Omit<Plugin.Config<T>, "name"> & {
+declare const definePluginConfig: <T extends Plugin.Types>(defaultConfig: Plugin.Config<T>) => (userConfig?: Omit<T["config"], "name">) => Omit<Plugin.Config<T>, "name"> & {
   /**
    * Cast name to `any` so it doesn't throw type error in `plugins` array.
    * We could allow any `string` as plugin `name` in the object syntax, but
@@ -47,6 +47,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 };
 }
@@ -226,7 +655,8 @@ declare const tsc: {
     exportClass,
     extendedClasses,
     name,
-    nodes
+    nodes,
+    typeParameters
   }: {
     decorator?: {
       args: any[];
@@ -236,6 +666,7 @@ declare const tsc: {
     extendedClasses?: ReadonlyArray<string>;
     name: string;
     nodes: ReadonlyArray<typescript0.ClassElement>;
+    typeParameters?: ReadonlyArray<typescript0.TypeParameterDeclaration>;
   }) => typescript0.ClassDeclaration;
   conditionalExpression: ({
     condition,
@@ -339,9 +770,7 @@ declare const tsc: {
     returnType?: string | typescript0.Identifier;
     statements: ReadonlyArray<typescript0.Statement>;
   }) => typescript0.GetAccessorDeclaration;
-  identifier: ({
-    text
-  }: {
+  identifier: (args: string | {
     text: string;
   }) => typescript0.Identifier;
   ifStatement: ({
@@ -475,6 +904,13 @@ declare const tsc: {
     required?: boolean;
     type?: typescript0.TypeNode;
   }) => typescript0.ParameterDeclaration;
+  prefixUnaryExpression: ({
+    expression,
+    prefix
+  }: {
+    expression: string | typescript0.Expression;
+    prefix: ("!" | "-") | typescript0.PrefixUnaryOperator;
+  }) => typescript0.PrefixUnaryExpression;
   propertyAccessExpression: ({
     expression,
     isOptional,
@@ -498,12 +934,12 @@ declare const tsc: {
   }) => typescript0.PropertyAssignment;
   propertyDeclaration: ({
     initializer,
-    modifier,
+    modifiers,
     name,
     type
   }: {
     initializer?: typescript0.Expression;
-    modifier?: Modifier;
+    modifiers?: Modifier | ReadonlyArray<Modifier>;
     name: string | typescript0.PropertyName;
     type?: typescript0.TypeNode;
   }) => typescript0.PropertyDeclaration;
@@ -769,7 +1205,8 @@ declare const compiler: {
     exportClass,
     extendedClasses,
     name,
-    nodes
+    nodes,
+    typeParameters
   }: {
     decorator?: {
       args: any[];
@@ -779,6 +1216,7 @@ declare const compiler: {
     extendedClasses?: ReadonlyArray<string>;
     name: string;
     nodes: ReadonlyArray<typescript0.ClassElement>;
+    typeParameters?: ReadonlyArray<typescript0.TypeParameterDeclaration>;
   }) => typescript0.ClassDeclaration;
   conditionalExpression: ({
     condition,
@@ -882,9 +1320,7 @@ declare const compiler: {
     returnType?: string | typescript0.Identifier;
     statements: ReadonlyArray<typescript0.Statement>;
   }) => typescript0.GetAccessorDeclaration;
-  identifier: ({
-    text
-  }: {
+  identifier: (args: string | {
     text: string;
   }) => typescript0.Identifier;
   ifStatement: ({
@@ -1018,6 +1454,13 @@ declare const compiler: {
     required?: boolean;
     type?: typescript0.TypeNode;
   }) => typescript0.ParameterDeclaration;
+  prefixUnaryExpression: ({
+    expression,
+    prefix
+  }: {
+    expression: string | typescript0.Expression;
+    prefix: ("!" | "-") | typescript0.PrefixUnaryOperator;
+  }) => typescript0.PrefixUnaryExpression;
   propertyAccessExpression: ({
     expression,
     isOptional,
@@ -1041,12 +1484,12 @@ declare const compiler: {
   }) => typescript0.PropertyAssignment;
   propertyDeclaration: ({
     initializer,
-    modifier,
+    modifiers,
     name,
     type
   }: {
     initializer?: typescript0.Expression;
-    modifier?: Modifier;
+    modifiers?: Modifier | ReadonlyArray<Modifier>;
     name: string | typescript0.PropertyName;
     type?: typescript0.TypeNode;
   }) => typescript0.PropertyDeclaration;
@@ -1272,5 +1715,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.ts.map

package/dist/index.js

@@ -1 +1 @@
-import{_ as e,a as t,b as n,c as r,r as i,s as a,v as o,x as s}from"./getSpec-1BMHZkPH.js";import{i as c,n as l,r as u,t as d}from"./src-CQ_69Vcm.js";export{c as Logger,a as clientDefaultConfig,r as clientDefaultMeta,t as clientPluginHandler,e as compiler,u as createClient,s as defaultPaginationKeywords,i as defaultPlugins,d as defineConfig,n as definePluginConfig,o as tsc,l as utils};
+import{a as e,c as t,d as n,h as r,l as i,m as a,o,u as s}from"./openApi-D7xrG_wR.js";import{i as c,n as l,r as u,t as d}from"./src-CZCpIWy7.js";export{c as Logger,t as clientDefaultConfig,i as clientDefaultMeta,o as clientPluginHandler,s as compiler,u as createClient,r as defaultPaginationKeywords,e as defaultPlugins,d as defineConfig,a as definePluginConfig,n as tsc,l as utils};

package/dist/internal.cjs

@@ -1 +1 @@
-const e=require(`./getSpec-xn4as4li.cjs`);exports.getSpec=e.t,exports.initConfigs=e.n,exports.parseOpenApiSpec=e.u;
+const e=require(`./openApi-CCTdD3hW.cjs`);exports.getSpec=e.r,exports.initConfigs=e.i,exports.parseOpenApiSpec=e.t;

package/dist/internal.d.cts

@@ -1,4 +1,4 @@
-import { a as Input, c as parseOpenApiSpec, i as UserConfig, n as WatchValues, r as Config, u as Logger } from "./types-Dh80P1tV.cjs";
+import { m as Logger, n as UserConfig, p as Context, r as Input, t as Config } from "./config-PWeoedFF.cjs";
 import { getResolvedInput } from "@hey-api/json-schema-ref-parser";
 
 //#region src/config/init.d.ts
@@ -22,6 +22,25 @@ declare const initConfigs: ({
   userConfigs: ReadonlyArray<UserConfig>;
 }) => Promise<Configs>;
 //#endregion
+//#region src/types/types.d.ts
+interface WatchValues {
+  /**
+   * Headers to be sent with each HEAD and/or GET request. This effectively
+   * serves as a mechanism resolver because setting certain headers will opt
+   * into comparing the specifications using that method.
+   */
+  headers: Headers;
+  /**
+   * Can we send a HEAD request instead of fetching the whole specification?
+   * This value will be set after the first successful fetch.
+   */
+  isHeadMethodSupported?: boolean;
+  /**
+   * String content of the last successfully fetched specification.
+   */
+  lastValue?: string;
+}
+//#endregion
 //#region src/getSpec.d.ts
 type SpecResponse = {
   arrayBuffer: ArrayBuffer | undefined;
@@ -50,5 +69,23 @@ declare const getSpec: ({
   watch: WatchValues;
 }) => Promise<SpecResponse | SpecError>;
 //#endregion
+//#region src/openApi/index.d.ts
+/**
+ * @internal
+ * Parse the resolved OpenAPI specification. This will populate and return
+ * `context` with intermediate representation obtained from the parsed spec.
+ */
+declare const parseOpenApiSpec: ({
+  config,
+  dependencies,
+  logger,
+  spec
+}: {
+  config: Config;
+  dependencies: Record<string, string>;
+  logger: Logger;
+  spec: unknown;
+}) => Context;
+//#endregion
 export { getSpec, initConfigs, parseOpenApiSpec };
 //# sourceMappingURL=internal.d.cts.map

package/dist/internal.d.ts

@@ -1,4 +1,4 @@
-import { a as Input, c as parseOpenApiSpec, i as UserConfig, n as WatchValues, r as Config, u as Logger } from "./types-BRmx9r9T.js";
+import { m as Logger, n as UserConfig, p as Context, r as Input, t as Config } from "./config-CNi83ZTD.js";
 import { getResolvedInput } from "@hey-api/json-schema-ref-parser";
 
 //#region src/config/init.d.ts
@@ -22,6 +22,25 @@ declare const initConfigs: ({
   userConfigs: ReadonlyArray<UserConfig>;
 }) => Promise<Configs>;
 //#endregion
+//#region src/types/types.d.ts
+interface WatchValues {
+  /**
+   * Headers to be sent with each HEAD and/or GET request. This effectively
+   * serves as a mechanism resolver because setting certain headers will opt
+   * into comparing the specifications using that method.
+   */
+  headers: Headers;
+  /**
+   * Can we send a HEAD request instead of fetching the whole specification?
+   * This value will be set after the first successful fetch.
+   */
+  isHeadMethodSupported?: boolean;
+  /**
+   * String content of the last successfully fetched specification.
+   */
+  lastValue?: string;
+}
+//#endregion
 //#region src/getSpec.d.ts
 type SpecResponse = {
   arrayBuffer: ArrayBuffer | undefined;
@@ -50,5 +69,23 @@ declare const getSpec: ({
   watch: WatchValues;
 }) => Promise<SpecResponse | SpecError>;
 //#endregion
+//#region src/openApi/index.d.ts
+/**
+ * @internal
+ * Parse the resolved OpenAPI specification. This will populate and return
+ * `context` with intermediate representation obtained from the parsed spec.
+ */
+declare const parseOpenApiSpec: ({
+  config,
+  dependencies,
+  logger,
+  spec
+}: {
+  config: Config;
+  dependencies: Record<string, string>;
+  logger: Logger;
+  spec: unknown;
+}) => Context;
+//#endregion
 export { getSpec, initConfigs, parseOpenApiSpec };
 //# sourceMappingURL=internal.d.ts.map