@lssm/lib.contracts-transformers 0.0.0-canary-20251217054315 → 0.0.0-canary-20251217060433

package/dist/common/index.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,51 @@
+//#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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,69 @@
+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 };

package/dist/openapi/types.d.ts

@@ -0,0 +1,221 @@
+import { SpecSource, TransportHints } from "../common/types.js";
+import { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
+
+//#region src/openapi/types.d.ts
+
+/**
+ * Supported OpenAPI versions.
+ */
+type OpenApiVersion = '3.0' | '3.1';
+/**
+ * OpenAPI document (union of supported versions).
+ */
+type OpenApiDocument = OpenAPIV3.Document | OpenAPIV3_1.Document;
+/**
+ * OpenAPI operation object.
+ */
+type OpenApiOperation = OpenAPIV3.OperationObject | OpenAPIV3_1.OperationObject;
+/**
+ * OpenAPI schema object.
+ */
+type OpenApiSchema = OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject | OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject;
+/**
+ * OpenAPI parameter object.
+ */
+type OpenApiParameter = OpenAPIV3.ParameterObject | OpenAPIV3_1.ParameterObject | OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject;
+/**
+ * HTTP methods supported by OpenAPI.
+ */
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options' | 'trace';
+/**
+ * Parameter location in OpenAPI.
+ */
+type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+/**
+ * Server configuration for OpenAPI export.
+ */
+interface OpenApiServer {
+  url: string;
+  description?: string;
+  variables?: Record<string, {
+    default: string;
+    enum?: string[];
+    description?: string;
+  }>;
+}
+/**
+ * Options for exporting to OpenAPI.
+ */
+interface OpenApiExportOptions {
+  /** API title */
+  title?: string;
+  /** API version */
+  version?: string;
+  /** API description */
+  description?: string;
+  /** Server configurations */
+  servers?: OpenApiServer[];
+  /** Additional OpenAPI extensions */
+  extensions?: Record<string, unknown>;
+}
+/**
+ * Options for importing from OpenAPI.
+ */
+interface OpenApiImportOptions {
+  /** Prefix for generated spec names */
+  prefix?: string;
+  /** Only import operations with these tags */
+  tags?: string[];
+  /** Exclude operations with these operationIds */
+  exclude?: string[];
+  /** Include operations with these operationIds (overrides exclude) */
+  include?: string[];
+  /** Default stability for imported specs */
+  defaultStability?: 'experimental' | 'beta' | 'stable' | 'deprecated';
+  /** Default owners for imported specs */
+  defaultOwners?: string[];
+  /** Default auth level for imported specs */
+  defaultAuth?: 'anonymous' | 'user' | 'admin';
+}
+/**
+ * Options for parsing OpenAPI documents.
+ */
+interface OpenApiParseOptions {
+  /** Base URL for resolving relative references */
+  baseUrl?: string;
+  /** Whether to resolve $ref references */
+  resolveRefs?: boolean;
+  /** Timeout for HTTP requests (ms) */
+  timeout?: number;
+}
+/**
+ * Parsed operation with resolved metadata.
+ */
+interface ParsedOperation {
+  /** Operation ID (generated if not present) */
+  operationId: string;
+  /** HTTP method */
+  method: HttpMethod;
+  /** Path template */
+  path: string;
+  /** Operation summary */
+  summary?: string;
+  /** Operation description */
+  description?: string;
+  /** Operation tags */
+  tags: string[];
+  /** Path parameters */
+  pathParams: ParsedParameter[];
+  /** Query parameters */
+  queryParams: ParsedParameter[];
+  /** Header parameters */
+  headerParams: ParsedParameter[];
+  /** Cookie parameters */
+  cookieParams: ParsedParameter[];
+  /** Request body schema */
+  requestBody?: {
+    required: boolean;
+    schema: OpenApiSchema;
+    contentType: string;
+  };
+  /** Response schemas by status code */
+  responses: Record<string, {
+    description: string;
+    schema?: OpenApiSchema;
+    contentType?: string;
+  }>;
+  /** Whether the operation is deprecated */
+  deprecated: boolean;
+  /** Security requirements */
+  security?: Array<Record<string, string[]>>;
+  /** ContractSpec extension data if present */
+  contractSpecMeta?: {
+    name: string;
+    version: number;
+    kind: 'command' | 'query';
+  };
+}
+/**
+ * Parsed parameter with resolved schema.
+ */
+interface ParsedParameter {
+  /** Parameter name */
+  name: string;
+  /** Parameter location */
+  in: ParameterLocation;
+  /** Whether the parameter is required */
+  required: boolean;
+  /** Parameter description */
+  description?: string;
+  /** Parameter schema */
+  schema: OpenApiSchema;
+  /** Whether the parameter is deprecated */
+  deprecated: boolean;
+}
+/**
+ * Result of parsing an OpenAPI document.
+ */
+interface ParseResult {
+  /** Original document */
+  document: OpenApiDocument;
+  /** Detected OpenAPI version */
+  version: OpenApiVersion;
+  /** API info */
+  info: {
+    title: string;
+    version: string;
+    description?: string;
+  };
+  /** Parsed operations */
+  operations: ParsedOperation[];
+  /** Component schemas (resolved) */
+  schemas: Record<string, OpenApiSchema>;
+  /** Servers */
+  servers: OpenApiServer[];
+  /** Parse warnings */
+  warnings: string[];
+}
+/**
+ * OpenAPI-specific transport hints.
+ */
+interface OpenApiTransportHints extends TransportHints {
+  rest: {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    path: string;
+    params?: {
+      path?: string[];
+      query?: string[];
+      header?: string[];
+      cookie?: string[];
+    };
+  };
+}
+/**
+ * OpenAPI-specific source information.
+ */
+interface OpenApiSource extends SpecSource {
+  type: 'openapi';
+  /** OpenAPI version of source document */
+  openApiVersion: OpenApiVersion;
+  /** Original operationId from OpenAPI */
+  operationId: string;
+}
+/**
+ * ContractSpec-compatible OpenAPI document structure.
+ * Used for export to maintain compatibility with existing code.
+ */
+interface ContractSpecOpenApiDocument {
+  openapi: '3.1.0';
+  info: {
+    title: string;
+    version: string;
+    description?: string;
+  };
+  servers?: OpenApiServer[];
+  paths: Record<string, Record<string, unknown>>;
+  components: {
+    schemas: Record<string, Record<string, unknown>>;
+  };
+}
+//#endregion
+export { ContractSpecOpenApiDocument, HttpMethod, OpenApiDocument, OpenApiExportOptions, OpenApiImportOptions, OpenApiOperation, OpenApiParameter, OpenApiParseOptions, OpenApiSchema, OpenApiServer, OpenApiSource, OpenApiTransportHints, OpenApiVersion, ParameterLocation, ParseResult, ParsedOperation, ParsedParameter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.contracts-transformers",
-  "version": "0.0.0-canary-20251217054315",
+  "version": "0.0.0-canary-20251217060433",
   "description": "Contract format transformations: import/export between ContractSpec and external formats (OpenAPI, AsyncAPI, etc.)",
   "type": "module",
   "scripts": {
@@ -17,15 +17,15 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@lssm/lib.contracts": "0.0.0-canary-20251217054315",
-    "@lssm/lib.schema": "0.0.0-canary-20251217054315",
+    "@lssm/lib.contracts": "0.0.0-canary-20251217060433",
+    "@lssm/lib.schema": "0.0.0-canary-20251217060433",
     "openapi-types": "^12.1.3",
     "yaml": "^2.7.1",
     "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@lssm/tool.tsdown": "0.0.0-canary-20251217054315",
-    "@lssm/tool.typescript": "0.0.0-canary-20251217054315",
+    "@lssm/tool.tsdown": "0.0.0-canary-20251217060433",
+    "@lssm/tool.typescript": "0.0.0-canary-20251217060433",
     "tsdown": "^0.17.4",
     "typescript": "^5.9.3"
   },
@@ -37,9 +37,9 @@
   ],
   "module": "./dist/index.js",
   "exports": {
-    ".": "./src/index.ts",
-    "./common": "./src/common/index.ts",
-    "./openapi": "./src/openapi/index.ts",
+    ".": "./dist/index.js",
+    "./common": "./dist/common/index.js",
+    "./openapi": "./dist/openapi/index.js",
     "./*": "./*"
   },
   "publishConfig": {