@skmtc/core 0.0.808 → 0.0.810

package/esm/context/types.d.ts

@@ -1,4 +1,3 @@
-import type { GeneratorKey } from '../types/GeneratorKeys.js';
 import type { ManifestEntry } from '../types/Manifest.js';
 import type { Mapping, Preview } from '../types/Preview.js';
 import type { ResultsItem } from '../types/Results.js';
@@ -14,13 +13,6 @@ export type GetFileOptions = {
     /** Whether to throw an error if the file is not found */
     throwIfNotFound?: boolean;
 };
-/**
- * Arguments for adding a generator key to the context.
- */
-export type AddGeneratorKeyArgs = {
-    /** The generator key to add */
-    generatorKey: GeneratorKey;
-};
 /**
  * Result of rendering files in the context.
  */

package/esm/context/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/context/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEtE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAA;AAEvD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yDAAyD;IACzD,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+BAA+B;IAC/B,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrC,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACpC,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,oCAAoC;IACpC,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAA;AAE3F;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,qBAAqB,GACrB,qBAAqB,GACrB,qBAAqB,GACrB,oBAAoB,GACpB,sBAAsB,GACtB,iBAAiB,GACjB,cAAc,GACd,iBAAiB,GACjB,kBAAkB,GAClB,mBAAmB,GACnB,kBAAkB,GAClB,gBAAgB,GAChB,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,wBAAwB,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/context/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEtE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAA;AAEvD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yDAAyD;IACzD,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrC,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACpC,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,oCAAoC;IACpC,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAA;AAE3F;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,qBAAqB,GACrB,qBAAqB,GACrB,qBAAqB,GACrB,oBAAoB,GACpB,sBAAsB,GACtB,iBAAiB,GACjB,cAAc,GACd,iBAAiB,GACjB,kBAAkB,GAClB,mBAAmB,GACnB,kBAAkB,GAClB,gBAAgB,GAChB,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,wBAAwB,CAAA"}

package/esm/dsl/model/toModelBase.d.ts

@@ -1,9 +1,9 @@
 import type { GenerateContext } from '../../context/GenerateContext.js';
 import type { RefName } from '../../types/RefName.js';
 import type { ContentSettings } from '../ContentSettings.js';
-import { ModelBase } from './ModelBase.js';
 import type { Identifier } from '../Identifier.js';
 import * as v from 'valibot';
+import type { ModelInsertable } from './types.js';
 /**
  * Arguments for creating a model insertable instance.
  *
@@ -17,6 +17,10 @@ export type ModelInsertableArgs<EnrichmentType = undefined> = {
     /** Reference name identifying the model schema */
     refName: RefName;
 };
+type ToEnrichmentsArgs = {
+    refName: RefName;
+    context: GenerateContext;
+};
 /**
  * Configuration for creating a base model class.
  *
@@ -81,5 +85,23 @@ export type BaseModelConfig<EnrichmentType = undefined> = {
  * });
  * ```
  */
-export declare const toModelBase: <EnrichmentType = undefined>(config: BaseModelConfig<EnrichmentType>) => new (args: ModelInsertableArgs<EnrichmentType>) => ModelBase<EnrichmentType>;
+export declare const toModelBase: <EnrichmentType = undefined>(config: BaseModelConfig<EnrichmentType>) => {
+    new (args: ModelInsertableArgs<EnrichmentType>): {
+        settings: ContentSettings<EnrichmentType>;
+        refName: RefName;
+        generatorKey: import("../../mod.js").GeneratorKey;
+        insertModel<V extends import("../../mod.js").GeneratedValue, EnrichmentType_1 = undefined>(insertable: ModelInsertable<V, EnrichmentType_1>, refName: RefName, options?: Pick<import("../../mod.js").InsertModelOptions<"force">, "noExport">): import("../Inserted.js").Inserted<V, "force", EnrichmentType_1>;
+        insertNormalizedModel<V extends import("../../mod.js").GeneratedValue, Schema extends import("../../mod.js").OasSchema | import("../../mod.js").OasRef<"schema"> | import("../../mod.js").OasVoid, EnrichmentType_2 = undefined>(insertable: ModelInsertable<V, EnrichmentType_2>, { schema, fallbackName }: Omit<import("../../mod.js").InsertNormalisedModelArgs<Schema>, "destinationPath">, options?: Pick<import("../../mod.js").InsertModelOptions<"force">, "noExport">): import("../../mod.js").InsertNormalisedModelReturn<V, Schema>;
+        register(args: import("../../mod.js").BaseRegisterArgs): void;
+        context: GenerateContext;
+        skipped: boolean;
+    };
+    id: string;
+    type: "model";
+    toIdentifier: (refName: RefName) => Identifier;
+    toExportPath: (refName: RefName) => string;
+    toEnrichments: ({ refName, context }: ToEnrichmentsArgs) => EnrichmentType;
+    isSupported: () => boolean;
+};
+export {};
 //# sourceMappingURL=toModelBase.d.ts.map

package/esm/dsl/model/toModelBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toModelBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/toModelBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAEvE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC5D,2EAA2E;IAC3E,OAAO,EAAE,eAAe,CAAA;IACxB,iEAAiE;IACjE,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAOD;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,cAAc,GAAG,SAAS,IAAI;IACxD,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAA;IACV,4DAA4D;IAC5D,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,UAAU,CAAA;IAC9C,6DAA6D;IAC7D,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAA;IAC1C,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,GAAI,cAAc,GAAG,SAAS,EACpD,QAAQ,eAAe,CAAC,cAAc,CAAC,KACtC,KAAK,IAAI,EAAE,mBAAmB,CAAC,cAAc,CAAC,KAAK,SAAS,CAAC,cAAc,CA0B7E,CAAA"}
+{"version":3,"file":"toModelBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/toModelBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAEvE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC5D,2EAA2E;IAC3E,OAAO,EAAE,eAAe,CAAA;IACxB,iEAAiE;IACjE,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,KAAK,iBAAiB,GAAG;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,eAAe,CAAA;CACzB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,cAAc,GAAG,SAAS,IAAI;IACxD,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAA;IACV,4DAA4D;IAC5D,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,UAAU,CAAA;IAC9C,6DAA6D;IAC7D,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAA;IAC1C,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,GAAI,cAAc,GAAG,SAAS,EACpD,QAAQ,eAAe,CAAC,cAAc,CAAC;eAiBnB,mBAAmB,CAAC,cAAc,CAAC;;;;;;;;;;;UAbvC,OAAO;4BA1DC,OAAO,KAAK,UAAU;4BAEtB,OAAO,KAAK,MAAM;oBA4DhB,sBAAsB,iBAAiB,KAAG,cAAc;;CAmBnF,CAAA"}

package/esm/dsl/model/types.d.ts

@@ -30,7 +30,7 @@ export type WithTransformModel = {
 /**
  * Arguments for generating enrichment data for models.
  */
-export type ModelToEnrichmentsArgs = {
+export type ToModelEnrichmentsArgs = {
     refName: RefName;
     context: GenerateContext;
 };
@@ -81,7 +81,7 @@ export type ModelInsertable<V, EnrichmentType = undefined> = {
     type: 'model';
     toIdentifier: (refName: RefName) => Identifier;
     toExportPath: (refName: RefName) => string;
-    toEnrichments: ({ refName, context }: ModelToEnrichmentsArgs) => EnrichmentType;
+    toEnrichments: ({ refName, context }: ToModelEnrichmentsArgs) => EnrichmentType;
     schemaToValueFn: SchemaToValueFn;
     createIdentifier: (name: string) => Identifier;
 } & Function;

package/esm/dsl/operation/toOperationBase.d.ts

@@ -1,7 +1,7 @@
+import type { GenerateContext } from '../../context/GenerateContext.js';
 import type { OasOperation } from '../../oas/operation/Operation.js';
-import { OperationBase } from './OperationBase.js';
 import type { Identifier } from '../Identifier.js';
-import type { OperationInsertableArgs } from './types.js';
+import type { OperationInsertable, OperationInsertableArgs } from './types.js';
 import * as v from 'valibot';
 /**
  * Configuration for creating a base operation class.
@@ -21,6 +21,10 @@ export type BaseOperationConfig<EnrichmentType = undefined> = {
     /** Optional function to provide enrichment validation schema */
     toEnrichmentSchema?: () => v.BaseSchema<EnrichmentType, EnrichmentType, v.BaseIssue<unknown>>;
 };
+type ToEnrichmentsArgs = {
+    operation: OasOperation;
+    context: GenerateContext;
+};
 /**
  * Creates a base operation class constructor for generating type-safe operation artifacts.
  *
@@ -67,5 +71,24 @@ export type BaseOperationConfig<EnrichmentType = undefined> = {
  * });
  * ```
  */
-export declare const toOperationBase: <EnrichmentType = undefined>(config: BaseOperationConfig<EnrichmentType>) => new (args: OperationInsertableArgs<EnrichmentType>) => OperationBase<EnrichmentType>;
+export declare const toOperationBase: <EnrichmentType = undefined>(config: BaseOperationConfig<EnrichmentType>) => {
+    new (args: OperationInsertableArgs<EnrichmentType>): {
+        settings: import("../ContentSettings.js").ContentSettings<EnrichmentType>;
+        operation: OasOperation;
+        generatorKey: import("../../mod.js").GeneratorKey;
+        insertOperation<V extends import("../../mod.js").GeneratedValue, EnrichmentType_1 = undefined>(insertable: OperationInsertable<V, EnrichmentType_1>, operation: OasOperation, options?: Pick<import("../../mod.js").InsertOperationOptions<"force">, "noExport">): import("../Inserted.js").Inserted<V, "force", EnrichmentType_1>;
+        insertModel<V extends import("../../mod.js").GeneratedValue, EnrichmentType_2 = undefined>(insertable: import("../model/types.js").ModelInsertable<V, EnrichmentType_2>, refName: import("../../mod.js").RefName, options?: Pick<import("../../mod.js").InsertModelOptions<"force">, "noExport">): import("../Inserted.js").Inserted<V, "force", EnrichmentType_2>;
+        insertNormalizedModel<V extends import("../../mod.js").GeneratedValue, Schema extends import("../../mod.js").OasSchema | import("../../mod.js").OasRef<"schema"> | import("../../mod.js").OasVoid, EnrichmentType_3 = undefined>(insertable: import("../model/types.js").ModelInsertable<V, EnrichmentType_3>, { schema, fallbackName }: Omit<import("../../mod.js").InsertNormalisedModelArgs<Schema>, "destinationPath">, options?: Pick<import("../../mod.js").InsertModelOptions<"force">, "noExport">): import("../../mod.js").InsertNormalisedModelReturn<V, Schema>;
+        defineAndRegister<V extends import("../../mod.js").GeneratedValue>({ identifier, value, noExport }: Omit<import("../../mod.js").DefineAndRegisterArgs<V>, "destinationPath">): import("../Definition.js").Definition<V>;
+        register(args: import("../../mod.js").BaseRegisterArgs): void;
+        context: GenerateContext;
+        skipped: boolean;
+    };
+    id: string;
+    type: "operation";
+    toIdentifier: (operation: OasOperation) => Identifier;
+    toExportPath: (operation: OasOperation) => string;
+    toEnrichments: ({ operation, context }: ToEnrichmentsArgs) => EnrichmentType;
+};
+export {};
 //# sourceMappingURL=toOperationBase.d.ts.map

package/esm/dsl/operation/toOperationBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toOperationBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/operation/toOperationBase.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AACzD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC5D,oDAAoD;IACpD,EAAE,EAAE,MAAM,CAAA;IACV,uDAAuD;IACvD,YAAY,EAAE,CAAC,SAAS,EAAE,YAAY,KAAK,UAAU,CAAA;IACrD,wDAAwD;IACxD,YAAY,EAAE,CAAC,SAAS,EAAE,YAAY,KAAK,MAAM,CAAA;IACjD,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9F,CAAA;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,eAAe,GAAI,cAAc,GAAG,SAAS,EACxD,QAAQ,mBAAmB,CAAC,cAAc,CAAC,KAC1C,KAAK,IAAI,EAAE,uBAAuB,CAAC,cAAc,CAAC,KAAK,aAAa,CAAC,cAAc,CA6BrF,CAAA"}
+{"version":3,"file":"toOperationBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/operation/toOperationBase.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAC9E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC5D,oDAAoD;IACpD,EAAE,EAAE,MAAM,CAAA;IACV,uDAAuD;IACvD,YAAY,EAAE,CAAC,SAAS,EAAE,YAAY,KAAK,UAAU,CAAA;IACrD,wDAAwD;IACxD,YAAY,EAAE,CAAC,SAAS,EAAE,YAAY,KAAK,MAAM,CAAA;IACjD,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9F,CAAA;AAED,KAAK,iBAAiB,GAAG;IACvB,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,eAAe,CAAA;CACzB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,eAAe,GAAI,cAAc,GAAG,SAAS,EACxD,QAAQ,mBAAmB,CAAC,cAAc,CAAC;eAoBvB,uBAAuB,CAAC,cAAc,CAAC;;;;;;;;;;;;;UAhB3C,WAAW;8BA/DD,YAAY,KAAK,UAAU;8BAE3B,YAAY,KAAK,MAAM;oBAkEvB,wBAAwB,iBAAiB,KAAG,cAAc;CAqBrF,CAAA"}

package/esm/dsl/operation/types.d.ts

@@ -54,7 +54,7 @@ export type IsSupportedOperationArgs = {
 /**
  * Arguments for generating enrichment data for operations.
  */
-export type OperationToEnrichmentsArgs = {
+export type ToOperationEnrichmentsArgs = {
     operation: OasOperation;
     context: GenerateContext;
 };
@@ -95,7 +95,7 @@ export type OperationInsertable<V, EnrichmentType = undefined> = {
     type: 'operation';
     toIdentifier: (operation: OasOperation) => Identifier;
     toExportPath: (operation: OasOperation) => string;
-    toEnrichments: ({ operation, context }: OperationToEnrichmentsArgs) => EnrichmentType;
+    toEnrichments: ({ operation, context }: ToOperationEnrichmentsArgs) => EnrichmentType;
 } & Function;
 /**
  * Arguments for checking if an operation is supported for generation.

package/esm/oas/array/array-types.d.ts

@@ -4,67 +4,280 @@ import { type OasSchemaRefData } from '../ref/ref-types.js';
 /**
  * Valibot schema for validating OpenAPI array data objects.
  *
- * Validates array schemas including item type definitions, length constraints,
- * uniqueness requirements, and enumeration values. Uses lazy evaluation
- * to handle recursive schema references.
+ * This comprehensive schema validates OpenAPI array schemas according to the OpenAPI v3
+ * specification, including item type definitions, length constraints, uniqueness requirements,
+ * and enumeration values. It uses lazy evaluation to handle recursive schema references,
+ * allowing for complex nested array structures and self-referential schemas.
+ *
+ * The schema supports both direct schema definitions and reference objects for the items
+ * property, enabling flexible array type definitions that can reference other schemas
+ * in the document or define inline item types.
+ *
+ * @example Validating a simple array schema
+ * ```typescript
+ * import { oasArrayData } from '@skmtc/core/oas/array';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'string'
+ *   },
+ *   description: 'List of user names',
+ *   minItems: 1,
+ *   maxItems: 100
+ * };
+ *
+ * const validated = v.parse(oasArrayData, schema);
+ * console.log(validated.minItems); // 1
+ * ```
+ *
+ * @example Validating array with reference items
+ * ```typescript
+ * const refArraySchema = {
+ *   type: 'array',
+ *   items: {
+ *     $ref: '#/components/schemas/User'
+ *   },
+ *   title: 'User List',
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ *
+ * const result = v.parse(oasArrayData, refArraySchema);
+ * console.log(result.uniqueItems); // true
+ * ```
+ *
+ * @example Validating constrained arrays
+ * ```typescript
+ * const constrainedArray = {
+ *   type: 'array',
+ *   items: { type: 'number' },
+ *   minItems: 2,
+ *   maxItems: 10,
+ *   uniqueItems: true,
+ *   enums: [[1, 2, 3], [4, 5, 6]]
+ * };
+ *
+ * const validated = v.parse(oasArrayData, constrainedArray);
+ * console.log(validated.maxItems); // 10
+ * ```
  */
 export declare const oasArrayData: v.GenericSchema<OasArrayData>;
 /**
  * Valibot schema for array data without the items property.
  *
- * Used for parsing array schemas when the items property is handled separately,
- * typically during schema transformation and validation processes.
+ * This specialized schema validates array schemas when the items property is processed
+ * separately from the main array constraints. It's commonly used during schema parsing
+ * and transformation processes where items need special handling, such as when resolving
+ * references or applying schema merging operations.
+ *
+ * This pattern is useful in multi-phase parsing where array constraints (like min/max
+ * items, uniqueness) are validated independently from the item type definitions,
+ * allowing for more flexible processing pipelines.
+ *
+ * @example Validating array constraints without items
+ * ```typescript
+ * import { oasArrayDataWithoutItems } from '@skmtc/core/oas/array';
+ * import * as v from 'valibot';
+ *
+ * const constraintsOnly = {
+ *   type: 'array',
+ *   title: 'Validation Rules',
+ *   minItems: 1,
+ *   maxItems: 50,
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ *
+ * const validated = v.parse(oasArrayDataWithoutItems, constraintsOnly);
+ * console.log(validated.uniqueItems); // true
+ * ```
+ *
+ * @example Usage in two-phase parsing
+ * ```typescript
+ * function parseArraySchema(schema: unknown) {
+ *   // Phase 1: Validate basic array structure
+ *   const arrayConstraints = v.parse(oasArrayDataWithoutItems, schema);
+ *
+ *   // Phase 2: Process items separately (not shown)
+ *   const items = processItemsSchema((schema as any).items);
+ *
+ *   return { ...arrayConstraints, items };
+ * }
+ * ```
  */
 export declare const oasArrayDataWithoutItems: v.GenericSchema<OasArrayDataWithoutItems>;
 /**
  * Data type for OpenAPI array schema objects.
  *
- * Represents array schemas with item type specifications, length constraints,
- * and validation rules. Used throughout the SKMTC pipeline for array type
- * processing and code generation.
+ * Represents the complete structure of OpenAPI array schemas as processed by the SKMTC
+ * pipeline. This type includes all standard OpenAPI array schema properties including
+ * item type specifications, length constraints, uniqueness requirements, and metadata
+ * fields. It's used throughout the array processing pipeline for type-safe handling
+ * of array schema definitions.
+ *
+ * ## Usage in SKMTC Pipeline
+ *
+ * This type is used by:
+ * - Schema parsers to validate incoming array schema data
+ * - Array processors to transform OpenAPI schemas into OAS objects
+ * - Code generators to access array constraints and generate validation code
+ * - Type generators to create appropriate array type definitions
+ *
+ * @example Basic string array schema
+ * ```typescript
+ * import type { OasArrayData } from '@skmtc/core/oas/array';
+ *
+ * const tagListSchema: OasArrayData = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'string',
+ *     minLength: 1,
+ *     maxLength: 50
+ *   },
+ *   title: 'Tag List',
+ *   description: 'Collection of tags for categorization',
+ *   minItems: 0,
+ *   maxItems: 20,
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ * ```
+ *
+ * @example Array of referenced objects
+ * ```typescript
+ * const userListSchema: OasArrayData = {
+ *   type: 'array',
+ *   items: {
+ *     $ref: '#/components/schemas/User'
+ *   },
+ *   title: 'User Collection',
+ *   description: 'List of user objects',
+ *   minItems: 1,
+ *   default: []
+ * };
+ * ```
+ *
+ * @example Complex nested array schema
+ * ```typescript
+ * const matrixSchema: OasArrayData = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'array',
+ *     items: {
+ *       type: 'number'
+ *     },
+ *     minItems: 3,
+ *     maxItems: 3
+ *   },
+ *   title: '3x3 Matrix',
+ *   description: 'Two-dimensional number array representing a 3x3 matrix',
+ *   minItems: 3,
+ *   maxItems: 3
+ * };
+ * ```
+ *
+ * @example Enum array with constraints
+ * ```typescript
+ * const statusListSchema: OasArrayData = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'string',
+ *     enum: ['active', 'inactive', 'pending']
+ *   },
+ *   title: 'Status List',
+ *   description: 'Multiple status values',
+ *   uniqueItems: true,
+ *   enums: [
+ *     ['active'],
+ *     ['active', 'pending'],
+ *     ['inactive', 'pending']
+ *   ]
+ * };
+ * ```
  */
 export type OasArrayData = {
     /** Type identifier (always 'array') */
     type: 'array';
-    /** Schema definition for array items */
+    /** Schema definition for array items (can be direct schema or reference) */
     items: OasSchemaData | OasSchemaRefData;
-    /** Human-readable title for the array */
+    /** Human-readable title for the array schema */
     title?: string;
-    /** Detailed description of the array's purpose */
+    /** Detailed description explaining the array's purpose and contents */
     description?: string;
-    /** Default value for the array */
+    /** Default value used when no explicit array is provided */
     default?: unknown[];
-    /** Maximum number of items allowed */
+    /** Maximum number of items allowed in the array */
     maxItems?: number;
-    /** Minimum number of items required */
+    /** Minimum number of items required in the array */
     minItems?: number;
-    /** Whether all items must be unique */
+    /** Whether all items in the array must be unique */
     uniqueItems?: boolean;
-    /** Array of valid enumeration values */
+    /** Array of valid enumeration values for the entire array */
     enums?: unknown[];
 };
 /**
  * Array schema data without the items property.
  *
- * Represents an array schema with all properties except the items definition.
- * Used during parsing phases where item schemas are processed separately.
+ * Represents an array schema with all standard properties except the items definition.
+ * This type is used during parsing phases where item schemas are processed separately
+ * from array constraints, enabling more flexible processing pipelines and better
+ * separation of concerns in complex schema transformation operations.
+ *
+ * ## Common Use Cases
+ *
+ * - **Two-phase parsing**: Validate array structure first, then process items
+ * - **Schema merging**: Combine array constraints from multiple sources
+ * - **Constraint extraction**: Extract array rules for validation generation
+ * - **Reference resolution**: Process items after resolving schema references
+ *
+ * @example Array constraints for validation
+ * ```typescript
+ * import type { OasArrayDataWithoutItems } from '@skmtc/core/oas/array';
+ *
+ * const constraintsSchema: OasArrayDataWithoutItems = {
+ *   type: 'array',
+ *   title: 'Validation Rules',
+ *   description: 'Array with length and uniqueness constraints',
+ *   minItems: 1,
+ *   maxItems: 100,
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ * ```
+ *
+ * @example Enum constraints without item types
+ * ```typescript
+ * const enumArrayConstraints: OasArrayDataWithoutItems = {
+ *   type: 'array',
+ *   title: 'Option Groups',
+ *   description: 'Predefined option combinations',
+ *   enums: [
+ *     ['option1', 'option2'],
+ *     ['option3', 'option4'],
+ *     ['option1', 'option3', 'option4']
+ *   ],
+ *   uniqueItems: true
+ * };
+ * ```
  */
 export type OasArrayDataWithoutItems = {
     /** Type identifier (always 'array') */
     type: 'array';
-    /** Human-readable title for the array */
+    /** Human-readable title for the array schema */
     title?: string;
-    /** Detailed description of the array's purpose */
+    /** Detailed description explaining the array's purpose and contents */
     description?: string;
-    /** Default value for the array */
+    /** Default value used when no explicit array is provided */
     default?: unknown[];
-    /** Maximum number of items allowed */
+    /** Maximum number of items allowed in the array */
     maxItems?: number;
-    /** Minimum number of items required */
+    /** Minimum number of items required in the array */
     minItems?: number;
-    /** Whether all items must be unique */
+    /** Whether all items in the array must be unique */
     uniqueItems?: boolean;
-    /** Array of valid enumeration values */
+    /** Array of valid enumeration values for the entire array */
     enums?: unknown[];
 };
 //# sourceMappingURL=array-types.d.ts.map

package/esm/oas/array/array-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-types.d.ts","sourceRoot":"","sources":["../../../src/oas/array/array-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,qBAAqB,CAAA;AAE7E;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAUrD,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAS7E,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,wCAAwC;IACxC,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACvC,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,kCAAkC;IAClC,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,wCAAwC;IACxC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,kCAAkC;IAClC,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,wCAAwC;IACxC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA"}
+{"version":3,"file":"array-types.d.ts","sourceRoot":"","sources":["../../../src/oas/array/array-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,qBAAqB,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAUrD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAS7E,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,4EAA4E;IAC5E,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACvC,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA"}

package/esm/oas/array/array-types.js

@@ -4,9 +4,64 @@ import { oasSchemaRefData } from '../ref/ref-types.js';
 /**
  * Valibot schema for validating OpenAPI array data objects.
  *
- * Validates array schemas including item type definitions, length constraints,
- * uniqueness requirements, and enumeration values. Uses lazy evaluation
- * to handle recursive schema references.
+ * This comprehensive schema validates OpenAPI array schemas according to the OpenAPI v3
+ * specification, including item type definitions, length constraints, uniqueness requirements,
+ * and enumeration values. It uses lazy evaluation to handle recursive schema references,
+ * allowing for complex nested array structures and self-referential schemas.
+ *
+ * The schema supports both direct schema definitions and reference objects for the items
+ * property, enabling flexible array type definitions that can reference other schemas
+ * in the document or define inline item types.
+ *
+ * @example Validating a simple array schema
+ * ```typescript
+ * import { oasArrayData } from '@skmtc/core/oas/array';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'string'
+ *   },
+ *   description: 'List of user names',
+ *   minItems: 1,
+ *   maxItems: 100
+ * };
+ *
+ * const validated = v.parse(oasArrayData, schema);
+ * console.log(validated.minItems); // 1
+ * ```
+ *
+ * @example Validating array with reference items
+ * ```typescript
+ * const refArraySchema = {
+ *   type: 'array',
+ *   items: {
+ *     $ref: '#/components/schemas/User'
+ *   },
+ *   title: 'User List',
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ *
+ * const result = v.parse(oasArrayData, refArraySchema);
+ * console.log(result.uniqueItems); // true
+ * ```
+ *
+ * @example Validating constrained arrays
+ * ```typescript
+ * const constrainedArray = {
+ *   type: 'array',
+ *   items: { type: 'number' },
+ *   minItems: 2,
+ *   maxItems: 10,
+ *   uniqueItems: true,
+ *   enums: [[1, 2, 3], [4, 5, 6]]
+ * };
+ *
+ * const validated = v.parse(oasArrayData, constrainedArray);
+ * console.log(validated.maxItems); // 10
+ * ```
  */
 export const oasArrayData = v.object({
     type: v.literal('array'),
@@ -22,8 +77,45 @@ export const oasArrayData = v.object({
 /**
  * Valibot schema for array data without the items property.
  *
- * Used for parsing array schemas when the items property is handled separately,
- * typically during schema transformation and validation processes.
+ * This specialized schema validates array schemas when the items property is processed
+ * separately from the main array constraints. It's commonly used during schema parsing
+ * and transformation processes where items need special handling, such as when resolving
+ * references or applying schema merging operations.
+ *
+ * This pattern is useful in multi-phase parsing where array constraints (like min/max
+ * items, uniqueness) are validated independently from the item type definitions,
+ * allowing for more flexible processing pipelines.
+ *
+ * @example Validating array constraints without items
+ * ```typescript
+ * import { oasArrayDataWithoutItems } from '@skmtc/core/oas/array';
+ * import * as v from 'valibot';
+ *
+ * const constraintsOnly = {
+ *   type: 'array',
+ *   title: 'Validation Rules',
+ *   minItems: 1,
+ *   maxItems: 50,
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ *
+ * const validated = v.parse(oasArrayDataWithoutItems, constraintsOnly);
+ * console.log(validated.uniqueItems); // true
+ * ```
+ *
+ * @example Usage in two-phase parsing
+ * ```typescript
+ * function parseArraySchema(schema: unknown) {
+ *   // Phase 1: Validate basic array structure
+ *   const arrayConstraints = v.parse(oasArrayDataWithoutItems, schema);
+ *
+ *   // Phase 2: Process items separately (not shown)
+ *   const items = processItemsSchema((schema as any).items);
+ *
+ *   return { ...arrayConstraints, items };
+ * }
+ * ```
  */
 export const oasArrayDataWithoutItems = v.object({
     type: v.literal('array'),