genoc 0.1.0

package/dist/generator/method-generator.js

@@ -0,0 +1,249 @@
+import { getOperationTypePrefix, getSuccessType } from '../utils/generator-helpers.js';
+function buildParameters(op) {
+    const params = [];
+    for (const param of op.pathParams) {
+        params.push(`${param.name}: string`);
+    }
+    if (op.queryParams.length > 0) {
+        const prefix = getOperationTypePrefix(op);
+        const allOptional = op.queryParams.every((p) => !p.required);
+        const hasRequiredAfter = op.headerParams.some((p) => p.required) || !!op.requestBody?.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`);
+        }
+        else {
+            // Normal case: use optional notation
+            const optional = allOptional ? '?' : '';
+            params.push(`query${optional}: ${prefix}Query`);
+        }
+    }
+    if (op.headerParams.length > 0) {
+        const prefix = getOperationTypePrefix(op);
+        const allOptional = op.headerParams.every((p) => !p.required);
+        if (allOptional && op.requestBody?.required) {
+            params.push(`headers: ${prefix}Headers | undefined`);
+        }
+        else {
+            const optional = allOptional ? '?' : '';
+            params.push(`headers${optional}: ${prefix}Headers`);
+        }
+    }
+    if (op.requestBody) {
+        const prefix = getOperationTypePrefix(op);
+        const optional = op.requestBody.required ? '' : '?';
+        params.push(`body${optional}: ${prefix}Body`);
+    }
+    return params.join(', ');
+}
+function buildJsDoc(op) {
+    const lines = [];
+    if (op.summary) {
+        lines.push(` * ${op.summary}`);
+    }
+    if (op.description && op.description !== op.summary) {
+        if (lines.length > 0) {
+            lines.push(' *');
+        }
+        lines.push(` * ${op.description}`);
+    }
+    const allParams = [...op.pathParams, ...op.queryParams, ...op.headerParams, ...op.cookieParams];
+    const paramsWithDescriptions = allParams.filter((param) => param.description);
+    if (paramsWithDescriptions.length > 0) {
+        if (lines.length > 0) {
+            lines.push(' *');
+        }
+        for (const param of paramsWithDescriptions) {
+            lines.push(` * @param ${param.name} — ${param.description}`);
+        }
+    }
+    if (op.requestBody && op.requestBody.contentTypes.length > 0) {
+        if (lines.length > 0) {
+            lines.push(' *');
+        }
+        lines.push(` * @param body — request body`);
+    }
+    if (op.tags && op.tags.length > 0) {
+        if (lines.length > 0) {
+            lines.push(' *');
+        }
+        for (const tag of op.tags) {
+            lines.push(` * @category ${tag}`);
+        }
+    }
+    if (op.deprecated) {
+        if (lines.length > 0) {
+            lines.push(' *');
+        }
+        lines.push(' * @deprecated');
+    }
+    const deprecatedParams = allParams.filter((param) => param.deprecated === true);
+    if (deprecatedParams.length > 0) {
+        if (lines.length > 0) {
+            lines.push(' *');
+        }
+        for (const param of deprecatedParams) {
+            lines.push(` * @deprecated ${param.name} — This parameter is deprecated`);
+        }
+    }
+    if (lines.length === 0) {
+        return '';
+    }
+    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.headerParams.length > 0) {
+        requesterOpts.push('headers');
+    }
+    if (op.requestBody) {
+        requesterOpts.push('body');
+    }
+    // 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
+ */
+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/index.d.ts

@@ -0,0 +1,7 @@
+import { type ApiClient } from './generator/client-generator.js';
+import { ApiError, DefaultApiError } from './generator/error-types.js';
+import type { GeneratorConfig } from './types/client.js';
+export declare function generateClient(config: GeneratorConfig): Promise<void>;
+export type { GeneratorConfig, ApiClient, ApiError, DefaultApiError };
+export type { GenerationOptions } from './generator/client-generator.js';
+export { load as loadSpec } from './parser/spec-reader.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+import { generateFullOutput } from './generator/client-generator.js';
+import { ApiError, DefaultApiError } from './generator/error-types.js';
+import { load } from './parser/spec-reader.js';
+export async function generateClient(config) {
+    const doc = await load(config.input);
+    await generateFullOutput(doc, config);
+}
+export { load as loadSpec } from './parser/spec-reader.js';

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

@@ -0,0 +1,24 @@
+import type { OpenAPIDocument, ReferenceObject, SchemaObject } from '../types/openapi.js';
+export declare class RefResolver {
+    private doc;
+    private preserveRefSiblings;
+    constructor(doc: OpenAPIDocument, documentUrl?: string, options?: {
+        preserveRefSiblings?: boolean;
+    });
+    /**
+     * If input has `$ref`, resolve it; otherwise return as-is.
+     */
+    resolve<T>(ref: ReferenceObject | T): T;
+    /**
+     * Resolve a JSON Pointer $ref string to the referenced object.
+     * Follows chained refs up to MAX_DEPTH hops.
+     * Throws on cycles, external refs, missing targets, and depth overflow.
+     */
+    resolveRef(refString: string): unknown;
+    /**
+     * Specifically resolve schema references, following chained refs.
+     * Returns a SchemaObject (never a reference).
+     */
+    resolveSchema(schema: SchemaObject | ReferenceObject): SchemaObject;
+    private resolveRefInternal;
+}

package/dist/parser/ref-resolver.js

@@ -0,0 +1,119 @@
+import { parseJsonPointer } from '../utils/url.js';
+const MAX_DEPTH = 10;
+export class RefResolver {
+    doc;
+    preserveRefSiblings;
+    constructor(doc, documentUrl, options) {
+        this.doc = doc;
+        this.preserveRefSiblings = options?.preserveRefSiblings ?? false;
+        void documentUrl;
+    }
+    /**
+     * If input has `$ref`, resolve it; otherwise return as-is.
+     */
+    resolve(ref) {
+        const obj = ref;
+        if (obj !== null && typeof obj === 'object' && '$ref' in obj) {
+            const resolved = this.resolveRef(obj.$ref);
+            if (this.preserveRefSiblings) {
+                const siblings = {};
+                for (const [key, value] of Object.entries(obj)) {
+                    if (key !== '$ref') {
+                        siblings[key] = value;
+                    }
+                }
+                if (Object.keys(siblings).length > 0) {
+                    return { ...resolved, ...siblings };
+                }
+            }
+            return resolved;
+        }
+        return ref;
+    }
+    /**
+     * Resolve a JSON Pointer $ref string to the referenced object.
+     * Follows chained refs up to MAX_DEPTH hops.
+     * Throws on cycles, external refs, missing targets, and depth overflow.
+     */
+    resolveRef(refString) {
+        const resolving = new Set();
+        return this.resolveRefInternal(refString, resolving, 0);
+    }
+    /**
+     * Specifically resolve schema references, following chained refs.
+     * Returns a SchemaObject (never a reference).
+     */
+    resolveSchema(schema) {
+        const obj = schema;
+        if (obj !== null && typeof obj === 'object' && '$ref' in obj) {
+            let resolved = this.resolveRef(obj.$ref);
+            if (this.preserveRefSiblings) {
+                const siblings = {};
+                for (const [key, value] of Object.entries(obj)) {
+                    if (key !== '$ref') {
+                        siblings[key] = value;
+                    }
+                }
+                if (Object.keys(siblings).length > 0) {
+                    resolved = {
+                        ...resolved,
+                        ...siblings,
+                    };
+                }
+            }
+            if (resolved !== null && typeof resolved === 'object' && '$ref' in resolved) {
+                return this.resolveSchema(resolved);
+            }
+            return resolved;
+        }
+        return schema;
+    }
+    resolveRefInternal(refString, resolving, depth) {
+        if (refString.startsWith('http://') || refString.startsWith('https://')) {
+            throw new Error(`External $ref resolution is not supported: ${refString}`);
+        }
+        if (!refString.startsWith('#')) {
+            throw new Error(`External $ref resolution is not supported: ${refString}`);
+        }
+        if (depth >= MAX_DEPTH) {
+            throw new Error(`Maximum $ref depth (${MAX_DEPTH}) exceeded: ${refString}`);
+        }
+        if (resolving.has(refString)) {
+            const cyclePath = [...resolving, refString].join(' -> ');
+            throw new Error(`Circular $ref detected: ${cyclePath}`);
+        }
+        resolving.add(refString);
+        const pointer = refString.slice(1);
+        const segments = parseJsonPointer(pointer);
+        let current = this.doc;
+        for (let i = 0; i < segments.length; i++) {
+            if (current === null || current === undefined) {
+                throw new Error(`$ref "${refString}" could not be resolved: segment "${segments[i]}" not found`);
+            }
+            if (typeof current !== 'object') {
+                throw new Error(`$ref "${refString}" could not be resolved: segment "${segments[i]}" is not an object`);
+            }
+            if (Array.isArray(current)) {
+                const index = Number(segments[i]);
+                if (Number.isNaN(index)) {
+                    throw new Error(`$ref "${refString}" could not be resolved: "${segments[i]}" is not a valid array index`);
+                }
+                current = current[index];
+            }
+            else {
+                current = current[segments[i]];
+            }
+        }
+        if (current === undefined) {
+            throw new Error(`$ref "${refString}" could not be resolved`);
+        }
+        if (current !== null &&
+            typeof current === 'object' &&
+            !Array.isArray(current) &&
+            '$ref' in current) {
+            const chainedRef = current.$ref;
+            return this.resolveRefInternal(chainedRef, new Set(resolving), depth + 1);
+        }
+        return current;
+    }
+}

package/dist/parser/spec-reader.d.ts

@@ -0,0 +1,4 @@
+import type { OpenAPIDocument } from '../types/openapi.js';
+export declare function loadFromFile(filePath: string): Promise<OpenAPIDocument>;
+export declare function loadFromUrl(url: string): Promise<OpenAPIDocument>;
+export declare function load(source: string): Promise<OpenAPIDocument>;

package/dist/parser/spec-reader.js

@@ -0,0 +1,116 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { isUrl } from '../utils/url.js';
+const VALID_EXTENSIONS = ['.json', '.yaml', '.yml'];
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+function assertSupportedVersion(doc) {
+    if (typeof doc !== 'object' ||
+        doc === null ||
+        !('openapi' in doc) ||
+        typeof doc.openapi !== 'string') {
+        throw new Error("Invalid spec: missing or invalid 'openapi' field.");
+    }
+    const version = doc.openapi;
+    // Check for valid version format
+    if (!version.match(/^\d+\.\d+(\.\d+)?$/)) {
+        throw new Error(`Invalid OpenAPI version format: ${version}`);
+    }
+    // Check that major version is 3 (but don't restrict minor versions)
+    if (!version.startsWith('3.')) {
+        throw new Error(`Unsupported OpenAPI version: ${version}. Supported versions: 3.0, 3.1, 3.2`);
+    }
+}
+function parseContent(content, ext) {
+    if (ext === '.json') {
+        try {
+            return JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse JSON: ${err.message}`, { cause: err });
+        }
+    }
+    try {
+        return parseYaml(content);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse YAML: ${err.message}`, { cause: err });
+    }
+}
+export async function loadFromFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (!VALID_EXTENSIONS.includes(ext)) {
+        throw new Error(`Unsupported file extension: "${ext}". Supported extensions: ${VALID_EXTENSIONS.join(', ')}`);
+    }
+    let fileStat;
+    try {
+        fileStat = await stat(filePath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            throw new Error(`Failed to load spec: file not found: ${filePath}`, { cause: err });
+        }
+        throw new Error(`Failed to load spec from file: ${err.message}`, { cause: err });
+    }
+    if (fileStat.size > MAX_FILE_SIZE) {
+        throw new Error(`Spec file too large: ${(fileStat.size / 1024 / 1024).toFixed(1)}MB exceeds 50MB limit`);
+    }
+    let content;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            throw new Error(`Failed to load spec: file not found: ${filePath}`, { cause: err });
+        }
+        throw new Error(`Failed to load spec from file: ${err.message}`, { cause: err });
+    }
+    const doc = parseContent(content, ext);
+    if (typeof doc !== 'object' || doc === null) {
+        throw new Error('Failed to parse: spec is not an object.');
+    }
+    assertSupportedVersion(doc);
+    return doc;
+}
+export async function loadFromUrl(url) {
+    let response;
+    try {
+        response = await fetch(url);
+    }
+    catch (err) {
+        throw new Error(`Failed to fetch spec from URL: ${err.message}`, { cause: err });
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to fetch spec from URL: ${response.status} ${response.statusText}`);
+    }
+    const contentLength = response.headers.get('content-length');
+    if (contentLength && Number(contentLength) > MAX_FILE_SIZE) {
+        throw new Error(`Spec from URL too large: ${(Number(contentLength) / 1024 / 1024).toFixed(1)}MB exceeds 50MB limit`);
+    }
+    const text = await response.text();
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        try {
+            doc = parseYaml(text);
+        }
+        catch (yamlErr) {
+            throw new Error(`Failed to parse spec from URL as JSON or YAML: ${yamlErr.message}`, { cause: yamlErr });
+        }
+    }
+    if (typeof doc !== 'object' || doc === null) {
+        throw new Error('Failed to parse: spec is not an object.');
+    }
+    assertSupportedVersion(doc);
+    return doc;
+}
+export async function load(source) {
+    if (isUrl(source)) {
+        return loadFromUrl(source);
+    }
+    return loadFromFile(source);
+}

package/dist/parser/validators.d.ts

@@ -0,0 +1,7 @@
+import type { VersionStrategy } from './version/version-strategy.js';
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export declare function validateOpenAPIVersion(version: string): boolean;
+export declare function validateSpec(doc: unknown, strategy?: VersionStrategy): ValidationResult;

package/dist/parser/validators.js

@@ -0,0 +1,79 @@
+export function validateOpenAPIVersion(version) {
+    return typeof version === 'string' && version.startsWith('3.1');
+}
+export function validateSpec(doc, strategy) {
+    if (strategy) {
+        try {
+            const normalized = strategy.normalizeSpec(doc);
+            return strategy.validateSpec(normalized);
+        }
+        catch (error) {
+            // normalizeSpec may throw for structurally invalid specs;
+            // but re-throw "not yet supported" errors
+            if (typeof error === 'object' && error !== null && 'message' in error) {
+                const errorMessage = error.message;
+                if (errorMessage.includes('not yet supported')) {
+                    throw error;
+                }
+            }
+            // fall through to default 3.1-only validation below
+        }
+    }
+    const errors = [];
+    if (!doc || typeof doc !== 'object' || Array.isArray(doc)) {
+        errors.push('Document must be an object');
+        return { valid: false, errors };
+    }
+    const spec = doc;
+    // Check openapi field
+    if (!spec.openapi || typeof spec.openapi !== 'string') {
+        errors.push("OpenAPI specification must have an 'openapi' field with string value");
+    }
+    else if (!validateOpenAPIVersion(spec.openapi)) {
+        errors.push(`OpenAPI version must start with '3.1', got: ${spec.openapi}`);
+    }
+    // Check info field
+    if (!spec.info || typeof spec.info !== 'object' || Array.isArray(spec.info)) {
+        errors.push("OpenAPI specification must have an 'info' field with object value");
+    }
+    else {
+        const info = spec.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");
+        }
+    }
+    // Check at least one of paths, components, webhooks exists
+    if (!spec.paths && !spec.components && !spec.webhooks) {
+        errors.push("OpenAPI specification must have at least one of 'paths', 'components', or 'webhooks'");
+    }
+    // Validate paths if it exists
+    if (spec.paths) {
+        if (Array.isArray(spec.paths) || typeof spec.paths !== 'object') {
+            errors.push("'paths' field must be an object");
+        }
+    }
+    // Validate components.schemas if it exists
+    if (spec.components && typeof spec.components === 'object' && !Array.isArray(spec.components)) {
+        const components = spec.components;
+        if (components.schemas) {
+            if (Array.isArray(components.schemas) || typeof components.schemas !== 'object') {
+                errors.push("'components.schemas' must be an object");
+            }
+            else {
+                const schemas = components.schemas;
+                for (const [key, schema] of Object.entries(schemas)) {
+                    if (typeof schema !== 'object' || Array.isArray(schema)) {
+                        errors.push(`Schema '${key}' must be an object`);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Version strategy interface 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;

package/dist/parser/version/index.js

@@ -0,0 +1,16 @@
+/**
+ * Version detection and registry 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());