@lssm/lib.contracts-transformers 0.0.0-canary-20251217083314 → 1.41.0

package/dist/openapi/schema-converter.js

@@ -1,201 +1,4 @@
-import { toCamelCase, toPascalCase, toValidIdentifier } from "../common/utils.js";
-
-//#region src/openapi/schema-converter.ts
-/**
-* Map JSON Schema types to ContractSpec ScalarTypeEnum values.
-*/
-const JSON_SCHEMA_TO_SCALAR = {
-	string: "ScalarTypeEnum.STRING",
-	integer: "ScalarTypeEnum.INT",
-	number: "ScalarTypeEnum.FLOAT",
-	boolean: "ScalarTypeEnum.BOOLEAN",
-	"string:date": "ScalarTypeEnum.DATE",
-	"string:date-time": "ScalarTypeEnum.DATE_TIME",
-	"string:email": "ScalarTypeEnum.EMAIL",
-	"string:uri": "ScalarTypeEnum.URL",
-	"string:uuid": "ScalarTypeEnum.ID"
-};
-/**
-* Check if a schema is a reference object.
-*/
-function isReference(schema) {
-	return "$ref" in schema;
-}
-/**
-* Extract type name from a $ref.
-*/
-function typeNameFromRef(ref) {
-	const parts = ref.split("/");
-	return parts[parts.length - 1] ?? "Unknown";
-}
-/**
-* Convert a JSON Schema to a TypeScript type representation.
-*/
-function jsonSchemaToType(schema, name) {
-	if (isReference(schema)) return {
-		type: toPascalCase(typeNameFromRef(schema.$ref)),
-		optional: false,
-		array: false,
-		primitive: false
-	};
-	const schemaObj = schema;
-	const type = schemaObj["type"];
-	const format = schemaObj["format"];
-	const nullable = schemaObj["nullable"];
-	if (type === "array") {
-		const items = schemaObj["items"];
-		if (items) return {
-			...jsonSchemaToType(items, name),
-			array: true,
-			optional: nullable ?? false
-		};
-		return {
-			type: "unknown",
-			optional: nullable ?? false,
-			array: true,
-			primitive: false
-		};
-	}
-	if (type === "object" || schemaObj["properties"]) return {
-		type: name ? toPascalCase(name) : "Record<string, unknown>",
-		optional: nullable ?? false,
-		array: false,
-		primitive: false
-	};
-	if (schemaObj["enum"]) return {
-		type: name ? toPascalCase(name) : "string",
-		optional: nullable ?? false,
-		array: false,
-		primitive: false
-	};
-	format && `${type}${format}`;
-	if (type === "string") return {
-		type: "string",
-		optional: nullable ?? false,
-		array: false,
-		primitive: true
-	};
-	if (type === "integer" || type === "number") return {
-		type: "number",
-		optional: nullable ?? false,
-		array: false,
-		primitive: true
-	};
-	if (type === "boolean") return {
-		type: "boolean",
-		optional: nullable ?? false,
-		array: false,
-		primitive: true
-	};
-	return {
-		type: "unknown",
-		optional: nullable ?? false,
-		array: false,
-		primitive: false
-	};
-}
-/**
-* Get the ScalarTypeEnum value for a JSON Schema type.
-*/
-function getScalarType(schema) {
-	if (isReference(schema)) return;
-	const schemaObj = schema;
-	const type = schemaObj["type"];
-	const format = schemaObj["format"];
-	if (!type) return void 0;
-	return JSON_SCHEMA_TO_SCALAR[format ? `${type}:${format}` : type] ?? JSON_SCHEMA_TO_SCALAR[type];
-}
-/**
-* Convert a JSON Schema to a SchemaModel field definition.
-*/
-function jsonSchemaToField(schema, fieldName, required) {
-	const type = jsonSchemaToType(schema, fieldName);
-	const scalarType = getScalarType(schema);
-	let enumValues;
-	if (!isReference(schema)) {
-		const enumArr = schema["enum"];
-		if (enumArr) enumValues = enumArr.map(String);
-	}
-	return {
-		name: toValidIdentifier(toCamelCase(fieldName)),
-		type: {
-			...type,
-			optional: !required || type.optional,
-			description: !isReference(schema) ? schema["description"] : void 0
-		},
-		scalarType,
-		enumValues
-	};
-}
-/**
-* Generate SchemaModel TypeScript code for a JSON Schema object.
-*/
-function generateSchemaModelCode(schema, modelName, indent = 0) {
-	const spaces = "  ".repeat(indent);
-	const fields = [];
-	let description;
-	if (isReference(schema)) return {
-		name: toPascalCase(typeNameFromRef(schema.$ref)),
-		fields: [],
-		code: `// Reference to ${schema.$ref}`
-	};
-	const schemaObj = schema;
-	description = schemaObj["description"];
-	const properties = schemaObj["properties"];
-	const required = schemaObj["required"] ?? [];
-	if (!properties) return {
-		name: toPascalCase(modelName),
-		description,
-		fields: [],
-		code: `${spaces}// Empty schema for ${modelName}`
-	};
-	for (const [propName, propSchema] of Object.entries(properties)) {
-		const isRequired = required.includes(propName);
-		fields.push(jsonSchemaToField(propSchema, propName, isRequired));
-	}
-	const lines = [];
-	const safeModelName = toPascalCase(toValidIdentifier(modelName));
-	lines.push(`${spaces}export const ${safeModelName} = defineSchemaModel({`);
-	lines.push(`${spaces}  name: '${safeModelName}',`);
-	if (description) lines.push(`${spaces}  description: ${JSON.stringify(description)},`);
-	lines.push(`${spaces}  fields: {`);
-	for (const field of fields) {
-		const fieldLines = generateFieldCode(field, indent + 2);
-		lines.push(fieldLines);
-	}
-	lines.push(`${spaces}  },`);
-	lines.push(`${spaces}});`);
-	return {
-		name: safeModelName,
-		description,
-		fields,
-		code: lines.join("\n")
-	};
-}
-/**
-* Generate TypeScript code for a single field.
-*/
-function generateFieldCode(field, indent) {
-	const spaces = "  ".repeat(indent);
-	const lines = [];
-	lines.push(`${spaces}${field.name}: {`);
-	if (field.enumValues) lines.push(`${spaces}  type: new EnumType([${field.enumValues.map((v) => `'${v}'`).join(", ")}]),`);
-	else if (field.scalarType) lines.push(`${spaces}  type: ${field.scalarType},`);
-	else lines.push(`${spaces}  type: ${field.type.type}, // TODO: Define or import this type`);
-	if (field.type.optional) lines.push(`${spaces}  isOptional: true,`);
-	if (field.type.array) lines.push(`${spaces}  isArray: true,`);
-	lines.push(`${spaces}},`);
-	return lines.join("\n");
-}
-/**
-* Generate import statements for a SchemaModel.
-*/
-function generateImports(fields) {
-	const imports = /* @__PURE__ */ new Set();
-	imports.add("import { defineSchemaModel, ScalarTypeEnum, EnumType } from '@lssm/lib.schema';");
-	for (const field of fields) if (!field.type.primitive && !field.enumValues && !field.scalarType) {}
-	return Array.from(imports).join("\n");
-}
-
-//#endregion
-export { generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToField, jsonSchemaToType };
+import{toCamelCase as e,toPascalCase as t,toValidIdentifier as n}from"../common/utils.js";const r={string:`ScalarTypeEnum.STRING`,integer:`ScalarTypeEnum.INT`,number:`ScalarTypeEnum.FLOAT`,boolean:`ScalarTypeEnum.BOOLEAN`,"string:date":`ScalarTypeEnum.DATE`,"string:date-time":`ScalarTypeEnum.DATE_TIME`,"string:email":`ScalarTypeEnum.EMAIL`,"string:uri":`ScalarTypeEnum.URL`,"string:uuid":`ScalarTypeEnum.ID`};function i(e){return`$ref`in e}function a(e){let t=e.split(`/`);return t[t.length-1]??`Unknown`}function o(e,n){if(i(e))return{type:t(a(e.$ref)),optional:!1,array:!1,primitive:!1};let r=e,s=r.type,c=r.format,l=r.nullable;if(s===`array`){let e=r.items;return e?{...o(e,n),array:!0,optional:l??!1}:{type:`unknown`,optional:l??!1,array:!0,primitive:!1}}return s===`object`||r.properties?{type:n?t(n):`Record<string, unknown>`,optional:l??!1,array:!1,primitive:!1}:r.enum?{type:n?t(n):`string`,optional:l??!1,array:!1,primitive:!1}:(c&&`${s}${c}`,s===`string`?{type:`string`,optional:l??!1,array:!1,primitive:!0}:s===`integer`||s===`number`?{type:`number`,optional:l??!1,array:!1,primitive:!0}:s===`boolean`?{type:`boolean`,optional:l??!1,array:!1,primitive:!0}:{type:`unknown`,optional:l??!1,array:!1,primitive:!1})}function s(e){if(i(e))return;let t=e,n=t.type,a=t.format;if(n)return r[a?`${n}:${a}`:n]??r[n]}function c(t,r,a){let c=o(t,r),l=s(t),u;if(!i(t)){let e=t.enum;e&&(u=e.map(String))}return{name:n(e(r)),type:{...c,optional:!a||c.optional,description:i(t)?void 0:t.description},scalarType:l,enumValues:u}}function l(e,r,o=0){let s=`  `.repeat(o),l=[],d;if(i(e))return{name:t(a(e.$ref)),fields:[],code:`// Reference to ${e.$ref}`};let f=e;d=f.description;let p=f.properties,m=f.required??[];if(!p)return{name:t(r),description:d,fields:[],code:`${s}// Empty schema for ${r}`};for(let[e,t]of Object.entries(p)){let n=m.includes(e);l.push(c(t,e,n))}let h=[],g=t(n(r));h.push(`${s}export const ${g} = defineSchemaModel({`),h.push(`${s}  name: '${g}',`),d&&h.push(`${s}  description: ${JSON.stringify(d)},`),h.push(`${s}  fields: {`);for(let e of l){let t=u(e,o+2);h.push(t)}return h.push(`${s}  },`),h.push(`${s}});`),{name:g,description:d,fields:l,code:h.join(`
+`)}}function u(e,t){let n=`  `.repeat(t),r=[];return r.push(`${n}${e.name}: {`),e.enumValues?r.push(`${n}  type: new EnumType([${e.enumValues.map(e=>`'${e}'`).join(`, `)}]),`):e.scalarType?r.push(`${n}  type: ${e.scalarType},`):r.push(`${n}  type: ${e.type.type}, // TODO: Define or import this type`),e.type.optional&&r.push(`${n}  isOptional: true,`),e.type.array&&r.push(`${n}  isArray: true,`),r.push(`${n}},`),r.join(`
+`)}function d(e){let t=new Set;t.add(`import { defineSchemaModel, ScalarTypeEnum, EnumType } from '@lssm/lib.schema';`);for(let t of e)!t.type.primitive&&!t.enumValues&&t.scalarType;return Array.from(t).join(`
+`)}export{d as generateImports,l as generateSchemaModelCode,s as getScalarType,c as jsonSchemaToField,o as jsonSchemaToType};

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@lssm/lib.contracts-transformers",
-  "version": "0.0.0-canary-20251217083314",
+  "version": "1.41.0",
   "description": "Contract format transformations: import/export between ContractSpec and external formats (OpenAPI, AsyncAPI, etc.)",
   "type": "module",
   "scripts": {
     "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
-    "publish:pkg:canary": "bun publish:pkg --tag canary",
     "build": "bun build:bundle && bun build:types",
     "build:bundle": "tsdown",
     "build:types": "tsc --noEmit",
@@ -17,15 +16,15 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@lssm/lib.contracts": "0.0.0-canary-20251217083314",
-    "@lssm/lib.schema": "0.0.0-canary-20251217083314",
+    "@lssm/lib.contracts": "workspace:*",
+    "@lssm/lib.schema": "workspace:*",
     "openapi-types": "^12.1.3",
     "yaml": "^2.7.1",
     "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@lssm/tool.tsdown": "0.0.0-canary-20251217083314",
-    "@lssm/tool.typescript": "0.0.0-canary-20251217083314",
+    "@lssm/tool.tsdown": "workspace:*",
+    "@lssm/tool.typescript": "workspace:*",
     "tsdown": "^0.17.4",
     "typescript": "^5.9.3"
   },
@@ -37,9 +36,9 @@
   ],
   "module": "./dist/index.js",
   "exports": {
-    ".": "./dist/index.js",
-    "./common": "./dist/common/index.js",
-    "./openapi": "./dist/openapi/index.js",
+    ".": "./src/index.ts",
+    "./common": "./src/common/index.ts",
+    "./openapi": "./src/openapi/index.ts",
     "./*": "./*"
   },
   "publishConfig": {

package/dist/common/index.d.ts

@@ -1,3 +0,0 @@
-import { DiffChange, DiffChangeType, ImportResult, ImportedSpec, SpecDiff, SpecSource, SyncResult, TransportHints, ValidationResult } from "./types.js";
-import { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecName, toValidIdentifier } from "./utils.js";
-export { DiffChange, DiffChangeType, ImportResult, ImportedSpec, SpecDiff, SpecSource, SyncResult, TransportHints, ValidationResult, deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecName, toValidIdentifier };

package/dist/common/types.d.ts

@@ -1,152 +0,0 @@
-import { AnyContractSpec } from "@lssm/lib.contracts";
-
-//#region src/common/types.d.ts
-
-/**
- * Source information for imported specs.
- */
-interface SpecSource {
-  /** The format the spec was imported from */
-  type: 'openapi' | 'asyncapi' | 'graphql' | 'protobuf';
-  /** URL if fetched from remote */
-  url?: string;
-  /** File path if loaded from local file */
-  file?: string;
-  /** Original identifier in source format */
-  sourceId: string;
-  /** Timestamp of import */
-  importedAt: Date;
-}
-/**
- * Transport hints preserved from external formats.
- * These enable accurate round-trip transformations.
- */
-interface TransportHints {
-  rest?: {
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-    path: string;
-    params?: {
-      path?: string[];
-      query?: string[];
-      header?: string[];
-      cookie?: string[];
-    };
-  };
-  graphql?: {
-    type: 'query' | 'mutation' | 'subscription';
-    fieldName: string;
-  };
-}
-/**
- * Result of importing a single spec from an external format.
- */
-interface ImportedSpec {
-  /** The generated ContractSpec */
-  spec: AnyContractSpec;
-  /** Generated TypeScript code for the spec */
-  code: string;
-  /** Suggested file name for the spec */
-  fileName: string;
-  /** Source information for provenance tracking */
-  source: SpecSource;
-  /** Transport hints for accurate round-trips */
-  transportHints: TransportHints;
-}
-/**
- * Result of an import operation.
- */
-interface ImportResult {
-  /** Successfully imported specs */
-  specs: ImportedSpec[];
-  /** Specs that were skipped (e.g., unsupported features) */
-  skipped: Array<{
-    sourceId: string;
-    reason: string;
-  }>;
-  /** Errors encountered during import */
-  errors: Array<{
-    sourceId: string;
-    error: string;
-  }>;
-  /** Summary statistics */
-  summary: {
-    total: number;
-    imported: number;
-    skipped: number;
-    errors: number;
-  };
-}
-/**
- * Type of change detected during diff.
- */
-type DiffChangeType = 'added' | 'removed' | 'modified' | 'type_changed' | 'required_changed';
-/**
- * A single change detected during diff.
- */
-interface DiffChange {
-  /** JSON path to the changed property */
-  path: string;
-  /** Type of change */
-  type: DiffChangeType;
-  /** Previous value (for modified/removed) */
-  oldValue?: unknown;
-  /** New value (for modified/added) */
-  newValue?: unknown;
-  /** Human-readable description of the change */
-  description: string;
-}
-/**
- * Result of diffing two specs.
- */
-interface SpecDiff {
-  /** Identifier for the operation */
-  operationId: string;
-  /** Existing ContractSpec (if any) */
-  existing?: AnyContractSpec;
-  /** Incoming imported spec */
-  incoming: ImportedSpec;
-  /** List of detected changes */
-  changes: DiffChange[];
-  /** Whether specs are semantically equivalent */
-  isEquivalent: boolean;
-  /** User's resolution choice (for interactive sync) */
-  resolution?: 'keep' | 'replace' | 'merge' | 'skip';
-}
-/**
- * Result of a sync operation.
- */
-interface SyncResult {
-  /** Specs that were added (new imports) */
-  added: ImportedSpec[];
-  /** Specs that were updated */
-  updated: Array<{
-    spec: ImportedSpec;
-    changes: DiffChange[];
-  }>;
-  /** Specs that were kept unchanged */
-  unchanged: string[];
-  /** Specs that had conflicts requiring resolution */
-  conflicts: SpecDiff[];
-  /** Summary statistics */
-  summary: {
-    added: number;
-    updated: number;
-    unchanged: number;
-    conflicts: number;
-  };
-}
-/**
- * Validation result for a single spec.
- */
-interface ValidationResult {
-  /** Whether the spec is valid against the source */
-  valid: boolean;
-  /** Detected differences */
-  diffs: DiffChange[];
-  /** Validation errors */
-  errors: string[];
-  /** Validation warnings */
-  warnings: string[];
-}
-//#endregion
-export { DiffChange, DiffChangeType, ImportResult, ImportedSpec, SpecDiff, SpecSource, SyncResult, TransportHints, ValidationResult };

package/dist/common/utils.d.ts

@@ -1,51 +0,0 @@
-//#region src/common/utils.d.ts
-/**
- * Common utilities for contract transformations.
- */
-/**
- * Convert a string to PascalCase.
- */
-declare function toPascalCase(str: string): string;
-/**
- * Convert a string to camelCase.
- */
-declare function toCamelCase(str: string): string;
-/**
- * Convert a string to kebab-case.
- */
-declare function toKebabCase(str: string): string;
-/**
- * Convert a string to snake_case.
- */
-declare function toSnakeCase(str: string): string;
-/**
- * Sanitize a string to be a valid TypeScript identifier.
- */
-declare function toValidIdentifier(str: string): string;
-/**
- * Generate a ContractSpec name from an operation identifier.
- */
-declare function toSpecName(operationId: string, prefix?: string): string;
-/**
- * Generate a file name from a spec name.
- */
-declare function toFileName(specName: string): string;
-/**
- * Deep equality check for objects.
- */
-declare function deepEqual(a: unknown, b: unknown): boolean;
-/**
- * Get a value from an object by JSON path.
- */
-declare function getByPath(obj: unknown, path: string): unknown;
-/**
- * Extract path parameters from a URL path template.
- * e.g., "/users/{userId}/orders/{orderId}" -> ["userId", "orderId"]
- */
-declare function extractPathParams(path: string): string[];
-/**
- * Normalize a URL path for comparison.
- */
-declare function normalizePath(path: string): string;
-//#endregion
-export { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecName, toValidIdentifier };

package/dist/index.d.ts

@@ -1,9 +0,0 @@
-import { DiffChange, DiffChangeType, ImportResult, ImportedSpec, SpecDiff, SpecSource, SyncResult, TransportHints, ValidationResult } from "./common/types.js";
-import { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecName, toValidIdentifier } from "./common/utils.js";
-import { ContractSpecOpenApiDocument, HttpMethod, OpenApiDocument, OpenApiExportOptions, OpenApiImportOptions, OpenApiOperation, OpenApiParameter, OpenApiParseOptions, OpenApiSchema, OpenApiServer, OpenApiSource, OpenApiTransportHints, OpenApiVersion, ParameterLocation, ParseResult, ParsedOperation, ParsedParameter } from "./openapi/types.js";
-import { detectFormat, detectVersion, parseOpenApi, parseOpenApiDocument, parseOpenApiString } from "./openapi/parser.js";
-import { defaultRestPath, openApiForRegistry, openApiToJson, openApiToYaml } from "./openapi/exporter.js";
-import { importFromOpenApi, importOperation } from "./openapi/importer.js";
-import { GeneratedModel, SchemaField, TypescriptType, generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToField, jsonSchemaToType } from "./openapi/schema-converter.js";
-import { DiffOptions, createSpecDiff, diffAll, diffSpecVsOperation, diffSpecs, formatDiffChanges } from "./openapi/differ.js";
-export { ContractSpecOpenApiDocument, DiffChange, DiffChangeType, DiffOptions, GeneratedModel, HttpMethod, ImportResult, ImportedSpec, OpenApiDocument, OpenApiExportOptions, OpenApiImportOptions, OpenApiOperation, OpenApiParameter, OpenApiParseOptions, OpenApiSchema, OpenApiServer, OpenApiSource, OpenApiTransportHints, OpenApiVersion, ParameterLocation, ParseResult, ParsedOperation, ParsedParameter, SchemaField, SpecDiff, SpecSource, SyncResult, TransportHints, TypescriptType, ValidationResult, createSpecDiff, deepEqual, defaultRestPath, detectFormat, detectVersion, diffAll, diffSpecVsOperation, diffSpecs, extractPathParams, formatDiffChanges, generateImports, generateSchemaModelCode, getByPath, getScalarType, importFromOpenApi, importOperation, jsonSchemaToField, jsonSchemaToType, normalizePath, openApiForRegistry, openApiToJson, openApiToYaml, parseOpenApi, parseOpenApiDocument, parseOpenApiString, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecName, toValidIdentifier };

package/dist/openapi/differ.d.ts

@@ -1,41 +0,0 @@
-import { DiffChange, ImportedSpec, SpecDiff } from "../common/types.js";
-import { ParsedOperation } from "./types.js";
-import { AnyContractSpec } from "@lssm/lib.contracts";
-
-//#region src/openapi/differ.d.ts
-
-/**
- * Options for diffing specs.
- */
-interface DiffOptions {
-  /** Ignore description changes */
-  ignoreDescriptions?: boolean;
-  /** Ignore tag changes */
-  ignoreTags?: boolean;
-  /** Ignore transport changes (path, method) */
-  ignoreTransport?: boolean;
-  /** Custom paths to ignore */
-  ignorePaths?: string[];
-}
-/**
- * Diff a ContractSpec against an OpenAPI operation.
- */
-declare function diffSpecVsOperation(spec: AnyContractSpec, operation: ParsedOperation, options?: DiffOptions): DiffChange[];
-/**
- * Diff two ContractSpecs.
- */
-declare function diffSpecs(oldSpec: AnyContractSpec, newSpec: AnyContractSpec, options?: DiffOptions): DiffChange[];
-/**
- * Create a SpecDiff from an existing spec and an imported spec.
- */
-declare function createSpecDiff(operationId: string, existing: AnyContractSpec | undefined, incoming: ImportedSpec, options?: DiffOptions): SpecDiff;
-/**
- * Batch diff multiple specs against OpenAPI operations.
- */
-declare function diffAll(existingSpecs: Map<string, AnyContractSpec>, importedSpecs: ImportedSpec[], options?: DiffOptions): SpecDiff[];
-/**
- * Format diff changes for display.
- */
-declare function formatDiffChanges(changes: DiffChange[]): string;
-//#endregion
-export { DiffOptions, createSpecDiff, diffAll, diffSpecVsOperation, diffSpecs, formatDiffChanges };

package/dist/openapi/exporter.d.ts

@@ -1,27 +0,0 @@
-import { ContractSpecOpenApiDocument, OpenApiExportOptions, OpenApiServer } from "./types.js";
-import { SpecRegistry } from "@lssm/lib.contracts";
-
-//#region src/openapi/exporter.d.ts
-
-/**
- * Generate default REST path from spec name and version.
- */
-declare function defaultRestPath(name: string, version: number): string;
-/**
- * Export a SpecRegistry to an OpenAPI 3.1 document.
- *
- * @param registry - The SpecRegistry containing specs to export
- * @param options - Export options (title, version, description, servers)
- * @returns OpenAPI 3.1 document
- */
-declare function openApiForRegistry(registry: SpecRegistry, options?: OpenApiExportOptions): ContractSpecOpenApiDocument;
-/**
- * Export a SpecRegistry to OpenAPI JSON string.
- */
-declare function openApiToJson(registry: SpecRegistry, options?: OpenApiExportOptions): string;
-/**
- * Export a SpecRegistry to OpenAPI YAML string.
- */
-declare function openApiToYaml(registry: SpecRegistry, options?: OpenApiExportOptions): string;
-//#endregion
-export { defaultRestPath, openApiForRegistry, openApiToJson, openApiToYaml };

package/dist/openapi/importer.d.ts

@@ -1,15 +0,0 @@
-import { ImportResult } from "../common/types.js";
-import { OpenApiImportOptions, ParseResult, ParsedOperation } from "./types.js";
-
-//#region src/openapi/importer.d.ts
-
-/**
- * Import operations from a parsed OpenAPI document.
- */
-declare function importFromOpenApi(parseResult: ParseResult, options?: OpenApiImportOptions): ImportResult;
-/**
- * Import a single operation to ContractSpec code.
- */
-declare function importOperation(operation: ParsedOperation, options?: OpenApiImportOptions): string;
-//#endregion
-export { importFromOpenApi, importOperation };

package/dist/openapi/index.d.ts

@@ -1,7 +0,0 @@
-import { ContractSpecOpenApiDocument, HttpMethod, OpenApiDocument, OpenApiExportOptions, OpenApiImportOptions, OpenApiOperation, OpenApiParameter, OpenApiParseOptions, OpenApiSchema, OpenApiServer, OpenApiSource, OpenApiTransportHints, OpenApiVersion, ParameterLocation, ParseResult, ParsedOperation, ParsedParameter } from "./types.js";
-import { detectFormat, detectVersion, parseOpenApi, parseOpenApiDocument, parseOpenApiString } from "./parser.js";
-import { defaultRestPath, openApiForRegistry, openApiToJson, openApiToYaml } from "./exporter.js";
-import { importFromOpenApi, importOperation } from "./importer.js";
-import { GeneratedModel, SchemaField, TypescriptType, generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToField, jsonSchemaToType } from "./schema-converter.js";
-import { DiffOptions, createSpecDiff, diffAll, diffSpecVsOperation, diffSpecs, formatDiffChanges } from "./differ.js";
-export { type ContractSpecOpenApiDocument, type DiffOptions, type GeneratedModel, type HttpMethod, type OpenApiDocument, type OpenApiExportOptions, type OpenApiImportOptions, type OpenApiOperation, type OpenApiParameter, type OpenApiParseOptions, type OpenApiSchema, type OpenApiServer, type OpenApiSource, type OpenApiTransportHints, type OpenApiVersion, type ParameterLocation, type ParseResult, type ParsedOperation, type ParsedParameter, type SchemaField, type TypescriptType, createSpecDiff, defaultRestPath, detectFormat, detectVersion, diffAll, diffSpecVsOperation, diffSpecs, formatDiffChanges, generateImports, generateSchemaModelCode, getScalarType, importFromOpenApi, importOperation, jsonSchemaToField, jsonSchemaToType, openApiForRegistry, openApiToJson, openApiToYaml, parseOpenApi, parseOpenApiDocument, parseOpenApiString };

package/dist/openapi/parser.d.ts

@@ -1,31 +0,0 @@
-import { OpenApiDocument, OpenApiParseOptions, OpenApiVersion, ParseResult } from "./types.js";
-
-//#region src/openapi/parser.d.ts
-
-/**
- * Parse an OpenAPI document from a string (JSON or YAML).
- */
-declare function parseOpenApiString(content: string, format?: 'json' | 'yaml'): OpenApiDocument;
-/**
- * Detect the format of content (JSON or YAML).
- */
-declare function detectFormat(content: string): 'json' | 'yaml';
-/**
- * Detect OpenAPI version from document.
- */
-declare function detectVersion(doc: OpenApiDocument): OpenApiVersion;
-/**
- * Parse an OpenAPI document into a structured result.
- */
-declare function parseOpenApiDocument(doc: OpenApiDocument, _options?: OpenApiParseOptions): ParseResult;
-/**
- * Parse OpenAPI from a file path or URL.
- * Note: This is an async function that requires I/O adapters.
- * For pure parsing, use parseOpenApiString or parseOpenApiDocument.
- */
-declare function parseOpenApi(source: string, options?: OpenApiParseOptions & {
-  fetch?: typeof globalThis.fetch;
-  readFile?: (path: string) => Promise<string>;
-}): Promise<ParseResult>;
-//#endregion
-export { detectFormat, detectVersion, parseOpenApi, parseOpenApiDocument, parseOpenApiString };

package/dist/openapi/schema-converter.d.ts

@@ -1,69 +0,0 @@
-import { OpenApiSchema } from "./types.js";
-
-//#region src/openapi/schema-converter.d.ts
-
-/**
- * TypeScript type representation for code generation.
- */
-interface TypescriptType {
-  /** The type expression (e.g., "string", "number", "MyModel") */
-  type: string;
-  /** Whether the type is optional */
-  optional: boolean;
-  /** Whether the type is an array */
-  array: boolean;
-  /** Whether this is a primitive type */
-  primitive: boolean;
-  /** Description for documentation */
-  description?: string;
-}
-/**
- * SchemaModel field representation for code generation.
- */
-interface SchemaField {
-  /** Field name */
-  name: string;
-  /** Field type */
-  type: TypescriptType;
-  /** Scalar type enum value (for FieldType) */
-  scalarType?: string;
-  /** Enum values if this is an enum type */
-  enumValues?: string[];
-  /** Nested model if this is an object type */
-  nestedModel?: GeneratedModel;
-}
-/**
- * Generated model representation.
- */
-interface GeneratedModel {
-  /** Model name (PascalCase) */
-  name: string;
-  /** Model description */
-  description?: string;
-  /** Fields */
-  fields: SchemaField[];
-  /** Generated TypeScript code */
-  code: string;
-}
-/**
- * Convert a JSON Schema to a TypeScript type representation.
- */
-declare function jsonSchemaToType(schema: OpenApiSchema, name?: string): TypescriptType;
-/**
- * Get the ScalarTypeEnum value for a JSON Schema type.
- */
-declare function getScalarType(schema: OpenApiSchema): string | undefined;
-/**
- * Convert a JSON Schema to a SchemaModel field definition.
- */
-declare function jsonSchemaToField(schema: OpenApiSchema, fieldName: string, required: boolean): SchemaField;
-/**
- * Generate SchemaModel TypeScript code for a JSON Schema object.
- */
-declare function generateSchemaModelCode(schema: OpenApiSchema, modelName: string, indent?: number): GeneratedModel;
-/**
- * Generate import statements for a SchemaModel.
- */
-declare function generateImports(fields: SchemaField[]): string;
-//#endregion
-export { GeneratedModel, SchemaField, TypescriptType, generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToField, jsonSchemaToType };