@skmtc/core 0.0.983 → 0.16.1

package/script/dsl/operation/gql/GqlOperationDriver.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GqlOperationDriver = void 0;
+const normalize_js_1 = require("../../../deps/jsr.io/@std/path/1.1.4/normalize.js");
+const GeneratorKeys_js_1 = require("../../GeneratorKeys.js");
+const Variant_js_1 = require("../../../types/Variant.js");
+const get_js_1 = __importDefault(require("lodash-es/get.js"));
+/**
+ * Driver for the GraphQL operation insertion lifecycle.
+ *
+ * GraphQL counterpart to {@link OasOperationDriver}: resolves the
+ * projection's identifier and export path, looks up an existing
+ * `Definition` in the target file, instantiates the projection when no
+ * cache hit exists, registers the new definition, and stitches an import
+ * into `destinationPath` if it differs from the projection's `exportPath`.
+ */
+class GqlOperationDriver {
+    constructor({ context, projection, operation, destinationPath, noExport, variant }) {
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "projection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "operation", {
+            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
+        });
+        Object.defineProperty(this, "noExport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "variant", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = context;
+        this.projection = projection;
+        this.operation = operation;
+        this.destinationPath = destinationPath;
+        this.noExport = noExport;
+        this.variant = variant;
+        assertPeerVariantExists({
+            context,
+            generatorId: projection.id,
+            operation,
+            variant
+        });
+        assertPeerSupported({ context, projection, operation });
+        this.settings = this.context.toOperationContentSettings({
+            operation,
+            projection,
+            variant
+        });
+        this.definition = this.apply({ destinationPath });
+    }
+    apply({ destinationPath } = {}) {
+        const { identifier, exportPath } = this.settings;
+        const definition = this.getDefinition({ identifier, exportPath });
+        if (destinationPath && (0, normalize_js_1.normalize)(exportPath) !== (0, normalize_js_1.normalize)(destinationPath)) {
+            // Cross-file import of the peer's identifier from its export path.
+            // The language builds the import object (`toImport`) and creates the
+            // destination file on first write (caller-side); the engine stores
+            // via the pure-data `context.register`. The import lands in the
+            // caller's file (`destinationPath`); `insertOperation` only composes
+            // same-language generators, so the peer's `lang` is the caller's.
+            this.ensureFile(destinationPath);
+            this.context.register({
+                imports: [this.projection.lang.toImport({ identifier, module: exportPath })],
+                destinationPath
+            });
+        }
+        return definition;
+    }
+    /**
+     * Ensure the file at `path` exists, creating it on first write through
+     * the projection's language — the static read off the projection class
+     * at the use site, never persisted (works pre-construction on the
+     * cache-hit path). Returns the normalized path.
+     */
+    ensureFile(path) {
+        const normalizedPath = (0, normalize_js_1.normalize)(path);
+        if (!this.context.getFile(normalizedPath)) {
+            this.context.addFile(this.projection.lang.createFile({ path: normalizedPath, settings: this.context.settings }));
+        }
+        return normalizedPath;
+    }
+    getDefinition({ identifier, exportPath }) {
+        const cachedDefinition = this.context.findDefinition({
+            name: identifier.name,
+            exportPath
+        });
+        if (this.affirmDefinition(cachedDefinition, exportPath)) {
+            return cachedDefinition;
+        }
+        const value = new this.projection({
+            context: this.context,
+            operation: this.operation,
+            settings: this.settings
+        });
+        const definition = this.projection.lang.toDefinition({
+            context: this.context,
+            identifier,
+            value,
+            noExport: this.noExport
+        });
+        this.ensureFile(exportPath);
+        this.context.register({
+            definitions: [definition],
+            destinationPath: exportPath
+        });
+        return definition;
+    }
+    affirmDefinition(definition, exportPath) {
+        if (!definition) {
+            return false;
+        }
+        const currentKey = (0, GeneratorKeys_js_1.toGqlOperationGeneratorKey)({
+            generatorId: this.projection.id,
+            operation: this.operation,
+            variant: this.settings.variant
+        });
+        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.projection;
+    }
+}
+exports.GqlOperationDriver = GqlOperationDriver;
+/**
+ * GraphQL counterpart to the OAS-side {@link assertPeerVariantExists}.
+ * Same invariant: `'main'` is universally safe; any other variant
+ * must be declared in the peer's enrichment block at
+ * `[generatorId][rootKind][fieldName]`. See the OAS implementation
+ * for the full rationale.
+ */
+const assertPeerVariantExists = ({ context, generatorId, operation, variant }) => {
+    if (variant === Variant_js_1.DEFAULT_VARIANT) {
+        return;
+    }
+    const opEnrichments = (0, get_js_1.default)(context.settings, ['enrichments', generatorId, operation.rootKind, operation.fieldName]);
+    const operationLabel = `${operation.rootKind} ${operation.fieldName}`;
+    if (opEnrichments === null || opEnrichments === undefined) {
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for '${operationLabel}' — ` +
+            `peer has no enrichments configured. Only '${Variant_js_1.DEFAULT_VARIANT}' is permitted.`);
+    }
+    if (typeof opEnrichments !== 'object' || Array.isArray(opEnrichments)) {
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for '${operationLabel}' — ` +
+            `peer enrichment is not a variant record.`);
+    }
+    if (!(variant in opEnrichments)) {
+        const available = Object.keys(opEnrichments).join(', ');
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for '${operationLabel}'. ` +
+            `Available variants: ${available}.`);
+    }
+};
+/**
+ * GraphQL counterpart to the OAS-side {@link assertPeerSupported}.
+ *
+ * Same invariant: cross-generator `insertOperation` bypasses
+ * `skip` / `include` (dependency edges are filter-blind) but must
+ * still honour `isSupported` — a peer cannot produce a valid
+ * Definition for an operation it has declared unsupported. The Driver
+ * throws so the calling generator's item is recorded as `error` by
+ * `GenerateContext`'s per-item `try/catch`. A peer with no static
+ * `isSupported` is treated as supporting every operation.
+ */
+const assertPeerSupported = ({ context, projection, operation }) => {
+    if (typeof projection.isSupported !== 'function') {
+        return;
+    }
+    if (!projection.isSupported({ operation, context })) {
+        const operationLabel = `${operation.rootKind} ${operation.fieldName}`;
+        throw new Error(`[${projection.id}] Cannot insert '${operationLabel}' — peer generator ` +
+            `does not support this operation (isSupported returned false).`);
+    }
+};

package/script/dsl/operation/gql/toGqlOperationEntry.d.ts

@@ -0,0 +1,44 @@
+import * as v from 'valibot';
+import type { GqlOperation } from '../../../gql/operation/GqlOperation.js';
+import type { EnrichmentRequest } from '../../../types/EnrichmentRequest.js';
+import type { IsSupportedGqlOperationArgs, ToGqlOperationPreviewModuleArgs, ToGqlOperationMappingArgs, TransformGqlOperationArgs, IsSupportedGqlOperationConfigArgs } from './types.js';
+import type { MappingModule, PreviewModule } from '../../../types/Preview.js';
+/**
+ * Configuration arguments for creating GraphQL operation generator entries.
+ *
+ * Defines the structure for operation generator configuration including transform
+ * functions, enrichment schemas, preview/mapping modules, and support validation.
+ *
+ * @template EnrichmentType - Type of enrichment data this operation can provide
+ */
+export type ToGqlOperationConfigArgs<EnrichmentType = undefined> = {
+    id: string;
+    transform: ({ context, operation, variant }: TransformGqlOperationArgs) => void;
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
+    isSupported?: ({ context, operation }: IsSupportedGqlOperationConfigArgs<EnrichmentType>) => boolean;
+    toPreviewModule?: ({ context, operation }: ToGqlOperationPreviewModuleArgs) => PreviewModule;
+    toMappingModule?: ({ context, operation }: ToGqlOperationMappingArgs) => MappingModule;
+    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(operation: GqlOperation) => EnrichmentRequest<RequestedEnrichment> | undefined;
+};
+/**
+ * Creates a configured GraphQL operation generator entry.
+ *
+ * Transforms operation configuration arguments into a standardized operation generator
+ * entry that can be used within the SKMTC generation pipeline. Provides type-safe
+ * GraphQL-operation processing with optional enrichment support and preview capabilities.
+ *
+ * @template EnrichmentType - Type of enrichment data this operation provides
+ * @param config - Configuration object defining operation behavior
+ * @returns Configured operation generator entry ready for pipeline integration
+ */
+export declare const toGqlOperationEntry: <EnrichmentType = undefined>({ id, transform, toEnrichmentSchema, isSupported, toPreviewModule, toMappingModule, toEnrichmentRequest }: ToGqlOperationConfigArgs<EnrichmentType>) => {
+    id: string;
+    type: "gqlOperation";
+    transform: ({ context, operation, variant }: TransformGqlOperationArgs) => void;
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
+    isSupported: ({ context, operation }: IsSupportedGqlOperationArgs) => boolean;
+    toPreviewModule?: ({ context, operation }: ToGqlOperationPreviewModuleArgs) => PreviewModule;
+    toMappingModule?: ({ context, operation }: ToGqlOperationMappingArgs) => MappingModule;
+    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(operation: GqlOperation) => EnrichmentRequest<RequestedEnrichment> | undefined;
+};
+//# sourceMappingURL=toGqlOperationEntry.d.ts.map

package/script/dsl/operation/gql/toGqlOperationEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toGqlOperationEntry.d.ts","sourceRoot":"","sources":["../../../../src/dsl/operation/gql/toGqlOperationEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAC5E,OAAO,KAAK,EACV,2BAA2B,EAC3B,+BAA+B,EAC/B,yBAAyB,EACzB,yBAAyB,EACzB,iCAAiC,EAClC,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAI7E;;;;;;;GAOG;AACH,MAAM,MAAM,wBAAwB,CAAC,cAAc,GAAG,SAAS,IAAI;IACjE,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,yBAAyB,KAAK,IAAI,CAAA;IAC/E,kBAAkB,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IACzD,WAAW,CAAC,EAAE,CAAC,EACb,OAAO,EACP,SAAS,EACV,EAAE,iCAAiC,CAAC,cAAc,CAAC,KAAK,OAAO,CAAA;IAChE,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,+BAA+B,KAAK,aAAa,CAAA;IAC5F,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,yBAAyB,KAAK,aAAa,CAAA;IACtF,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,SAAS,EAAE,YAAY,KACpB,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;CACxD,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,cAAc,GAAG,SAAS,EAAE,2GAQ7D,wBAAwB,CAAC,cAAc,CAAC,KAAG;IAC5C,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,cAAc,CAAA;IACpB,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,yBAAyB,KAAK,IAAI,CAAA;IAC/E,kBAAkB,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IACzD,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,2BAA2B,KAAK,OAAO,CAAA;IAC7E,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,+BAA+B,KAAK,aAAa,CAAA;IAC5F,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,yBAAyB,KAAK,aAAa,CAAA;IACtF,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,SAAS,EAAE,YAAY,KACpB,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;CAoCxD,CAAA"}

package/script/dsl/operation/gql/toGqlOperationEntry.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGqlOperationEntry = void 0;
+const v = __importStar(require("valibot"));
+const Enrichments_js_1 = require("../../../types/Enrichments.js");
+const get_js_1 = __importDefault(require("lodash-es/get.js"));
+/**
+ * Creates a configured GraphQL operation generator entry.
+ *
+ * Transforms operation configuration arguments into a standardized operation generator
+ * entry that can be used within the SKMTC generation pipeline. Provides type-safe
+ * GraphQL-operation processing with optional enrichment support and preview capabilities.
+ *
+ * @template EnrichmentType - Type of enrichment data this operation provides
+ * @param config - Configuration object defining operation behavior
+ * @returns Configured operation generator entry ready for pipeline integration
+ */
+const toGqlOperationEntry = ({ id, transform, toEnrichmentSchema, isSupported, toPreviewModule, toMappingModule, toEnrichmentRequest }) => {
+    return {
+        id,
+        type: 'gqlOperation',
+        transform,
+        toEnrichmentSchema,
+        isSupported: ({ context, operation, variant }) => {
+            if (!isSupported) {
+                return true;
+            }
+            // Assemble the `{ subject, generator, stack }` enrichment umbrella and
+            // parse it cast-free — see the OAS-side shim for the rationale. Subject
+            // is variant-scoped (`[id][rootKind][fieldName][variant]`); generator
+            // and stack are run-constants.
+            const raw = {
+                subject: (0, get_js_1.default)(context.settings, ['enrichments', id, operation.rootKind, operation.fieldName, variant]),
+                generator: (0, get_js_1.default)(context.settings, ['enrichments', id, Enrichments_js_1.GENERATOR_ENRICHMENT_KEY]),
+                stack: (0, get_js_1.default)(context.settings, ['enrichments', Enrichments_js_1.STACK_ENRICHMENT_KEY])
+            };
+            return isSupported({
+                context,
+                operation,
+                enrichments: v.parse(toEnrichmentSchema(), raw),
+                variant
+            });
+        },
+        toPreviewModule,
+        toMappingModule,
+        toEnrichmentRequest
+    };
+};
+exports.toGqlOperationEntry = toGqlOperationEntry;

package/script/dsl/operation/gql/toGqlOperationProjectionBase.d.ts

@@ -0,0 +1,128 @@
+import type { GenerateContextType } from '../../../context/generateTypes.js';
+import type { InsertOperationOptions, InsertModelOptions, InsertNormalizedModelArgs, InsertNormalizedModelReturn } from '../../../context/generateTypes.js';
+import type { GqlOperation } from '../../../gql/operation/GqlOperation.js';
+import type { ContentSettings } from '../../ContentSettings.js';
+import type { Lang, LangSnippetConstructor } from '../../Lang.js';
+import type { IdentifierType } from '../../IdentifierType.js';
+import type { GeneratedValue } from '../../GeneratedValue.js';
+import type { Inserted } from '../../Inserted.js';
+import type { ModelProjection } from '../../model/types.js';
+import type { RefName } from '../../../types/RefName.js';
+import type { OasSchema } from '../../../oas/schema/Schema.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { OasVoid } from '../../../oas/void/Void.js';
+import type { GqlOperationProjection, GqlOperationProjectionConstructorArgs, ToGqlOperationIdentifierNameArgs, ToGqlOperationExportPathArgs } from './types.js';
+import * as v from 'valibot';
+/**
+ * Configuration for {@link toGqlOperationProjectionBase}.
+ *
+ * Generic over the language `L`: a language veneer parameterizes this config
+ * (`GqlOperationProjectionBaseConfig<E, KtLang>`) so `toIdentifierType`'s
+ * return tightens to that language's `IdentifierType<L>` — no recast.
+ */
+export type GqlOperationProjectionBaseConfig<EnrichmentType = undefined, L extends Lang = Lang> = {
+    id: string;
+    /** Pure: the cache-key name (the cache-check path runs this). */
+    toIdentifierName: (args: ToGqlOperationIdentifierNameArgs<EnrichmentType>) => string;
+    /**
+     * Context-aware, overridable: the non-`name` parts of the identifier,
+     * derived from the operation/schema. Runs only on cache-miss. Returns this
+     * language's `IdentifierType<L>` (the loose `kind: string` when `L = Lang`);
+     * the tightening rides the type argument, replacing the old veneer recast.
+     */
+    toIdentifierType: (operation: GqlOperation, context: GenerateContextType) => IdentifierType<L>;
+    toExportPath: (args: ToGqlOperationExportPathArgs<EnrichmentType>) => string;
+    /**
+     * Required composite schema for the `{ subject, generator, stack }`
+     * enrichment umbrella. Required (not optional) is load-bearing: it is what
+     * lets `static toEnrichments` parse cast-free. A no-enrichment generator
+     * passes `emptyEnrichmentSchema`.
+     */
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
+    /**
+     * Family-level applicability predicate. Becomes a static `isSupported`
+     * on the returned base class so other projections can probe it via the
+     * operation-reference protocol. When omitted, advertises support for
+     * every operation.
+     */
+    isSupported?: (args: {
+        operation: GqlOperation;
+        context: GenerateContextType;
+    }) => boolean;
+};
+type ToEnrichmentsArgs = {
+    operation: GqlOperation;
+    context: GenerateContextType;
+    /** Operation variant whose enrichment should be resolved (see {@link Variant}) */
+    variant: string;
+};
+/**
+ * Build a GraphQL operation projection base class from a per-generator
+ * config.
+ *
+ * The returned class extends `base` — the generator's language
+ * snippet base — so the projection hierarchy is language-bound at its root
+ * while core stays language-blind (the base arrives as an opaque
+ * constructor; core never names a concrete language class). The class
+ * exposes the generator's `id`, `toIdentifierName`, `toIdentifierType`,
+ * `toExportPath`, `toEnrichments`, and `isSupported` statics, inherits the
+ * static `lang`
+ * from the base, and injects `generatorKey` so subclasses don't have to.
+ *
+ * Defines NO `register` / `registerInto` — register ergonomics are typed by
+ * each language's concise vocabulary, which core can't name, so they live
+ * in the language package's projection-base veneer over this factory.
+ *
+ * The projection machinery previously hosted on
+ * `GqlOperationProjectionBase` lives here now, because the base class is no
+ * longer statically known.
+ */
+export declare const toGqlOperationProjectionBase: <EnrichmentType = undefined, L extends Lang = Lang>(base: LangSnippetConstructor<L>, config: GqlOperationProjectionBaseConfig<EnrichmentType, L>) => {
+    new (args: GqlOperationProjectionConstructorArgs<EnrichmentType>): {
+        settings: ContentSettings<EnrichmentType>;
+        operation: GqlOperation;
+        /**
+         * Insert a related operation. The inserted operation is exported to this
+         * projection's own `exportPath` unless `noExport` is set.
+         *
+         * Pass `{ variant }` to target a specific variant on the peer (e.g.
+         * to thread `this.settings.variant` into a within-package sibling
+         * Projection that's also variants-aware). Omitting it defaults to
+         * the peer's `'main'` variant — the safe choice for variants-unaware
+         * peers and the standard pattern for cross-package composition.
+         */
+        insertOperation<V extends GeneratedValue, PeerEnrichmentType = undefined>(projection: GqlOperationProjection<V, PeerEnrichmentType>, operation: GqlOperation, options?: Pick<InsertOperationOptions, "noExport" | "variant">): Inserted<V, PeerEnrichmentType>;
+        /**
+         * Insert a related model into this projection's export file.
+         *
+         * Pass `{ variant }` to target a specific variant on the peer model
+         * projection. Omitting it defaults to the peer's `'main'` variant.
+         */
+        insertModel<V extends GeneratedValue, PeerEnrichmentType_1 = undefined>(projection: ModelProjection<V, PeerEnrichmentType_1>, refName: RefName, options?: Pick<InsertModelOptions, "noExport" | "variant">): Inserted<V, PeerEnrichmentType_1>;
+        /**
+         * Insert a related model with reference normalization. Useful for
+         * schemas that may be either a `$ref` or a concrete object.
+         *
+         * `{ variant }` flows through the `$ref` branch only; for inline
+         * schemas, bake the variant into `fallbackName`.
+         */
+        insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<"schema"> | OasVoid, PeerEnrichmentType_2 = undefined>(projection: ModelProjection<V, PeerEnrichmentType_2>, { schema, fallbackName }: Omit<InsertNormalizedModelArgs<Schema>, "destinationPath">, options?: Pick<InsertModelOptions, "noExport" | "variant">): InsertNormalizedModelReturn<V, Schema>;
+        context: GenerateContextType;
+        skipped: boolean;
+        generatorKey: import("../../GeneratorKeys.js").GeneratorKey | undefined;
+        stackTrail: import("../../../mod.js").StackTrail;
+    };
+    id: string;
+    type: "gqlOperation";
+    toIdentifierName: (args: ToGqlOperationIdentifierNameArgs<EnrichmentType>) => string;
+    toIdentifierType: (operation: GqlOperation, context: GenerateContextType) => IdentifierType<L>;
+    toExportPath: (args: ToGqlOperationExportPathArgs<EnrichmentType>) => string;
+    isSupported: (args: {
+        operation: GqlOperation;
+        context: GenerateContextType;
+    }) => boolean;
+    toEnrichments: ({ operation, context, variant }: ToEnrichmentsArgs) => EnrichmentType;
+    lang: L;
+};
+export {};
+//# sourceMappingURL=toGqlOperationProjectionBase.d.ts.map

package/script/dsl/operation/gql/toGqlOperationProjectionBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toGqlOperationProjectionBase.d.ts","sourceRoot":"","sources":["../../../../src/dsl/operation/gql/toGqlOperationProjectionBase.ts"],"names":[],"mappings":"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"}