@prisma/client-engine-runtime 6.15.0-dev.3 → 6.15.0-dev.5

package/dist/index.mjs

@@ -395,15 +395,15 @@ var DataMapperError = class extends Error {
 };
 function applyDataMap(data, structure, enums) {
   switch (structure.type) {
-    case "AffectedRows":
+    case "affectedRows":
       if (typeof data !== "number") {
         throw new DataMapperError(`Expected an affected rows count, got: ${typeof data} (${data})`);
       }
       return { count: data };
-    case "Object":
+    case "object":
       return mapArrayOrObject(data, structure.fields, enums, structure.skipNulls);
-    case "Value":
-      return mapValue(data, "<result>", structure.resultType, enums);
+    case "field":
+      return mapValue(data, "<result>", structure.fieldType, enums);
     default:
       assertNever(structure, `Invalid data mapping type: '${structure.type}'`);
   }
@@ -441,10 +441,10 @@ function mapObject(data, fields, enums) {
   const result = {};
   for (const [name, node] of Object.entries(fields)) {
     switch (node.type) {
-      case "AffectedRows": {
+      case "affectedRows": {
         throw new DataMapperError(`Unexpected 'AffectedRows' node in data mapping for field '${name}'`);
       }
-      case "Object": {
+      case "object": {
         if (node.serializedName !== null && !Object.hasOwn(data, node.serializedName)) {
           throw new DataMapperError(
             `Missing data field (Object): '${name}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
@@ -454,11 +454,11 @@ function mapObject(data, fields, enums) {
         result[name] = mapArrayOrObject(target, node.fields, enums, node.skipNulls);
         break;
       }
-      case "Value":
+      case "field":
         {
           const dbName = node.dbName;
           if (Object.hasOwn(data, dbName)) {
-            result[name] = mapValue(data[dbName], dbName, node.resultType, enums);
+            result[name] = mapField(data[dbName], dbName, node.fieldType, enums);
           } else {
             throw new DataMapperError(
               `Missing data field (Value): '${dbName}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
@@ -472,20 +472,27 @@ function mapObject(data, fields, enums) {
   }
   return result;
 }
-function mapValue(value, columnName, resultType, enums) {
+function mapField(value, columnName, fieldType, enums) {
   if (value === null) {
-    return resultType.type === "Array" ? [] : null;
+    return fieldType.arity === "list" ? [] : null;
   }
-  switch (resultType.type) {
-    case "Any":
+  if (fieldType.arity === "list") {
+    const values = value;
+    return values.map((v, i) => mapValue(v, `${columnName}[${i}]`, fieldType, enums));
+  }
+  return mapValue(value, columnName, fieldType, enums);
+}
+function mapValue(value, columnName, scalarType, enums) {
+  switch (scalarType.type) {
+    case "unsupported":
       return value;
-    case "String": {
+    case "string": {
       if (typeof value !== "string") {
         throw new DataMapperError(`Expected a string in column '${columnName}', got ${typeof value}: ${value}`);
       }
       return value;
     }
-    case "Int": {
+    case "int": {
       switch (typeof value) {
         case "number": {
           return Math.trunc(value);
@@ -506,13 +513,13 @@ function mapValue(value, columnName, resultType, enums) {
           throw new DataMapperError(`Expected an integer in column '${columnName}', got ${typeof value}: ${value}`);
       }
     }
-    case "BigInt": {
+    case "bigint": {
       if (typeof value !== "number" && typeof value !== "string") {
         throw new DataMapperError(`Expected a bigint in column '${columnName}', got ${typeof value}: ${value}`);
       }
       return { $type: "BigInt", value };
     }
-    case "Float": {
+    case "float": {
       if (typeof value === "number") return value;
       if (typeof value === "string") {
         const parsedValue = Number(value);
@@ -523,7 +530,7 @@ function mapValue(value, columnName, resultType, enums) {
       }
       throw new DataMapperError(`Expected a float in column '${columnName}', got ${typeof value}: ${value}`);
     }
-    case "Boolean": {
+    case "boolean": {
       if (typeof value === "boolean") return value;
       if (typeof value === "number") return value === 1;
       if (typeof value === "string") {
@@ -535,7 +542,7 @@ function mapValue(value, columnName, resultType, enums) {
           throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
         }
       }
-      if (value instanceof Uint8Array) {
+      if (Array.isArray(value)) {
         for (const byte of value) {
           if (byte !== 0) return true;
         }
@@ -543,37 +550,27 @@ function mapValue(value, columnName, resultType, enums) {
       }
       throw new DataMapperError(`Expected a boolean in column '${columnName}', got ${typeof value}: ${value}`);
     }
-    case "Decimal":
+    case "decimal":
       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 };
-    case "Date": {
+    case "datetime": {
       if (typeof value === "string") {
-        return { $type: "DateTime", value: ensureTimezoneInIsoString(value) };
+        return { $type: "DateTime", value: normalizeDateTime(value) };
       }
       if (typeof value === "number" || value instanceof Date) {
         return { $type: "DateTime", value };
       }
       throw new DataMapperError(`Expected a date in column '${columnName}', got ${typeof value}: ${value}`);
     }
-    case "Time": {
-      if (typeof value === "string") {
-        return { $type: "DateTime", value: `1970-01-01T${ensureTimezoneInIsoString(value)}` };
-      }
-      throw new DataMapperError(`Expected a time in column '${columnName}', got ${typeof value}: ${value}`);
-    }
-    case "Array": {
-      const values = value;
-      return values.map((v, i) => mapValue(v, `${columnName}[${i}]`, resultType.inner, enums));
-    }
-    case "Object": {
+    case "object": {
       return { $type: "Json", value: safeJsonStringify(value) };
     }
-    case "Json": {
+    case "json": {
       return { $type: "Json", value: `${value}` };
     }
-    case "Bytes": {
+    case "bytes": {
       if (typeof value === "string" && value.startsWith("\\x")) {
         return { $type: "Bytes", value: Buffer.from(value.slice(2), "hex").toString("base64") };
       }
@@ -585,31 +582,38 @@ function mapValue(value, columnName, resultType, enums) {
       }
       throw new DataMapperError(`Expected a byte array in column '${columnName}', got ${typeof value}: ${value}`);
     }
-    case "Enum": {
-      const enumDef = enums[resultType.inner];
+    case "enum": {
+      const enumDef = enums[scalarType.name];
       if (enumDef === void 0) {
-        throw new DataMapperError(`Unknown enum '${resultType.inner}'`);
+        throw new DataMapperError(`Unknown enum '${scalarType.name}'`);
       }
       const enumValue = enumDef[`${value}`];
       if (enumValue === void 0) {
-        throw new DataMapperError(`Value '${value}' not found in enum '${resultType.inner}'`);
+        throw new DataMapperError(`Value '${value}' not found in enum '${scalarType.name}'`);
       }
       return enumValue;
     }
     default:
-      assertNever(resultType, `DataMapper: Unknown result type: ${resultType.type}`);
+      assertNever(scalarType, `DataMapper: Unknown result type: ${scalarType["type"]}`);
   }
 }
-var TIMEZONE_PATTERN = /Z$|(?<!\d{4}-\d{2})[+-]\d{2}(:?\d{2})?$/;
-function ensureTimezoneInIsoString(dt) {
-  const results = TIMEZONE_PATTERN.exec(dt);
-  if (results === null) {
+var TIME_TZ_PATTERN = /\d{2}:\d{2}:\d{2}(?:\.\d+)?(Z|[+-]\d{2}(:?\d{2})?)?$/;
+function normalizeDateTime(dt) {
+  const matches = TIME_TZ_PATTERN.exec(dt);
+  if (matches === null) {
     return `${dt}Z`;
-  } else if (results[0] !== "Z" && results[1] === void 0) {
-    return `${dt}:00`;
-  } else {
-    return dt;
   }
+  let dtWithTz = dt;
+  const [timeTz, tz, tzMinuteOffset] = matches;
+  if (tz !== void 0 && tz !== "Z" && tzMinuteOffset === void 0) {
+    dtWithTz = `${dt}:00`;
+  } else if (tz === void 0) {
+    dtWithTz = `${dt}Z`;
+  }
+  if (timeTz.length === dt.length) {
+    return `1970-01-01T${dtWithTz}`;
+  }
+  return dtWithTz;
 }
 
 // src/tracing.ts
@@ -688,10 +692,10 @@ var GeneratorRegistry = class {
    * method being called, meaning that the built-in time-based generators will always return
    * the same value on repeated calls as long as the same snapshot is used.
    */
-  snapshot(provider) {
+  snapshot() {
     return Object.create(this.#generators, {
       now: {
-        value: provider === "mysql" ? new MysqlNowGenerator() : new NowGenerator()
+        value: new NowGenerator()
       }
     });
   }
@@ -708,12 +712,6 @@ var NowGenerator = class {
     return this.#now.toISOString();
   }
 };
-var MysqlNowGenerator = class {
-  #now = /* @__PURE__ */ new Date();
-  generate() {
-    return this.#now.toISOString().replace("T", " ").replace("Z", "");
-  }
-};
 var UuidGenerator = class {
   generate(arg) {
     if (arg === 4) {
@@ -867,74 +865,82 @@ function isPrismaValuePlaceholder(value) {
 function isPrismaValueGenerator(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "generatorCall";
 }
-function isPrismaValueBytes(value) {
-  return typeof value === "object" && value !== null && value["prisma__type"] === "bytes";
-}
-function isPrismaValueBigInt(value) {
-  return typeof value === "object" && value !== null && value["prisma__type"] === "bigint";
-}
 
 // src/interpreter/render-query.ts
 function renderQuery(dbQuery, scope, generators, maxChunkSize) {
-  const queryType = dbQuery.type;
-  const params = evaluateParams(dbQuery.params, scope, generators);
-  switch (queryType) {
+  const args = dbQuery.args.map((arg) => evaluateArg(arg, scope, generators));
+  switch (dbQuery.type) {
     case "rawSql":
-      return [renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators))];
+      return [renderRawSql(dbQuery.sql, args, dbQuery.argTypes)];
     case "templateSql": {
-      const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, params, maxChunkSize) : [params];
-      return chunks.map((params2) => {
-        if (maxChunkSize !== void 0 && params2.length > maxChunkSize) {
+      const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, args, maxChunkSize) : [args];
+      return chunks.map((params) => {
+        if (maxChunkSize !== void 0 && params.length > maxChunkSize) {
           throw new UserFacingError("The query parameter limit supported by your database is exceeded.", "P2029");
         }
-        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params2);
+        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params, dbQuery.argTypes);
       });
     }
     default:
-      assertNever(queryType, `Invalid query type`);
+      assertNever(dbQuery["type"], `Invalid query type`);
   }
 }
-function evaluateParams(params, scope, generators) {
-  return params.map((param) => evaluateParam(param, scope, generators));
-}
-function evaluateParam(param, scope, generators) {
-  let value = param;
-  while (doesRequireEvaluation(value)) {
-    if (isPrismaValuePlaceholder(value)) {
-      const found = scope[value.prisma__value.name];
+function evaluateArg(arg, scope, generators) {
+  while (doesRequireEvaluation(arg)) {
+    if (isPrismaValuePlaceholder(arg)) {
+      const found = scope[arg.prisma__value.name];
       if (found === void 0) {
-        throw new Error(`Missing value for query variable ${value.prisma__value.name}`);
+        throw new Error(`Missing value for query variable ${arg.prisma__value.name}`);
       }
-      value = found;
-    } else if (isPrismaValueGenerator(value)) {
-      const { name, args } = value.prisma__value;
+      arg = found;
+    } else if (isPrismaValueGenerator(arg)) {
+      const { name, args } = arg.prisma__value;
       const generator = generators[name];
       if (!generator) {
         throw new Error(`Encountered an unknown generator '${name}'`);
       }
-      value = generator.generate(...args.map((arg) => evaluateParam(arg, scope, generators)));
+      arg = generator.generate(...args.map((arg2) => evaluateArg(arg2, scope, generators)));
     } else {
-      assertNever(value, `Unexpected unevaluated value type: ${value}`);
+      assertNever(arg, `Unexpected unevaluated value type: ${arg}`);
     }
   }
-  if (Array.isArray(value)) {
-    value = value.map((el) => evaluateParam(el, scope, generators));
-  } else if (isPrismaValueBytes(value)) {
-    value = Buffer.from(value.prisma__value, "base64");
-  } else if (isPrismaValueBigInt(value)) {
-    value = BigInt(value.prisma__value);
+  if (Array.isArray(arg)) {
+    arg = arg.map((el) => evaluateArg(el, scope, generators));
   }
-  return value;
+  return arg;
 }
-function renderTemplateSql(fragments, placeholderFormat, params) {
+function renderTemplateSql(fragments, placeholderFormat, params, argTypes) {
   let sql = "";
   const ctx = { placeholderNumber: 1 };
   const flattenedParams = [];
-  for (const fragment of pairFragmentsWithParams(fragments, params)) {
-    flattenedParams.push(...flattenedFragmentParams(fragment));
+  const flattenedArgTypes = [];
+  for (const fragment of pairFragmentsWithParams(fragments, params, argTypes)) {
     sql += renderFragment(fragment, placeholderFormat, ctx);
+    if (fragment.type === "stringChunk") {
+      continue;
+    }
+    const length = flattenedParams.length;
+    const added = flattenedParams.push(...flattenedFragmentParams(fragment)) - length;
+    if (fragment.argType.arity === "tuple") {
+      if (added % fragment.argType.elements.length !== 0) {
+        throw new Error(
+          `Malformed query template. Expected the number of parameters to match the tuple arity, but got ${added} parameters for a tuple of arity ${fragment.argType.elements.length}.`
+        );
+      }
+      for (let i = 0; i < added / fragment.argType.elements.length; i++) {
+        flattenedArgTypes.push(...fragment.argType.elements);
+      }
+    } else {
+      for (let i = 0; i < added; i++) {
+        flattenedArgTypes.push(fragment.argType);
+      }
+    }
   }
-  return renderRawSql(sql, flattenedParams);
+  return {
+    sql,
+    args: flattenedParams,
+    argTypes: flattenedArgTypes
+  };
 }
 function renderFragment(fragment, placeholderFormat, ctx) {
   const fragmentType = fragment.type;
@@ -960,36 +966,17 @@ function renderFragment(fragment, placeholderFormat, ctx) {
 function formatPlaceholder(placeholderFormat, placeholderNumber) {
   return placeholderFormat.hasNumbering ? `${placeholderFormat.prefix}${placeholderNumber}` : placeholderFormat.prefix;
 }
-function renderRawSql(sql, params) {
-  const argTypes = params.map((param) => toArgType(param));
+function renderRawSql(sql, args, argTypes) {
   return {
     sql,
-    args: params,
+    args,
     argTypes
   };
 }
-function toArgType(value) {
-  if (typeof value === "string") {
-    return "Text";
-  }
-  if (typeof value === "number") {
-    return "Numeric";
-  }
-  if (typeof value === "boolean") {
-    return "Boolean";
-  }
-  if (Array.isArray(value)) {
-    return "Array";
-  }
-  if (Buffer.isBuffer(value)) {
-    return "Bytes";
-  }
-  return "Unknown";
-}
 function doesRequireEvaluation(param) {
   return isPrismaValuePlaceholder(param) || isPrismaValueGenerator(param);
 }
-function* pairFragmentsWithParams(fragments, params) {
+function* pairFragmentsWithParams(fragments, params, argTypes) {
   let index = 0;
   for (const fragment of fragments) {
     switch (fragment.type) {
@@ -997,7 +984,8 @@ function* pairFragmentsWithParams(fragments, params) {
         if (index >= params.length) {
           throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
         }
-        yield { ...fragment, value: params[index++] };
+        yield { ...fragment, value: params[index], argType: argTypes?.[index] };
+        index++;
         break;
       }
       case "stringChunk": {
@@ -1008,15 +996,16 @@ function* pairFragmentsWithParams(fragments, params) {
         if (index >= params.length) {
           throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
         }
-        const value = params[index++];
-        yield { ...fragment, value: Array.isArray(value) ? value : [value] };
+        const value = params[index];
+        yield { ...fragment, value: Array.isArray(value) ? value : [value], argType: argTypes?.[index] };
+        index++;
         break;
       }
       case "parameterTupleList": {
         if (index >= params.length) {
           throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
         }
-        const value = params[index++];
+        const value = params[index];
         if (!Array.isArray(value)) {
           throw new Error(`Malformed query template. Tuple list expected.`);
         }
@@ -1028,7 +1017,8 @@ function* pairFragmentsWithParams(fragments, params) {
             throw new Error(`Malformed query template. Tuple expected.`);
           }
         }
-        yield { ...fragment, value };
+        yield { ...fragment, value, argType: argTypes?.[index] };
+        index++;
         break;
       }
     }
@@ -1054,7 +1044,7 @@ function* flattenedFragmentParams(fragment) {
 function chunkParams(fragments, params, maxChunkSize) {
   let totalParamCount = 0;
   let maxParamsPerFragment = 0;
-  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+  for (const fragment of pairFragmentsWithParams(fragments, params, void 0)) {
     let paramSize = 0;
     for (const _ of flattenedFragmentParams(fragment)) {
       void _;
@@ -1064,7 +1054,7 @@ function chunkParams(fragments, params, maxChunkSize) {
     totalParamCount += paramSize;
   }
   let chunkedParams = [[]];
-  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+  for (const fragment of pairFragmentsWithParams(fragments, params, void 0)) {
     switch (fragment.type) {
       case "parameter": {
         for (const params2 of chunkedParams) {
@@ -1130,16 +1120,8 @@ function chunkArray(array, chunkSize) {
 // src/interpreter/serialize-sql.ts
 import { ColumnTypeEnum } from "@prisma/driver-adapter-utils";
 function serializeSql(resultSet) {
-  const mappers = resultSet.columnTypes.map((type) => {
-    switch (type) {
-      case ColumnTypeEnum.Bytes:
-        return (value) => Array.isArray(value) ? new Uint8Array(value) : value;
-      default:
-        return (value) => value;
-    }
-  });
   return resultSet.rows.map(
-    (row) => row.map((value, index) => mappers[index](value)).reduce((acc, value, index) => {
+    (row) => row.reduce((acc, value, index) => {
       const splitByDot = resultSet.columnNames[index].split(".");
       let nested = acc;
       for (let i = 0; i < splitByDot.length; i++) {
@@ -1433,14 +1415,14 @@ var QueryInterpreter = class _QueryInterpreter {
       queryPlan,
       queryable,
       this.#placeholderValues,
-      this.#generators.snapshot(queryable.provider)
+      this.#generators.snapshot()
     ).catch((e) => rethrowAsUserFacing(e));
     return value;
   }
   async interpretNode(node, queryable, scope, generators) {
     switch (node.type) {
       case "value": {
-        return { value: evaluateParam(node.args, scope, generators) };
+        return { value: evaluateArg(node.args, scope, generators) };
       }
       case "seq": {
         let result;
@@ -1545,7 +1527,7 @@ var QueryInterpreter = class _QueryInterpreter {
       }
       case "mapField": {
         const { value, lastInsertId } = await this.interpretNode(node.args.records, queryable, scope, generators);
-        return { value: mapField(value, node.args.field), lastInsertId };
+        return { value: mapField2(value, node.args.field), lastInsertId };
       }
       case "join": {
         const { value: parent, lastInsertId } = await this.interpretNode(node.args.parent, queryable, scope, generators);
@@ -1688,9 +1670,9 @@ function asRecord(value) {
   }
   throw new Error(`Expected object, got ${typeof value}`);
 }
-function mapField(value, field) {
+function mapField2(value, field) {
   if (Array.isArray(value)) {
-    return value.map((element) => mapField(element, field));
+    return value.map((element) => mapField2(element, field));
   }
   if (typeof value === "object" && value !== null) {
     return value[field] ?? null;
@@ -1734,7 +1716,7 @@ function attachChildrenToParents(parentRecords, children) {
 function evalFieldInitializer(initializer, lastInsertId, scope, generators) {
   switch (initializer.type) {
     case "value":
-      return evaluateParam(initializer.value, scope, generators);
+      return evaluateArg(initializer.value, scope, generators);
     case "lastInsertId":
       return lastInsertId;
     default:
@@ -1744,16 +1726,16 @@ function evalFieldInitializer(initializer, lastInsertId, scope, generators) {
 function evalFieldOperation(op, value, scope, generators) {
   switch (op.type) {
     case "set":
-      return evaluateParam(op.value, scope, generators);
+      return evaluateArg(op.value, scope, generators);
     case "add":
-      return asNumber2(value) + asNumber2(evaluateParam(op.value, scope, generators));
+      return asNumber2(value) + asNumber2(evaluateArg(op.value, scope, generators));
     case "subtract":
-      return asNumber2(value) - asNumber2(evaluateParam(op.value, scope, generators));
+      return asNumber2(value) - asNumber2(evaluateArg(op.value, scope, generators));
     case "multiply":
-      return asNumber2(value) * asNumber2(evaluateParam(op.value, scope, generators));
+      return asNumber2(value) * asNumber2(evaluateArg(op.value, scope, generators));
     case "divide": {
       const lhs = asNumber2(value);
-      const rhs = asNumber2(evaluateParam(op.value, scope, generators));
+      const rhs = asNumber2(evaluateArg(op.value, scope, generators));
       if (rhs === 0) {
         return null;
       }
@@ -2074,8 +2056,6 @@ export {
   deserializeJsonResponse,
   doKeysMatch,
   isDeepStrictEqual,
-  isPrismaValueBigInt,
-  isPrismaValueBytes,
   isPrismaValueGenerator,
   isPrismaValuePlaceholder,
   noopTracingHelper,

package/dist/interpreter/generators.d.ts

@@ -1,4 +1,3 @@
-import { Provider } from '@prisma/driver-adapter-utils';
 export declare class GeneratorRegistry {
     #private;
     constructor();
@@ -7,7 +6,7 @@ export declare class GeneratorRegistry {
      * method being called, meaning that the built-in time-based generators will always return
      * the same value on repeated calls as long as the same snapshot is used.
      */
-    snapshot(provider?: Provider): Readonly<GeneratorRegistrySnapshot>;
+    snapshot(): Readonly<GeneratorRegistrySnapshot>;
     /**
      * Registers a new generator with the given name.
      */

package/dist/interpreter/render-query.d.ts

@@ -1,6 +1,6 @@
 import { SqlQuery } from '@prisma/driver-adapter-utils';
-import type { PrismaValue, QueryPlanDbQuery } from '../query-plan';
+import { type 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[];
-export declare function evaluateParam(param: PrismaValue, scope: ScopeBindings, generators: GeneratorRegistrySnapshot): unknown;
+export declare function evaluateArg(arg: unknown, scope: ScopeBindings, generators: GeneratorRegistrySnapshot): unknown;

package/dist/query-plan.d.ts

@@ -1,3 +1,4 @@
+import { ArgType, Arity } from '@prisma/driver-adapter-utils';
 export type PrismaValuePlaceholder = {
     prisma__type: 'param';
     prisma__value: {
@@ -14,59 +15,18 @@ export type PrismaValueGenerator = {
     };
 };
 export declare function isPrismaValueGenerator(value: unknown): value is PrismaValueGenerator;
-export type PrismaValueBytes = {
-    prisma__type: 'bytes';
-    prisma__value: string;
-};
-export declare function isPrismaValueBytes(value: unknown): value is PrismaValueBytes;
-export type PrismaValueBigInt = {
-    prisma__type: 'bigint';
-    prisma__value: string;
-};
-export declare function isPrismaValueBigInt(value: unknown): value is PrismaValueBigInt;
-export type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder | PrismaValueGenerator | PrismaValueBytes | PrismaValueBigInt;
-export type PrismaValueType = {
-    type: 'Any';
-} | {
-    type: 'String';
-} | {
-    type: 'Int';
-} | {
-    type: 'BigInt';
-} | {
-    type: 'Float';
-} | {
-    type: 'Boolean';
-} | {
-    type: 'Decimal';
-} | {
-    type: 'Date';
-} | {
-    type: 'Time';
-} | {
-    type: 'Array';
-    inner: PrismaValueType;
-} | {
-    type: 'Json';
-} | {
-    type: 'Object';
-} | {
-    type: 'Bytes';
-} | {
-    type: 'Enum';
-    inner: string;
-};
+export type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder | PrismaValueGenerator;
 export type ResultNode = {
-    type: 'AffectedRows';
+    type: 'affectedRows';
 } | {
-    type: 'Object';
+    type: 'object';
     fields: Record<string, ResultNode>;
     serializedName: string | null;
     skipNulls: boolean;
 } | {
-    type: 'Value';
+    type: 'field';
     dbName: string;
-    resultType: PrismaValueType;
+    fieldType: FieldType;
 };
 export type QueryPlanBinding = {
     name: string;
@@ -75,14 +35,20 @@ export type QueryPlanBinding = {
 export type QueryPlanDbQuery = {
     type: 'rawSql';
     sql: string;
-    params: PrismaValue[];
+    args: PrismaValue[];
+    argTypes: ArgType[];
 } | {
     type: 'templateSql';
     fragments: Fragment[];
     placeholderFormat: PlaceholderFormat;
-    params: PrismaValue[];
+    args: PrismaValue[];
+    argTypes: DynamicArgType[];
     chunkable: boolean;
 };
+export type DynamicArgType = ArgType | {
+    arity: 'tuple';
+    elements: ArgType[];
+};
 export type Fragment = {
     type: 'stringChunk';
     chunk: string;
@@ -300,3 +266,12 @@ export type ValidationError = {
         child: string;
     };
 };
+export type FieldType = {
+    arity: Arity;
+} & FieldScalarType;
+export type FieldScalarType = {
+    type: 'string' | 'int' | 'bigint' | 'float' | 'boolean' | 'json' | 'object' | 'datetime' | 'decimal' | 'bytes' | 'unsupported';
+} | {
+    type: 'enum';
+    name: string;
+};