@prisma-next/mongo-contract 0.13.0-dev.9 → 0.14.0-dev.1

package/dist/entity-kinds-C9KNr9IE.mjs

@@ -0,0 +1,572 @@
+import { CrossReferenceSchema } from "@prisma-next/contract/types";
+import { type } from "arktype";
+import { IRNodeBase, freezeNode } from "@prisma-next/framework-components/ir";
+//#region src/contract-schema.ts
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+const ScalarFieldTypeSchema = type({
+	"+": "reject",
+	kind: "'scalar'",
+	codecId: "string",
+	"typeParams?": "Record<string, unknown>"
+});
+const ValueObjectFieldTypeSchema = type({
+	"+": "reject",
+	kind: "'valueObject'",
+	name: "string"
+});
+const UnionFieldTypeSchema = type({
+	"+": "reject",
+	kind: "'union'",
+	members: ScalarFieldTypeSchema.or(ValueObjectFieldTypeSchema).array()
+});
+const FieldSchema = type({
+	"+": "reject",
+	type: ScalarFieldTypeSchema.or(ValueObjectFieldTypeSchema).or(UnionFieldTypeSchema),
+	"nullable?": "boolean",
+	"many?": "boolean",
+	"dict?": "boolean"
+}).pipe((field) => ({
+	...field,
+	nullable: field.nullable ?? false
+}));
+const RelationSchema = type({
+	"+": "reject",
+	to: CrossReferenceSchema,
+	cardinality: "'1:1' | '1:N' | 'N:1'",
+	"on?": type({
+		"+": "reject",
+		localFields: "string[]",
+		targetFields: "string[]"
+	})
+});
+const StorageRelationEntrySchema = type({
+	"+": "reject",
+	field: "string"
+});
+const MongoJsonPrimitiveSchema = type.declare().type("string | number | boolean | null");
+function isMongoJsonRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function withUnseenReference(value, seen, visit) {
+	if (seen.has(value)) return false;
+	seen.add(value);
+	const result = visit();
+	seen.delete(value);
+	return result;
+}
+function isMongoJsonObject(value, seen) {
+	return isMongoJsonRecord(value) && withUnseenReference(value, seen, () => Object.values(value).every((entry) => isMongoJsonValue(entry, seen)));
+}
+function isMongoJsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (MongoJsonPrimitiveSchema.allows(value)) return true;
+	if (Array.isArray(value)) return withUnseenReference(value, seen, () => value.every((entry) => isMongoJsonValue(entry, seen)));
+	return isMongoJsonObject(value, seen);
+}
+const MongoJsonValueSchema = type("unknown").narrow((value, ctx) => isMongoJsonValue(value) ? true : ctx.mustBe("a JSON-serializable MongoJsonValue"));
+const MongoJsonObjectSchema = type({ "[string]": "unknown" }).narrow((value, ctx) => isMongoJsonRecord(value) && Object.values(value).every((entry) => MongoJsonValueSchema.allows(entry)) ? true : ctx.mustBe("a JSON object with MongoJsonValue entries"));
+const NumberRecordSchema = type({ "[string]": "number" });
+const IndexFieldsSchema = type({
+	"+": "reject",
+	"[string]": "1 | -1 | \"text\" | \"2dsphere\" | \"2d\" | \"hashed\""
+}).narrow((fields, ctx) => Object.keys(fields).length > 0 ? true : ctx.mustBe("an index field map with at least one entry"));
+const CollationSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-collation-options'",
+	locale: "string",
+	"caseLevel?": "boolean",
+	"caseFirst?": "\"off\" | \"upper\" | \"lower\"",
+	"strength?": "1 | 2 | 3 | 4 | 5",
+	"numericOrdering?": "boolean",
+	"alternate?": "\"non-ignorable\" | \"shifted\"",
+	"maxVariable?": "\"punct\" | \"space\"",
+	"backwards?": "boolean",
+	"normalization?": "boolean"
+});
+const IndexOptionDefaultsSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-index-option-defaults'",
+	"storageEngine?": MongoJsonObjectSchema
+});
+const TimeSeriesCollectionOptionsSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-time-series-collection-options'",
+	timeField: "string",
+	"metaField?": "string",
+	"granularity?": "\"seconds\" | \"minutes\" | \"hours\"",
+	"bucketMaxSpanSeconds?": "number",
+	"bucketRoundingSeconds?": "number"
+});
+const ClusteredCollectionOptionsSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-clustered-collection-options'",
+	"name?": "string",
+	key: type({
+		"+": "reject",
+		"[string]": "1"
+	}).narrow((key, ctx) => Object.keys(key).length > 0 ? true : ctx.mustBe("a clustered index key map with at least one entry")),
+	unique: "boolean"
+});
+const ChangeStreamPreAndPostImagesSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-change-stream-pre-and-post-images-options'",
+	enabled: "boolean"
+});
+type({
+	"+": "reject",
+	"capped?": "boolean",
+	"size?": "number",
+	"max?": "number",
+	"storageEngine?": MongoJsonObjectSchema,
+	"indexOptionDefaults?": IndexOptionDefaultsSchema,
+	"collation?": CollationSchema,
+	"timeseries?": TimeSeriesCollectionOptionsSchema,
+	"clusteredIndex?": ClusteredCollectionOptionsSchema,
+	"expireAfterSeconds?": "number",
+	"changeStreamPreAndPostImages?": ChangeStreamPreAndPostImagesSchema
+});
+const ModelStorageSchema = type({
+	"+": "reject",
+	"collection?": "string",
+	"relations?": type({ "[string]": StorageRelationEntrySchema })
+});
+const DiscriminatorSchema = type({
+	"+": "reject",
+	field: "string"
+});
+const VariantEntrySchema = type({
+	"+": "reject",
+	value: "string"
+});
+const ModelDefinitionSchema = type({
+	"+": "reject",
+	fields: type({ "[string]": FieldSchema }),
+	storage: ModelStorageSchema,
+	"relations?": type({ "[string]": RelationSchema }),
+	"discriminator?": DiscriminatorSchema,
+	"variants?": type({ "[string]": VariantEntrySchema }),
+	"base?": CrossReferenceSchema,
+	"owner?": "string"
+});
+type({
+	"+": "reject",
+	fields: IndexFieldsSchema,
+	"options?": type({
+		"+": "reject",
+		"kind?": "'mongo-index-options'",
+		"unique?": "boolean",
+		"name?": "string",
+		"partialFilterExpression?": MongoJsonObjectSchema,
+		"sparse?": "boolean",
+		"expireAfterSeconds?": "number",
+		"weights?": NumberRecordSchema,
+		"default_language?": "string",
+		"language_override?": "string",
+		"textIndexVersion?": "number",
+		"2dsphereIndexVersion?": "number",
+		"bits?": "number",
+		"min?": "number",
+		"max?": "number",
+		"bucketSize?": "number",
+		"hidden?": "boolean",
+		"collation?": CollationSchema,
+		"wildcardProjection?": type({
+			"+": "reject",
+			"[string]": "0 | 1"
+		})
+	})
+});
+const MongoStorageIndexSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-index'",
+	keys: type({
+		"+": "reject",
+		field: "string",
+		direction: "1 | -1 | \"text\" | \"2dsphere\" | \"2d\" | \"hashed\""
+	}).array().atLeastLength(1),
+	"unique?": "boolean",
+	"sparse?": "boolean",
+	"expireAfterSeconds?": "number",
+	"partialFilterExpression?": "Record<string, unknown>",
+	"wildcardProjection?": "Record<string, 0 | 1>",
+	"collation?": "Record<string, unknown>",
+	"weights?": "Record<string, number>",
+	"default_language?": "string",
+	"language_override?": "string"
+});
+const MongoStorageValidatorSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-validator'",
+	jsonSchema: "Record<string, unknown>",
+	validationLevel: "'strict' | 'moderate'",
+	validationAction: "'error' | 'warn'"
+});
+const MongoCollectionOptionsSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-collection-options'",
+	"capped?": type({
+		"+": "reject",
+		size: "number",
+		"max?": "number"
+	}),
+	"storageEngine?": MongoJsonObjectSchema,
+	"indexOptionDefaults?": IndexOptionDefaultsSchema,
+	"timeseries?": type({
+		"+": "reject",
+		"kind?": "'mongo-time-series-collection-options'",
+		timeField: "string",
+		"metaField?": "string",
+		"granularity?": "'seconds' | 'minutes' | 'hours'",
+		"bucketMaxSpanSeconds?": "number",
+		"bucketRoundingSeconds?": "number"
+	}),
+	"collation?": "Record<string, unknown>",
+	"expireAfterSeconds?": "number",
+	"changeStreamPreAndPostImages?": ChangeStreamPreAndPostImagesSchema,
+	"clusteredIndex?": type({
+		"+": "reject",
+		"name?": "string"
+	})
+});
+const StorageCollectionSchema = type({
+	"+": "reject",
+	"kind?": "'mongo-collection'",
+	"indexes?": MongoStorageIndexSchema.array(),
+	"validator?": MongoStorageValidatorSchema,
+	"options?": MongoCollectionOptionsSchema,
+	"control?": ControlPolicySchema
+});
+function collectionEntrySchema(fragments) {
+	if (fragments === void 0 || fragments.size === 0) return StorageCollectionSchema;
+	return type("unknown").narrow((entry, ctx) => {
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return ctx.mustBe("an object");
+		const kind = entry.kind;
+		if (typeof kind === "string") {
+			const fragment = fragments.get(kind);
+			if (fragment !== void 0) {
+				const parsed = fragment(entry);
+				if (parsed instanceof type.errors) return ctx.reject({ expected: parsed.summary });
+				return true;
+			}
+		}
+		const parsed = StorageCollectionSchema(entry);
+		if (parsed instanceof type.errors) return ctx.reject({ expected: parsed.summary });
+		return true;
+	});
+}
+/**
+* Builds the per-namespace envelope schema for Mongo storage. Pack
+* contributions are keyed by the descriptor's `discriminator` and
+* validate each entry by matching the entry's `kind` field. Mongo today
+* has no pack contributions; the composition surface exists for symmetry
+* with SQL and as the substrate for future entity kinds.
+*
+* `'kind?': 'string'` because `kind` is non-enumerable on built
+* Mongo namespace IR classes and therefore absent from the wire shape; the
+* type-side narrowing is enforced by the IR class, not by this validator.
+*/
+function createMongoNamespaceEnvelopeSchema(fragments) {
+	return type({
+		"+": "reject",
+		id: "string",
+		"kind?": "string",
+		entries: type({ "collection?": type({ "[string]": collectionEntrySchema(fragments) }) })
+	}).narrow((ns, ctx) => {
+		if (typeof ns !== "object" || ns === null || Array.isArray(ns)) return ctx.mustBe("an object");
+		if (Object.hasOwn(ns, "collections") || Object.hasOwn(ns, "tables")) return ctx.reject({ expected: "namespace must use `entries: { collection? }`; flat `collections` / `tables` keys are no longer accepted" });
+		return true;
+	});
+}
+/**
+* Builds the full Mongo contract schema. The per-namespace entry
+* threading happens through {@link createMongoNamespaceEnvelopeSchema};
+* the rest of the envelope is family-shared.
+*/
+function createMongoContractSchema(fragments) {
+	const namespaceEnvelope = createMongoNamespaceEnvelopeSchema(fragments);
+	return type({
+		"+": "reject",
+		targetFamily: "'mongo'",
+		"schemaVersion?": "string",
+		"target?": "string",
+		"storageHash?": "string",
+		"profileHash?": "string",
+		roots: type({ "[string]": CrossReferenceSchema }),
+		"capabilities?": "Record<string, unknown>",
+		"extensionPacks?": "Record<string, unknown>",
+		"meta?": "Record<string, unknown>",
+		"defaultControlPolicy?": ControlPolicySchema,
+		"sources?": "Record<string, unknown>",
+		"_generated?": "Record<string, unknown>",
+		domain: type({ namespaces: type({ "[string]": type({
+			models: type({ "[string]": ModelDefinitionSchema }),
+			"valueObjects?": type({ "[string]": type({
+				"+": "reject",
+				fields: type({ "[string]": FieldSchema })
+			}) })
+		}) }) }),
+		storage: type({
+			"+": "reject",
+			namespaces: type({ "[string]": namespaceEnvelope }),
+			"storageHash?": "string"
+		})
+	});
+}
+const MongoContractSchema = createMongoContractSchema();
+//#endregion
+//#region src/ir/mongo-change-stream-pre-and-post-images-options.ts
+/**
+* Change-stream pre-and-post-images collection option. Lifted from a
+* `type =` data shape to an AST class extending `IRNodeBase` per
+* FR18. Single-field shape; the class exists for AST-pattern
+* consistency (every nested data shape inside `MongoCollectionOptions`
+* is an AST node so the verifier can walk uniformly).
+*/
+var MongoChangeStreamPreAndPostImagesOptions = class extends IRNodeBase {
+	kind = "mongo-change-stream-pre-and-post-images-options";
+	enabled;
+	constructor(options) {
+		super();
+		this.enabled = options.enabled;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/mongo-collation-options.ts
+/**
+* Mongo Contract IR leaf for collection / index collation options.
+*
+* Lifted from a `type =` data shape to an AST class extending
+* `IRNodeBase` per FR18 ("Mongo's Contract IR is fully unified under
+* the AST-class pattern, layered family / target"). Single concrete class
+* (no target subclass): collation options carry no target-specific
+* variation at this layer — both Atlas and self-hosted Mongo consume the
+* same option vocabulary.
+*
+* Undefined optional fields are not assigned, so `JSON.stringify` omits
+* them from the canonical JSON output (matches the pre-lift data shape's
+* round-trip behaviour, modulo the new `kind` discriminator).
+*/
+var MongoCollationOptions = class extends IRNodeBase {
+	kind = "mongo-collation-options";
+	locale;
+	constructor(options) {
+		super();
+		this.locale = options.locale;
+		if (options.caseLevel !== void 0) this.caseLevel = options.caseLevel;
+		if (options.caseFirst !== void 0) this.caseFirst = options.caseFirst;
+		if (options.strength !== void 0) this.strength = options.strength;
+		if (options.numericOrdering !== void 0) this.numericOrdering = options.numericOrdering;
+		if (options.alternate !== void 0) this.alternate = options.alternate;
+		if (options.maxVariable !== void 0) this.maxVariable = options.maxVariable;
+		if (options.backwards !== void 0) this.backwards = options.backwards;
+		if (options.normalization !== void 0) this.normalization = options.normalization;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/mongo-index-option-defaults.ts
+/**
+* Collection-level default index options (the `indexOptionDefaults`
+* collection-creation field on Mongo's `createCollection`). Lifted from
+* a `type =` data shape to an AST class extending `IRNodeBase` per
+* FR18 (Mongo Contract IR fully unified under the AST-class pattern).
+*
+* Carries `storageEngine` only — the underlying MongoDB option set is
+* intentionally narrow at this layer; per-engine richer option vocabularies
+* are out of scope for this project.
+*/
+var MongoIndexOptionDefaults = class extends IRNodeBase {
+	kind = "mongo-index-option-defaults";
+	constructor(options = {}) {
+		super();
+		if (options.storageEngine !== void 0) this.storageEngine = options.storageEngine;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/mongo-time-series-collection-options.ts
+/**
+* Time-series collection options. Lifted from a `type =` data shape to
+* an AST class extending `IRNodeBase` per FR18.
+*
+* MongoDB requires `timeField` for any time-series collection; the
+* constructor enforces presence by type signature (`timeField: string`
+* is required on the input).
+*/
+var MongoTimeSeriesCollectionOptions = class extends IRNodeBase {
+	kind = "mongo-time-series-collection-options";
+	timeField;
+	constructor(options) {
+		super();
+		this.timeField = options.timeField;
+		if (options.metaField !== void 0) this.metaField = options.metaField;
+		if (options.granularity !== void 0) this.granularity = options.granularity;
+		if (options.bucketMaxSpanSeconds !== void 0) this.bucketMaxSpanSeconds = options.bucketMaxSpanSeconds;
+		if (options.bucketRoundingSeconds !== void 0) this.bucketRoundingSeconds = options.bucketRoundingSeconds;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/mongo-collection-options.ts
+/**
+* Mongo Contract IR node for collection-level creation options (the
+* second argument to `db.createCollection(name, options)`). Lifted from
+* the pre-M2R2 `MongoStorageCollectionOptions` storage interface to a
+* class extending `IRNodeBase` per FR18.
+*
+* Single concrete family-layer class (no target subclass). The
+* constructor accepts the storage JSON envelope shape ({@link
+* MongoCollectionOptionsInput}) so the family-base hydration walker
+* can pass arktype-validated objects directly to `new`. Authoring
+* vocabulary is translated to this shape upstream in the contract-ts
+* builder.
+*
+* Nested IR sub-shapes (collation, timeseries, …) are normalised to
+* their respective IR class instances inside the constructor so
+* downstream walks see a uniform AST regardless of whether the input
+* was a JSON literal or an already-constructed class.
+*/
+var MongoCollectionOptions = class extends IRNodeBase {
+	kind = "mongo-collection-options";
+	constructor(input = {}) {
+		super();
+		if (input.capped !== void 0) this.capped = {
+			size: input.capped.size,
+			...input.capped.max != null && { max: input.capped.max }
+		};
+		if (input.storageEngine !== void 0) this.storageEngine = input.storageEngine;
+		if (input.indexOptionDefaults !== void 0) this.indexOptionDefaults = input.indexOptionDefaults instanceof MongoIndexOptionDefaults ? input.indexOptionDefaults : new MongoIndexOptionDefaults(input.indexOptionDefaults);
+		if (input.collation !== void 0) this.collation = input.collation instanceof MongoCollationOptions ? input.collation : new MongoCollationOptions(input.collation);
+		if (input.timeseries !== void 0) this.timeseries = input.timeseries instanceof MongoTimeSeriesCollectionOptions ? input.timeseries : new MongoTimeSeriesCollectionOptions(input.timeseries);
+		if (input.clusteredIndex !== void 0) this.clusteredIndex = input.clusteredIndex.name !== void 0 ? { name: input.clusteredIndex.name } : {};
+		if (input.expireAfterSeconds !== void 0) this.expireAfterSeconds = input.expireAfterSeconds;
+		if (input.changeStreamPreAndPostImages !== void 0) this.changeStreamPreAndPostImages = input.changeStreamPreAndPostImages instanceof MongoChangeStreamPreAndPostImagesOptions ? input.changeStreamPreAndPostImages : new MongoChangeStreamPreAndPostImagesOptions(input.changeStreamPreAndPostImages);
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/mongo-index.ts
+/**
+* Mongo Contract IR node for a single collection index entry (one
+* element of `MongoCollection.indexes`). Lifted from the
+* pre-M2R2 `MongoStorageIndex` storage interface to a class extending
+* `IRNodeBase` per FR18.
+*
+* Single concrete family-layer class (no target subclass). The spec's
+* `MongoTargetIndex extends MongoIndex` pattern remains additive — a
+* future Mongo target with target-specific index extensions is free to
+* subclass; for the single Mongo target shipped today a concrete
+* family-layer class is enough and avoids a target-import layering
+* violation from the contract-ts builder.
+*/
+var MongoIndex = class extends IRNodeBase {
+	kind = "mongo-index";
+	keys;
+	constructor(input) {
+		super();
+		this.keys = input.keys;
+		if (input.unique !== void 0) this.unique = input.unique;
+		if (input.sparse !== void 0) this.sparse = input.sparse;
+		if (input.expireAfterSeconds !== void 0) this.expireAfterSeconds = input.expireAfterSeconds;
+		if (input.partialFilterExpression !== void 0) this.partialFilterExpression = input.partialFilterExpression;
+		if (input.wildcardProjection !== void 0) this.wildcardProjection = input.wildcardProjection;
+		if (input.collation !== void 0) this.collation = input.collation;
+		if (input.weights !== void 0) this.weights = input.weights;
+		if (input.default_language !== void 0) this.default_language = input.default_language;
+		if (input.language_override !== void 0) this.language_override = input.language_override;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/mongo-validator.ts
+/**
+* Mongo Contract IR node for collection-level document validators (the
+* `validator` field on Mongo's `createCollection`). Lifted from the
+* pre-M2R2 `MongoStorageValidator` storage interface to a class extending
+* `IRNodeBase` per FR18.
+*
+* Concrete at the family layer (no target subclass). The spec's
+* abstract-family + target-concrete pattern (`MongoTargetValidator
+* extends MongoValidator`) becomes meaningful when a second Mongo target
+* introduces target-specific validator extensions (Atlas search rules,
+* DocumentDB-specific levels, …); for the single Mongo target shipped
+* today, a concrete family-layer class lets the PSL JSON-Schema deriver
+* and the contract-ts builder construct instances directly without a
+* target-import layering violation. Target subclassing remains additive
+* — a future `MongoTargetValidator extends MongoValidator` is an
+* additive change, not a breaking one.
+*/
+var MongoValidator = class extends IRNodeBase {
+	kind = "mongo-validator";
+	jsonSchema;
+	validationLevel;
+	validationAction;
+	constructor(input) {
+		super();
+		this.jsonSchema = input.jsonSchema;
+		this.validationLevel = input.validationLevel;
+		this.validationAction = input.validationAction;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/mongo-collection.ts
+/**
+* Mongo Contract IR node for a single collection entry in a namespace's
+* `collections` map. Lifted from the pre-M2R2
+* `MongoStorageCollection` storage interface to a class extending
+* `IRNodeBase` per FR18.
+*
+* Concrete at the family layer (no target subclass). The spec's
+* `MongoTargetCollection extends MongoCollection` pattern remains
+* additive: a future Mongo target with target-specific extensions is
+* free to subclass without breaking the family-layer construction
+* sites.
+*
+* The unprefixed name `MongoCollection` is now the contract IR class.
+* Note that `@prisma-next/mongo-orm` also exports a (different)
+* `MongoCollection<TContract, ModelName>` generic for the user-facing
+* ORM query builder; the two live in separate packages and are
+* resolved by import path. A source file that needs both should alias
+* one (e.g. `import { MongoCollection as MongoContractCollection }
+* from '@prisma-next/mongo-contract'`).
+*/
+var MongoCollection = class extends IRNodeBase {
+	kind = "mongo-collection";
+	constructor(input = {}) {
+		super();
+		if (input.indexes !== void 0) this.indexes = input.indexes.map((idx) => idx instanceof MongoIndex ? idx : new MongoIndex(idx));
+		if (input.validator !== void 0) this.validator = input.validator instanceof MongoValidator ? input.validator : new MongoValidator(input.validator);
+		if (input.options !== void 0) this.options = input.options instanceof MongoCollectionOptions ? input.options : new MongoCollectionOptions(input.options);
+		if (input.control !== void 0) this.control = input.control;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/entity-kinds.ts
+const collectionEntityKind = {
+	kind: "collection",
+	schema: StorageCollectionSchema,
+	construct: (input) => new MongoCollection(input)
+};
+/**
+* Assembles the `kind → descriptor` registry for Mongo namespaces: the built-in
+* `collection` kind plus any target `packKinds`. This builds the lookup table —
+* it does not touch contract data. `hydrateNamespaceEntities` later consumes
+* this registry to turn a namespace's raw entries into IR instances. Throws on
+* a duplicate kind.
+*/
+function composeMongoEntityKinds(packKinds = []) {
+	const kinds = new Map([["collection", collectionEntityKind]]);
+	for (const descriptor of packKinds) {
+		if (kinds.has(descriptor.kind)) throw new Error(`composeMongoEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`);
+		kinds.set(descriptor.kind, descriptor);
+	}
+	return kinds;
+}
+//#endregion
+export { MongoIndex as a, MongoIndexOptionDefaults as c, MongoContractSchema as d, createMongoContractSchema as f, MongoValidator as i, MongoCollationOptions as l, composeMongoEntityKinds as n, MongoCollectionOptions as o, createMongoNamespaceEnvelopeSchema as p, MongoCollection as r, MongoTimeSeriesCollectionOptions as s, collectionEntityKind as t, MongoChangeStreamPreAndPostImagesOptions as u };
+
+//# sourceMappingURL=entity-kinds-C9KNr9IE.mjs.map