@skmtc/core 0.0.490 → 0.0.492

package/script/dsl/Identifier.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Identifier = void 0;
+const EntityType_js_1 = require("./EntityType.js");
+class Identifier {
+    constructor({ name, typeName, entityType }) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "entityType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "typeName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = name;
+        this.typeName = typeName;
+        this.entityType = entityType;
+    }
+    static createVariable(name, typeName) {
+        if (typeName) {
+            return new Identifier({
+                name,
+                typeName,
+                entityType: new EntityType_js_1.EntityType('variable')
+            });
+        }
+        return new Identifier({
+            name,
+            entityType: new EntityType_js_1.EntityType('variable')
+        });
+    }
+    static createType(name) {
+        return new Identifier({
+            name,
+            entityType: new EntityType_js_1.EntityType('type')
+        });
+    }
+    toString() {
+        return this.name;
+    }
+}
+exports.Identifier = Identifier;

package/script/dsl/Import.d.ts

@@ -0,0 +1,22 @@
+type ConstructorArgs = {
+    module: string;
+    importNames: ImportNameArg[];
+};
+export declare class Import {
+    module: string;
+    importNames: ImportName[];
+    constructor({ module, importNames }: ConstructorArgs);
+    toRecord(): Record<string, ImportNameArg[]>;
+    toString(): string;
+}
+export type ImportNameArg = string | {
+    [name: string]: string;
+};
+export declare class ImportName {
+    name: string;
+    alias?: string;
+    constructor(name: ImportNameArg);
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=Import.d.ts.map

package/script/dsl/Import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Import.d.ts","sourceRoot":"","sources":["../../src/dsl/Import.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,aAAa,EAAE,CAAA;CAC7B,CAAA;AAED,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,UAAU,EAAE,CAAA;gBAEb,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,eAAe;IAKpD,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC;IAQ3C,QAAQ,IAAI,MAAM;CAKnB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;gBAEF,IAAI,EAAE,aAAa;IAW/B,QAAQ,IAAI,MAAM;CAGnB"}

package/script/dsl/Import.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportName = exports.Import = void 0;
+class Import {
+    constructor({ module, importNames }) {
+        Object.defineProperty(this, "module", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "importNames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.module = module;
+        this.importNames = importNames.map(importName => new ImportName(importName));
+    }
+    toRecord() {
+        return {
+            [this.module]: this.importNames.map(({ name, alias }) => alias ? { [name]: alias } : name)
+        };
+    }
+    toString() {
+        // @TODO move syntax to typescript package to enable
+        // language agnostic use
+        return `import { ${this.importNames.join(', ')} } from '${this.module}'`;
+    }
+}
+exports.Import = Import;
+class ImportName {
+    constructor(name) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "alias", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (typeof name === 'string') {
+            this.name = name;
+        }
+        else {
+            const [n, alias] = Object.entries(name)[0];
+            this.name = n;
+            this.alias = alias;
+        }
+    }
+    toString() {
+        return this.alias ? `${this.name} as ${this.alias}` : this.name;
+    }
+}
+exports.ImportName = ImportName;

package/script/dsl/Inserted.d.ts

@@ -0,0 +1,18 @@
+import type { GeneratedDefinition, GeneratedValue, GenerationType } from '../types/GeneratedValue.js';
+import type { ContentSettings } from './ContentSettings.js';
+import type { Identifier } from './Identifier.js';
+type ConstructorArgs<V extends GeneratedValue, T extends GenerationType> = {
+    settings: ContentSettings;
+    definition: GeneratedDefinition<V, T>;
+};
+export declare class Inserted<V extends GeneratedValue, T extends GenerationType> {
+    settings: ContentSettings;
+    definition: GeneratedDefinition<V, T>;
+    constructor({ settings, definition }: ConstructorArgs<V, T>);
+    toName(): string;
+    toIdentifier(): Identifier;
+    toExportPath(): string;
+    toValue(): T extends 'force' ? V : V | undefined;
+}
+export {};
+//# sourceMappingURL=Inserted.d.ts.map

package/script/dsl/Inserted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Inserted.d.ts","sourceRoot":"","sources":["../../src/dsl/Inserted.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,cAAc,EACf,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,cAAc,IAAI;IACzE,QAAQ,EAAE,eAAe,CAAA;IACzB,UAAU,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CACtC,CAAA;AAED,qBAAa,QAAQ,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,cAAc;IACtE,QAAQ,EAAE,eAAe,CAAA;IACzB,UAAU,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;gBACzB,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;IAK3D,MAAM,IAAI,MAAM;IAIhB,YAAY,IAAI,UAAU;IAI1B,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,CAAC,SAAS,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,SAAS;CAGjD"}

package/script/dsl/Inserted.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inserted = void 0;
+class Inserted {
+    constructor({ settings, definition }) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "definition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+        this.definition = definition;
+    }
+    toName() {
+        return this.settings.identifier.name;
+    }
+    toIdentifier() {
+        return this.settings.identifier;
+    }
+    toExportPath() {
+        return this.settings.exportPath;
+    }
+    toValue() {
+        return this.definition?.value;
+    }
+}
+exports.Inserted = Inserted;

package/script/dsl/Stringable.d.ts

@@ -0,0 +1,4 @@
+export type Stringable = {
+    toString: () => string;
+};
+//# sourceMappingURL=Stringable.d.ts.map

package/script/dsl/Stringable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stringable.d.ts","sourceRoot":"","sources":["../../src/dsl/Stringable.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,MAAM,CAAA;CACvB,CAAA"}

package/script/dsl/Stringable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/dsl/ValueBase.d.ts

@@ -0,0 +1,16 @@
+import type { GenerateContext } from '../context/GenerateContext.js';
+import type { RegisterArgs } from '../context/GenerateContext.js';
+import type { GeneratorKey } from '../types/GeneratorKeys.js';
+type ValueBaseArgs = {
+    context: GenerateContext;
+    generatorKey?: GeneratorKey;
+};
+export declare class ValueBase {
+    context: GenerateContext;
+    skipped: boolean;
+    generatorKey: GeneratorKey | undefined;
+    constructor({ context, generatorKey }: ValueBaseArgs);
+    register(args: RegisterArgs): void;
+}
+export {};
+//# sourceMappingURL=ValueBase.d.ts.map

package/script/dsl/ValueBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueBase.d.ts","sourceRoot":"","sources":["../../src/dsl/ValueBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,eAAe,CAAA;IACxB,YAAY,CAAC,EAAE,YAAY,CAAA;CAC5B,CAAA;AAED,qBAAa,SAAS;IACpB,OAAO,EAAE,eAAe,CAAA;IACxB,OAAO,EAAE,OAAO,CAAQ;IACxB,YAAY,EAAE,YAAY,GAAG,SAAS,CAAA;gBAE1B,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,aAAa;IAOpD,QAAQ,CAAC,IAAI,EAAE,YAAY;CAG5B"}

package/script/dsl/ValueBase.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueBase = void 0;
+class ValueBase {
+    constructor({ context, generatorKey }) {
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "skipped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "generatorKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = context;
+        this.generatorKey = generatorKey;
+        return new Proxy(this, proxyHandler);
+    }
+    register(args) {
+        this.context.register(args);
+    }
+}
+exports.ValueBase = ValueBase;
+const proxyHandler = {
+    get: (target, propertyName) => {
+        return propertyName === 'toString'
+            ? new Proxy(target[propertyName], {
+                apply: (toString, thisArg) => {
+                    if (target.generatorKey) {
+                        target.context.callback(target.generatorKey);
+                    }
+                    return toString.apply(thisArg);
+                }
+            })
+            : target[propertyName];
+    }
+};

package/script/dsl/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const EMPTY = "__EMPTY__";
+//# sourceMappingURL=constants.d.ts.map

package/script/dsl/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/dsl/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,cAAc,CAAA"}

package/script/dsl/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY = void 0;
+exports.EMPTY = '__EMPTY__';

package/script/dsl/model/ModelBase.d.ts

@@ -0,0 +1,23 @@
+import type { GenerateContext, RegisterArgs } from '../../context/GenerateContext.js';
+import type { GeneratedValue } from '../../types/GeneratedValue.js';
+import type { GeneratorKey } from '../../types/GeneratorKeys.js';
+import type { RefName } from '../../types/RefName.js';
+import type { ContentSettings } from '../ContentSettings.js';
+import type { ModelInsertable } from './ModelInsertable.js';
+import { ValueBase } from '../ValueBase.js';
+import type { Inserted } from '../Inserted.js';
+export type ModelBaseArgs = {
+    context: GenerateContext;
+    settings: ContentSettings;
+    generatorKey: GeneratorKey;
+    refName: RefName;
+};
+export declare class ModelBase extends ValueBase {
+    settings: ContentSettings;
+    refName: RefName;
+    generatorKey: GeneratorKey;
+    constructor({ context, settings, generatorKey, refName }: ModelBaseArgs);
+    insertModel<V extends GeneratedValue, EnrichmentType>(insertable: ModelInsertable<V, EnrichmentType>, refName: RefName): Inserted<V, 'force'>;
+    register(args: Omit<RegisterArgs, 'destinationPath'>): void;
+}
+//# sourceMappingURL=ModelBase.d.ts.map

package/script/dsl/model/ModelBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/ModelBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACrF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,eAAe,CAAA;IACxB,QAAQ,EAAE,eAAe,CAAA;IACzB,YAAY,EAAE,YAAY,CAAA;IAC1B,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,qBAAa,SAAU,SAAQ,SAAS;IACtC,QAAQ,EAAE,eAAe,CAAA;IACzB,OAAO,EAAE,OAAO,CAAA;IAEP,YAAY,EAAE,YAAY,CAAA;gBACvB,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,aAAa;IAQvE,WAAW,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,EAClD,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,EAC9C,OAAO,EAAE,OAAO,GACf,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IASd,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,iBAAiB,CAAC,GAAG,IAAI;CAMrE"}

package/script/dsl/model/ModelBase.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelBase = void 0;
+const ValueBase_js_1 = require("../ValueBase.js");
+class ModelBase extends ValueBase_js_1.ValueBase {
+    constructor({ context, settings, generatorKey, refName }) {
+        super({ context });
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "refName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "generatorKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.generatorKey = generatorKey;
+        this.refName = refName;
+        this.settings = settings;
+    }
+    insertModel(insertable, refName) {
+        return this.context.insertModel({
+            insertable,
+            refName,
+            generation: 'force',
+            destinationPath: this.settings.exportPath
+        });
+    }
+    register(args) {
+        this.context.register({
+            ...args,
+            destinationPath: this.settings.exportPath
+        });
+    }
+}
+exports.ModelBase = ModelBase;

package/script/dsl/model/ModelDriver.d.ts

@@ -0,0 +1,27 @@
+import type { ModelInsertable } from './ModelInsertable.js';
+import type { GenerateContext } from '../../context/GenerateContext.js';
+import type { ContentSettings } from '../ContentSettings.js';
+import type { GeneratedDefinition, GenerationType } from '../../types/GeneratedValue.js';
+import type { GeneratedValue } from '../../types/GeneratedValue.js';
+import type { RefName } from '../../types/RefName.js';
+type CreateModelArgs<V extends GeneratedValue, T extends GenerationType, EnrichmentType> = {
+    context: GenerateContext;
+    insertable: ModelInsertable<V, EnrichmentType>;
+    refName: RefName;
+    generation?: T;
+    destinationPath?: string;
+};
+export declare class ModelDriver<V extends GeneratedValue, T extends GenerationType, EnrichmentType> {
+    context: GenerateContext;
+    insertable: ModelInsertable<V, EnrichmentType>;
+    refName: RefName;
+    settings: ContentSettings;
+    destinationPath?: string;
+    definition: GeneratedDefinition<V, T>;
+    constructor({ context, insertable, refName, generation, destinationPath }: CreateModelArgs<V, T, EnrichmentType>);
+    private apply;
+    private getDefinition;
+    private affirmDefinition;
+}
+export {};
+//# sourceMappingURL=ModelDriver.d.ts.map

package/script/dsl/model/ModelDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelDriver.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/ModelDriver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAI5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAGrD,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,cAAc,EAAE,cAAc,IAAI;IACzF,OAAO,EAAE,eAAe,CAAA;IACxB,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,CAAC,EAAE,CAAC,CAAA;IACd,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAWD,qBAAa,WAAW,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,cAAc,EAAE,cAAc;IACzF,OAAO,EAAE,eAAe,CAAA;IACxB,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,eAAe,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;gBACzB,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,UAAU,EACV,eAAe,EAChB,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,cAAc,CAAC;IAWxC,OAAO,CAAC,KAAK;IAsBb,OAAO,CAAC,aAAa;IA+BrB,OAAO,CAAC,gBAAgB;CAqBzB"}

package/script/dsl/model/ModelDriver.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelDriver = void 0;
+const mod_js_1 = require("../../deps/jsr.io/@std/path/1.0.6/mod.js");
+const Definition_js_1 = require("../Definition.js");
+const GeneratorKeys_js_1 = require("../../types/GeneratorKeys.js");
+class ModelDriver {
+    constructor({ context, insertable, refName, generation, destinationPath }) {
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "insertable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "refName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "destinationPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "definition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = context;
+        this.insertable = insertable;
+        this.refName = refName;
+        this.destinationPath = destinationPath;
+        this.settings = this.context.toModelContentSettings({ refName, insertable });
+        this.definition = this.apply({ generation, destinationPath });
+    }
+    apply({ generation, destinationPath } = {}) {
+        const { identifier, exportPath, selected } = this.settings;
+        if (!selected && generation !== 'force') {
+            return undefined;
+        }
+        const definition = this.getDefinition({ identifier, exportPath });
+        if (destinationPath && (0, mod_js_1.normalize)(exportPath) !== (0, mod_js_1.normalize)(destinationPath)) {
+            this.context.register({
+                imports: { [exportPath]: [identifier.name] },
+                destinationPath
+            });
+        }
+        return definition;
+    }
+    getDefinition({ identifier, exportPath }) {
+        const cachedDefinition = this.context.findDefinition({
+            name: identifier.name,
+            exportPath
+        });
+        if (this.affirmDefinition(cachedDefinition, exportPath)) {
+            return cachedDefinition;
+        }
+        const value = new this.insertable({
+            refName: this.refName,
+            context: this.context,
+            settings: this.settings,
+            destinationPath: this.settings.exportPath
+        });
+        const definition = new Definition_js_1.Definition({
+            context: this.context,
+            value,
+            identifier
+        });
+        this.context.register({
+            definitions: [definition],
+            destinationPath: exportPath
+        });
+        return definition;
+    }
+    affirmDefinition(definition, exportPath) {
+        if (!definition) {
+            return false;
+        }
+        const currentKey = (0, GeneratorKeys_js_1.toModelGeneratorKey)({
+            generatorId: this.insertable.id,
+            refName: this.refName
+        });
+        if (currentKey !== definition.generatorKey) {
+            throw new Error(`Registered definition mismatch: '${definition.identifier.name}' in file '${exportPath}'. Cached key '${definition.generatorKey}' does not match new key '${currentKey}'`);
+        }
+        return definition.value instanceof this.insertable;
+    }
+}
+exports.ModelDriver = ModelDriver;

package/script/dsl/model/ModelInsertable.d.ts

@@ -0,0 +1,29 @@
+import type { GenerateContext } from '../../context/GenerateContext.js';
+import type { ContentSettings } from '../ContentSettings.js';
+import type { RefName } from '../../types/RefName.js';
+import type { Identifier } from '../Identifier.js';
+import type { EnrichmentRequest } from '../../types/EnrichmentRequest.js';
+type ModelInsertableConstructorArgs = {
+    context: GenerateContext;
+    refName: RefName;
+    settings: ContentSettings;
+    destinationPath: string;
+};
+export type WithTransformModel = {
+    transformModel: (refName: RefName) => void;
+};
+export type ModelInsertable<V, EnrichmentType> = {
+    prototype: V;
+} & {
+    new ({ context, refName, settings, destinationPath }: ModelInsertableConstructorArgs): V;
+    id: string;
+    type: 'model';
+    _class: 'ModelInsertable';
+    toIdentifier: (refName: RefName) => Identifier;
+    toExportPath: (refName: RefName) => string;
+    toEnrichmentRequest?: (refName: RefName) => EnrichmentRequest<EnrichmentType> | undefined;
+    isSupported: () => boolean;
+    pinnable: boolean;
+} & Function;
+export {};
+//# sourceMappingURL=ModelInsertable.d.ts.map

package/script/dsl/model/ModelInsertable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelInsertable.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/ModelInsertable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,KAAK,8BAA8B,GAAG;IACpC,OAAO,EAAE,eAAe,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,eAAe,CAAA;IACzB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,cAAc,IAAI;IAAE,SAAS,EAAE,CAAC,CAAA;CAAE,GAAG;IAClE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,EAAE,8BAA8B,GAAG,CAAC,CAAA;IACxF,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,OAAO,CAAA;IACb,MAAM,EAAE,iBAAiB,CAAA;IAEzB,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,UAAU,CAAA;IAC9C,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAA;IAC1C,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,iBAAiB,CAAC,cAAc,CAAC,GAAG,SAAS,CAAA;IACzF,WAAW,EAAE,MAAM,OAAO,CAAA;IAE1B,QAAQ,EAAE,OAAO,CAAA;CAGlB,GAAG,QAAQ,CAAA"}

package/script/dsl/model/ModelInsertable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/dsl/model/toModelInsertable.d.ts

@@ -0,0 +1,36 @@
+import type { GenerateContext } from '../../context/GenerateContext.js';
+import type { RefName } from '../../types/RefName.js';
+import type { ContentSettings } from '../ContentSettings.js';
+import type { Identifier } from '../Identifier.js';
+import type { EnrichmentRequest } from '../../types/EnrichmentRequest.js';
+export type ModelInsertableArgs = {
+    context: GenerateContext;
+    settings: ContentSettings;
+    refName: RefName;
+};
+export type ModelConfig<EnrichmentType> = {
+    id: string;
+    toIdentifier: (refName: RefName) => Identifier;
+    toExportPath: (refName: RefName) => string;
+    toEnrichmentRequest?: (refName: RefName) => EnrichmentRequest<EnrichmentType> | undefined;
+};
+export declare const toModelInsertable: <EnrichmentType>(config: ModelConfig<EnrichmentType>) => {
+    new (args: ModelInsertableArgs): {
+        settings: ContentSettings;
+        refName: RefName;
+        generatorKey: import("../../types/GeneratorKeys.js").GeneratorKey;
+        insertModel<V extends import("../../mod.js").GeneratedValue, EnrichmentType_1>(insertable: import("./ModelInsertable.js").ModelInsertable<V, EnrichmentType_1>, refName: RefName): import("../Inserted.js").Inserted<V, "force">;
+        register(args: Omit<import("../../context/GenerateContext.js").RegisterArgs, "destinationPath">): void;
+        context: GenerateContext;
+        skipped: boolean;
+    };
+    id: string;
+    type: "model";
+    _class: "ModelInsertable";
+    toIdentifier: (refName: RefName) => Identifier;
+    toExportPath: (refName: RefName) => string;
+    toEnrichmentRequest: ((refName: RefName) => EnrichmentRequest<EnrichmentType> | undefined) | undefined;
+    isSupported: () => boolean;
+    pinnable: boolean;
+};
+//# sourceMappingURL=toModelInsertable.d.ts.map

package/script/dsl/model/toModelInsertable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toModelInsertable.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/toModelInsertable.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,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AACzE,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,eAAe,CAAA;IACxB,QAAQ,EAAE,eAAe,CAAA;IACzB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,WAAW,CAAC,cAAc,IAAI;IACxC,EAAE,EAAE,MAAM,CAAA;IACV,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,UAAU,CAAA;IAC9C,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAA;IAC1C,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,iBAAiB,CAAC,cAAc,CAAC,GAAG,SAAS,CAAA;CAC1F,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,cAAc,UAAU,WAAW,CAAC,cAAc,CAAC;eAc/D,mBAAmB;;;;;;;;;;;;4BAnBf,OAAO,KAAK,UAAU;4BACtB,OAAO,KAAK,MAAM;oCACV,OAAO,KAAK,iBAAiB,gBAAgB,GAAG,SAAS;;;CA6B1F,CAAA"}

package/script/dsl/model/toModelInsertable.js

@@ -0,0 +1,75 @@
+"use strict";
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toModelInsertable = void 0;
+const GeneratorKeys_js_1 = require("../../types/GeneratorKeys.js");
+const ModelBase_js_1 = require("./ModelBase.js");
+const toModelInsertable = (config) => {
+    var _a;
+    const ModelInsertable = (_a = class extends ModelBase_js_1.ModelBase {
+            constructor(args) {
+                super({
+                    ...args,
+                    generatorKey: (0, GeneratorKeys_js_1.toModelGeneratorKey)({
+                        generatorId: config.id,
+                        refName: args.refName
+                    })
+                });
+            }
+        },
+        __setFunctionName(_a, "ModelInsertable"),
+        Object.defineProperty(_a, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config.id
+        }),
+        Object.defineProperty(_a, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'model'
+        }),
+        Object.defineProperty(_a, "_class", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'ModelInsertable'
+        }),
+        Object.defineProperty(_a, "toIdentifier", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config.toIdentifier.bind(config)
+        }),
+        Object.defineProperty(_a, "toExportPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config.toExportPath.bind(config)
+        }),
+        Object.defineProperty(_a, "toEnrichmentRequest", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config.toEnrichmentRequest?.bind(config)
+        }),
+        Object.defineProperty(_a, "isSupported", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => true
+        }),
+        Object.defineProperty(_a, "pinnable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        }),
+        _a);
+    return ModelInsertable;
+};
+exports.toModelInsertable = toModelInsertable;