genoc 0.3.0 → 0.4.0

package/dist/generator/method-generator.js

@@ -1,33 +1,32 @@
-import { getOperationTypePrefix, getSuccessType, sanitizeJsDocText, } from '../utils/generator-helpers.js';
+import { sanitizeJsDocText } from '../utils/generator-helpers.js';
+import { getSuccessType, operationEmissions } from '../utils/operation-naming.js';
 function buildParameters(op) {
     const params = [];
+    const emissions = operationEmissions(op);
     for (const param of op.pathParams) {
         params.push(`${param.name}: string`);
     }
-    if (op.queryParams.length > 0) {
-        const prefix = getOperationTypePrefix(op);
+    if (emissions.query !== undefined) {
         const allOptional = op.queryParams.every((p) => !p.required);
         const hasRequiredAfter = !!op.requestBody?.required || op.headerParams.some((p) => p.required);
         if (allOptional && hasRequiredAfter) {
             // All optional query params + required param after: use explicit undefined to avoid "required param cannot follow optional" error
-            params.push(`query: ${prefix}Query | undefined`);
+            params.push(`query: ${emissions.query} | undefined`);
         }
         else {
             // Normal case: use optional notation
             const optional = allOptional ? '?' : '';
-            params.push(`query${optional}: ${prefix}Query`);
+            params.push(`query${optional}: ${emissions.query}`);
         }
     }
     if (op.requestBody) {
-        const prefix = getOperationTypePrefix(op);
         const optional = op.requestBody.required ? '' : '?';
-        params.push(`body${optional}: ${prefix}Body`);
+        params.push(`body${optional}: ${emissions.body}`);
     }
-    if (op.headerParams.length > 0) {
-        const prefix = getOperationTypePrefix(op);
+    if (emissions.headers !== undefined) {
         const allOptional = op.headerParams.every((p) => !p.required);
         const optional = allOptional ? '?' : '';
-        params.push(`headers${optional}: ${prefix}Headers`);
+        params.push(`headers${optional}: ${emissions.headers}`);
     }
     return params.join(', ');
 }
@@ -96,159 +95,20 @@ function buildJsDoc(op) {
     }
     return `/**\n${lines.join('\n')}\n */`;
 }
-function buildUrlConstruction(op) {
-    let url = op.path;
-    for (const param of op.pathParams) {
-        url = url.replace(`{${param.name}}`, `\${encodeURIComponent(${param.name})}`);
-    }
-    return `\`${url}\``;
-}
-function buildImplementation(op) {
-    const successType = getSuccessType(op);
-    const prefix = getOperationTypePrefix(op);
-    const lines = [];
-    if (op.pathParams.length > 0) {
-        lines.push(`const url = ${buildUrlConstruction(op)};`);
-    }
-    else {
-        lines.push(`const url = "${op.path}";`);
-    }
-    if (op.queryParams.length > 0) {
-        lines.push(`const queryString = query ? "?" + new URLSearchParams(query as Record<string, string>).toString() : "";`);
-        lines.push('const fullUrl = url + queryString;');
-    }
-    const finalUrl = op.queryParams.length > 0 ? 'fullUrl' : 'url';
-    const requesterOpts = [];
-    if (op.queryParams.length > 0) {
-        requesterOpts.push('query');
-    }
-    if (op.requestBody) {
-        requesterOpts.push('body');
-    }
-    if (op.headerParams.length > 0) {
-        requesterOpts.push('headers');
-    }
-    // Error responses for status-specific checks
-    const errorResponses = op.responses.filter((r) => !r.isSuccess && r.statusCode !== 'default');
-    // Lines for inside `if (result instanceof ErrorResponse) { ... }`
-    const hasDefaultResponse = op.responses.some((r) => !r.isSuccess && r.statusCode === 'default');
-    const errorCheckLines = [];
-    for (const errResp of errorResponses) {
-        const status = errResp.statusCode;
-        errorCheckLines.push(`if (result.status === ${status}) throw new ApiError(${status}, result.data as ${prefix}Error${status}, result.message ?? \`Request failed with status ${status}\`);`);
-    }
-    if (hasDefaultResponse) {
-        errorCheckLines.push(`throw new DefaultApiError(result.status, result.data as ${prefix}DefaultError, result.message ?? \`Request failed with status \${result.status}\`);`);
-    }
-    else {
-        errorCheckLines.push('throw new UnspecifiedApiError(result.status, result.data, result.message ?? `Request failed with status ${result.status}`);');
-    }
-    // Build try/catch block around requester call
-    const buildTryCatch = (opts) => {
-        const block = [];
-        block.push('try {');
-        block.push(`  const result = await requester<${successType}>("${op.method.toUpperCase()}", ${finalUrl}, ${opts});`);
-        block.push('  if (result instanceof ErrorResponse) {');
-        for (const check of errorCheckLines) {
-            block.push(`    ${check}`);
-        }
-        block.push('  }');
-        if (op.responses.some((r) => r.isSuccess && r.isBinary)) {
-            block.push('  if (!(result instanceof StreamResponse)) {');
-            block.push('    throw new RequesterFailError(new Error("Expected stream response"));');
-            block.push('  }');
-        }
-        else {
-            block.push('  if (result instanceof StreamResponse) {');
-            block.push('    throw new RequesterFailError(new Error("Unexpected stream response"));');
-            block.push('  }');
-        }
-        block.push('  return result;');
-        block.push('} catch (error) {');
-        block.push('  if (error instanceof UnspecifiedApiError) throw error;');
-        block.push('  if (error instanceof ApiError) throw error;');
-        block.push('  throw new RequesterFailError(error);');
-        block.push('}');
-        return block;
-    };
-    if (op.requestBody?.isMultipart && op.requestBody.schema) {
-        const schema = op.requestBody.schema;
-        const requiredSet = new Set((schema?.required ?? []));
-        const properties = schema.properties ?? {};
-        const propNames = Object.keys(properties);
-        const bodyRequired = op.requestBody.required;
-        const formDataLines = [];
-        formDataLines.push('const formData = new FormData();');
-        for (const propName of propNames) {
-            const propSchema = properties[propName];
-            const isArrayBinary = propSchema?.type === 'array' && propSchema?.items?.format === 'binary';
-            if (propSchema?.format === 'binary') {
-                if (requiredSet.has(propName)) {
-                    formDataLines.push(`formData.append("${propName}", body.${propName}.data, body.${propName}.filename);`);
-                }
-                else {
-                    formDataLines.push(`if (body.${propName} !== undefined) formData.append("${propName}", body.${propName}.data, body.${propName}.filename);`);
-                }
-            }
-            else if (isArrayBinary) {
-                formDataLines.push(`if (body.${propName} !== undefined) { for (const file of body.${propName}) { formData.append("${propName}", file.data, file.filename); } }`);
-            }
-            else {
-                formDataLines.push(`if (body.${propName} !== undefined) formData.append("${propName}", body.${propName});`);
-            }
-        }
-        const bodyIdx = requesterOpts.indexOf('body');
-        if (bodyIdx !== -1)
-            requesterOpts[bodyIdx] = 'body: formData';
-        if (op.responses.some((r) => r.isSuccess && r.isBinary)) {
-            requesterOpts.push('expectStream: true');
-        }
-        const multipartOpts = requesterOpts.length > 0 ? `{ ${requesterOpts.join(', ')} }` : '{}';
-        if (bodyRequired) {
-            lines.push(...formDataLines);
-            lines.push(...buildTryCatch(multipartOpts));
-        }
-        else {
-            lines.push('if (body) {');
-            for (const line of formDataLines) {
-                lines.push(`  ${line}`);
-            }
-            for (const line of buildTryCatch(multipartOpts)) {
-                lines.push(`  ${line}`);
-            }
-            lines.push('}');
-            const fallbackOpts = requesterOpts.filter((o) => o !== 'body: formData' && o !== 'body');
-            const fallbackOptsStr = fallbackOpts.length > 0 ? `{ ${fallbackOpts.join(', ')} }` : '{}';
-            lines.push(...buildTryCatch(fallbackOptsStr));
-        }
-    }
-    else {
-        if (op.responses.some((r) => r.isSuccess && r.isBinary)) {
-            requesterOpts.push('expectStream: true');
-        }
-        const optsStr = requesterOpts.length > 0 ? `{ ${requesterOpts.join(', ')} }` : '{}';
-        lines.push(...buildTryCatch(optsStr));
-    }
-    return lines.join('\n  ');
-}
 /**
  * Generate a client method from an analyzed OpenAPI operation.
  *
  * @param op - The analyzed operation
- * @returns Generated method with name, JSDoc, signature, and implementation
+ * @returns Generated method with name, JSDoc, and signature
  */
 export function generateMethod(op) {
     const params = buildParameters(op);
     const successType = getSuccessType(op);
     const jsDoc = buildJsDoc(op);
     const signature = `${op.methodName}(${params}): Promise<${successType}>`;
-    const implementation = `${signature} {
-  ${buildImplementation(op)}
-}`;
     return {
         name: op.methodName,
         jsDoc,
         signature,
-        implementation,
     };
 }

package/dist/parser/ref-resolver.d.ts

@@ -2,7 +2,7 @@ import type { OpenAPIDocument, ReferenceObject, SchemaObject } from '../types/op
 export declare class RefResolver {
     private doc;
     private preserveRefSiblings;
-    constructor(doc: OpenAPIDocument, documentUrl?: string, options?: {
+    constructor(doc: OpenAPIDocument, options?: {
         preserveRefSiblings?: boolean;
     });
     /**

package/dist/parser/ref-resolver.js

@@ -3,10 +3,9 @@ const MAX_DEPTH = 10;
 export class RefResolver {
     doc;
     preserveRefSiblings;
-    constructor(doc, documentUrl, options) {
+    constructor(doc, options) {
         this.doc = doc;
         this.preserveRefSiblings = options?.preserveRefSiblings ?? false;
-        void documentUrl;
     }
     /**
      * If input has `$ref`, resolve it; otherwise return as-is.

package/dist/parser/version/index.d.ts

@@ -1,18 +1,6 @@
 /**
- * Version strategy interface for multi-version OpenAPI support
+ * Version detection and validation for multi-version OpenAPI support
  */
-export type { VersionStrategy } from './version-strategy.js';
-/**
- * Version detection and registry for multi-version OpenAPI support
- */
-export { detectSpecVersion } from './version-detector.js';
-export { VersionStrategyRegistry } from './registry.js';
-/**
- * Normalized schema and specification types for consistent multi-version handling
- */
-export type { NormalizedSchema, NormalizedSpec } from './normalized-spec.js';
-export { V3_0_VersionStrategy } from './v3.0/strategy.js';
-export { V3_1_VersionStrategy } from './v3.1/strategy.js';
-export { V3_2_VersionStrategy } from './v3.2/strategy.js';
-import { VersionStrategyRegistry } from './registry.js';
-export declare const defaultRegistry: VersionStrategyRegistry;
+export { detectSpecVersion, resolveVersion } from './version-detector.js';
+export type { VersionProfile } from './version-detector.js';
+export { validateSpec } from './validate.js';

package/dist/parser/version/index.js

@@ -1,16 +1,5 @@
 /**
- * Version detection and registry for multi-version OpenAPI support
+ * Version detection and validation for multi-version OpenAPI support
  */
-export { detectSpecVersion } from './version-detector.js';
-export { VersionStrategyRegistry } from './registry.js';
-export { V3_0_VersionStrategy } from './v3.0/strategy.js';
-export { V3_1_VersionStrategy } from './v3.1/strategy.js';
-export { V3_2_VersionStrategy } from './v3.2/strategy.js';
-import { VersionStrategyRegistry } from './registry.js';
-import { V3_0_VersionStrategy } from './v3.0/strategy.js';
-import { V3_1_VersionStrategy } from './v3.1/strategy.js';
-import { V3_2_VersionStrategy } from './v3.2/strategy.js';
-export const defaultRegistry = new VersionStrategyRegistry();
-defaultRegistry.register(new V3_0_VersionStrategy());
-defaultRegistry.register(new V3_1_VersionStrategy());
-defaultRegistry.register(new V3_2_VersionStrategy());
+export { detectSpecVersion, resolveVersion } from './version-detector.js';
+export { validateSpec } from './validate.js';

package/dist/parser/version/v3.0/validator.d.ts

@@ -1,4 +1,4 @@
-import type { ValidationResult } from '../../validators.js';
+import type { ValidationResult } from '../validate.js';
 /**
  * Validate a raw OpenAPI 3.0.x specification.
  *

package/dist/parser/version/v3.1/validator.d.ts

@@ -0,0 +1,17 @@
+import type { ValidationResult } from '../validate.js';
+/**
+ * Validate a raw OpenAPI 3.1.x specification.
+ *
+ * 3.1-specific validation rules:
+ * - `openapi` must start with "3.1"
+ * - at least one of `paths`, `components`, or `webhooks` (unlike 3.0 where `paths` is required)
+ * - `info` with `title` and `version` required
+ * - `paths` must be an object when present
+ * - `components.schemas` entries must be objects, validated recursively for 3.0-only features
+ * - Warns about 3.0-only features in schemas: `nullable`, boolean `exclusiveMinimum`/`exclusiveMaximum`,
+ *   array-form `items` (tuples must use `prefixItems` in 3.1)
+ * - Accepts `type` as array, `$schema`, `$id`, `$comment`, `const`, `examples`, and `$ref` siblings
+ *   (all legal in 3.1 via JSON Schema 2020-12)
+ * - Accepts schema-level `example` (deprecated in 3.1 but still legal)
+ */
+export declare function validateSpec31(spec: unknown): ValidationResult;

package/dist/parser/version/v3.1/validator.js

@@ -0,0 +1,126 @@
+/**
+ * Validate a raw OpenAPI 3.1.x specification.
+ *
+ * 3.1-specific validation rules:
+ * - `openapi` must start with "3.1"
+ * - at least one of `paths`, `components`, or `webhooks` (unlike 3.0 where `paths` is required)
+ * - `info` with `title` and `version` required
+ * - `paths` must be an object when present
+ * - `components.schemas` entries must be objects, validated recursively for 3.0-only features
+ * - Warns about 3.0-only features in schemas: `nullable`, boolean `exclusiveMinimum`/`exclusiveMaximum`,
+ *   array-form `items` (tuples must use `prefixItems` in 3.1)
+ * - Accepts `type` as array, `$schema`, `$id`, `$comment`, `const`, `examples`, and `$ref` siblings
+ *   (all legal in 3.1 via JSON Schema 2020-12)
+ * - Accepts schema-level `example` (deprecated in 3.1 but still legal)
+ */
+export function validateSpec31(spec) {
+    const errors = [];
+    if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
+        errors.push('Document must be an object');
+        return { valid: false, errors };
+    }
+    const s = spec;
+    if (!s.openapi || typeof s.openapi !== 'string') {
+        errors.push("OpenAPI specification must have an 'openapi' field with string value");
+    }
+    else if (!s.openapi.startsWith('3.1')) {
+        errors.push(`OpenAPI version must start with '3.1', got: ${s.openapi}`);
+    }
+    if (!s.info || typeof s.info !== 'object' || Array.isArray(s.info)) {
+        errors.push("OpenAPI specification must have an 'info' field with object value");
+    }
+    else {
+        const info = s.info;
+        if (!info.title || typeof info.title !== 'string') {
+            errors.push("Info object must have a 'title' field with string value");
+        }
+        if (!info.version || typeof info.version !== 'string') {
+            errors.push("Info object must have a 'version' field with string value");
+        }
+    }
+    if (!s.paths && !s.components && !s.webhooks) {
+        errors.push("OpenAPI specification must have at least one of 'paths', 'components', or 'webhooks'");
+    }
+    if (s.paths) {
+        if (typeof s.paths !== 'object' || Array.isArray(s.paths)) {
+            errors.push("'paths' field must be an object");
+        }
+    }
+    if (s.components && typeof s.components === 'object' && !Array.isArray(s.components)) {
+        const components = s.components;
+        if (components.schemas) {
+            if (typeof components.schemas !== 'object' || Array.isArray(components.schemas)) {
+                errors.push("'components.schemas' must be an object");
+            }
+            else {
+                for (const [key, schema] of Object.entries(components.schemas)) {
+                    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+                        errors.push(`Schema '${key}' must be an object`);
+                    }
+                    else {
+                        validateSchema31(schema, `components.schemas.${key}`, errors);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Recursively validate a schema object for 3.1-specific rules.
+ * Detects 3.0-only features and reports them as errors.
+ */
+function validateSchema31(schema, path, errors) {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+        return;
+    }
+    const s = schema;
+    if ('nullable' in s) {
+        errors.push(`Schema '${path}' uses 'nullable' which is a 3.0-only feature`);
+    }
+    if (typeof s.exclusiveMinimum === 'boolean') {
+        errors.push(`Schema '${path}' uses 'exclusiveMinimum' as a boolean which is a 3.0-only feature`);
+    }
+    if (typeof s.exclusiveMaximum === 'boolean') {
+        errors.push(`Schema '${path}' uses 'exclusiveMaximum' as a boolean which is a 3.0-only feature`);
+    }
+    if (s.items !== undefined && Array.isArray(s.items)) {
+        errors.push(`Schema '${path}' uses 'items' as an array which is not allowed in 3.1 (use 'prefixItems')`);
+    }
+    if (s.properties && typeof s.properties === 'object' && !Array.isArray(s.properties)) {
+        for (const [key, prop] of Object.entries(s.properties)) {
+            validateSchema31(prop, `${path}.properties.${key}`, errors);
+        }
+    }
+    if (s.items && typeof s.items === 'object' && !Array.isArray(s.items)) {
+        validateSchema31(s.items, `${path}.items`, errors);
+    }
+    if (s.additionalProperties &&
+        typeof s.additionalProperties === 'object' &&
+        !Array.isArray(s.additionalProperties)) {
+        validateSchema31(s.additionalProperties, `${path}.additionalProperties`, errors);
+    }
+    if (Array.isArray(s.allOf)) {
+        s.allOf.forEach((item, i) => {
+            validateSchema31(item, `${path}.allOf[${i}]`, errors);
+        });
+    }
+    if (Array.isArray(s.oneOf)) {
+        s.oneOf.forEach((item, i) => {
+            validateSchema31(item, `${path}.oneOf[${i}]`, errors);
+        });
+    }
+    if (Array.isArray(s.anyOf)) {
+        s.anyOf.forEach((item, i) => {
+            validateSchema31(item, `${path}.anyOf[${i}]`, errors);
+        });
+    }
+    if (Array.isArray(s.prefixItems)) {
+        s.prefixItems.forEach((item, i) => {
+            validateSchema31(item, `${path}.prefixItems[${i}]`, errors);
+        });
+    }
+}

package/dist/parser/version/validate.d.ts

@@ -0,0 +1,9 @@
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Validate a raw OpenAPI document against the rules of the given dialect.
+ * Throws when the document is invalid; returns void otherwise.
+ */
+export declare function validateSpec(doc: unknown, version: '3.0' | '3.1'): void;

package/dist/parser/version/validate.js

@@ -0,0 +1,12 @@
+import { validateSpec30 } from './v3.0/validator.js';
+import { validateSpec31 } from './v3.1/validator.js';
+/**
+ * Validate a raw OpenAPI document against the rules of the given dialect.
+ * Throws when the document is invalid; returns void otherwise.
+ */
+export function validateSpec(doc, version) {
+    const result = version === '3.0' ? validateSpec30(doc) : validateSpec31(doc);
+    if (!result.valid) {
+        throw new Error(`Invalid OpenAPI specification:\n${result.errors.map((e) => `  - ${e}`).join('\n')}`);
+    }
+}

package/dist/parser/version/version-detector.d.ts

@@ -1,4 +1,25 @@
 /**
  * Version detector for multi-version OpenAPI support
  */
+/**
+ * The dialect of a spec and every behavioral consequence derived from it.
+ * Produced by `resolveVersion`; the only sanctioned way code outside this
+ * module learns about spec dialect.
+ */
+export interface VersionProfile {
+    /** Dialect actually found in the document. */
+    detected: '3.0' | '3.1';
+    /** Dialect in effect: the override when provided, otherwise `detected`. */
+    effective: '3.0' | '3.1';
+    /** Whether sibling properties alongside `$ref` are preserved (3.1 behavior). */
+    preserveRefSiblings: boolean;
+}
 export declare function detectSpecVersion(rawSpec: unknown): string;
+/**
+ * Resolve the dialect of a document into a `VersionProfile`.
+ *
+ * Detection always runs, even when an override is provided (so a 3.2 document
+ * is rejected regardless). The override, when given, becomes the effective
+ * dialect; `preserveRefSiblings` follows the effective dialect.
+ */
+export declare function resolveVersion(doc: unknown, override?: '3.0' | '3.1'): VersionProfile;

package/dist/parser/version/version-detector.js

@@ -32,3 +32,22 @@ export function detectSpecVersion(rawSpec) {
     }
     return majorMinorVersion;
 }
+/**
+ * Resolve the dialect of a document into a `VersionProfile`.
+ *
+ * Detection always runs, even when an override is provided (so a 3.2 document
+ * is rejected regardless). The override, when given, becomes the effective
+ * dialect; `preserveRefSiblings` follows the effective dialect.
+ */
+export function resolveVersion(doc, override) {
+    const detected = detectSpecVersion(doc);
+    if (detected !== '3.0' && detected !== '3.1') {
+        throw new Error('OpenAPI 3.2 is not yet supported. Supported versions: 3.0, 3.1');
+    }
+    const effective = override ?? detected;
+    return {
+        detected,
+        effective,
+        preserveRefSiblings: effective === '3.1',
+    };
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,13 @@
+import type { GeneratorConfig } from './types/client.js';
+import type { OpenAPIDocument } from './types/openapi.js';
+/** Options for controlling generation behavior. */
+export interface GenerationOptions {
+    /** When true, sibling properties alongside $ref are preserved (OpenAPI 3.1 behavior). */
+    preserveRefSiblings?: boolean;
+}
+/**
+ * Generate and write all output files to disk: builds the resolver, runs the
+ * single `analyze()` pass, feeds both renderers via `generateOutput`, and
+ * writes contracts.ts / client.ts / index.ts into the configured directory.
+ */
+export declare function generateFullOutput(doc: OpenAPIDocument, config: GeneratorConfig, options?: GenerationOptions): Promise<void>;

package/dist/pipeline.js

@@ -0,0 +1,24 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { analyze } from './analyzer/analyze.js';
+import { generateOutput } from './generator/client-generator.js';
+import { RefResolver } from './parser/ref-resolver.js';
+/**
+ * Generate and write all output files to disk: builds the resolver, runs the
+ * single `analyze()` pass, feeds both renderers via `generateOutput`, and
+ * writes contracts.ts / client.ts / index.ts into the configured directory.
+ */
+export async function generateFullOutput(doc, config, options) {
+    const resolver = new RefResolver(doc, {
+        preserveRefSiblings: options?.preserveRefSiblings,
+    });
+    const analyzed = analyze(doc, {
+        resolver,
+        strategy: config.methodNameStrategy ?? 'path-based',
+    });
+    const { contracts, client, index } = generateOutput(analyzed, config);
+    await mkdir(config.outputDir, { recursive: true });
+    await writeFile(join(config.outputDir, 'contracts.ts'), contracts, 'utf-8');
+    await writeFile(join(config.outputDir, 'client.ts'), client, 'utf-8');
+    await writeFile(join(config.outputDir, 'index.ts'), index, 'utf-8');
+}

package/dist/types/client.d.ts

@@ -4,24 +4,12 @@ export type GeneratorConfig = {
     outputDir: string;
     methodNameStrategy?: MethodNameStrategy;
     requesterModuleName?: string;
-    specVersion?: string;
     strictVersion?: boolean;
     runtimeImportPath?: string;
     proxy?: string;
 };
-export type RequesterFunction = <TResponse>(method: string, path: string, options: {
-    query?: Record<string, unknown>;
-    body?: unknown;
-    headers?: Record<string, string>;
-}) => Promise<TResponse>;
 export type GeneratedMethod = {
     name: string;
     jsDoc: string;
     signature: string;
-    implementation: string;
-};
-export type ClientOutput = {
-    imports: string[];
-    methods: GeneratedMethod[];
-    errorTypes: string[];
 };

package/dist/utils/generator-helpers.d.ts

@@ -1,11 +1,4 @@
-import type { AnalyzedOperation } from '../analyzer/path-analyzer.js';
 import type { SchemaObject } from '../types/openapi.js';
-/**
- * Reserved type names used by the generated output's built-in classes,
- * functions, and types. User-defined schema names that collide with these
- * are automatically renamed with a suffix to prevent duplicate identifiers.
- */
-export declare const RESERVED_TYPE_NAMES: ReadonlySet<string>;
 /** Default module specifier generated code imports shared runtime classes from. */
 export declare const DEFAULT_RUNTIME_IMPORT_PATH = "genoc/runtime";
 /**
@@ -42,23 +35,6 @@ export declare function buildSchemaRenameMap(schemaNames: Iterable<string>, rese
  * and colon-separated segments.
  */
 export declare function toPascalCase(str: string): string;
-/**
- * Build a PascalCase type-name prefix from an operation's method + path.
- * get + /api/v1/products → "GetApiV1Products"
- *
- * Returns the deduped prefix assigned by analyzePaths when available
- * (distinct routes folding to the same identifier get numbered suffixes),
- * otherwise computes it from the operation directly.
- */
-export declare function getOperationTypePrefix(op: AnalyzedOperation): string;
-/**
- * Determine the success return type for an operation.
- */
-export declare function getSuccessType(op: AnalyzedOperation): string;
-/**
- * Determine the error type name for an operation.
- */
-export declare function getErrorType(op: AnalyzedOperation): string;
 /**
  * Generate the auto-generated header comment.
  */
@@ -94,3 +70,4 @@ export declare function buildFieldJsDocLines(schema: SchemaObject): string[];
  * ≥2 segments → multiline block with a blank ` *` line between segments.
  */
 export declare function buildTypeJsDoc(schema: SchemaObject): string;
+export declare function isBinaryContentType(ct: string): boolean;