@prisma/client-engine-runtime 6.14.0-dev.35 → 6.14.0-dev.37

package/dist/index.mjs

@@ -1,5 +1,5 @@
-// src/interpreter/DataMapper.ts
-import Decimal2 from "decimal.js";
+// src/json-protocol.ts
+import { Decimal as Decimal2 } from "decimal.js";
 
 // src/utils.ts
 import Decimal from "decimal.js";
@@ -93,7 +93,303 @@ function safeJsonStringify(obj) {
   });
 }
 
-// src/interpreter/DataMapper.ts
+// src/json-protocol.ts
+function normalizeJsonProtocolValues(result) {
+  if (result === null) {
+    return result;
+  }
+  if (Array.isArray(result)) {
+    return result.map(normalizeJsonProtocolValues);
+  }
+  if (typeof result === "object") {
+    if (isTaggedValue(result)) {
+      return normalizeTaggedValue(result);
+    }
+    if (result.constructor !== null && result.constructor.name !== "Object") {
+      return result;
+    }
+    return mapObjectValues(result, normalizeJsonProtocolValues);
+  }
+  return result;
+}
+function isTaggedValue(value) {
+  return value !== null && typeof value == "object" && typeof value["$type"] === "string";
+}
+function normalizeTaggedValue({ $type, value }) {
+  switch ($type) {
+    case "BigInt":
+      return { $type, value: String(value) };
+    case "Bytes":
+      return { $type, value };
+    case "DateTime":
+      return { $type, value: new Date(value).toISOString() };
+    case "Decimal":
+      return { $type, value: String(new Decimal2(value)) };
+    case "Json":
+      return { $type, value: JSON.stringify(JSON.parse(value)) };
+    default:
+      assertNever(value, "Unknown tagged value");
+  }
+}
+function mapObjectValues(object, mapper) {
+  const result = {};
+  for (const key of Object.keys(object)) {
+    result[key] = mapper(object[key], key);
+  }
+  return result;
+}
+function deserializeJsonResponse(result) {
+  if (result === null) {
+    return result;
+  }
+  if (Array.isArray(result)) {
+    return result.map(deserializeJsonResponse);
+  }
+  if (typeof result === "object") {
+    if (isTaggedValue(result)) {
+      return deserializeTaggedValue(result);
+    }
+    if (result.constructor !== null && result.constructor.name !== "Object") {
+      return result;
+    }
+    return mapObjectValues(result, deserializeJsonResponse);
+  }
+  return result;
+}
+function deserializeTaggedValue({ $type, value }) {
+  switch ($type) {
+    case "BigInt":
+      return BigInt(value);
+    case "Bytes": {
+      const { buffer, byteOffset, byteLength } = Buffer.from(value, "base64");
+      return new Uint8Array(buffer, byteOffset, byteLength);
+    }
+    case "DateTime":
+      return new Date(value);
+    case "Decimal":
+      return new Decimal2(value);
+    case "Json":
+      return JSON.parse(value);
+    default:
+      assertNever(value, "Unknown tagged value");
+  }
+}
+
+// src/user-facing-error.ts
+import { isDriverAdapterError } from "@prisma/driver-adapter-utils";
+var UserFacingError = class extends Error {
+  name = "UserFacingError";
+  code;
+  meta;
+  constructor(message, code, meta) {
+    super(message);
+    this.code = code;
+    this.meta = meta ?? {};
+  }
+  toQueryResponseErrorObject() {
+    return {
+      error: this.message,
+      user_facing_error: {
+        is_panic: false,
+        message: this.message,
+        meta: this.meta,
+        error_code: this.code
+      }
+    };
+  }
+};
+function rethrowAsUserFacing(error) {
+  if (!isDriverAdapterError(error)) {
+    throw error;
+  }
+  const code = getErrorCode(error);
+  const message = renderErrorMessage(error);
+  if (!code || !message) {
+    throw error;
+  }
+  throw new UserFacingError(message, code, { driverAdapterError: error });
+}
+function rethrowAsUserFacingRawError(error) {
+  if (!isDriverAdapterError(error)) {
+    throw error;
+  }
+  throw new UserFacingError(
+    `Raw query failed. Code: \`${error.cause.originalCode ?? "N/A"}\`. Message: \`${error.cause.originalMessage ?? renderErrorMessage(error)}\``,
+    "P2010",
+    { driverAdapterError: error }
+  );
+}
+function getErrorCode(err) {
+  switch (err.cause.kind) {
+    case "AuthenticationFailed":
+      return "P1000";
+    case "DatabaseNotReachable":
+      return "P1001";
+    case "DatabaseDoesNotExist":
+      return "P1003";
+    case "SocketTimeout":
+      return "P1008";
+    case "DatabaseAlreadyExists":
+      return "P1009";
+    case "DatabaseAccessDenied":
+      return "P1010";
+    case "TlsConnectionError":
+      return "P1011";
+    case "ConnectionClosed":
+      return "P1017";
+    case "TransactionAlreadyClosed":
+      return "P1018";
+    case "LengthMismatch":
+      return "P2000";
+    case "UniqueConstraintViolation":
+      return "P2002";
+    case "ForeignKeyConstraintViolation":
+      return "P2003";
+    case "UnsupportedNativeDataType":
+      return "P2010";
+    case "NullConstraintViolation":
+      return "P2011";
+    case "ValueOutOfRange":
+      return "P2020";
+    case "TableDoesNotExist":
+      return "P2021";
+    case "ColumnNotFound":
+      return "P2022";
+    case "InvalidIsolationLevel":
+    case "InconsistentColumnData":
+      return "P2023";
+    case "MissingFullTextSearchIndex":
+      return "P2030";
+    case "TransactionWriteConflict":
+      return "P2034";
+    case "GenericJs":
+      return "P2036";
+    case "TooManyConnections":
+      return "P2037";
+    case "postgres":
+    case "sqlite":
+    case "mysql":
+    case "mssql":
+      return;
+    default:
+      assertNever(err.cause, `Unknown error: ${err.cause}`);
+  }
+}
+function renderErrorMessage(err) {
+  switch (err.cause.kind) {
+    case "AuthenticationFailed": {
+      const user = err.cause.user ?? "(not available)";
+      return `Authentication failed against the database server, the provided database credentials for \`${user}\` are not valid`;
+    }
+    case "DatabaseNotReachable": {
+      const address = err.cause.host && err.cause.port ? `${err.cause.host}:${err.cause.port}` : err.cause.host;
+      return `Can't reach database server${address ? ` at ${address}` : ""}`;
+    }
+    case "DatabaseDoesNotExist": {
+      const db = err.cause.db ?? "(not available)";
+      return `Database \`${db}\` does not exist on the database server`;
+    }
+    case "SocketTimeout":
+      return `Operation has timed out`;
+    case "DatabaseAlreadyExists": {
+      const db = err.cause.db ?? "(not available)";
+      return `Database \`${db}\` already exists on the database server`;
+    }
+    case "DatabaseAccessDenied": {
+      const db = err.cause.db ?? "(not available)";
+      return `User was denied access on the database \`${db}\``;
+    }
+    case "TlsConnectionError": {
+      return `Error opening a TLS connection: ${err.cause.reason}`;
+    }
+    case "ConnectionClosed": {
+      return "Server has closed the connection.";
+    }
+    case "TransactionAlreadyClosed":
+      return err.cause.cause;
+    case "LengthMismatch": {
+      const column = err.cause.column ?? "(not available)";
+      return `The provided value for the column is too long for the column's type. Column: ${column}`;
+    }
+    case "UniqueConstraintViolation":
+      return `Unique constraint failed on the ${renderConstraint(err.cause.constraint)}`;
+    case "ForeignKeyConstraintViolation":
+      return `Foreign key constraint violated on the ${renderConstraint(err.cause.constraint)}`;
+    case "UnsupportedNativeDataType":
+      return `Failed to deserialize column of type '${err.cause.type}'. If you're using $queryRaw and this column is explicitly marked as \`Unsupported\` in your Prisma schema, try casting this column to any supported Prisma type such as \`String\`.`;
+    case "NullConstraintViolation":
+      return `Null constraint violation on the ${renderConstraint(err.cause.constraint)}`;
+    case "ValueOutOfRange":
+      return `Value out of range for the type: ${err.cause.cause}`;
+    case "TableDoesNotExist": {
+      const table = err.cause.table ?? "(not available)";
+      return `The table \`${table}\` does not exist in the current database.`;
+    }
+    case "ColumnNotFound": {
+      const column = err.cause.column ?? "(not available)";
+      return `The column \`${column}\` does not exist in the current database.`;
+    }
+    case "InvalidIsolationLevel":
+      return `Error in connector: Conversion error: ${err.cause.level}`;
+    case "InconsistentColumnData":
+      return `Inconsistent column data: ${err.cause.cause}`;
+    case "MissingFullTextSearchIndex":
+      return "Cannot find a fulltext index to use for the native search, try adding a @@fulltext([Fields...]) to your schema";
+    case "TransactionWriteConflict":
+      return `Transaction failed due to a write conflict or a deadlock. Please retry your transaction`;
+    case "GenericJs":
+      return `Error in external connector (id ${err.cause.id})`;
+    case "TooManyConnections":
+      return `Too many database connections opened: ${err.cause.cause}`;
+    case "sqlite":
+    case "postgres":
+    case "mysql":
+    case "mssql":
+      return;
+    default:
+      assertNever(err.cause, `Unknown error: ${err.cause}`);
+  }
+}
+function renderConstraint(constraint) {
+  if (constraint && "fields" in constraint) {
+    return `fields: (${constraint.fields.map((field) => `\`${field}\``).join(", ")})`;
+  } else if (constraint && "index" in constraint) {
+    return `constraint: \`${constraint.index}\``;
+  } else if (constraint && "foreignKey" in constraint) {
+    return `foreign key`;
+  }
+  return "(not available)";
+}
+
+// src/batch.ts
+function convertCompactedRows(rows, compiledBatch) {
+  const keysPerRow = rows.map(
+    (item) => compiledBatch.keys.reduce((acc, key) => {
+      acc[key] = deserializeJsonResponse(item[key]);
+      return acc;
+    }, {})
+  );
+  const selection = new Set(compiledBatch.nestedSelection);
+  return compiledBatch.arguments.map((args) => {
+    const rowIndex = keysPerRow.findIndex((rowKeys) => doKeysMatch(rowKeys, args));
+    if (rowIndex === -1) {
+      if (compiledBatch.expectNonEmpty) {
+        return new UserFacingError(
+          "An operation failed because it depends on one or more records that were required but not found",
+          "P2025"
+        );
+      } else {
+        return null;
+      }
+    } else {
+      const selected = Object.entries(rows[rowIndex]).filter(([k]) => selection.has(k));
+      return Object.fromEntries(selected);
+    }
+  });
+}
+
+// src/interpreter/data-mapper.ts
+import Decimal3 from "decimal.js";
 var DataMapperError = class extends Error {
   name = "DataMapperError";
 };
@@ -248,7 +544,7 @@ function mapValue(value, columnName, resultType, enums) {
       throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
     }
     case "Decimal":
-      if (typeof value !== "number" && typeof value !== "string" && !Decimal2.isDecimal(value)) {
+      if (typeof value !== "number" && typeof value !== "string" && !Decimal3.isDecimal(value)) {
         throw new DataMapperError(`Expected a decimal in column '${columnName}', got ${typeof value}: ${value}`);
       }
       return { $type: "Decimal", value };
@@ -372,192 +668,6 @@ async function withQuerySpanAndEvent({
   );
 }
 
-// src/UserFacingError.ts
-import { isDriverAdapterError } from "@prisma/driver-adapter-utils";
-var UserFacingError = class extends Error {
-  name = "UserFacingError";
-  code;
-  meta;
-  constructor(message, code, meta) {
-    super(message);
-    this.code = code;
-    this.meta = meta ?? {};
-  }
-  toQueryResponseErrorObject() {
-    return {
-      error: this.message,
-      user_facing_error: {
-        is_panic: false,
-        message: this.message,
-        meta: this.meta,
-        error_code: this.code
-      }
-    };
-  }
-};
-function rethrowAsUserFacing(error) {
-  if (!isDriverAdapterError(error)) {
-    throw error;
-  }
-  const code = getErrorCode(error);
-  const message = renderErrorMessage(error);
-  if (!code || !message) {
-    throw error;
-  }
-  throw new UserFacingError(message, code, { driverAdapterError: error });
-}
-function rethrowAsUserFacingRawError(error) {
-  if (!isDriverAdapterError(error)) {
-    throw error;
-  }
-  throw new UserFacingError(
-    `Raw query failed. Code: \`${error.cause.originalCode ?? "N/A"}\`. Message: \`${error.cause.originalMessage ?? renderErrorMessage(error)}\``,
-    "P2010",
-    { driverAdapterError: error }
-  );
-}
-function getErrorCode(err) {
-  switch (err.cause.kind) {
-    case "AuthenticationFailed":
-      return "P1000";
-    case "DatabaseNotReachable":
-      return "P1001";
-    case "DatabaseDoesNotExist":
-      return "P1003";
-    case "SocketTimeout":
-      return "P1008";
-    case "DatabaseAlreadyExists":
-      return "P1009";
-    case "DatabaseAccessDenied":
-      return "P1010";
-    case "TlsConnectionError":
-      return "P1011";
-    case "ConnectionClosed":
-      return "P1017";
-    case "TransactionAlreadyClosed":
-      return "P1018";
-    case "LengthMismatch":
-      return "P2000";
-    case "UniqueConstraintViolation":
-      return "P2002";
-    case "ForeignKeyConstraintViolation":
-      return "P2003";
-    case "UnsupportedNativeDataType":
-      return "P2010";
-    case "NullConstraintViolation":
-      return "P2011";
-    case "ValueOutOfRange":
-      return "P2020";
-    case "TableDoesNotExist":
-      return "P2021";
-    case "ColumnNotFound":
-      return "P2022";
-    case "InvalidIsolationLevel":
-    case "InconsistentColumnData":
-      return "P2023";
-    case "MissingFullTextSearchIndex":
-      return "P2030";
-    case "TransactionWriteConflict":
-      return "P2034";
-    case "GenericJs":
-      return "P2036";
-    case "TooManyConnections":
-      return "P2037";
-    case "postgres":
-    case "sqlite":
-    case "mysql":
-    case "mssql":
-      return;
-    default:
-      assertNever(err.cause, `Unknown error: ${err.cause}`);
-  }
-}
-function renderErrorMessage(err) {
-  switch (err.cause.kind) {
-    case "AuthenticationFailed": {
-      const user = err.cause.user ?? "(not available)";
-      return `Authentication failed against the database server, the provided database credentials for \`${user}\` are not valid`;
-    }
-    case "DatabaseNotReachable": {
-      const address = err.cause.host && err.cause.port ? `${err.cause.host}:${err.cause.port}` : err.cause.host;
-      return `Can't reach database server${address ? ` at ${address}` : ""}`;
-    }
-    case "DatabaseDoesNotExist": {
-      const db = err.cause.db ?? "(not available)";
-      return `Database \`${db}\` does not exist on the database server`;
-    }
-    case "SocketTimeout":
-      return `Operation has timed out`;
-    case "DatabaseAlreadyExists": {
-      const db = err.cause.db ?? "(not available)";
-      return `Database \`${db}\` already exists on the database server`;
-    }
-    case "DatabaseAccessDenied": {
-      const db = err.cause.db ?? "(not available)";
-      return `User was denied access on the database \`${db}\``;
-    }
-    case "TlsConnectionError": {
-      return `Error opening a TLS connection: ${err.cause.reason}`;
-    }
-    case "ConnectionClosed": {
-      return "Server has closed the connection.";
-    }
-    case "TransactionAlreadyClosed":
-      return err.cause.cause;
-    case "LengthMismatch": {
-      const column = err.cause.column ?? "(not available)";
-      return `The provided value for the column is too long for the column's type. Column: ${column}`;
-    }
-    case "UniqueConstraintViolation":
-      return `Unique constraint failed on the ${renderConstraint(err.cause.constraint)}`;
-    case "ForeignKeyConstraintViolation":
-      return `Foreign key constraint violated on the ${renderConstraint(err.cause.constraint)}`;
-    case "UnsupportedNativeDataType":
-      return `Failed to deserialize column of type '${err.cause.type}'. If you're using $queryRaw and this column is explicitly marked as \`Unsupported\` in your Prisma schema, try casting this column to any supported Prisma type such as \`String\`.`;
-    case "NullConstraintViolation":
-      return `Null constraint violation on the ${renderConstraint(err.cause.constraint)}`;
-    case "ValueOutOfRange":
-      return `Value out of range for the type: ${err.cause.cause}`;
-    case "TableDoesNotExist": {
-      const table = err.cause.table ?? "(not available)";
-      return `The table \`${table}\` does not exist in the current database.`;
-    }
-    case "ColumnNotFound": {
-      const column = err.cause.column ?? "(not available)";
-      return `The column \`${column}\` does not exist in the current database.`;
-    }
-    case "InvalidIsolationLevel":
-      return `Error in connector: Conversion error: ${err.cause.level}`;
-    case "InconsistentColumnData":
-      return `Inconsistent column data: ${err.cause.cause}`;
-    case "MissingFullTextSearchIndex":
-      return "Cannot find a fulltext index to use for the native search, try adding a @@fulltext([Fields...]) to your schema";
-    case "TransactionWriteConflict":
-      return `Transaction failed due to a write conflict or a deadlock. Please retry your transaction`;
-    case "GenericJs":
-      return `Error in external connector (id ${err.cause.id})`;
-    case "TooManyConnections":
-      return `Too many database connections opened: ${err.cause.cause}`;
-    case "sqlite":
-    case "postgres":
-    case "mysql":
-    case "mssql":
-      return;
-    default:
-      assertNever(err.cause, `Unknown error: ${err.cause}`);
-  }
-}
-function renderConstraint(constraint) {
-  if (constraint && "fields" in constraint) {
-    return `fields: (${constraint.fields.map((field) => `\`${field}\``).join(", ")})`;
-  } else if (constraint && "index" in constraint) {
-    return `constraint: \`${constraint.index}\``;
-  } else if (constraint && "foreignKey" in constraint) {
-    return `foreign key`;
-  }
-  return "(not available)";
-}
-
 // src/interpreter/generators.ts
 import cuid1 from "@bugsnag/cuid";
 import { createId as cuid2 } from "@paralleldrive/cuid2";
@@ -750,7 +860,7 @@ function getRecordKey(record, fields) {
   return JSON.stringify(fields.map((field) => record[field]));
 }
 
-// src/QueryPlan.ts
+// src/query-plan.ts
 function isPrismaValuePlaceholder(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "param";
 }
@@ -764,7 +874,7 @@ function isPrismaValueBigInt(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "bigint";
 }
 
-// src/interpreter/renderQuery.ts
+// src/interpreter/render-query.ts
 function renderQuery(dbQuery, scope, generators, maxChunkSize) {
   const queryType = dbQuery.type;
   const params = evaluateParams(dbQuery.params, scope, generators);
@@ -1017,7 +1127,7 @@ function chunkArray(array, chunkSize) {
   return result;
 }
 
-// src/interpreter/serializeSql.ts
+// src/interpreter/serialize-sql.ts
 import { ColumnTypeEnum } from "@prisma/driver-adapter-utils";
 function serializeSql(resultSet) {
   const mappers = resultSet.columnTypes.map((type) => {
@@ -1276,7 +1386,7 @@ function getErrorCode2(error) {
   }
 }
 
-// src/interpreter/QueryInterpreter.ts
+// src/interpreter/query-interpreter.ts
 var QueryInterpreter = class _QueryInterpreter {
   #transactionManager;
   #placeholderValues;
@@ -1654,53 +1764,6 @@ function evalFieldOperation(op, value, scope, generators) {
   }
 }
 
-// src/json-protocol.ts
-import { Decimal as Decimal3 } from "decimal.js";
-function normalizeJsonProtocolValues(result) {
-  if (result === null) {
-    return result;
-  }
-  if (Array.isArray(result)) {
-    return result.map(normalizeJsonProtocolValues);
-  }
-  if (typeof result === "object") {
-    if (isTaggedValue(result)) {
-      return normalizeTaggedValue(result);
-    }
-    if (result.constructor !== null && result.constructor.name !== "Object") {
-      return result;
-    }
-    return mapObjectValues(result, normalizeJsonProtocolValues);
-  }
-  return result;
-}
-function isTaggedValue(value) {
-  return value !== null && typeof value == "object" && typeof value["$type"] === "string";
-}
-function normalizeTaggedValue({ $type, value }) {
-  switch ($type) {
-    case "BigInt":
-      return { $type, value: String(value) };
-    case "Bytes":
-      return { $type, value };
-    case "DateTime":
-      return { $type, value: new Date(value).toISOString() };
-    case "Decimal":
-      return { $type, value: String(new Decimal3(value)) };
-    case "Json":
-      return { $type, value: JSON.stringify(JSON.parse(value)) };
-    default:
-      assertNever(value, "Unknown tagged value");
-  }
-}
-function mapObjectValues(object, mapper) {
-  const result = {};
-  for (const key of Object.keys(object)) {
-    result[key] = mapper(object[key], key);
-  }
-  return result;
-}
-
 // src/raw-json-protocol.ts
 import Decimal4 from "decimal.js";
 function normalizeRawJsonProtocolResponse(response) {
@@ -1730,7 +1793,7 @@ function normalizeValue(type, value) {
   }
 }
 
-// src/transactionManager/TransactionManager.ts
+// src/transaction-manager/transaction-manager.ts
 import { Debug } from "@prisma/debug";
 
 // src/crypto.ts
@@ -1742,7 +1805,7 @@ async function randomUUID() {
   return crypto.randomUUID();
 }
 
-// src/transactionManager/TransactionManagerErrors.ts
+// src/transaction-manager/transaction-manager-error.ts
 var TransactionManagerError = class extends UserFacingError {
   name = "TransactionManagerError";
   constructor(message, meta) {
@@ -1795,7 +1858,7 @@ var InvalidTransactionIsolationLevelError = class extends TransactionManagerErro
   }
 };
 
-// src/transactionManager/TransactionManager.ts
+// src/transaction-manager/transaction-manager.ts
 var MAX_CLOSED_TRANSACTIONS = 100;
 var debug = Debug("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
@@ -1997,6 +2060,8 @@ export {
   TransactionManager,
   TransactionManagerError,
   UserFacingError,
+  convertCompactedRows,
+  deserializeJsonResponse,
   doKeysMatch,
   isDeepStrictEqual,
   isPrismaValueBigInt,

package/dist/interpreter/{DataMapper.d.ts → data-mapper.d.ts}

@@ -1,4 +1,4 @@
-import { ResultNode } from '../QueryPlan';
+import { ResultNode } from '../query-plan';
 import { Value } from './scope';
 export declare class DataMapperError extends Error {
     name: string;

package/dist/interpreter/in-memory-processing.d.ts

@@ -1,3 +1,3 @@
-import { InMemoryOps } from '../QueryPlan';
+import { InMemoryOps } from '../query-plan';
 export declare function processRecords(value: unknown, ops: InMemoryOps): unknown;
 export declare function getRecordKey(record: {}, fields: string[]): string;

package/dist/interpreter/{QueryInterpreter.d.ts → query-interpreter.d.ts}

@@ -1,9 +1,9 @@
 import { ConnectionInfo, SqlQueryable, SqlResultSet } from '@prisma/driver-adapter-utils';
 import { QueryEvent } from '../events';
-import { QueryPlanNode } from '../QueryPlan';
+import { QueryPlanNode } from '../query-plan';
 import { type SchemaProvider } from '../schema';
 import { type TracingHelper } from '../tracing';
-import { type TransactionManager } from '../transactionManager/TransactionManager';
+import { type TransactionManager } from '../transaction-manager/transaction-manager';
 import { Value } from './scope';
 export type QueryInterpreterTransactionManager = {
     enabled: true;

package/dist/interpreter/{renderQuery.d.ts → render-query.d.ts}

@@ -1,5 +1,5 @@
 import { SqlQuery } from '@prisma/driver-adapter-utils';
-import type { PrismaValue, QueryPlanDbQuery } from '../QueryPlan';
+import type { PrismaValue, QueryPlanDbQuery } from '../query-plan';
 import { GeneratorRegistrySnapshot } from './generators';
 import { ScopeBindings } from './scope';
 export declare function renderQuery(dbQuery: QueryPlanDbQuery, scope: ScopeBindings, generators: GeneratorRegistrySnapshot, maxChunkSize?: number): SqlQuery[];

package/dist/interpreter/validation.d.ts

@@ -1,3 +1,3 @@
-import { DataRule, ValidationError } from '../QueryPlan';
+import { DataRule, ValidationError } from '../query-plan';
 export declare function performValidation(data: unknown, rules: DataRule[], error: ValidationError): void;
 export declare function doesSatisfyRule(data: unknown, rule: DataRule): boolean;

package/dist/json-protocol.d.ts

@@ -1,3 +1,4 @@
+import { Decimal } from 'decimal.js';
 export type DateTaggedValue = {
     $type: 'DateTime';
     value: string;
@@ -30,4 +31,8 @@ export type JsonTaggedValue = {
 };
 export type JsonInputTaggedValue = DateTaggedValue | DecimalTaggedValue | BytesTaggedValue | BigIntTaggedValue | FieldRefTaggedValue | JsonTaggedValue | EnumTaggedValue;
 export type JsonOutputTaggedValue = DateTaggedValue | DecimalTaggedValue | BytesTaggedValue | BigIntTaggedValue | JsonTaggedValue;
+export type JsOutputValue = null | string | number | boolean | bigint | Uint8Array | Date | Decimal | JsOutputValue[] | {
+    [key: string]: JsOutputValue;
+};
 export declare function normalizeJsonProtocolValues(result: unknown): unknown;
+export declare function deserializeJsonResponse(result: unknown): unknown;