@prisma/orm-target-mongo 8.0.0-rc.2-dev.2 → 8.0.0-rc.20

package/dist/{control-CxXmTy_h.d.mts → control-CrFS8bqh.d.mts}

@@ -1,20 +1,21 @@
-import { a as MongoRunnerDependencies } from "./control-rPM2HNxW.mjs";
-import { s as OpFactoryCall$1 } from "./op-factory-call-B7EKa4Ri-B2Lb6W68.mjs";
+import { c as RenameCollectionCall, l as RenameFieldCall, s as OpFactoryCall$1, u as UnsetFieldCall } from "./op-factory-call-BoYr7vvM-CjA8nx36.mjs";
+import "@prisma/orm-framework/utils/structured-error";
 import { Namespace, NamespaceBase } from "@prisma/orm-framework/components/ir";
-import { AnyMongoMigrationOperation, MongoAndExpr, MongoExistsExpr, MongoExprFilter, MongoFieldFilter, MongoFilterExpr, MongoFilterVisitor, MongoMigrationPlanOperation, MongoNotExpr, MongoOrExpr } from "@prisma/orm-family-mongo/query-ast/control";
+import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
 import { MongoSchemaIR } from "@prisma/orm-family-mongo/schema-ir";
+import { AnyMongoMigrationOperation, MongoAndExpr, MongoExistsExpr, MongoExprFilter, MongoFieldFilter, MongoFilterExpr, MongoFilterVisitor, MongoNotExpr, MongoOrExpr } from "@prisma/orm-family-mongo/query-ast/control";
 import { MongoControlTargetDescriptor } from "@prisma/orm-family-mongo/family/control";
+import { MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerPerSpaceSuccessValue, MigrationScaffoldContext, OperationContext, PlanOrigin, ResolvedMigrationStatement, SchemaDiffIssue, SchemaVerifyOptions, VerifyDatabaseSchemaResult } from "@prisma/orm-framework/components/control";
 import { Result } from "@prisma/orm-framework/utils/result";
-import { Migration, MigrationMeta } from "@prisma/orm-toolchain/migration-tools/migration";
-import { MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerPerSpaceSuccessValue, MigrationScaffoldContext, OperationContext, SchemaDiffIssue, SchemaVerifyOptions, VerifyDatabaseSchemaResult } from "@prisma/orm-framework/components/control";
-import { ImportSpecifierResolver } from "@prisma/orm-framework/components/emission";
 import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
 import { MongoCollection, MongoCollectionInput, MongoContract, MongoNamespaceEntries, MongoStorage, MongoValueSetInput } from "@prisma/orm-family-mongo/contract";
 import { Contract } from "@prisma/orm-framework/contract/types";
-import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+import { Migration, MigrationMeta } from "@prisma/orm-toolchain/migration-tools/migration";
+import { ImportSpecifierResolver } from "@prisma/orm-framework/components/emission";
+import { MongoRunnerDependencies } from "@prisma/orm-family-mongo/family/control-adapter";
 import { AggregateMigrationEdgeRef } from "@prisma/orm-toolchain/migration-tools/aggregate";
 import { JsonObject } from "@prisma/orm-framework/utils/json";
-//#region ../../../3-mongo-target/1-mongo-target/dist/control.d.mts
+//#region ../../../3-targets/mongo/1-target/dist/control.d.mts
 //#region src/core/mongo-target-contract.d.ts
 /**
  * Mongo target contract envelope: the result of
@@ -30,7 +31,7 @@ type MongoTargetContract = Omit<MongoContract, 'storage'> & {
   readonly storage: MongoStorage;
 };
 //#endregion
-//#region src/core/control-target.d.ts
+//#region src/core/migrations/control-target.d.ts
 /**
  * `migration.ts` default-exports a `Migration` subclass whose `operations`
  * getter returns the ordered list of operations and whose `describe()`
@@ -43,7 +44,7 @@ type MongoTargetContract = Omit<MongoContract, 'storage'> & {
  */
 declare const mongoTargetDescriptor: MongoControlTargetDescriptor<MongoTargetContract>;
 //#endregion
-//#region src/core/filter-evaluator.d.ts
+//#region src/core/migrations/filter-evaluator.d.ts
 declare class FilterEvaluator implements MongoFilterVisitor<boolean> {
   private doc;
   evaluate(filter: MongoFilterExpr, doc: Record<string, unknown>): boolean;
@@ -55,15 +56,31 @@ declare class FilterEvaluator implements MongoFilterVisitor<boolean> {
   expr(_expr: MongoExprFilter): boolean;
 }
 //#endregion
-//#region src/core/mongo-ops-serializer.d.ts
+//#region src/core/migrations/mongo-ops-serializer.d.ts
 declare function deserializeMongoOp(json: unknown): AnyMongoMigrationOperation;
 declare function deserializeMongoOps(json: readonly unknown[]): AnyMongoMigrationOperation[];
 declare function serializeMongoOps(ops: readonly AnyMongoMigrationOperation[]): string;
 //#endregion
-//#region src/core/mongo-planner.d.ts
+//#region src/core/migrations/mongo-statement-planning.d.ts
+/**
+ * The calls statements and removed fields add to a plan, with the schema the diff starts from:
+ * the origin with each renamed collection under its new name, so the diff does not drop and
+ * create it again.
+ */
+interface StatementCalls {
+  readonly schema: MongoSchemaIR;
+  /** Run first. */
+  readonly collectionRenames: readonly RenameCollectionCall[];
+  /** Run after index drops and before index creates. */
+  readonly rewrites: readonly (RenameFieldCall | UnsetFieldCall)[];
+}
+//#endregion
+//#region src/core/migrations/mongo-planner.d.ts
 type PlanCallsResult = {
   readonly kind: 'success';
   readonly calls: OpFactoryCall$1[];
+  /** One for each change a collection's control policy left out of the plan. */
+  readonly warnings: readonly MigrationPlannerConflict[];
 } | {
   readonly kind: 'failure';
   readonly conflicts: MigrationPlannerConflict[];
@@ -74,17 +91,21 @@ declare class MongoMigrationPlanner implements MigrationPlanner<'mongo', 'mongo'
     readonly schema: unknown;
     readonly policy: MigrationOperationPolicy;
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
+    /** The contract the planner reads as the starting state, or `null` when it has none. */
+    readonly fromContract: Contract | null;
+    /** What the statements and removed fields plan; its `schema` is diffed in place of `schema`. */
+    readonly statementCalls?: StatementCalls;
   }): PlanCallsResult;
   plan(options: {
     readonly contract: unknown;
     readonly schema: unknown;
     readonly policy: MigrationOperationPolicy;
-    /**
-     * The "from" contract (state the planner assumes the database starts at),
-     * or `null` for reconciliation flows. Used to populate `describe().from`
-     * on the produced plan as `fromContract?.storage.storageHash ?? null`.
-     */
+    /** The contract the planner reads as the starting state, or `null` when it has none. */
     readonly fromContract: Contract | null;
+    /** The origin the produced plan asserts: its `describe().from` and `origin`. */
+    readonly origin: PlanOrigin | null;
+    /** The `--rename` statements, resolved. */
+    readonly statements: readonly ResolvedMigrationStatement[];
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
     /**
      * POSIX-relative path from the migration package dir to
@@ -105,7 +126,11 @@ declare class MongoMigrationPlanner implements MigrationPlanner<'mongo', 'mongo'
   emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface;
 }
 //#endregion
-//#region src/core/mongo-runner.d.ts
+//#region src/core/mongo-target-errors.d.ts
+/** The codes the Mongo migration runner returns a failure with. */
+type MongoMigrationRunnerErrorCode = 'MIGRATION.EXECUTION_FAILED' | 'MIGRATION.MARKER_CAS_FAILURE' | 'MIGRATION.MARKER_ORIGIN_MISMATCH' | 'MIGRATION.POLICY_VIOLATION' | 'MIGRATION.POSTCHECK_FAILED' | 'MIGRATION.PRECHECK_FAILED' | 'MIGRATION.SCHEMA_VERIFY_FAILED';
+//#endregion
+//#region src/core/migrations/mongo-runner.d.ts
 interface MongoMigrationRunnerExecuteOptions {
   readonly plan: MigrationPlan;
   readonly destinationContract: MongoContract;
@@ -131,89 +156,35 @@ interface MongoMigrationRunnerExecuteOptions {
   readonly scopeVerifyResult?: (result: VerifyDatabaseSchemaResult) => VerifyDatabaseSchemaResult;
   /** Per-edge breakdown from graph-walk planning; drives per-edge ledger writes. */
   readonly migrationEdges: readonly AggregateMigrationEdgeRef[];
+  /** Whether an earlier space of the same apply already changed the database. */
+  readonly databaseChangedBefore?: boolean;
+}
+/** A failure of the Mongo runner: one of the codes it returns. */
+interface MongoMigrationRunnerFailure extends MigrationRunnerFailure {
+  readonly code: MongoMigrationRunnerErrorCode;
 }
-type MongoMigrationRunnerResult = Result<MigrationRunnerPerSpaceSuccessValue, MigrationRunnerFailure>;
+/** A space's apply: what the framework reports, and whether it changed the database, its marker and ledger included. */
+interface MongoSpaceSuccessValue extends MigrationRunnerPerSpaceSuccessValue {
+  readonly changedDatabase: boolean;
+}
+type MongoMigrationRunnerResult = Result<MongoSpaceSuccessValue, MongoMigrationRunnerFailure>;
 declare class MongoMigrationRunner {
   private readonly deps;
   constructor(deps: MongoRunnerDependencies);
   execute(options: MongoMigrationRunnerExecuteOptions): Promise<MongoMigrationRunnerResult>;
+  /** Applies the plan, calling `wrote` after each command that changes the database. */
+  private apply;
   private recordLedgerEntries;
-  private executeDataTransform;
-  private evaluateDataTransformChecks;
+  private executeDmlOperation;
+  private evaluateDmlChecks;
   private evaluateChecks;
+  private firstFailingCheck;
   private allChecksSatisfied;
   private enforcePolicyCompatibility;
   private ensureMarkerCompatibility;
 }
 //#endregion
-//#region src/core/mongo-target-contract-serializer.d.ts
-declare class MongoTargetContractSerializer extends MongoContractSerializerBase<MongoTargetContract> {
-  protected constructTargetContract(validated: MongoContract): MongoTargetContract;
-  serializeContract(contract: MongoTargetContract): JsonObject;
-}
-//#endregion
-//#region src/core/mongo-target-database.d.ts
-interface MongoTargetDatabaseInput {
-  readonly id: string;
-  readonly entries?: Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
-    readonly collection?: Readonly<Record<string, MongoCollectionInput>>;
-    readonly valueSet?: Readonly<Record<string, MongoValueSetInput>>;
-  };
-}
-/**
- * Mongo target `Namespace` concretion. In Mongo the "namespace" concept
- * binds to the connection's `db` field — a `MongoTargetDatabase` instance
- * names the database the collections live under. `entries['collection']`
- * holds collection IR. The unbound singleton (below) is the late-bound
- * namespace whose binding the connection's `db` resolves at runtime rather
- * than at authoring time.
- *
- * Qualifier emission is the rendering seam: query / DDL emission asks the
- * namespace for its qualifier (e.g. `"<db>.<collection>"`) and consumes
- * the result polymorphically. The unbound singleton overrides these
- * methods to elide the prefix entirely — call sites stay polymorphic and
- * never branch on `id === UNBOUND_NAMESPACE_ID`.
- */
-declare class MongoTargetDatabase extends NamespaceBase {
-  readonly kind: string;
-  readonly id: string;
-  readonly entries: MongoNamespaceEntries;
-  constructor(input: MongoTargetDatabaseInput);
-  get collection(): Readonly<Record<string, MongoCollection>>;
-  /**
-   * The bare qualifier as it would appear in a rendered string. The
-   * unbound-database singleton overrides this to return `''`.
-   */
-  qualifier(): string;
-  /**
-   * Qualify a collection name with the database prefix. The
-   * unbound-database singleton overrides this to emit just the
-   * collection name. Used by emission/introspection paths that need a
-   * fully-qualified reference.
-   */
-  qualifyCollection(collectionName: string): string;
-}
-/**
- * Singleton subclass for the reserved sentinel namespace id
- * (`UNBOUND_NAMESPACE_ID`) — the late-bound namespace whose binding the
- * connection's `db` resolves at runtime. Overrides qualifier emission
- * to elide the database prefix; call sites that consume `qualifier()`
- * / `qualifyCollection()` get unqualified output without branching on
- * the namespace id.
- *
- * This is the target-side materialization of "the framework provides
- * affordances; targets implement specifics": the framework names the
- * sentinel; Mongo decides what late-bound means here (the collection
- * name, naked — the database is supplied by the live connection).
- */
-declare class MongoTargetUnboundDatabase extends MongoTargetDatabase {
-  static readonly instance: MongoTargetUnboundDatabase;
-  private constructor();
-  qualifier(): string;
-  qualifyCollection(collectionName: string): string;
-}
-//#endregion
-//#region src/core/mongo-target-schema-verifier.d.ts
+//#region src/core/migrations/mongo-target-schema-verifier.d.ts
 /**
  * Mongo target `SchemaVerifier` concretion. Extends the family base's
  * namespace-walk scaffolding and contributes the per-namespace diff via
@@ -245,7 +216,7 @@ declare class MongoTargetSchemaVerifier extends MongoSchemaVerifierBase<MongoTar
   protected verifyTargetExtensions(_options: SchemaVerifyOptions<MongoTargetContract, MongoSchemaIR>): readonly SchemaDiffIssue[];
 }
 //#endregion
-//#region src/core/planner-produced-migration.d.ts
+//#region src/core/migrations/planner-produced-migration.d.ts
 /**
  * Planner-produced Mongo migration, returned by `MongoMigrationPlanner.plan(...)`
  * and `MongoMigrationPlanner.emptyMigration(...)`.
@@ -272,10 +243,10 @@ declare class PlannerProducedMongoMigration extends Migration<AnyMongoMigrationO
   renderTypeScript(resolveImportSpecifier: ImportSpecifierResolver): string;
 }
 //#endregion
-//#region src/core/render-ops.d.ts
-declare function renderOps(calls: ReadonlyArray<OpFactoryCall$1>): MongoMigrationPlanOperation[];
+//#region src/core/migrations/render-ops.d.ts
+declare function renderOps(calls: ReadonlyArray<OpFactoryCall$1>): AnyMongoMigrationOperation[];
 //#endregion
-//#region src/core/render-typescript.d.ts
+//#region src/core/migrations/render-typescript.d.ts
 interface RenderMigrationMeta {
   readonly from: string | null;
   readonly to: string;
@@ -308,5 +279,72 @@ interface RenderMigrationMeta {
  */
 declare function renderCallsToTypeScript(calls: ReadonlyArray<OpFactoryCall$1>, meta: RenderMigrationMeta): string;
 //#endregion
-export { renderOps as _, MongoTargetContract as a, MongoTargetSchemaVerifier as c, PlannerProducedMongoMigration as d, RenderMigrationMeta as f, renderCallsToTypeScript as g, mongoTargetDescriptor as h, MongoMigrationRunnerExecuteOptions as i, MongoTargetUnboundDatabase as l, deserializeMongoOps as m, MongoMigrationPlanner as n, MongoTargetContractSerializer as o, deserializeMongoOp as p, MongoMigrationRunner as r, MongoTargetDatabase as s, FilterEvaluator as t, PlanCallsResult as u, serializeMongoOps as v };
-//# sourceMappingURL=control-CxXmTy_h.d.mts.map
+//#region src/core/mongo-target-contract-serializer.d.ts
+declare class MongoTargetContractSerializer extends MongoContractSerializerBase<MongoTargetContract> {
+  protected constructTargetContract(validated: MongoContract): MongoTargetContract;
+  serializeContract(contract: MongoTargetContract): JsonObject;
+}
+//#endregion
+//#region src/core/mongo-target-database.d.ts
+interface MongoTargetDatabaseInput {
+  readonly id: string;
+  readonly entries?: Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
+    readonly collection?: Readonly<Record<string, MongoCollectionInput>>;
+    readonly valueSet?: Readonly<Record<string, MongoValueSetInput>>;
+  };
+}
+/**
+ * Mongo target `Namespace` concretion. In Mongo the "namespace" concept
+ * binds to the connection's `db` field — a `MongoTargetDatabase` instance
+ * names the database the collections live under. `entries['collection']`
+ * holds collection IR. The unbound singleton (below) is the late-bound
+ * namespace whose binding the connection's `db` resolves at runtime rather
+ * than at authoring time.
+ *
+ * Qualifier emission is the rendering seam: query / DDL emission asks the
+ * namespace for its qualifier (e.g. `"<db>.<collection>"`) and consumes
+ * the result polymorphically. The unbound singleton overrides these
+ * methods to elide the prefix entirely — call sites stay polymorphic and
+ * never branch on `id === UNBOUND_NAMESPACE_ID`.
+ */
+declare class MongoTargetDatabase extends NamespaceBase {
+  readonly kind: string;
+  readonly id: string;
+  readonly entries: MongoNamespaceEntries;
+  constructor(input: MongoTargetDatabaseInput);
+  get collection(): Readonly<Record<string, MongoCollection>>;
+  /**
+   * The bare qualifier as it would appear in a rendered string. The
+   * unbound-database singleton overrides this to return `''`.
+   */
+  qualifier(): string;
+  /**
+   * Qualify a collection name with the database prefix. The
+   * unbound-database singleton overrides this to emit just the
+   * collection name. Used by emission/introspection paths that need a
+   * fully-qualified reference.
+   */
+  qualifyCollection(collectionName: string): string;
+}
+/**
+ * Singleton subclass for the reserved sentinel namespace id
+ * (`UNBOUND_NAMESPACE_ID`) — the late-bound namespace whose binding the
+ * connection's `db` resolves at runtime. Overrides qualifier emission
+ * to elide the database prefix; call sites that consume `qualifier()`
+ * / `qualifyCollection()` get unqualified output without branching on
+ * the namespace id.
+ *
+ * This is the target-side materialization of "the framework provides
+ * affordances; targets implement specifics": the framework names the
+ * sentinel; Mongo decides what late-bound means here (the collection
+ * name, naked — the database is supplied by the live connection).
+ */
+declare class MongoTargetUnboundDatabase extends MongoTargetDatabase {
+  static readonly instance: MongoTargetUnboundDatabase;
+  private constructor();
+  qualifier(): string;
+  qualifyCollection(collectionName: string): string;
+}
+//#endregion
+export { deserializeMongoOps as _, MongoMigrationRunnerExecuteOptions as a, renderOps as b, MongoTargetContract as c, MongoTargetSchemaVerifier as d, MongoTargetUnboundDatabase as f, deserializeMongoOp as g, RenderMigrationMeta as h, MongoMigrationRunnerErrorCode as i, MongoTargetContractSerializer as l, PlannerProducedMongoMigration as m, MongoMigrationPlanner as n, MongoMigrationRunnerFailure as o, PlanCallsResult as p, MongoMigrationRunner as r, MongoMigrationRunnerResult as s, FilterEvaluator as t, MongoTargetDatabase as u, mongoTargetDescriptor as v, serializeMongoOps as x, renderCallsToTypeScript as y };
+//# sourceMappingURL=control-CrFS8bqh.d.mts.map

package/dist/control-CrFS8bqh.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-CrFS8bqh.d.mts","names":[],"sources":["../../../../3-targets/mongo/1-target/dist/control.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BK,sBAAsB,KAAK;WACrB,SAAS;;;;;;;;;;;;;;cAcN,uBAAuB,6BAA6B;;;cAGpD,2BAA2B;UAC/B;EACR,SAAS,QAAQ,iBAAiB,KAAK;EACvC,MAAM,MAAM;EACZ,IAAI,MAAM;EACV,GAAG,MAAM;EACT,IAAI,MAAM;EACV,OAAO,MAAM;EACb,KAAK,OAAO;;;;iBAIG,mBAAmB,gBAAgB;iBACnC,oBAAoB,2BAA2B;iBAC/C,kBAAkB,cAAc;;;;;;;;UAQvC;WACC,QAAQ;;WAER,4BAA4B;;WAE5B,oBAAoB,kBAAkB;;;;KAI5C;WACM;WACA,OAAO;;WAEP,mBAAmB;;WAEnB;WACA,WAAW;;cAER,iCAAiC;EAC7C,UAAU;aACC;aACA;aACA,QAAQ;aACR,qBAAqB,cAAc;;aAEnC,cAAc;;aAEd,iBAAiB;MACxB;EACJ,KAAK;aACM;aACA;aACA,QAAQ;;aAER,cAAc;;aAEd,QAAQ;;aAER,qBAAqB;aACrB,qBAAqB,cAAc;;;;;;aAMnC;MACP;;;;;;;;;;EAUJ,eAAe,SAAS,2BAA2B;;;;;KAKhD;;;UAGK;WACC,MAAM;WACN,qBAAqB;WACrB,QAAQ;WACR;IACP,kBAAkB,IAAI;IACtB,qBAAqB,IAAI;;WAElB,kBAAkB;WAClB,qBAAqB,cAAc;WACnC;WACA,UAAU;;;;;;;;;;;WAWV,qBAAqB,QAAQ,+BAA+B;;WAE5D,yBAAyB;;WAEzB;;;UAGD,oCAAoC;WACnC,MAAM;;;UAGP,+BAA+B;WAC9B;;KAEN,6BAA6B,OAAO,wBAAwB;cACnD;mBACK;EACjB,YAAY,MAAM;EAClB,QAAQ,SAAS,qCAAqC,QAAQ;;UAEtD;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;;;;;;;;;;;;;;;;;;;;;;;;cAyBI,kCAAkC,wBAAwB,qBAAqB;YACjF,gBAAgB;aACf,UAAU;aACV,QAAQ;aACR;aACA,WAAW;eACT;YACH,uBAAuB,UAAU,oBAAoB,qBAAqB,0BAA0B;;;;;;;;;;;;;;;;;;;cAmBlG,sCAAsC,UAAU,uCAAuC;mBAClF;mBACA;mBACA;WACR;EACT,YAAY,gBAAgB,mBAAiB,MAAM,eAAe;MAC9D,uBAAuB;EAC3B,YAAY;EACZ,iBAAiB,wBAAwB;;;;iBAI1B,UAAU,OAAO,cAAc,mBAAiB;;;UAGvD;WACC;WACA;;WAEA;;;;;;;WAOA,yBAAyB;;;;;;;;;;;;;;;;;;;iBAmBnB,wBAAwB,OAAO,cAAc,kBAAgB,MAAM;;;cAGtE,sCAAsC,4BAA4B;YACpE,wBAAwB,WAAW,gBAAgB;EAC7D,kBAAkB,UAAU,sBAAsB;;;;UAI1C;WACC;WACA,UAAU,SAAS,eAAe,SAAS;aACzC,aAAa,SAAS,eAAe;aACrC,WAAW,SAAS,eAAe;;;;;;;;;;;;;;;;;cAiBlC,4BAA4B;WAC/B;WACA;WACA,SAAS;EAClB,YAAY,OAAO;MACf,cAAc,SAAS,eAAe;;;;;EAK1C;;;;;;;EAOA,kBAAkB;;;;;;;;;;;;;;;cAeN,mCAAmC;kBAC/B,UAAU;UAClB;EACR;EACA,kBAAkB"}

package/dist/data-types-LShlnAUM.d.mts

@@ -0,0 +1,25 @@
+import { DataType, DataTypeId } from "@prisma/orm-framework/components/codec";
+//#region ../../../3-targets/mongo/1-target/dist/data-types.d.mts
+//#region src/core/data-types.d.ts
+/** The vector's dimension: the TypeScript type `Vector<n>` and the type's reader read it. */
+declare const mongoVectorParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  length?: number;
+}, {}>;
+declare const mongoString: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoInt32: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoInt64: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoDecimal128: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoDouble: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoObjectId: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoBool: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoDate: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoVector: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoBinary: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoJson: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoBson: import("@prisma/orm-family-mongo/contract/data-type").MongoDataType;
+declare const mongoDataTypes: readonly DataType[];
+/** MongoDB's text data type: `string`. */
+declare const mongoTextDataTypes: readonly DataTypeId[];
+//#endregion
+export { mongoDate as a, mongoInt32 as c, mongoObjectId as d, mongoString as f, mongoVectorParams as h, mongoDataTypes as i, mongoInt64 as l, mongoVector as m, mongoBool as n, mongoDecimal128 as o, mongoTextDataTypes as p, mongoBson as r, mongoDouble as s, mongoBinary as t, mongoJson as u };
+//# sourceMappingURL=data-types-LShlnAUM.d.mts.map

package/dist/data-types-LShlnAUM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-types-LShlnAUM.d.mts","names":[],"sources":["../../../../3-targets/mongo/1-target/dist/data-types.d.mts"],"mappings":";;;;cAGc,iEAAiE;EAC7E;;cAEY,0DAA0D;cAC1D,yDAAyD;cACzD,yDAAyD;cACzD,8DAA8D;cAC9D,0DAA0D;cAC1D,4DAA4D;cAC5D,wDAAwD;cACxD,wDAAwD;cACxD,0DAA0D;cAC1D,0DAA0D;cAC1D,wDAAwD;cACxD,wDAAwD;cACxD,yBAAyB;;cAEzB,6BAA6B"}