@creator.co/creatorco-prisma-client 1.0.19 → 1.0.20

package/runtime/library.d.ts

@@ -79,7 +79,7 @@ declare type BatchQueryOptionsCbArgs = {
 };
 
 declare type BatchTransactionOptions = {
-    isolationLevel?: Transaction_2.IsolationLevel;
+    isolationLevel?: Transaction.IsolationLevel;
 };
 
 declare interface BinaryTargetsEnvValue {
@@ -165,10 +165,6 @@ declare type ComputedFieldsMap = {
     [fieldName: string]: ComputedField;
 };
 
-declare type ConnectionInfo = {
-    schemaName?: string;
-};
-
 declare interface Context {
     /**
      * Get a value from the context.
@@ -558,27 +554,6 @@ declare function defineExtension(ext: ExtensionArgs | ((client: Client) => Clien
 
 declare const denylist: readonly ["$connect", "$disconnect", "$on", "$transaction", "$use", "$extends"];
 
-/**
- * Detect the current JavaScript runtime following
- * the WinterCG Runtime Keys proposal:
- *
- * - `edge-routine` Alibaba Cloud Edge Routine
- * - `workerd` Cloudflare Workers
- * - `deno` Deno and Deno Deploy
- * - `lagon` Lagon
- * - `react-native` React Native
- * - `netlify` Netlify Edge Functions
- * - `electron` Electron
- * - `node` Node.js
- * - `bun` Bun
- * - `edge-light` Vercel Edge Functions
- * - `fastly` Fastly Compute@Edge
- *
- * @see https://runtime-keys.proposal.wintercg.org/
- * @returns {Runtime}
- */
-export declare function detectRuntime(): Runtime;
-
 export declare type DevTypeMapDef = {
     meta: {
         modelProps: string;
@@ -599,59 +574,59 @@ export declare type DevTypeMapFnDef = {
     payload: OperationPayload;
 };
 
-declare type Dictionary<T> = {
-    [key: string]: T | undefined;
-};
-
-declare interface Dictionary_2<T> {
+declare interface Dictionary<T> {
     [key: string]: T;
 }
 
+declare type Dictionary_2<T> = {
+    [key: string]: T | undefined;
+};
+
 export declare namespace DMMF {
-    export type Document = ReadonlyDeep_2<{
+    export interface Document {
         datamodel: Datamodel;
         schema: Schema;
         mappings: Mappings;
-    }>;
-    export type Mappings = ReadonlyDeep_2<{
+    }
+    export interface Mappings {
         modelOperations: ModelMapping[];
         otherOperations: {
             read: string[];
             write: string[];
         };
-    }>;
-    export type OtherOperationMappings = ReadonlyDeep_2<{
+    }
+    export interface OtherOperationMappings {
         read: string[];
         write: string[];
-    }>;
-    export type DatamodelEnum = ReadonlyDeep_2<{
+    }
+    export interface DatamodelEnum {
         name: string;
         values: EnumValue[];
         dbName?: string | null;
         documentation?: string;
-    }>;
-    export type SchemaEnum = ReadonlyDeep_2<{
+    }
+    export interface SchemaEnum {
         name: string;
         values: string[];
-    }>;
-    export type EnumValue = ReadonlyDeep_2<{
+    }
+    export interface EnumValue {
         name: string;
         dbName: string | null;
-    }>;
-    export type Datamodel = ReadonlyDeep_2<{
+    }
+    export interface Datamodel {
         models: Model[];
         enums: DatamodelEnum[];
         types: Model[];
-    }>;
-    export type uniqueIndex = ReadonlyDeep_2<{
+    }
+    export interface uniqueIndex {
         name: string;
         fields: string[];
-    }>;
-    export type PrimaryKey = ReadonlyDeep_2<{
+    }
+    export interface PrimaryKey {
         name: string | null;
         fields: string[];
-    }>;
-    export type Model = ReadonlyDeep_2<{
+    }
+    export interface Model {
         name: string;
         dbName: string | null;
         fields: Field[];
@@ -660,11 +635,11 @@ export declare namespace DMMF {
         documentation?: string;
         primaryKey: PrimaryKey | null;
         isGenerated?: boolean;
-    }>;
+    }
     export type FieldKind = 'scalar' | 'object' | 'enum' | 'unsupported';
     export type FieldNamespace = 'model' | 'prisma';
     export type FieldLocation = 'scalar' | 'inputObjectTypes' | 'outputObjectTypes' | 'enumTypes' | 'fieldRefTypes';
-    export type Field = ReadonlyDeep_2<{
+    export interface Field {
         kind: FieldKind;
         name: string;
         isRequired: boolean;
@@ -687,13 +662,13 @@ export declare namespace DMMF {
         relationOnDelete?: string;
         relationName?: string;
         documentation?: string;
-    }>;
-    export type FieldDefault = ReadonlyDeep_2<{
+    }
+    export interface FieldDefault {
         name: string;
         args: any[];
-    }>;
+    }
     export type FieldDefaultScalar = string | boolean | number;
-    export type Schema = ReadonlyDeep_2<{
+    export interface Schema {
         rootQueryType?: string;
         rootMutationType?: string;
         inputObjectTypes: {
@@ -711,17 +686,17 @@ export declare namespace DMMF {
         fieldRefTypes: {
             prisma?: FieldRefType[];
         };
-    }>;
-    export type Query = ReadonlyDeep_2<{
+    }
+    export interface Query {
         name: string;
         args: SchemaArg[];
         output: QueryOutput;
-    }>;
-    export type QueryOutput = ReadonlyDeep_2<{
+    }
+    export interface QueryOutput {
         name: string;
         isRequired: boolean;
         isList: boolean;
-    }>;
+    }
     export type TypeRef<AllowedLocations extends FieldLocation> = {
         isList: boolean;
         type: string;
@@ -729,33 +704,33 @@ export declare namespace DMMF {
         namespace?: FieldNamespace;
     };
     export type InputTypeRef = TypeRef<'scalar' | 'inputObjectTypes' | 'enumTypes' | 'fieldRefTypes'>;
-    export type SchemaArg = ReadonlyDeep_2<{
+    export interface SchemaArg {
         name: string;
         comment?: string;
         isNullable: boolean;
         isRequired: boolean;
         inputTypes: InputTypeRef[];
         deprecation?: Deprecation;
-    }>;
-    export type OutputType = ReadonlyDeep_2<{
+    }
+    export interface OutputType {
         name: string;
         fields: SchemaField[];
-    }>;
-    export type SchemaField = ReadonlyDeep_2<{
+    }
+    export interface SchemaField {
         name: string;
         isNullable?: boolean;
         outputType: OutputTypeRef;
         args: SchemaArg[];
         deprecation?: Deprecation;
         documentation?: string;
-    }>;
+    }
     export type OutputTypeRef = TypeRef<'scalar' | 'outputObjectTypes' | 'enumTypes'>;
-    export type Deprecation = ReadonlyDeep_2<{
+    export interface Deprecation {
         sinceVersion: string;
         reason: string;
         plannedRemovalVersion?: string;
-    }>;
-    export type InputType = ReadonlyDeep_2<{
+    }
+    export interface InputType {
         name: string;
         constraints: {
             maxNumFields: number | null;
@@ -766,14 +741,14 @@ export declare namespace DMMF {
             source?: string;
         };
         fields: SchemaArg[];
-    }>;
-    export type FieldRefType = ReadonlyDeep_2<{
+    }
+    export interface FieldRefType {
         name: string;
         allowTypes: FieldRefAllowType[];
         fields: SchemaArg[];
-    }>;
+    }
     export type FieldRefAllowType = TypeRef<'scalar' | 'enumTypes'>;
-    export type ModelMapping = ReadonlyDeep_2<{
+    export interface ModelMapping {
         model: string;
         plural: string;
         findUnique?: string | null;
@@ -793,7 +768,7 @@ export declare namespace DMMF {
         count?: string | null;
         findRaw?: string | null;
         aggregateRaw?: string | null;
-    }>;
+    }
     export enum ModelAction {
         findUnique = "findUnique",
         findUniqueOrThrow = "findUniqueOrThrow",
@@ -817,24 +792,24 @@ export declare namespace DMMF {
 
 export declare class DMMFClass implements DMMF.Document {
     document: DMMF.Document;
-    private _compositeNames?;
-    private _inputTypesByName?;
-    private _typeAndModelMap?;
-    private _mappingsMap?;
-    private _outputTypeMap?;
-    private _rootFieldMap?;
+    private compositeNames;
+    private inputTypesByName;
+    readonly typeAndModelMap: Dictionary<DMMF.Model>;
+    readonly mappingsMap: Dictionary<DMMF.ModelMapping>;
+    readonly outputTypeMap: NamespacedTypeMap<DMMF.OutputType>;
+    readonly rootFieldMap: Dictionary<DMMF.SchemaField>;
     constructor(document: DMMF.Document);
-    private get compositeNames();
-    private get inputTypesByName();
-    get typeAndModelMap(): Dictionary_2<DMMF.Model>;
-    get mappingsMap(): Dictionary_2<DMMF.ModelMapping>;
-    get outputTypeMap(): NamespacedTypeMap<DMMF.OutputType>;
-    get rootFieldMap(): Dictionary_2<DMMF.SchemaField>;
     get datamodel(): DMMF.Datamodel;
     get mappings(): DMMF.Mappings;
     get schema(): DMMF.Schema;
-    get inputObjectTypes(): DMMF.Schema['inputObjectTypes'];
-    get outputObjectTypes(): DMMF.Schema['outputObjectTypes'];
+    get inputObjectTypes(): {
+        model?: DMMF.InputType[] | undefined;
+        prisma: DMMF.InputType[];
+    };
+    get outputObjectTypes(): {
+        model: DMMF.OutputType[];
+        prisma: DMMF.OutputType[];
+    };
     isComposite(modelOrTypeName: string): boolean;
     getOtherOperationNames(): string[];
     hasEnumInNamespace(enumName: string, namespace: DMMF.FieldNamespace): boolean;
@@ -853,11 +828,11 @@ export declare interface DriverAdapter extends Queryable {
     /**
      * Starts new transation.
      */
-    startTransaction(): Promise<Result_4<Transaction>>;
+    startTransaction(): Promise<Result_3<Transaction_2>>;
     /**
-     * Optional method that returns extra connection info
+     * Closes the connection to the database, if any.
      */
-    getConnectionInfo?(): Result_4<ConnectionInfo>;
+    close: () => Promise<Result_3<void>>;
 }
 
 /** Client */
@@ -1006,15 +981,15 @@ export declare const empty: Sql;
 export declare type EmptyToUnknown<T> = T;
 
 declare abstract class Engine<InteractiveTransactionPayload = unknown> {
-    abstract onBeforeExit(callback: () => Promise<void>): void;
+    abstract on(event: EngineEventType, listener: (args?: any) => any): void;
     abstract start(): Promise<void>;
     abstract stop(): Promise<void>;
     abstract version(forceRun?: boolean): Promise<string> | string;
-    abstract request<T>(query: JsonQuery, options: RequestOptions_2<InteractiveTransactionPayload>): Promise<QueryEngineResult<T>>;
+    abstract request<T>(query: JsonQuery, options: RequestOptions<InteractiveTransactionPayload>): Promise<QueryEngineResult<T>>;
     abstract requestBatch<T>(queries: JsonQuery[], options: RequestBatchOptions<InteractiveTransactionPayload>): Promise<BatchQueryEngineResult<T>[]>;
-    abstract transaction(action: 'start', headers: Transaction_2.TransactionHeaders, options?: Transaction_2.Options): Promise<Transaction_2.InteractiveTransactionInfo<unknown>>;
-    abstract transaction(action: 'commit', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
-    abstract transaction(action: 'rollback', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
+    abstract transaction(action: 'start', headers: Transaction.TransactionHeaders, options?: Transaction.Options): Promise<Transaction.InteractiveTransactionInfo<unknown>>;
+    abstract transaction(action: 'commit', headers: Transaction.TransactionHeaders, info: Transaction.InteractiveTransactionInfo<unknown>): Promise<void>;
+    abstract transaction(action: 'rollback', headers: Transaction.TransactionHeaders, info: Transaction.InteractiveTransactionInfo<unknown>): Promise<void>;
     abstract metrics(options: MetricsOptionsJson): Promise<Metrics>;
     abstract metrics(options: MetricsOptionsPrometheus): Promise<string>;
 }
@@ -1038,27 +1013,26 @@ declare interface EngineConfig {
     previewFeatures?: string[];
     engineEndpoint?: string;
     activeProvider?: string;
-    logEmitter: LogEmitter;
+    logEmitter: EventEmitter;
     /**
      * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`.
      * If set, this is only used in the library engine, and all queries would be performed through it,
      * rather than Prisma's Rust drivers.
-     * @remarks only used by LibraryEngine.ts
      */
     adapter?: ErrorCapturingDriverAdapter;
     /**
      * The contents of the schema encoded into a string
-     * @remarks only used by DataProxyEngine.ts
+     * @remarks only used for the purpose of data proxy
      */
     inlineSchema: string;
     /**
      * The contents of the datasource url saved in a string
-     * @remarks only used by DataProxyEngine.ts
+     * @remarks only used for the purpose of data proxy
      */
     inlineDatasources: GetPrismaClientConfig['inlineDatasources'];
     /**
      * The string hash that was produced for a given schema
-     * @remarks only used by DataProxyEngine.ts
+     * @remarks only used for the purpose of data proxy
      */
     inlineSchemaHash: string;
     /**
@@ -1077,14 +1051,11 @@ declare interface EngineConfig {
      * generated specifically for each type of client, eg. Node.js client and Edge
      * clients will have different implementations.
      * @remarks this is a callback on purpose, we only load the wasm if needed.
-     * @remarks only used by LibraryEngine.ts
      */
     getQueryEngineWasmModule?: () => Promise<unknown>;
 }
 
-declare type EngineEvent<E extends EngineEventType> = E extends QueryEventType ? QueryEvent : LogEvent;
-
-declare type EngineEventType = QueryEventType | LogEventType;
+declare type EngineEventType = 'query' | 'info' | 'warn' | 'error' | 'beforeExit';
 
 declare type EngineSpan = {
     span: boolean;
@@ -1159,7 +1130,10 @@ declare interface ErrorWithBatchIndex {
     batchRequestIdx?: number;
 }
 
-declare type EventCallback<E extends ExtendedEventType> = [E] extends ['beforeExit'] ? () => Promise<void> : [E] extends [LogLevel] ? (event: EngineEvent<E>) => void : never;
+declare interface EventEmitter {
+    on(event: string, listener: (...args: any[]) => void): unknown;
+    emit(event: string, args?: any): boolean;
+}
 
 export declare type Exact<A, W> = (A extends unknown ? (W extends A ? {
     [K in keyof A]: Exact<A[K], W[K]>;
@@ -1193,8 +1167,6 @@ declare interface ExceptionWithName {
     stack?: string;
 }
 
-declare type ExtendedEventType = LogLevel | 'beforeExit';
-
 declare type ExtendedSpanOptions = SpanOptions & {
     /** The name of the span */
     name: string;
@@ -1311,7 +1283,7 @@ declare interface GeneratorConfig {
     output: EnvValue | null;
     isCustomOutput?: boolean;
     provider: EnvValue;
-    config: Dictionary<string | string[]>;
+    config: Dictionary_2<string | string[]>;
     binaryTargets: BinaryTargetsEnvValue[];
     previewFeatures: string[];
 }
@@ -1389,7 +1361,7 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
          * @param middleware to hook
          */
         $use(middleware: QueryMiddleware): void;
-        $on<E extends ExtendedEventType>(eventType: E, callback: EventCallback<E>): void;
+        $on(eventType: EngineEventType, callback: (event: any) => void): void;
         $connect(): Promise<void>;
         /**
          * Disconnect from the database
@@ -1463,7 +1435,7 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
          */
         _transactionWithCallback({ callback, options, }: {
             callback: (client: Client) => Promise<unknown>;
-            options?: Options | undefined;
+            options?: Options_2 | undefined;
         }): Promise<unknown>;
         _createItxClient(transaction: PrismaPromiseInteractiveTransaction): Client;
         /**
@@ -1608,7 +1580,6 @@ declare type HandleErrorParams = {
     clientMethod: string;
     callsite?: CallSite;
     transaction?: PrismaPromiseTransaction;
-    modelName?: string;
 };
 
 /**
@@ -1638,7 +1609,7 @@ declare type InteractiveTransactionInfo<Payload = unknown> = {
     payload: Payload;
 };
 
-declare type InteractiveTransactionOptions<Payload> = Transaction_2.InteractiveTransactionInfo<Payload>;
+declare type InteractiveTransactionOptions<Payload> = Transaction.InteractiveTransactionInfo<Payload>;
 
 export declare type InternalArgs<R = {
     [K in string]: {
@@ -1733,7 +1704,7 @@ export declare type JsInputValue = null | undefined | string | number | boolean
     [key: string]: JsInputValue;
 };
 
-declare type JsonArgumentValue = number | string | boolean | null | RawTaggedValue | JsonArgumentValue[] | {
+declare type JsonArgumentValue = number | string | boolean | null | JsonTaggedValue | JsonArgumentValue[] | {
     [key: string]: JsonArgumentValue;
 };
 
@@ -1745,7 +1716,7 @@ export declare interface JsonConvertible {
 }
 
 declare type JsonFieldSelection = {
-    arguments?: Record<string, JsonArgumentValue> | RawTaggedValue;
+    arguments?: Record<string, JsonArgumentValue>;
     selection: JsonSelectionSet;
 };
 
@@ -1771,6 +1742,11 @@ declare type JsonSelectionSet = {
     [fieldName: string]: boolean | JsonFieldSelection;
 };
 
+declare type JsonTaggedValue = {
+    $type: 'Json';
+    value: string;
+};
+
 export declare type JsonValue = string | number | boolean | JsonObject | JsonArray | null;
 
 export declare type JsOutputValue = null | string | number | boolean | bigint | Uint8Array | Date | Decimal | JsOutputValue[] | {
@@ -1828,20 +1804,6 @@ declare type LogDefinition = {
     emit: 'stdout' | 'event';
 };
 
-declare type LogEmitter = {
-    on<E extends EngineEventType>(event: E, listener: (event: EngineEvent<E>) => void): LogEmitter;
-    emit(event: QueryEventType, payload: QueryEvent): void;
-    emit(event: LogEventType, payload: LogEvent): void;
-};
-
-declare type LogEvent = {
-    timestamp: Date;
-    message: string;
-    target: string;
-};
-
-declare type LogEventType = 'info' | 'warn' | 'error';
-
 declare type LogLevel = 'info' | 'query' | 'warn' | 'error';
 
 /**
@@ -2007,7 +1969,7 @@ export declare type NeverToUnknown<T> = [T] extends [never] ? unknown : T;
  * @param options
  * @returns
  */
-declare function nodeFetch(url: string, options?: RequestOptions): Promise<RequestResponse>;
+declare function nodeFetch(url: string, options?: RequestOptions_2): Promise<RequestResponse>;
 
 declare class NodeHeaders {
     readonly headers: Map<string, string>;
@@ -2095,20 +2057,20 @@ export declare type OptionalKeys<O> = {
     [K in keyof O]-?: {} extends Pick_2<O, K> ? K : never;
 }[keyof O];
 
+declare type Options = {
+    clientVersion: string;
+};
+
 /**
  * maxWait ?= 2000
  * timeout ?= 5000
  */
-declare type Options = {
+declare type Options_2 = {
     maxWait?: number;
     timeout?: number;
     isolationLevel?: IsolationLevel;
 };
 
-declare type Options_2 = {
-    clientVersion: string;
-};
-
 export declare type Or<A extends 1 | 0, B extends 1 | 0> = {
     0: {
         0: 0;
@@ -2166,7 +2128,7 @@ export declare type PrismaClientOptions = {
     /**
      * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale.
      */
-    adapter?: DriverAdapter | null;
+    adapter?: DriverAdapter;
     /**
      * Overwrites the datasource url from your schema.prisma file
      */
@@ -2203,8 +2165,6 @@ export declare type PrismaClientOptions = {
             endpoint?: string;
             allowTriggerPanic?: boolean;
         };
-        /** This can be used for testing purposes */
-        configOverride?: Partial<GetPrismaClientConfig>;
     };
 };
 
@@ -2224,7 +2184,7 @@ export declare class PrismaClientUnknownRequestError extends Error implements Er
 export declare class PrismaClientValidationError extends Error {
     name: string;
     clientVersion: string;
-    constructor(message: string, { clientVersion }: Options_2);
+    constructor(message: string, { clientVersion }: Options);
     get [Symbol.toStringTag](): string;
 }
 
@@ -2317,14 +2277,14 @@ declare type Query = {
 };
 
 declare interface Queryable {
-    readonly provider: 'mysql' | 'postgres' | 'sqlite';
+    readonly flavour: 'mysql' | 'postgres' | 'sqlite';
     /**
      * Execute a query given as SQL, interpolating the given parameters,
      * and returning the type-aware result set of the query.
      *
      * This is the preferred way of executing `SELECT` queries.
      */
-    queryRaw(params: Query): Promise<Result_4<ResultSet>>;
+    queryRaw(params: Query): Promise<Result_3<ResultSet>>;
     /**
      * Execute a query given as SQL, interpolating the given parameters,
      * and returning the number of affected rows.
@@ -2332,7 +2292,7 @@ declare interface Queryable {
      * This is the preferred way of executing `INSERT`, `UPDATE`, `DELETE` queries,
      * as well as transactional queries.
      */
-    executeRaw(params: Query): Promise<Result_4<number>>;
+    executeRaw(params: Query): Promise<Result_3<number>>;
 }
 
 declare type QueryEngineResult<T> = {
@@ -2340,16 +2300,6 @@ declare type QueryEngineResult<T> = {
     elapsed: number;
 };
 
-declare type QueryEvent = {
-    timestamp: Date;
-    query: string;
-    params: string;
-    duration: number;
-    target: string;
-};
-
-declare type QueryEventType = 'query';
-
 declare type QueryMiddleware = (params: QueryMiddlewareParams, next: (params: QueryMiddlewareParams) => Promise<unknown>) => Promise<unknown>;
 
 declare type QueryMiddlewareParams = {
@@ -2393,11 +2343,6 @@ export declare type RawParameters = {
 
 export declare type RawQueryArgs = Sql | [query: string, ...values: RawValue[]];
 
-declare type RawTaggedValue = {
-    $type: 'Raw';
-    value: unknown;
-};
-
 /**
  * Supported value or SQL instance.
  */
@@ -2407,10 +2352,6 @@ export declare type ReadonlyDeep<T> = {
     readonly [K in keyof T]: ReadonlyDeep<T[K]>;
 };
 
-declare type ReadonlyDeep_2<O> = {
-    +readonly [K in keyof O]: ReadonlyDeep_2<O[K]>;
-};
-
 declare type Record_2<T extends string | number | symbol, U> = {
     [P in T]: U;
 };
@@ -2421,7 +2362,7 @@ export declare type RenameAndNestPayloadKeys<P> = {
 };
 
 declare type RequestBatchOptions<InteractiveTransactionPayload> = {
-    transaction?: TransactionOptions_2<InteractiveTransactionPayload>;
+    transaction?: TransactionOptions<InteractiveTransactionPayload>;
     traceparent?: string;
     numTry?: number;
     containsWrite: boolean;
@@ -2432,7 +2373,7 @@ declare class RequestHandler {
     client: Client;
     dataloader: DataLoader<RequestParams>;
     private logEmitter?;
-    constructor(client: Client, logEmitter?: LogEmitter);
+    constructor(client: Client, logEmitter?: EventEmitter);
     request(params: RequestParams): Promise<any>;
     mapQueryEngineResult({ dataPath, unpacker }: RequestParams, response: QueryEngineResult<any>): any;
     /**
@@ -2440,19 +2381,13 @@ declare class RequestHandler {
      * handlers to finish.
      */
     handleAndLogRequestError(params: HandleErrorParams): never;
-    handleRequestError({ error, clientMethod, callsite, transaction, args, modelName }: HandleErrorParams): never;
+    handleRequestError({ error, clientMethod, callsite, transaction, args }: HandleErrorParams): never;
     sanitizeMessage(message: any): any;
     unpack(data: unknown, dataPath: string[], unpacker?: Unpacker): any;
     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>;
@@ -2460,6 +2395,12 @@ declare type RequestOptions_2<InteractiveTransactionPayload> = {
     customDataProxyFetch?: (fetch: Fetch) => Fetch;
 };
 
+declare type RequestOptions_2 = {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+};
+
 declare type RequestParams = {
     modelName?: string;
     action: Action;
@@ -2509,7 +2450,18 @@ export declare type Result<T, A, F extends Operation> = T extends {
 
 export declare type Result_2<T, A, F extends Operation> = Result<T, A, F>;
 
-declare namespace Result_3 {
+declare type Result_3<T> = {
+    map<U>(fn: (value: T) => U): Result_3<U>;
+    flatMap<U>(fn: (value: T) => Result_3<U>): Result_3<U>;
+} & ({
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: Error_2;
+});
+
+declare namespace Result_4 {
     export {
         Operation,
         FluentOperation,
@@ -2528,17 +2480,6 @@ declare namespace Result_3 {
     }
 }
 
-declare type Result_4<T> = {
-    map<U>(fn: (value: T) => U): Result_4<U>;
-    flatMap<U>(fn: (value: T) => Result_4<U>): Result_4<U>;
-} & ({
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly error: Error_2;
-});
-
 export declare type ResultArg = {
     [FieldName in string]: ResultFieldDefinition;
 };
@@ -2575,15 +2516,13 @@ declare interface ResultSet {
     rows: Array<Array<unknown>>;
     /**
      * The last ID of an `INSERT` statement, if any.
-     * This is required for `AUTO_INCREMENT` columns in databases based on MySQL and SQLite.
+     * This is required for `AUTO_INCREMENT` columns in MySQL and SQLite-flavoured databases.
      */
     lastInsertId?: string;
 }
 
 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 = {
     readonly models: Record<string, RuntimeModel>;
     readonly enums: Record<string, RuntimeEnum>;
@@ -2856,7 +2795,6 @@ export declare class Sql {
     constructor(rawStrings: readonly string[], rawValues: readonly RawValue[]);
     get text(): string;
     get sql(): string;
-    get statement(): string;
     inspect(): {
         text: string;
         sql: string;
@@ -2924,39 +2862,42 @@ declare interface TracingHelper {
     runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
 }
 
-declare interface Transaction extends Queryable {
+declare namespace Transaction {
+    export {
+        IsolationLevel,
+        Options_2 as Options,
+        InteractiveTransactionInfo,
+        TransactionHeaders
+    }
+}
+
+declare interface Transaction_2 extends Queryable {
     /**
      * Transaction options.
      */
-    readonly options: TransactionOptions;
+    readonly options: TransactionOptions_2;
     /**
      * Commit the transaction.
      */
-    commit(): Promise<Result_4<void>>;
+    commit(): Promise<Result_3<void>>;
     /**
      * Rolls back the transaction.
      */
-    rollback(): Promise<Result_4<void>>;
-}
-
-declare namespace Transaction_2 {
-    export {
-        IsolationLevel,
-        Options,
-        InteractiveTransactionInfo,
-        TransactionHeaders
-    }
+    rollback(): Promise<Result_3<void>>;
+    /**
+     * Discards and closes the transaction which may or may not have been committed or rolled back.
+     * This operation must be synchronous. If the implementation requires calling creating new
+     * asynchronous tasks on the event loop, the driver is responsible for handling the errors
+     * appropriately to ensure they don't crash the application.
+     */
+    dispose(): Result_3<void>;
 }
 
 declare type TransactionHeaders = {
     traceparent?: string;
 };
 
-declare type TransactionOptions = {
-    usePhantomQuery: boolean;
-};
-
-declare type TransactionOptions_2<InteractiveTransactionPayload> = {
+declare type TransactionOptions<InteractiveTransactionPayload> = {
     kind: 'itx';
     options: InteractiveTransactionOptions<InteractiveTransactionPayload>;
 } | {
@@ -2964,6 +2905,10 @@ declare type TransactionOptions_2<InteractiveTransactionPayload> = {
     options: BatchTransactionOptions;
 };
 
+declare type TransactionOptions_2 = {
+    usePhantomQuery: boolean;
+};
+
 export declare type TypeMapCbDef = Fn<{
     extArgs: InternalArgs;
 }, TypeMapDef>;
@@ -2973,7 +2918,7 @@ export declare type TypeMapDef = Record<any, any>;
 
 declare namespace Types {
     export {
-        Result_3 as Result,
+        Result_4 as Result,
         Extensions_2 as Extensions,
         Utils,
         Public_2 as Public,