ng-openapi 0.3.3 → 0.4.0

package/index.d.ts

@@ -277,7 +277,11 @@ interface GeneratorConfig {
     output: string;
     /** Distinguishes tokens/providers when several clients coexist in one app. */
     clientName?: string;
-    /** Custom acceptance check run on the parsed spec; returning false aborts generation. */
+    /**
+     * Custom acceptance check run on the parsed spec; returning false aborts
+     * generation. Receives the spec as authored — before deep-pointer `$ref`s
+     * are inlined (`core/inline-nested-refs.ts`).
+     */
     validateInput?: (spec: SwaggerSpec) => boolean;
     options: {
         /** How date/date-time formats are typed in generated models. */
@@ -446,15 +450,20 @@ interface GetMethodGenerationContext {
 declare class SwaggerParser {
     private readonly spec;
     private normalized?;
+    /** Non-fatal problems found while normalizing — a parameter with no usable name, for one. */
+    private readonly onWarning?;
     private constructor();
     /**
      * Loads, parses and wraps a spec.
      *
+     * @param onWarning receives non-fatal spec problems found while parsing or
+     *   normalizing — a deep-pointer `$ref` that cannot be inlined, a parameter
+     *   with no usable name.
      * @throws SpecLoadError when the file/URL cannot be read.
-     * @throws SpecParseError when the content cannot be parsed or the
-     *   config's `validateInput` hook rejects the spec.
+     * @throws SpecParseError when the content cannot be parsed, `$ref` inlining
+     *   fails, or the config's `validateInput` hook rejects the spec.
      */
-    static create(swaggerPathOrUrl: string, config: GeneratorConfig): Promise<SwaggerParser>;
+    static create(swaggerPathOrUrl: string, config: GeneratorConfig, onWarning?: (message: string) => void): Promise<SwaggerParser>;
     /**
      * The version-free model generators consume. Computed once and cached —
      * all generators share the same NormalizedOperation instances, so they
@@ -486,7 +495,7 @@ declare class SwaggerParser {
  * http-resource body, overloads) — computing it once keeps the derivations
  * identical by construction.
  */
-declare function normalizeSpec(spec: SwaggerSpec): NormalizedSpec;
+declare function normalizeSpec(spec: SwaggerSpec, onWarning?: (message: string) => void): NormalizedSpec;
 /**
  * Normalizes the JSON-Schema constructs OpenAPI 3.1 introduced so generators
  * never see them:
@@ -511,7 +520,29 @@ declare function normalizeSchema(schema: SwaggerDefinition): SwaggerDefinition;
 declare class NgOpenApiError extends Error {
     /** The underlying error that caused this one, when there is one. */
     readonly cause?: unknown;
-    constructor(message: string, cause?: unknown);
+    protected constructor(message: string, cause?: unknown);
+    /**
+     * `message` and `name` are non-enumerable on Error, so the default
+     * JSON.stringify dropped both — the least useful possible serialization for
+     * something that exists to be logged.
+     *
+     * The payload is spread rather than enumerated: `source`, `issues`,
+     * `operation`, `names` and `placeholders` are why these classes are typed
+     * in the first place, and listing fields by hand silently drops whichever
+     * ones a later subclass adds.
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Recognizes branded errors from another bundled copy of this module, so
+     * `error instanceof SpecLoadError` works for a plugin-thrown error too.
+     * The prototype chain is checked first, so a caller's own subclass of these
+     * classes still matches even though it carries no lineage entry.
+     *
+     * Never throws and never runs foreign code: both reflective reads sit
+     * inside the try, because a Proxy traps `getPrototypeOf` just as readily as
+     * `getOwnPropertyDescriptor`.
+     */
+    static [Symbol.hasInstance](value: unknown): boolean;
 }
 /**
  * The spec input could not be read at all: missing/unreadable file,
@@ -526,14 +557,152 @@ declare class SpecLoadError extends NgOpenApiError {
 }
 /**
  * The spec content was read but could not be used: malformed JSON/YAML,
- * undeterminable format, an unsupported spec version, or a spec rejected
- * by the user's `validateInput` hook.
+ * undeterminable format, an unsupported spec version, a spec rejected by the
+ * user's `validateInput` hook, or a document pathological enough to break
+ * `$ref` inlining (`core/inline-nested-refs.ts`) — `source` is the spec path
+ * or URL in that last case.
  */
 declare class SpecParseError extends NgOpenApiError {
     /** The file path or URL the content came from, when known. */
     readonly source?: string;
     constructor(message: string, source?: string, cause?: unknown);
 }
+/** Identifies the operation an emission-time error came from. */
+interface OperationRef {
+    /** The operationId, when the spec declares one. */
+    operationId?: string;
+    method: string;
+    path: string;
+}
+/** `(GET) /pets/{id}` — or `getPet ((GET) /pets/{id})` when the spec names it. */
+declare function describeOperation(operation: OperationRef): string;
+/**
+ * A name destined for generated code is not a usable TypeScript identifier.
+ * The built-in conversions cannot produce one (see `string.utils.ts`), so this
+ * only ever reports a name that came from a user hook — today
+ * `customizeMethodName` — or an operation missing the `operationId` that hook
+ * needs. Raised instead of emitting the name, because a broken identifier
+ * surfaces downstream as an opaque ts-morph manipulation error that says
+ * nothing about which operation caused it.
+ */
+declare class InvalidIdentifierError extends NgOpenApiError {
+    /** The rejected name, verbatim; absent when no name could be derived. */
+    readonly identifier?: string;
+    /** The operation whose name was being derived. */
+    readonly operation: OperationRef;
+    constructor(message: string, operation: OperationRef, identifier?: string);
+}
+/**
+ * Two operations produced the same generated name, which would emit colliding
+ * declarations. Distinct from InvalidIdentifierError: each name is valid on its
+ * own, they just cannot coexist.
+ */
+declare class DuplicateGeneratedNameError extends NgOpenApiError {
+    /** The colliding generated names. */
+    readonly names: readonly string[];
+    /** The operations that produced them, when known. */
+    readonly operations: readonly OperationRef[];
+    constructor(message: string, names: readonly string[], operations?: readonly OperationRef[]);
+}
+/**
+ * A path template contains a `{placeholder}` with no matching parameter. Raised
+ * rather than emitted: the unsubstituted placeholder used to ship as literal
+ * text in every request URL, which compiles and so escapes every compile-time
+ * check the suite has.
+ */
+declare class UnresolvedPathTemplateError extends NgOpenApiError {
+    /** The path as written in the spec. */
+    readonly path: string;
+    /** Placeholder names with no declared parameter. */
+    readonly placeholders: readonly string[];
+    constructor(message: string, path: string, placeholders: readonly string[]);
+}
+/**
+ * The user-supplied config is structurally invalid. Collects every issue
+ * instead of failing on the first, so a config file can be fixed in one pass.
+ */
+declare class ConfigValidationError extends NgOpenApiError {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+/**
+ * The config file itself could not be loaded or evaluated — distinct from
+ * SpecParseError, which says the *specification* failed to parse.
+ */
+declare class ConfigLoadError extends NgOpenApiError {
+    /** Path of the config file that failed to load. */
+    readonly source: string;
+    constructor(message: string, source: string, cause?: unknown);
+}
+
+/**
+ * Wire names and header values are free-form spec text that ends up inside
+ * emitted *string literals*, not just identifiers. Hardening the identifier
+ * path left these unguarded:
+ *
+ * - a quote closes the literal early, which is a syntax error;
+ * - a backslash is worse because it is silent: the emitted literal means a
+ *   different string, so the wrong name goes on the wire and still compiles;
+ * - a backtick or an interpolation opener inside a template literal (the
+ *   request URL) ends the literal or starts an interpolation, failing with the
+ *   same opaque ts-morph error as #125.
+ *
+ * Every emitted literal built from spec text must go through one of these.
+ */
+/** A single-quoted TypeScript string literal holding exactly `value`. */
+declare function quoteLiteral(value: string): string;
+/** The inside of a single-quoted literal — use when the quotes are already there. */
+declare function escapeSingleQuoted(value: string): string;
+/**
+ * Escapes `value` for a position inside a template literal, where a backtick
+ * ends the literal and `${` opens an interpolation.
+ */
+declare function escapeTemplateLiteral(value: string): string;
+/**
+ * An object-literal property key holding exactly `name`.
+ *
+ * `__proto__` is the one key whose *literal* form carries semantics: as a plain
+ * or quoted property key it invokes the prototype setter and creates no own
+ * property, so the field silently disappears from the emitted object. A
+ * computed key is an ordinary key — used only where it is needed, so normal
+ * generated output keeps the more readable quoted form.
+ */
+declare function emitObjectKey(name: string, quoteStyle?: "single" | "double"): string;
+/** The inside of a double-quoted literal. */
+declare function escapeDoubleQuoted(value: string): string;
+/**
+ * A property name in a *declaration* position (an interface member, a type
+ * literal): the bare identifier when it is one, otherwise a quoted and escaped
+ * key.
+ *
+ * The unescaped `"${name}"` this replaces emitted `"say"hi"` for the legal
+ * property name `say"hi` — three syntax errors in one model file from a valid
+ * spec, with generation reporting success. `__proto__` needs no special
+ * treatment here: a declaration has no prototype setter to invoke, unlike the
+ * object-literal position that `emitObjectKey` serves.
+ */
+declare function emitPropertyName(name: string): string;
+/**
+ * Escapes text for a JSDoc block.
+ *
+ * A `*` followed by `/` closes the comment, so a description containing one
+ * ends the block early and everything after it is emitted as code. From a
+ * remote spec — ng-openapi accepts a URL as input — that writes arbitrary
+ * declarations into the consumer's source tree, and at definition level the
+ * result is valid TypeScript, so it compiles and no compile assertion sees it.
+ *
+ * `*\/` neutralizes it: the backslash has no meaning inside a comment, so it
+ * renders as written and cannot terminate the block. (TypeScript's own emitter
+ * uses `*_/` for the same job; either works, and this one keeps the text readable.)
+ */
+declare function escapeJsDoc(text: string): string;
+/**
+ * The `docs` array for a ts-morph structure, or undefined when there is no
+ * description. Every generator goes through this rather than building
+ * `[description]` inline, so the escape cannot be forgotten at a call site — every
+ * count of them written here so far has been wrong within a round.
+ */
+declare function emitDocs(description: unknown): string[] | undefined;
 
 interface HeadersEmitOptions {
     /** Identifier of the per-request options parameter in the generated method ("options", "requestOptions", …). */
@@ -564,16 +733,78 @@ declare function emitHeaders(options: HeadersEmitOptions): string;
  */
 declare function emitDefaultHeadersMerge(optionsExpression: string, customHeaders: Record<string, string>): string;
 
+/** What a generator binds besides its arguments, and whether it takes a body. */
+interface ArgumentNameProfile {
+    /** Identifiers the emitted method already binds. */
+    readonly reserved: readonly string[];
+    /** Whether the emitted method takes the JSON request body as a parameter. */
+    readonly bindsRequestBody: boolean;
+}
+/**
+ * The core service method: `observe`/`options` are its trailing parameters,
+ * the rest are locals its body declares (see `emit/url.emit.ts`,
+ * `emit/query-params.emit.ts`, `emit/headers.emit.ts` and the form-data blocks
+ * of `service-method-body.generator.ts`).
+ */
+declare const SERVICE_ARGUMENT_PROFILE: ArgumentNameProfile;
+/**
+ * The httpResource plugin's equivalent. Deliberately a different set, not a
+ * copy: its trailing parameters are `resourceOptions`/`requestOptions` and it
+ * emits no `url`/`formData`/`formBody` locals. Reserving the core's names here
+ * would rename plugin parameters for no reason; reserving only the core's would
+ * let a `requestOptions` query parameter capture the plugin's own. It also
+ * wraps GETs only and never binds a request body, so reserving a body name
+ * would burn an identifier no emitted parameter uses.
+ */
+declare const RESOURCE_ARGUMENT_PROFILE: ArgumentNameProfile;
+/** A wire name that had to be renamed to stay distinct — surfaced as a warning. */
+interface RenamedArgument {
+    /** The wire name, or the type-derived name of the request body. */
+    source: string;
+    identifier: string;
+}
+interface ArgumentNames {
+    /** The identifier bound to `wireName`. */
+    of(wireName: string): string;
+    /** The identifier of the JSON request body, when the operation has one. */
+    readonly body?: string;
+    /** Every identifier assigned, for emitters that derive locals from them. */
+    readonly all: readonly string[];
+    readonly renamed: readonly RenamedArgument[];
+    /**
+     * Wire names declared in more than one location (a path *and* a query
+     * `id`). They collapse to a single parameter, so the later declaration's
+     * type is discarded and one value is sent to both — worth a warning.
+     */
+    readonly merged: readonly string[];
+}
+/**
+ * Assigns every argument of one operation a distinct TypeScript identifier.
+ *
+ * Resolution is per-generator, not per-spec: the set of names already taken is
+ * a property of the code being emitted (the core service and the httpResource
+ * plugin bind different ones), so this is deliberately NOT precomputed on
+ * `NormalizedOperation`. It is a pure function of its inputs, so every call
+ * site of one generator gets the same answer without threading it through.
+ *
+ * Doing it one name at a time — as `camelCase(param.name)` per call site did —
+ * cannot see collisions: wire names are free-form, so `filter[name]` and
+ * `filter.name` both camelCase to `filterName`, and `options[]` lands on the
+ * method's own `options` parameter. Order is significant and must stay stable;
+ * it decides which argument keeps the unsuffixed name.
+ */
+declare function resolveArgumentNames(operation: NormalizedOperation, config: MethodGenOptions, profile: ArgumentNameProfile): ArgumentNames;
+
 /**
  * Emits the `HttpParams` accumulation block for the core service method body.
  * Returns "" when the operation has no query parameters.
  */
-declare function emitQueryParams(queryParams: Parameter[]): string;
+declare function emitQueryParams(queryParams: Parameter[], argumentNames: ArgumentNames): string;
 /**
  * Signal-aware variant for the http-resource plugin: each parameter may be a
  * signal, so its value is read once before the null check.
  */
-declare function emitSignalAwareQueryParams(queryParams: Parameter[]): string;
+declare function emitSignalAwareQueryParams(queryParams: Parameter[], argumentNames: ArgumentNames): string;
 
 interface ServiceDecoratorEmitOptions {
     /** Class decorator flavor from GeneratorConfig; "service" requires Angular 22+. */
@@ -615,23 +846,34 @@ declare function plainParamValue(identifier: string): string;
 declare function signalAwareParamValue(identifier: string): string;
 /**
  * Builds the request-URL template literal, substituting `{param}` placeholders
- * with the (camelCased) method parameter identifiers.
+ * with the method parameter identifiers `argumentNames` assigned.
  */
-declare function emitUrlExpression(path: string, pathParams: Parameter[], paramValue?: (identifier: string) => string): string;
+declare function emitUrlExpression(path: string, pathParams: Parameter[], argumentNames: ArgumentNames, paramValue?: (identifier: string) => string): string;
 /** `const url = …;` statement used by the core service method body. */
-declare function emitUrlConstruction(path: string, pathParams: Parameter[]): string;
+declare function emitUrlConstruction(path: string, pathParams: Parameter[], argumentNames: ArgumentNames): string;
 
+/**
+ * Whether `name` can be emitted as-is as a TypeScript identifier. Only needed
+ * for names ng-openapi did not derive itself — everything out of `camelCase`
+ * and `pascalCase` already satisfies this.
+ */
+declare function isValidIdentifier(name: string): boolean;
 /**
  * Converts a string to camelCase. Dots, dashes, underscores and whitespace are
  * treated as word separators and removed (`"pet_id"` → `"petId"`,
- * `"filter.name"` → `"filterName"`).
+ * `"filter.name"` → `"filterName"`), as is every other character illegal in a
+ * TypeScript identifier (`"groups_{group_id}_delete"` →
+ * `"groupsGroupIdDelete"`), so the result is always a valid identifier.
  */
 declare function camelCase(str: string): string;
 /** Converts a string to kebab-case (`"PetStore"` → `"pet-store"`). */
 declare function kebabCase(str: string): string;
 /**
  * Converts a string to PascalCase. Dots, dashes, underscores and whitespace
- * are treated as word separators and removed (`"pet_store"` → `"PetStore"`).
+ * are treated as word separators and removed (`"pet_store"` → `"PetStore"`), as
+ * is every other character illegal in a TypeScript identifier
+ * (`"Groups (yes)"` → `"GroupsYes"`), so the result is always a valid
+ * identifier — service and resource class names are built from it.
  */
 declare function pascalCase(str: string): string;
 /** Converts a string to SCREAMING_SNAKE_CASE (`"PetStore"` → `"PET_STORE"`) — used for token names. */
@@ -642,6 +884,8 @@ declare function screamingSnakeCase(str: string): string;
  * prefixed with `_` so the result is always a valid TS identifier.
  */
 declare function pascalCaseForEnums(str: string): string;
+/** Uppercases the first character and leaves the rest exactly as given. */
+declare function capitalizeFirst(str: string): string;
 
 /**
  * Convert OpenAPI/Swagger types to TypeScript types
@@ -654,8 +898,6 @@ declare function pascalCaseForEnums(str: string): string;
 declare function getTypeScriptType(schemaOrType: TypeSchema | SwaggerDefinition | string | undefined, config: TypeMappingConfig, formatOrNullable?: string | boolean, isNullable?: boolean, context?: "type" | "service"): string;
 /** Appends `| null` to a type expression when the schema is nullable. */
 declare function nullableType(type: string, isNullable?: boolean): string;
-/** Escapes backslashes and single quotes for embedding in a single-quoted generated literal. */
-declare function escapeString(str: string): string;
 
 /** The content types the generators special-case when emitting method bodies. */
 declare const CONTENT_TYPES: {
@@ -690,6 +932,25 @@ declare function listGeneratedBarrelDirs(project: Project, rootPath: string): st
  * and suffixed, so multiple clients can coexist in one application
  * (`"PetsApi"` → `BASE_PATH_PETSAPI`); the default client uses `_DEFAULT`.
  */
+/**
+ * The client name generation actually uses. `""` counts as unset: one site
+ * used `|| "default"` and two used a default parameter (which fires only on
+ * undefined), so an empty clientName produced `BASE_PATH_` in the tokens file
+ * and an import of `BASE_PATH_DEFAULT` in the providers — unresolvable.
+ */
+declare function effectiveClientName(clientName?: string): string;
+/**
+ * clientName as the stem of a generated identifier (`provide<Stem>Client`,
+ * `<Stem>BaseInterceptor`, `<Stem>Config`).
+ *
+ * A name that already is an identifier is capitalized and otherwise kept
+ * verbatim — `my_client` gives `provideMy_clientClient`, as it always has.
+ * Sending every name through pascalCase would have renamed that to
+ * `provideMyClientClient`, the function every consumer imports, for a
+ * config that was valid all along. Only a name that could not have compiled
+ * before (`my-client`, `my client`) is sanitized.
+ */
+declare function clientNameIdentifier(clientName: string): string;
 /** Token identifying which client a request belongs to (read by interceptors). */
 declare function getClientContextTokenName(clientName?: string): string;
 /** Token providing the API base path for the client. */
@@ -709,9 +970,88 @@ declare function getResourceClassName(controllerName: string, naming?: NameDecor
  */
 declare function getModelTypeName(rawName: string, naming?: NameDecoration): string;
 
-/** Whether two or more declarations share a name — generation aborts on colliding method names. */
+/**
+ * Groups operations into the per-controller buckets each client generator
+ * emits one file from: the first tag when there is one, otherwise the second
+ * path segment, otherwise "Default".
+ *
+ * Shared because the core service generator, the httpResource plugin and the
+ * zod plugin must agree on the grouping — a controller name decides a class
+ * name AND a file name, and the barrel generators re-derive the class name
+ * from the file name.
+ *
+ * `onWarning` fires when two distinct *tags* normalize onto one controller
+ * ("Groups (yes)" and "Groups-yes" both become "GroupsYes"). They are merged
+ * into a single file rather than dropped, but silently merging two documented
+ * tags is worth saying out loud. Path-derived names are excluded: a tagged
+ * `Users` operation next to an untagged `/users/...` one is the ordinary
+ * partially-tagged spec, and merging them is the intended behaviour.
+ */
+declare function groupOperationsByController(operations: NormalizedOperation[], onWarning?: (message: string) => void): Record<string, NormalizedOperation[]>;
+
+/**
+ * Valid identifiers that still cannot name a generated method.
+ *
+ * `constructor` declares the class constructor, so ts-morph rejects a method
+ * by that name. The rest are members the generated classes bind themselves
+ * (`httpClient` in the service; `basePath`, `clientContextToken` and the context helper in
+ * both): an
+ * operationId of `basePath` emitted a method next to the property of the same
+ * name — TS2300 ten times over, reported as success. The same insight
+ * ArgumentNameProfile.reserved encodes for parameters, applied to methods.
+ * Other reserved words are fine — `class() {}` is a legal member.
+ */
+declare const RESERVED_MEMBER_NAMES: readonly string[];
+/**
+ * The derived method name that collided with a reserved member and was
+ * renamed, or undefined when it did not. For the generators to warn on: a
+ * rename is part of the public signature and must not be silent.
+ */
+declare function reservedMemberCollision(operation: NormalizedOperation, config: MethodGenOptions): {
+    from: string;
+    to: string;
+} | undefined;
+/**
+ * Single source of truth for the method name of an operation, shared by the
+ * service generator and the httpResource plugin — the two emit different
+ * clients over the same operations, and a user switching between them (or
+ * running both) must get the same method names.
+ */
+declare function getOperationMethodName(operation: NormalizedOperation, config: MethodGenOptions): string;
+
+/** What the assertion reads off a class: ts-morph's ClassDeclaration satisfies it structurally. */
+interface ClassMembers {
+    getMethods(): readonly {
+        getName(): string;
+    }[];
+    getProperties(): readonly {
+        getName(): string;
+    }[];
+}
+/**
+ * Throws when two operations produced the same method name, or a method name
+ * landed on a property the class binds itself. One implementation for the
+ * service and resource generators — the two copies had already begun to
+ * drift, and the property check was missing from both.
+ */
+declare function assertDistinctMemberNames(serviceClass: ClassMembers, className: string, operations: NormalizedOperation[], methodNameOf: (operation: NormalizedOperation) => string): void;
+
+/**
+ * Whether two or more declarations share a name.
+ *
+ * @deprecated The generators use `assertDistinctMemberNames`, which also
+ * catches a method landing on a property and reports the colliding operations.
+ * Kept because it was a public export; it will be removed in the next major.
+ */
 declare function hasDuplicateFunctionNames<T extends MethodDeclaration | FunctionDeclaration>(arr: T[]): boolean;
 
+/** Outcome of resolving a `$ref` parameter: the component, or why not. */
+type ParameterResolution = {
+    parameter: Parameter;
+} | {
+    problem: string;
+};
+type ResolveParameter = (ref: string) => ParameterResolution;
 /**
  * Flattens the spec's `paths` object into one PathInfo per (path, method)
  * pair, merging path-level parameters into each operation. Supports both
@@ -720,7 +1060,7 @@ declare function hasDuplicateFunctionNames<T extends MethodDeclaration | Functio
  */
 declare function extractPaths(swaggerPaths?: {
     [p: string]: Path;
-}, methods?: string[]): PathInfo[];
+}, methods?: string[], onWarning?: (message: string) => void, resolveParameter?: ResolveParameter): PathInfo[];
 
 /** Result of analyzing a response's content types once for both concerns. */
 interface ResponseTypeInfo {
@@ -870,15 +1210,15 @@ declare function validateInput(inputPath: string): void;
  */
 declare function generateFromConfig(config: GeneratorConfig, reporter?: Reporter): Promise<GenerationResult>;
 
+declare function validateGeneratorConfig(config: unknown): asserts config is GeneratorConfig;
+
 /**
- * Thrown when the user-supplied config is structurally invalid. Collects every
- * issue instead of failing on the first one, so a config file can be fixed in
- * one pass.
+ * Loads and normalizes a config file.
+ *
+ * Its own module rather than part of cli.ts: importing cli.ts runs the CLI
+ * (commander parses argv at import time), so the config-load contract — which
+ * hosts branch on via ConfigLoadError — could not otherwise be tested.
  */
-declare class ConfigValidationError extends Error {
-    readonly issues: string[];
-    constructor(issues: string[]);
-}
-declare function validateGeneratorConfig(config: unknown): asserts config is GeneratorConfig;
+declare function loadConfigFile(configPath: string): Promise<GeneratorConfig>;
 
-export { BASE_INTERCEPTOR_HEADER_COMMENT, CONTENT_TYPES, ConfigValidationError, type EnumValueObject, type GenerationPhase, type GenerationResult, type GeneratorConfig, type GetMethodGenerationContext, HTTP_RESOURCE_GENERATOR_HEADER_COMMENT, type HeadersEmitOptions, type IPluginGenerator, type IPluginGeneratorClass, MAIN_INDEX_GENERATOR_HEADER_COMMENT, type MethodGenOptions, type MethodGenerationContext, type NameDecoration, type NamingOptions, NgOpenApiError, type NgOpenapiClientConfig, type NormalizedOperation, type NormalizedSpec, type OpenApiSecurityScheme, PROVIDER_GENERATOR_HEADER_COMMENT, type Parameter, type PathInfo, type PluginGeneratorContext, REQUEST_PARAMS_GENERATOR_HEADER_COMMENT, type Reporter, type RequestBody, type ResponseKind, type ResponseTypeInfo, SERVICE_GENERATOR_HEADER_COMMENT, SERVICE_INDEX_GENERATOR_HEADER_COMMENT, type ServiceDecoratorEmit, type ServiceDecoratorEmitOptions, SpecLoadError, SpecParseError, type SpecVersion, type SwaggerDefinition, SwaggerParser, type SwaggerResponse, type SwaggerSpec, TYPE_GENERATOR_HEADER_COMMENT, type TypeGenOptions, type TypeMappingConfig, type TypeSchema, ZOD_PLUGIN_GENERATOR_HEADER_COMMENT, ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT, camelCase, defineConfig, emitDefaultHeadersMerge, emitHeaders, emitQueryParams, emitResponseTypeOption, emitServiceDecorator, emitSignalAwareQueryParams, emitUrlConstruction, emitUrlExpression, escapeString, extractPaths, generateFromConfig, generateParseRequestTypeParams, getBasePathTokenName, getClientContextTokenName, getInterceptorsTokenName, getModelTypeName, getRequestBodyType, getResourceClassName, getResponseInfoFromResponse, getResponseType, getResponseTypeFromResponse, getServiceClassName, getTypeScriptType, hasDuplicateFunctionNames, inferResponseTypeFromContentType, isDataTypeInterface, isPrimitiveType, isUrl, joinRequestOptionEntries, kebabCase, listGeneratedBarrelDirs, listGeneratedFileNames, normalizeSchema, normalizeSpec, nullableType, pascalCase, pascalCaseForEnums, plainParamValue, screamingSnakeCase, signalAwareParamValue, validateGeneratorConfig, validateInput };
+export { type ArgumentNameProfile, type ArgumentNames, BASE_INTERCEPTOR_HEADER_COMMENT, CONTENT_TYPES, ConfigLoadError, ConfigValidationError, DuplicateGeneratedNameError, type EnumValueObject, type GenerationPhase, type GenerationResult, type GeneratorConfig, type GetMethodGenerationContext, HTTP_RESOURCE_GENERATOR_HEADER_COMMENT, type HeadersEmitOptions, type IPluginGenerator, type IPluginGeneratorClass, InvalidIdentifierError, MAIN_INDEX_GENERATOR_HEADER_COMMENT, type MethodGenOptions, type MethodGenerationContext, type NameDecoration, type NamingOptions, NgOpenApiError, type NgOpenapiClientConfig, type NormalizedOperation, type NormalizedSpec, type OpenApiSecurityScheme, type OperationRef, PROVIDER_GENERATOR_HEADER_COMMENT, type Parameter, type PathInfo, type PluginGeneratorContext, REQUEST_PARAMS_GENERATOR_HEADER_COMMENT, RESERVED_MEMBER_NAMES, RESOURCE_ARGUMENT_PROFILE, type RenamedArgument, type Reporter, type RequestBody, type ResponseKind, type ResponseTypeInfo, SERVICE_ARGUMENT_PROFILE, SERVICE_GENERATOR_HEADER_COMMENT, SERVICE_INDEX_GENERATOR_HEADER_COMMENT, type ServiceDecoratorEmit, type ServiceDecoratorEmitOptions, SpecLoadError, SpecParseError, type SpecVersion, type SwaggerDefinition, SwaggerParser, type SwaggerResponse, type SwaggerSpec, TYPE_GENERATOR_HEADER_COMMENT, type TypeGenOptions, type TypeMappingConfig, type TypeSchema, UnresolvedPathTemplateError, ZOD_PLUGIN_GENERATOR_HEADER_COMMENT, ZOD_PLUGIN_INDEX_GENERATOR_HEADER_COMMENT, assertDistinctMemberNames, camelCase, capitalizeFirst, clientNameIdentifier, defineConfig, describeOperation, effectiveClientName, emitDefaultHeadersMerge, emitDocs, emitHeaders, emitObjectKey, emitPropertyName, emitQueryParams, emitResponseTypeOption, emitServiceDecorator, emitSignalAwareQueryParams, emitUrlConstruction, emitUrlExpression, escapeDoubleQuoted, escapeJsDoc, escapeSingleQuoted, escapeSingleQuoted as escapeString, escapeTemplateLiteral, extractPaths, generateFromConfig, generateParseRequestTypeParams, getBasePathTokenName, getClientContextTokenName, getInterceptorsTokenName, getModelTypeName, getOperationMethodName, getRequestBodyType, getResourceClassName, getResponseInfoFromResponse, getResponseType, getResponseTypeFromResponse, getServiceClassName, getTypeScriptType, groupOperationsByController, hasDuplicateFunctionNames, inferResponseTypeFromContentType, isDataTypeInterface, isPrimitiveType, isUrl, isValidIdentifier, joinRequestOptionEntries, kebabCase, listGeneratedBarrelDirs, listGeneratedFileNames, loadConfigFile, normalizeSchema, normalizeSpec, nullableType, pascalCase, pascalCaseForEnums, plainParamValue, quoteLiteral, reservedMemberCollision, resolveArgumentNames, screamingSnakeCase, signalAwareParamValue, validateGeneratorConfig, validateInput };