@merkl/api 0.10.115 → 0.10.117

package/dist/database/api/.generated/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "prisma-client-af23b443b8382cbb95d8d279f45acbbdabe8f79127bbf5f93b1dac1c0967596c",
+  "name": "prisma-client-99d661a46d9ba2164a463a26792cdf95f440e0d53d2d9f55f12c037aca8e34fe",
   "main": "index.js",
   "types": "index.d.ts",
   "browser": "index-browser.js",
@@ -77,8 +77,21 @@
       "import": "./generator-build/index.js",
       "default": "./generator-build/index.js"
     },
+    "./sql": {
+      "require": {
+        "types": "./sql.d.ts",
+        "node": "./sql.js",
+        "default": "./sql.js"
+      },
+      "import": {
+        "types": "./sql.d.ts",
+        "node": "./sql.mjs",
+        "default": "./sql.mjs"
+      },
+      "default": "./sql.js"
+    },
     "./*": "./*"
   },
-  "version": "5.18.0",
+  "version": "6.0.1",
   "sideEffects": false
 }

package/dist/database/api/.generated/runtime/library.d.ts

@@ -56,6 +56,13 @@ export declare type Args<T, F extends Operation> = T extends {
 
 export declare type Args_3<T, F extends Operation> = Args<T, F>;
 
+/**
+ * Original `quaint::ValueType` enum tag from Prisma's `quaint`.
+ * Query arguments marked with this type are sanitized before being sent to the database.
+ * Notice while a query argument may be `null`, `ArgType` is guaranteed to be defined.
+ */
+declare type ArgType = 'Int32' | 'Int64' | 'Float' | 'Double' | 'Text' | 'Enum' | 'EnumArray' | 'Bytes' | 'Boolean' | 'Char' | 'Array' | 'Numeric' | 'Json' | 'Xml' | 'Uuid' | 'DateTime' | 'Date' | 'Time';
+
 /**
  * Attributes is a map from string to attribute values.
  *
@@ -94,7 +101,7 @@ declare type BatchQuery = {
     args: JsArgs | RawQueryArgs;
 };
 
-declare type BatchQueryEngineResult<T> = QueryEngineResult<T> | Error;
+declare type BatchQueryEngineResult<T> = QueryEngineResultData<T> | Error;
 
 declare type BatchQueryOptionsCb = (args: BatchQueryOptionsCbArgs) => Promise<any>;
 
@@ -140,6 +147,15 @@ export declare type ClientOptionDef = undefined | {
     [K in string]: any;
 };
 
+export declare type ClientOtherOps = {
+    $queryRaw<T = unknown>(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise<T>;
+    $queryRawTyped<T>(query: TypedSql<unknown[], T>): PrismaPromise<T[]>;
+    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): PrismaPromise<T>;
+    $executeRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise<number>;
+    $executeRawUnsafe(query: string, ...values: any[]): PrismaPromise<number>;
+    $runCommandRaw(command: InputJsonObject): PrismaPromise<JsonObject>;
+};
+
 declare type ColumnType = (typeof ColumnTypeEnum)[keyof typeof ColumnTypeEnum];
 
 declare const ColumnTypeEnum: {
@@ -250,7 +266,36 @@ export declare type Count<O> = {
     [K in keyof O]: Count<number>;
 } & {};
 
-declare type CustomDataProxyFetch = (fetch: Fetch) => Fetch;
+/**
+ * Custom fetch function for `DataProxyEngine`.
+ *
+ * We can't use the actual type of `globalThis.fetch` because this will result
+ * in API Extractor referencing Node.js type definitions in the `.d.ts` bundle
+ * for the client runtime. We can only use such types in internal types that
+ * don't end up exported anywhere.
+
+ * It's also not possible to write a definition of `fetch` that would accept the
+ * actual `fetch` function from different environments such as Node.js and
+ * Cloudflare Workers (with their extensions to `RequestInit` and `Response`).
+ * `fetch` is used in both covariant and contravariant positions in
+ * `CustomDataProxyFetch`, making it invariant, so we need the exact same type.
+ * Even if we removed the argument and left `fetch` in covariant position only,
+ * then for an extension-supplied function to be assignable to `customDataProxyFetch`,
+ * the platform-specific (or custom) `fetch` function needs to be assignable
+ * to our `fetch` definition. This, in turn, requires the third-party `Response`
+ * to be a subtype of our `Response` (which is not a problem, we could declare
+ * a minimal `Response` type that only includes what we use) *and* requires the
+ * third-party `RequestInit` to be a supertype of our `RequestInit` (i.e. we
+ * have to declare all properties any `RequestInit` implementation in existence
+ * could possibly have), which is not possible.
+ *
+ * Since `@prisma/extension-accelerate` redefines the type of
+ * `__internalParams.customDataProxyFetch` to its own type anyway (probably for
+ * exactly this reason), our definition is never actually used and is completely
+ * ignored, so it doesn't matter, and we can just use `unknown` as the type of
+ * `fetch` here.
+ */
+declare type CustomDataProxyFetch = (fetch: unknown) => unknown;
 
 declare class DataLoader<T = unknown> {
     private options;
@@ -603,6 +648,8 @@ declare function defineExtension(ext: ExtensionArgs | ((client: Client) => Clien
 
 declare const denylist: readonly ["$connect", "$disconnect", "$on", "$transaction", "$use", "$extends"];
 
+export declare function deserializeJsonResponse(result: unknown): unknown;
+
 export declare type DevTypeMapDef = {
     meta: {
         modelProps: string;
@@ -671,6 +718,7 @@ export declare namespace DMMF {
     export type Model = ReadonlyDeep_2<{
         name: string;
         dbName: string | null;
+        schema: string | null;
         fields: Field[];
         uniqueFields: string[][];
         uniqueIndexes: uniqueIndex[];
@@ -696,6 +744,12 @@ export declare namespace DMMF {
          * BigInt, Boolean, Bytes, DateTime, Decimal, Float, Int, JSON, String, $ModelName
          */
         type: string;
+        /**
+         * Native database type, if specified.
+         * For example, `@db.VarChar(191)` is encoded as `['VarChar', ['191']]`,
+         * `@db.Text` is encoded as `['Text', []]`.
+         */
+        nativeType?: [string, string[]] | null;
         dbName?: string | null;
         hasDefaultValue: boolean;
         default?: FieldDefault | FieldDefaultScalar | FieldDefaultScalar[];
@@ -707,7 +761,7 @@ export declare namespace DMMF {
     }>;
     export type FieldDefault = ReadonlyDeep_2<{
         name: string;
-        args: any[];
+        args: Array<string | number>;
     }>;
     export type FieldDefaultScalar = string | boolean | number;
     export type Index = ReadonlyDeep_2<{
@@ -852,11 +906,13 @@ export declare namespace DMMF {
     }
 }
 
+export declare function dmmfToRuntimeDataModel(dmmfDataModel: DMMF.Datamodel): RuntimeDataModel;
+
 export declare interface DriverAdapter extends Queryable {
     /**
      * Starts new transaction.
      */
-    startTransaction(): Promise<Result_4<Transaction>>;
+    transactionContext(): Promise<Result_4<TransactionContext>>;
     /**
      * Optional method that returns extra connection info
      */
@@ -879,7 +935,7 @@ export declare type DynamicClientExtensionThis<TypeMap extends TypeMapDef, TypeM
 } & {
     [P in Exclude<TypeMap['meta']['modelProps'], keyof ExtArgs['client']>]: DynamicModelExtensionThis<TypeMap, ModelKey<TypeMap, P>, ExtArgs, ClientOptions>;
 } & {
-    [P in Exclude<keyof TypeMap['other']['operations'], keyof ExtArgs['client']>]: <R = GetResult<TypeMap['other']['payload'], any, P & Operation, ClientOptions>>(...args: ToTuple<TypeMap['other']['operations'][P]['args']>) => PrismaPromise<R>;
+    [P in Exclude<keyof TypeMap['other']['operations'], keyof ExtArgs['client']>]: P extends keyof ClientOtherOps ? ClientOtherOps[P] : never;
 } & {
     [P in Exclude<ClientBuiltInProp, keyof ExtArgs['client']>]: DynamicClientExtensionThisBuiltin<TypeMap, TypeMapCb, ExtArgs, ClientOptions>[P];
 } & {
@@ -1017,7 +1073,7 @@ declare interface Engine<InteractiveTransactionPayload = unknown> {
     start(): Promise<void>;
     stop(): Promise<void>;
     version(forceRun?: boolean): Promise<string> | string;
-    request<T>(query: JsonQuery, options: RequestOptions_2<InteractiveTransactionPayload>): Promise<QueryEngineResult<T>>;
+    request<T>(query: JsonQuery, options: RequestOptions<InteractiveTransactionPayload>): Promise<QueryEngineResultData<T>>;
     requestBatch<T>(queries: JsonQuery[], options: RequestBatchOptions<InteractiveTransactionPayload>): Promise<BatchQueryEngineResult<T>[]>;
     transaction(action: 'start', headers: Transaction_2.TransactionHeaders, options: Transaction_2.Options): Promise<Transaction_2.InteractiveTransactionInfo<unknown>>;
     transaction(action: 'commit', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
@@ -1121,6 +1177,7 @@ declare type EngineSpan = {
         trace_id: string;
         span_id: string;
     }[];
+    kind: EngineSpanKind;
 };
 
 declare type EngineSpanEvent = {
@@ -1128,6 +1185,8 @@ declare type EngineSpanEvent = {
     spans: EngineSpan[];
 };
 
+declare type EngineSpanKind = 'client' | 'internal';
+
 declare type EnvPaths = {
     rootEnvPath: string | null;
     schemaEnvPath: string | undefined;
@@ -1282,6 +1341,8 @@ declare namespace Extensions_2 {
     export {
         InternalArgs,
         DefaultArgs,
+        GetPayloadResultExtensionKeys,
+        GetPayloadResultExtensionObject,
         GetPayloadResult,
         GetSelect,
         GetOmit,
@@ -1310,6 +1371,7 @@ declare namespace Extensions_2 {
         DevTypeMapDef,
         DevTypeMapFnDef,
         ClientOptionDef,
+        ClientOtherOps,
         TypeMapCbDef,
         ModelKey,
         RequiredExtensionArgs as UserArgs
@@ -1322,8 +1384,6 @@ export declare type ExtractGlobalOmit<Options, ModelName extends string> = Optio
     };
 } ? GlobalOmit : {};
 
-declare type Fetch = typeof nodeFetch;
-
 /**
  * A reference to a specific field of a specific model
  */
@@ -1387,7 +1447,7 @@ export declare type GetFindResult<P extends OperationPayload, A, ClientOptions>
 } & Record<string, unknown> | {
     include: infer I extends object;
 } & Record<string, unknown> ? {
-    [K in keyof S | keyof I as (S & I)[K] extends false | undefined | null ? never : K]: (S & I)[K] extends object ? P extends SelectablePayloadFields<K, (infer O)[]> ? O extends OperationPayload ? GetFindResult<O, (S & I)[K], ClientOptions>[] : never : P extends SelectablePayloadFields<K, infer O | null> ? O extends OperationPayload ? GetFindResult<O, (S & I)[K], ClientOptions> | SelectField<P, K> & null : never : K extends '_count' ? Count<GetFindResult<P, (S & I)[K], ClientOptions>> : never : P extends SelectablePayloadFields<K, (infer O)[]> ? O extends OperationPayload ? DefaultSelection<O, {}, ClientOptions>[] : never : P extends SelectablePayloadFields<K, infer O | null> ? O extends OperationPayload ? DefaultSelection<O, {}, ClientOptions> | SelectField<P, K> & null : never : P extends {
+    [K in keyof S | keyof I as (S & I)[K] extends false | undefined | Skip | null ? never : K]: (S & I)[K] extends object ? P extends SelectablePayloadFields<K, (infer O)[]> ? O extends OperationPayload ? GetFindResult<O, (S & I)[K], ClientOptions>[] : never : P extends SelectablePayloadFields<K, infer O | null> ? O extends OperationPayload ? GetFindResult<O, (S & I)[K], ClientOptions> | SelectField<P, K> & null : never : K extends '_count' ? Count<GetFindResult<P, (S & I)[K], ClientOptions>> : never : P extends SelectablePayloadFields<K, (infer O)[]> ? O extends OperationPayload ? DefaultSelection<O, {}, ClientOptions>[] : never : P extends SelectablePayloadFields<K, infer O | null> ? O extends OperationPayload ? DefaultSelection<O, {}, ClientOptions> | SelectField<P, K> & null : never : P extends {
         scalars: {
             [k in K]: infer O;
         };
@@ -1406,14 +1466,18 @@ export declare type GetGroupByResult<P extends OperationPayload, A> = A extends
     [K in A['by']]: P['scalars'][K];
 }> : {}[];
 
-export declare type GetOmit<BaseKeys extends string, R extends InternalArgs['result'][string]> = {
-    [K in (string extends keyof R ? never : keyof R) | BaseKeys]?: boolean;
+export declare type GetOmit<BaseKeys extends string, R extends InternalArgs['result'][string], ExtraType = never> = {
+    [K in (string extends keyof R ? never : keyof R) | BaseKeys]?: boolean | ExtraType;
 };
 
-export declare type GetPayloadResult<Base extends Record<any, any>, R extends InternalArgs['result'][string], KR extends keyof R = string extends keyof R ? never : keyof R> = unknown extends R ? Base : {
-    [K in KR | keyof Base]: K extends KR ? R[K] extends () => {
+export declare type GetPayloadResult<Base extends Record<any, any>, R extends InternalArgs['result'][string]> = Omit<Base, GetPayloadResultExtensionKeys<R>> & GetPayloadResultExtensionObject<R>;
+
+export declare type GetPayloadResultExtensionKeys<R extends InternalArgs['result'][string], KR extends keyof R = string extends keyof R ? never : keyof R> = KR;
+
+export declare type GetPayloadResultExtensionObject<R extends InternalArgs['result'][string]> = {
+    [K in GetPayloadResultExtensionKeys<R>]: R[K] extends () => {
         compute: (...args: any) => infer C;
-    } ? C : never : Base[K];
+    } ? C : never;
 };
 
 export declare function getPrismaClient(config: GetPrismaClientConfig): {
@@ -1494,6 +1558,11 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
          * @returns
          */
         $queryRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise_2<unknown>;
+        /**
+         * Counterpart to $queryRaw, that returns strongly typed results
+         * @param typedSql
+         */
+        $queryRawTyped(typedSql: UnknownTypedSql): PrismaPromise_2<unknown>;
         /**
          * Unsafe counterpart of `$queryRaw` that is susceptible to SQL injections
          * @see https://github.com/prisma/prisma/issues/7142
@@ -1646,6 +1715,7 @@ export declare type GetResult<Payload extends OperationPayload, Args, OperationN
     count: GetCountResult<Args>;
     groupBy: GetGroupByResult<Payload, Args>;
     $queryRaw: unknown;
+    $queryRawTyped: unknown;
     $executeRaw: number;
     $queryRawUnsafe: unknown;
     $executeRawUnsafe: number;
@@ -1696,6 +1766,38 @@ declare type HandleErrorParams = {
  */
 declare type HrTime = [number, number];
 
+/**
+ * Matches a JSON array.
+ * Unlike \`JsonArray\`, readonly arrays are assignable to this type.
+ */
+export declare interface InputJsonArray extends ReadonlyArray<InputJsonValue | null> {
+}
+
+/**
+ * Matches a JSON object.
+ * Unlike \`JsonObject\`, this type allows undefined and read-only properties.
+ */
+export declare type InputJsonObject = {
+    readonly [Key in string]?: InputJsonValue | null;
+};
+
+/**
+ * Matches any valid value that can be used as an input for operations like
+ * create and update as the value of a JSON field. Unlike \`JsonValue\`, this
+ * type allows read-only arrays and read-only object properties and disallows
+ * \`null\` at the top level.
+ *
+ * \`null\` cannot be used as the value of a JSON field because its meaning
+ * would be ambiguous. Use \`Prisma.JsonNull\` to store the JSON null value or
+ * \`Prisma.DbNull\` to clear the JSON value and set the field to the database
+ * NULL value instead.
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-by-null-values
+ */
+export declare type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray | {
+    toJSON(): unknown;
+};
+
 declare type InteractiveTransactionInfo<Payload = unknown> = {
     /**
      * Transaction ID returned by the query engine.
@@ -1768,7 +1870,7 @@ declare type InternalRequestParams = {
     /** Used to convert args for middleware and back */
     middlewareArgsMapper?: MiddlewareArgsMapper<unknown, unknown>;
     /** Used for Accelerate client extension via Data Proxy */
-    customDataProxyFetch?: (fetch: Fetch) => Fetch;
+    customDataProxyFetch?: CustomDataProxyFetch;
 } & Omit<QueryMiddlewareParams, 'runInTransaction'>;
 
 declare enum IsolationLevel {
@@ -1779,6 +1881,10 @@ declare enum IsolationLevel {
     Serializable = "Serializable"
 }
 
+declare function isSkip(value: unknown): value is Skip;
+
+export declare function isTypedSql(value: unknown): value is UnknownTypedSql;
+
 export declare type ITXClientDenyList = (typeof denylist)[number];
 
 export declare const itxClientDenyList: readonly (string | symbol)[];
@@ -1801,7 +1907,7 @@ export declare type JsArgs = {
     [argName: string]: JsInputValue;
 };
 
-export declare type JsInputValue = null | undefined | string | number | boolean | bigint | Uint8Array | Date | DecimalJsLike | ObjectEnumValue | RawParameters | JsonConvertible | FieldRef<string, unknown> | JsInputValue[] | {
+export declare type JsInputValue = null | undefined | string | number | boolean | bigint | Uint8Array | Date | DecimalJsLike | ObjectEnumValue | RawParameters | JsonConvertible | FieldRef<string, unknown> | JsInputValue[] | Skip | {
     [key: string]: JsInputValue;
 };
 
@@ -1809,10 +1915,14 @@ declare type JsonArgumentValue = number | string | boolean | null | RawTaggedVal
     [key: string]: JsonArgumentValue;
 };
 
+/**
+ * From https://github.com/sindresorhus/type-fest/
+ * Matches a JSON array.
+ */
 export declare interface JsonArray extends Array<JsonValue> {
 }
 
-declare type JsonBatchQuery = {
+export declare type JsonBatchQuery = {
     batch: JsonQuery[];
     transaction?: {
         isolationLevel?: Transaction_2.IsolationLevel;
@@ -1831,11 +1941,16 @@ declare type JsonFieldSelection = {
 declare class JsonNull extends NullTypesEnumValue {
 }
 
+/**
+ * From https://github.com/sindresorhus/type-fest/
+ * Matches a JSON object.
+ * This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from.
+ */
 export declare type JsonObject = {
     [Key in string]?: JsonValue;
 };
 
-declare type JsonQuery = {
+export declare type JsonQuery = {
     modelName?: string;
     action: JsonQueryAction;
     query: JsonFieldSelection;
@@ -1850,6 +1965,10 @@ declare type JsonSelectionSet = {
     [fieldName: string]: boolean | JsonFieldSelection;
 };
 
+/**
+ * From https://github.com/sindresorhus/type-fest/
+ * Matches any valid JSON value.
+ */
 export declare type JsonValue = string | number | boolean | JsonObject | JsonArray | null;
 
 export declare type JsOutputValue = null | string | number | boolean | bigint | Uint8Array | Date | Decimal | JsOutputValue[] | {
@@ -1947,6 +2066,8 @@ declare type LogLevel = 'info' | 'query' | 'warn' | 'error';
  */
 export declare function makeStrictEnum<T extends Record<PropertyKey, string | number>>(definition: T): T;
 
+export declare function makeTypedQueryFactory(sql: string): (...values: any[]) => TypedSql<any[], unknown>;
+
 /**
  * Class that holds the list of all extensions, applied to particular instance,
  * as well as resolved versions of the components that need to apply on
@@ -2079,37 +2200,6 @@ export declare type Narrowable = string | number | bigint | boolean | [];
 
 export declare type NeverToUnknown<T> = [T] extends [never] ? unknown : T;
 
-/**
- * Imitates `fetch` via `https` to only suit our needs, it does nothing more.
- * This is because we cannot bundle `node-fetch` as it uses many other Node.js
- * utilities, while also bloating our bundles. This approach is much leaner.
- * @param url
- * @param options
- * @returns
- */
-declare function nodeFetch(url: string, options?: RequestOptions): Promise<RequestResponse>;
-
-declare class NodeHeaders {
-    readonly headers: Map<string, string>;
-    constructor(init?: Record<any, any>);
-    append(name: string, value: string): void;
-    delete(name: string): void;
-    get(name: string): string | null;
-    has(name: string): boolean;
-    set(name: string, value: string): void;
-    forEach(callbackfn: (value: string, key: string, parent: this) => void, thisArg?: any): void;
-}
-
-/**
- * @deprecated Please don´t rely on type checks to this error anymore.
- * This will become a regular `PrismaClientKnownRequestError` with code `P2025`
- * in the future major version of the client.
- * Instead of `error instanceof Prisma.NotFoundError` use `error.code === "P2025"`.
- */
-export declare class NotFoundError extends PrismaClientKnownRequestError {
-    constructor(message: string, clientVersion: string);
-}
-
 declare class NullTypesEnumValue extends ObjectEnumValue {
     _getNamespace(): string;
 }
@@ -2144,7 +2234,7 @@ export declare const objectEnumValues: {
 
 declare const officialPrismaAdapters: readonly ["@prisma/adapter-planetscale", "@prisma/adapter-neon", "@prisma/adapter-libsql", "@prisma/adapter-d1", "@prisma/adapter-pg", "@prisma/adapter-pg-worker"];
 
-export declare type Omission = Record<string, boolean>;
+export declare type Omission = Record<string, boolean | Skip>;
 
 declare type Omit_2<T, K extends string | number | symbol> = {
     [P in keyof T as P extends K ? never : P]: T[P];
@@ -2385,6 +2475,8 @@ declare type PrismaPromiseInteractiveTransaction<PayloadType = unknown> = {
 
 declare type PrismaPromiseTransaction<PayloadType = unknown> = PrismaPromiseBatchTransaction | PrismaPromiseInteractiveTransaction<PayloadType>;
 
+export declare const PrivateResultType: unique symbol;
+
 declare namespace Public {
     export {
         validator
@@ -2406,6 +2498,7 @@ declare namespace Public_2 {
 declare type Query = {
     sql: string;
     args: Array<unknown>;
+    argTypes: Array<ArgType>;
 };
 
 declare interface Queryable {
@@ -2476,9 +2569,8 @@ declare type QueryEngineRequest = {
     variables: Object;
 };
 
-declare type QueryEngineResult<T> = {
+declare type QueryEngineResultData<T> = {
     data: T;
-    elapsed: number;
 };
 
 declare type QueryEngineTelemetry = {
@@ -2537,7 +2629,7 @@ export declare type RawParameters = {
     values: string;
 };
 
-export declare type RawQueryArgs = Sql | [query: string, ...values: RawValue[]];
+export declare type RawQueryArgs = Sql | UnknownTypedSql | [query: string, ...values: RawValue[]];
 
 declare type RawTaggedValue = {
     $type: 'Raw';
@@ -2571,7 +2663,7 @@ declare type RequestBatchOptions<InteractiveTransactionPayload> = {
     traceparent?: string;
     numTry?: number;
     containsWrite: boolean;
-    customDataProxyFetch?: (fetch: Fetch) => Fetch;
+    customDataProxyFetch?: CustomDataProxyFetch;
 };
 
 declare interface RequestError {
@@ -2591,7 +2683,7 @@ declare class RequestHandler {
     private logEmitter?;
     constructor(client: Client, logEmitter?: LogEmitter);
     request(params: RequestParams): Promise<any>;
-    mapQueryEngineResult({ dataPath, unpacker }: RequestParams, response: QueryEngineResult<any>): any;
+    mapQueryEngineResult({ dataPath, unpacker }: RequestParams, response: QueryEngineResultData<any>): any;
     /**
      * Handles the error and logs it, logging the error is done synchronously waiting for the event
      * handlers to finish.
@@ -2603,18 +2695,12 @@ declare class RequestHandler {
     get [Symbol.toStringTag](): string;
 }
 
-declare type RequestOptions = {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string;
-};
-
-declare type RequestOptions_2<InteractiveTransactionPayload> = {
+declare type RequestOptions<InteractiveTransactionPayload> = {
     traceparent?: string;
     numTry?: number;
     interactiveTransaction?: InteractiveTransactionOptions<InteractiveTransactionPayload>;
     isWrite: boolean;
-    customDataProxyFetch?: (fetch: Fetch) => Fetch;
+    customDataProxyFetch?: CustomDataProxyFetch;
 };
 
 declare type RequestParams = {
@@ -2632,17 +2718,7 @@ declare type RequestParams = {
     otelParentCtx?: Context;
     otelChildCtx?: Context;
     globalOmit?: GlobalOmitOptions;
-    customDataProxyFetch?: (fetch: Fetch) => Fetch;
-};
-
-declare type RequestResponse = {
-    ok: boolean;
-    url: string;
-    statusText?: string;
-    status: number;
-    headers: NodeHeaders;
-    text: () => Promise<string>;
-    json: () => Promise<any>;
+    customDataProxyFetch?: CustomDataProxyFetch;
 };
 
 declare type RequiredExtensionArgs = NameArgs & ResultArgs & ModelArgs & ClientArgs & QueryOptions;
@@ -2753,7 +2829,7 @@ export declare type Return<T> = T extends (...args: any[]) => infer R ? R : T;
 
 declare type Runtime = "edge-routine" | "workerd" | "deno" | "lagon" | "react-native" | "netlify" | "electron" | "node" | "bun" | "edge-light" | "fastly" | "unknown";
 
-declare type RuntimeDataModel = {
+export declare type RuntimeDataModel = {
     readonly models: Record<string, RuntimeModel>;
     readonly enums: Record<string, RuntimeEnum>;
     readonly types: Record<string, RuntimeModel>;
@@ -2781,9 +2857,32 @@ export declare type SelectField<P extends SelectablePayloadFields<any, any>, K e
     composites: Record<K, any>;
 } ? P['composites'][K] : never;
 
-declare type Selection_2 = Record<string, boolean | JsArgs>;
+declare type Selection_2 = Record<string, boolean | Skip | JsArgs>;
 export { Selection_2 as Selection }
 
+export declare function serializeJsonQuery({ modelName, action, args, runtimeDataModel, extensions, callsite, clientMethod, errorFormat, clientVersion, previewFeatures, globalOmit, }: SerializeParams): JsonQuery;
+
+declare type SerializeParams = {
+    runtimeDataModel: RuntimeDataModel;
+    modelName?: string;
+    action: Action;
+    args?: JsArgs;
+    extensions?: MergedExtensionsList;
+    callsite?: CallSite;
+    clientMethod: string;
+    clientVersion: string;
+    errorFormat: ErrorFormat;
+    previewFeatures: string[];
+    globalOmit?: GlobalOmitOptions;
+};
+
+declare class Skip {
+    constructor(param?: symbol);
+    ifUndefined<T>(value: T | undefined): T | Skip;
+}
+
+export declare const skip: Skip;
+
 /**
  * An interface that represents a span. A span represents a single operation
  * within a trace. Examples of span might include remote procedure calls or a
@@ -3136,6 +3235,13 @@ declare namespace Transaction_2 {
     }
 }
 
+declare interface TransactionContext extends Queryable {
+    /**
+     * Starts new transaction.
+     */
+    startTransaction(): Promise<Result_4<Transaction>>;
+}
+
 declare type TransactionHeaders = {
     traceparent?: string;
 };
@@ -3152,6 +3258,13 @@ declare type TransactionOptions_2<InteractiveTransactionPayload> = {
     options: BatchTransactionOptions;
 };
 
+export declare class TypedSql<Values extends readonly unknown[], Result> {
+    [PrivateResultType]: Result;
+    constructor(sql: string, values: Values);
+    get sql(): string;
+    get values(): Values;
+}
+
 export declare type TypeMapCbDef = Fn<{
     extArgs: InternalArgs;
     clientOptions: ClientOptionDef;
@@ -3166,6 +3279,10 @@ declare namespace Types {
         Extensions_2 as Extensions,
         Utils,
         Public_2 as Public,
+        isSkip,
+        Skip,
+        skip,
+        UnknownTypedSql,
         OperationPayload as Payload
     }
 }
@@ -3176,6 +3293,8 @@ declare type UnknownErrorParams = {
     batchRequestIdx?: number;
 };
 
+export declare type UnknownTypedSql = TypedSql<unknown[], unknown>;
+
 declare type Unpacker = (data: any) => any;
 
 export declare type UnwrapPayload<P> = {} extends P ? unknown : {
@@ -3214,9 +3333,6 @@ declare namespace Utils {
         Narrow,
         Exact,
         Cast,
-        JsonObject,
-        JsonArray,
-        JsonValue,
         Record_2 as Record,
         UnwrapPromise,
         UnwrapTuple,

package/dist/database/api/.generated/schema.prisma

@@ -2,7 +2,7 @@ generator client {
   provider        = "prisma-client-js"
   binaryTargets   = ["native", "linux-arm64-openssl-1.1.x", "linux-musl-arm64-openssl-3.0.x"]
   output          = ".generated/"
-  previewFeatures = ["fullTextSearch"]
+  previewFeatures = ["fullTextSearchPostgres", "relationJoins"]
 }
 
 datasource db {

package/dist/database/api/.generated/wasm.d.ts

@@ -1 +1 @@
-export * from './index'
+export * from "./index"

package/dist/database/engine/.generated/default.d.ts

@@ -1 +1 @@
-export * from './index'
+export * from "./index"

package/dist/database/engine/.generated/edge.d.ts

@@ -1 +1 @@
-export * from './default'
+export * from "./default"