expo-backend-types 0.30.0-EXPO-308-auth.10 → 0.30.0-EXPO-309-Migrar-Configuracion.2

package/dist/types/prisma-schema/runtime/library.d.ts

@@ -23,7 +23,7 @@ declare type AccelerateEngineConfig = {
 
 export declare type Action = keyof typeof DMMF.ModelAction | 'executeRaw' | 'queryRaw' | 'runCommandRaw';
 
-declare type ActiveConnectorType = Exclude<ConnectorType, 'postgres' | 'prisma+postgres'>;
+declare type ActiveConnectorType = Exclude<ConnectorType, 'postgres'>;
 
 export declare type Aggregate = '_count' | '_max' | '_min' | '_avg' | '_sum';
 
@@ -101,7 +101,7 @@ declare type BatchQuery = {
     args: JsArgs | RawQueryArgs;
 };
 
-declare type BatchQueryEngineResult<T> = QueryEngineResultData<T> | Error;
+declare type BatchQueryEngineResult<T> = QueryEngineResult<T> | Error;
 
 declare type BatchQueryOptionsCb = (args: BatchQueryOptionsCbArgs) => Promise<any>;
 
@@ -193,24 +193,6 @@ declare const ColumnTypeEnum: {
     readonly UnknownNumber: 128;
 };
 
-declare type CompilerWasmLoadingConfig = {
-    /**
-     * WASM-bindgen runtime for corresponding module
-     */
-    getRuntime: () => {
-        __wbg_set_wasm(exports: unknown): any;
-        QueryCompiler: QueryCompilerConstructor;
-    };
-    /**
-     * Loads the raw wasm module for the wasm compiler engine. This configuration is
-     * 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 ClientEngine
-     */
-    getQueryCompilerWasmModule: () => Promise<unknown>;
-};
-
 export declare type Compute<T> = T extends Function ? T : {
     [K in keyof T]: T[K];
 } & unknown;
@@ -234,7 +216,7 @@ declare type ConnectionInfo = {
     maxBindValues?: number;
 };
 
-declare type ConnectorType = 'mysql' | 'mongodb' | 'sqlite' | 'postgresql' | 'postgres' | 'prisma+postgres' | 'sqlserver' | 'cockroachdb';
+declare type ConnectorType = 'mysql' | 'mongodb' | 'sqlite' | 'postgresql' | 'postgres' | 'sqlserver' | 'cockroachdb';
 
 declare interface Context {
     /**
@@ -284,38 +266,7 @@ export declare type Count<O> = {
     [K in keyof O]: Count<number>;
 } & {};
 
-export declare function createParam(name: string): Param<unknown, string>;
-
-/**
- * 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 type CustomDataProxyFetch = (fetch: Fetch) => Fetch;
 
 declare class DataLoader<T = unknown> {
     private options;
@@ -668,12 +619,8 @@ declare function defineExtension(ext: ExtensionArgs | ((client: Client) => Clien
 
 declare const denylist: readonly ["$connect", "$disconnect", "$on", "$transaction", "$use", "$extends"];
 
-declare type DeserializedResponse = Array<Record<string, unknown>>;
-
 export declare function deserializeJsonResponse(result: unknown): unknown;
 
-export declare function deserializeRawResult(response: RawResponse): DeserializedResponse;
-
 export declare type DevTypeMapDef = {
     meta: {
         modelProps: string;
@@ -742,7 +689,6 @@ export declare namespace DMMF {
     export type Model = ReadonlyDeep_2<{
         name: string;
         dbName: string | null;
-        schema: string | null;
         fields: Field[];
         uniqueFields: string[][];
         uniqueIndexes: uniqueIndex[];
@@ -768,25 +714,18 @@ 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[];
         relationFromFields?: string[];
         relationToFields?: string[];
         relationOnDelete?: string;
-        relationOnUpdate?: string;
         relationName?: string;
         documentation?: string;
     }>;
     export type FieldDefault = ReadonlyDeep_2<{
         name: string;
-        args: Array<string | number>;
+        args: any[];
     }>;
     export type FieldDefaultScalar = string | boolean | number;
     export type Index = ReadonlyDeep_2<{
@@ -900,7 +839,6 @@ export declare namespace DMMF {
         createManyAndReturn?: string | null;
         update?: string | null;
         updateMany?: string | null;
-        updateManyAndReturn?: string | null;
         upsert?: string | null;
         delete?: string | null;
         deleteMany?: string | null;
@@ -921,7 +859,6 @@ export declare namespace DMMF {
         createManyAndReturn = "createManyAndReturn",
         update = "update",
         updateMany = "updateMany",
-        updateManyAndReturn = "updateManyAndReturn",
         upsert = "upsert",
         delete = "delete",
         deleteMany = "deleteMany",
@@ -1100,7 +1037,7 @@ declare interface Engine<InteractiveTransactionPayload = unknown> {
     start(): Promise<void>;
     stop(): Promise<void>;
     version(forceRun?: boolean): Promise<string> | string;
-    request<T>(query: JsonQuery, options: RequestOptions<InteractiveTransactionPayload>): Promise<QueryEngineResultData<T>>;
+    request<T>(query: JsonQuery, options: RequestOptions_2<InteractiveTransactionPayload>): Promise<QueryEngineResult<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>;
@@ -1167,8 +1104,7 @@ declare interface EngineConfig {
     /**
      * Web Assembly module loading configuration
      */
-    engineWasm?: EngineWasmLoadingConfig;
-    compilerWasm?: CompilerWasmLoadingConfig;
+    engineWasm?: WasmLoadingConfig;
     /**
      * Allows Accelerate to use runtime utilities from the client. These are
      * necessary for the AccelerateEngine to function correctly.
@@ -1193,38 +1129,28 @@ declare type EngineEventType = QueryEventType | LogEventType;
 declare type EngineProtocol = 'graphql' | 'json';
 
 declare type EngineSpan = {
-    id: EngineSpanId;
-    parentId: string | null;
+    span: boolean;
     name: string;
-    startTime: HrTime;
-    endTime: HrTime;
+    trace_id: string;
+    span_id: string;
+    parent_span_id: string;
+    start_time: [number, number];
+    end_time: [number, number];
+    attributes?: Record<string, string>;
+    links?: {
+        trace_id: string;
+        span_id: string;
+    }[];
     kind: EngineSpanKind;
-    attributes?: Record<string, unknown>;
-    links?: EngineSpanId[];
 };
 
-declare type EngineSpanId = string;
+declare type EngineSpanEvent = {
+    span: boolean;
+    spans: EngineSpan[];
+};
 
 declare type EngineSpanKind = 'client' | 'internal';
 
-declare type EngineWasmLoadingConfig = {
-    /**
-     * WASM-bindgen runtime for corresponding module
-     */
-    getRuntime: () => {
-        __wbg_set_wasm(exports: unknown): any;
-        QueryEngine: QueryEngineConstructor;
-    };
-    /**
-     * Loads the raw wasm module for the wasm query engine. This configuration is
-     * 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
-     */
-    getQueryEngineWasmModule: () => Promise<unknown>;
-};
-
 declare type EnvPaths = {
     rootEnvPath: string | null;
     schemaEnvPath: string | undefined;
@@ -1422,6 +1348,8 @@ 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
  */
@@ -1432,8 +1360,6 @@ export declare interface FieldRef<Model, FieldType> {
     readonly isList: boolean;
 }
 
-declare type Flavour = 'mysql' | 'postgres' | 'sqlite';
-
 export declare type FluentOperation = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'create' | 'update' | 'upsert' | 'delete';
 
 export declare interface Fn<Params = unknown, Returns = unknown> {
@@ -1494,9 +1420,7 @@ export declare type GetFindResult<P extends OperationPayload, A, ClientOptions>
     } ? O : K extends '_count' ? Count<P['objects']> : never;
 } & (A extends {
     include: any;
-} & Record<string, unknown> ? DefaultSelection<P, A & {
-    omit: A['omit'];
-}, ClientOptions> : unknown) : DefaultSelection<P, A, ClientOptions>;
+} & Record<string, unknown> ? DefaultSelection<P, A, ClientOptions> : unknown) : DefaultSelection<P, A, ClientOptions>;
 
 export declare type GetGroupByResult<P extends OperationPayload, A> = A extends {
     by: string[];
@@ -1570,7 +1494,7 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
          * @param values
          * @returns
          */
-        $executeRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise_2<unknown, any>;
+        $executeRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise_2<unknown>;
         /**
          * Unsafe counterpart of `$executeRaw` that is susceptible to SQL injections
          * @see https://github.com/prisma/prisma/issues/7142
@@ -1579,14 +1503,14 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
          * @param values
          * @returns
          */
-        $executeRawUnsafe(query: string, ...values: RawValue[]): PrismaPromise_2<unknown, any>;
+        $executeRawUnsafe(query: string, ...values: RawValue[]): PrismaPromise_2<unknown>;
         /**
          * Executes a raw command only for MongoDB
          *
          * @param command
          * @returns
          */
-        $runCommandRaw(command: Record<string, JsInputValue>): PrismaPromise_2<unknown, any>;
+        $runCommandRaw(command: Record<string, JsInputValue>): PrismaPromise_2<unknown>;
         /**
          * Executes a raw query and returns selected data
          */
@@ -1599,12 +1523,12 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
          * @param values
          * @returns
          */
-        $queryRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise_2<unknown, any>;
+        $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, any>;
+        $queryRawTyped(typedSql: UnknownTypedSql): PrismaPromise_2<unknown>;
         /**
          * Unsafe counterpart of `$queryRaw` that is susceptible to SQL injections
          * @see https://github.com/prisma/prisma/issues/7142
@@ -1613,7 +1537,7 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
          * @param values
          * @returns
          */
-        $queryRawUnsafe(query: string, ...values: RawValue[]): PrismaPromise_2<unknown, any>;
+        $queryRawUnsafe(query: string, ...values: RawValue[]): PrismaPromise_2<unknown>;
         /**
          * Execute a batch of requests in a transaction
          * @param requests
@@ -1736,8 +1660,7 @@ declare type GetPrismaClientConfig = {
     /**
      * Optional wasm loading configuration
      */
-    engineWasm?: EngineWasmLoadingConfig;
-    compilerWasm?: CompilerWasmLoadingConfig;
+    engineWasm?: WasmLoadingConfig;
 };
 
 export declare type GetResult<Payload extends OperationPayload, Args, OperationName extends Operation = 'findUniqueOrThrow', ClientOptions = {}> = {
@@ -1751,7 +1674,6 @@ export declare type GetResult<Payload extends OperationPayload, Args, OperationN
     createManyAndReturn: GetFindResult<Payload, Args, ClientOptions>[];
     update: GetFindResult<Payload, Args, ClientOptions>;
     updateMany: GetBatchResult;
-    updateManyAndReturn: GetFindResult<Payload, Args, ClientOptions>[];
     upsert: GetFindResult<Payload, Args, ClientOptions>;
     delete: GetFindResult<Payload, Args, ClientOptions>;
     deleteMany: GetBatchResult;
@@ -1796,8 +1718,6 @@ declare type HandleErrorParams = {
     globalOmit?: GlobalOmitOptions;
 };
 
-declare type HrTime = [number, number];
-
 /**
  * Defines High-Resolution Time.
  *
@@ -1810,7 +1730,7 @@ declare type HrTime = [number, number];
  * HrTime[1] = Number((1609504210.150 - HrTime[0]).toFixed(9)) * 1e9 = 150000000.
  * This is represented in HrTime format as [1609504210, 150000000].
  */
-declare type HrTime_2 = [number, number];
+declare type HrTime = [number, number];
 
 /**
  * Matches a JSON array.
@@ -1916,7 +1836,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?: CustomDataProxyFetch;
+    customDataProxyFetch?: (fetch: Fetch) => Fetch;
 } & Omit<QueryMiddlewareParams, 'runInTransaction'>;
 
 declare enum IsolationLevel {
@@ -2002,7 +1922,7 @@ export declare type JsonQuery = {
     query: JsonFieldSelection;
 };
 
-declare type JsonQueryAction = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'findMany' | 'createOne' | 'createMany' | 'createManyAndReturn' | 'updateOne' | 'updateMany' | 'updateManyAndReturn' | 'deleteOne' | 'deleteMany' | 'upsertOne' | 'aggregate' | 'groupBy' | 'executeRaw' | 'queryRaw' | 'runCommandRaw' | 'findRaw' | 'aggregateRaw';
+declare type JsonQueryAction = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'findMany' | 'createOne' | 'createMany' | 'createManyAndReturn' | 'updateOne' | 'updateMany' | 'deleteOne' | 'deleteMany' | 'upsertOne' | 'aggregate' | 'groupBy' | 'executeRaw' | 'queryRaw' | 'runCommandRaw' | 'findRaw' | 'aggregateRaw';
 
 declare type JsonSelectionSet = {
     $scalars?: boolean;
@@ -2246,6 +2166,37 @@ 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;
 }
@@ -2289,7 +2240,7 @@ export { Omit_2 as Omit }
 
 export declare type OmitValue<Omit, Key> = Key extends keyof Omit ? Omit[Key] : false;
 
-export declare type Operation = 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'aggregate' | 'count' | 'groupBy' | '$queryRaw' | '$executeRaw' | '$queryRawUnsafe' | '$executeRawUnsafe' | 'findRaw' | 'aggregateRaw' | '$runCommandRaw';
+export declare type Operation = 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'deleteMany' | 'aggregate' | 'count' | 'groupBy' | '$queryRaw' | '$executeRaw' | '$queryRawUnsafe' | '$executeRawUnsafe' | 'findRaw' | 'aggregateRaw' | '$runCommandRaw';
 
 export declare type OperationPayload = {
     name: string;
@@ -2339,12 +2290,6 @@ export declare type Or<A extends 1 | 0, B extends 1 | 0> = {
     };
 }[A][B];
 
-export declare function Param<$Type, $Value extends string>(name: $Value): Param<$Type, $Value>;
-
-export declare type Param<out $Type, $Value extends string> = {
-    readonly name: $Value;
-};
-
 export declare type PatchFlat<O1, O2> = O1 & Omit_2<O2, keyof O1>;
 
 export declare type Path<O, P, Default = never> = O extends unknown ? P extends [infer K, ...infer R] ? K extends keyof O ? Path<O[K], R> : Default : O : never;
@@ -2462,12 +2407,6 @@ export declare class PrismaClientValidationError extends Error {
 
 declare function prismaGraphQLToJSError({ error, user_facing_error }: RequestError, clientVersion: string, activeProvider: string): PrismaClientKnownRequestError | PrismaClientUnknownRequestError;
 
-declare type PrismaOperationSpec<TArgs, TAction = string> = {
-    args: TArgs;
-    action: TAction;
-    model: string;
-};
-
 export declare interface PrismaPromise<T> extends Promise<T> {
     [Symbol.toStringTag]: 'PrismaPromise';
 }
@@ -2477,27 +2416,26 @@ export declare interface PrismaPromise<T> extends Promise<T> {
  * original `Promise` are optional so that it can be backwards-compatible.
  * @see [[createPrismaPromise]]
  */
-declare interface PrismaPromise_2<TResult, TSpec extends PrismaOperationSpec<unknown> = any> extends Promise<TResult> {
-    get spec(): TSpec;
+declare interface PrismaPromise_2<A> extends Promise<A> {
     /**
      * Extension of the original `.then` function
      * @param onfulfilled same as regular promises
      * @param onrejected same as regular promises
      * @param transaction transaction options
      */
-    then<R1 = TResult, R2 = never>(onfulfilled?: (value: TResult) => R1 | PromiseLike<R1>, onrejected?: (error: unknown) => R2 | PromiseLike<R2>, transaction?: PrismaPromiseTransaction): Promise<R1 | R2>;
+    then<R1 = A, R2 = never>(onfulfilled?: (value: A) => R1 | PromiseLike<R1>, onrejected?: (error: unknown) => R2 | PromiseLike<R2>, transaction?: PrismaPromiseTransaction): Promise<R1 | R2>;
     /**
      * Extension of the original `.catch` function
      * @param onrejected same as regular promises
      * @param transaction transaction options
      */
-    catch<R = never>(onrejected?: ((reason: any) => R | PromiseLike<R>) | undefined | null, transaction?: PrismaPromiseTransaction): Promise<TResult | R>;
+    catch<R = never>(onrejected?: ((reason: any) => R | PromiseLike<R>) | undefined | null, transaction?: PrismaPromiseTransaction): Promise<A | R>;
     /**
      * Extension of the original `.finally` function
      * @param onfinally same as regular promises
      * @param transaction transaction options
      */
-    finally(onfinally?: (() => void) | undefined | null, transaction?: PrismaPromiseTransaction): Promise<TResult>;
+    finally(onfinally?: (() => void) | undefined | null, transaction?: PrismaPromiseTransaction): Promise<A>;
     /**
      * Called when executing a batch of regular tx
      * @param transaction transaction options for batch tx
@@ -2513,7 +2451,7 @@ declare type PrismaPromiseBatchTransaction = {
     lock: PromiseLike<void>;
 };
 
-declare type PrismaPromiseCallback = (transaction?: PrismaPromiseTransaction) => Promise<unknown>;
+declare type PrismaPromiseCallback = (transaction?: PrismaPromiseTransaction) => PrismaPromise_2<unknown>;
 
 /**
  * Creates a [[PrismaPromise]]. It is Prisma's implementation of `Promise` which
@@ -2524,7 +2462,7 @@ declare type PrismaPromiseCallback = (transaction?: PrismaPromiseTransaction) =>
  * @see [[PrismaPromise]]
  * @returns
  */
-declare type PrismaPromiseFactory = <T extends PrismaOperationSpec<unknown>>(callback: PrismaPromiseCallback, op?: T) => PrismaPromise_2<unknown>;
+declare type PrismaPromiseFactory = (callback: PrismaPromiseCallback) => PrismaPromise_2<unknown>;
 
 declare type PrismaPromiseInteractiveTransaction<PayloadType = unknown> = {
     kind: 'itx';
@@ -2561,7 +2499,7 @@ declare type Query = {
 };
 
 declare interface Queryable {
-    readonly provider: Flavour;
+    readonly provider: 'mysql' | 'postgres' | 'sqlite';
     readonly adapterName: (typeof officialPrismaAdapters)[number] | (string & {});
     /**
      * Execute a query given as SQL, interpolating the given parameters,
@@ -2580,20 +2518,6 @@ declare interface Queryable {
     executeRaw(params: Query): Promise<Result_4<number>>;
 }
 
-declare type QueryCompiler = {
-    compile(request: string): Promise<string>;
-};
-
-declare interface QueryCompilerConstructor {
-    new (options: QueryCompilerOptions): QueryCompiler;
-}
-
-declare type QueryCompilerOptions = {
-    datamodel: string;
-    flavour: Flavour;
-    connectionInfo: ConnectionInfo;
-};
-
 declare type QueryEngineBatchGraphQLRequest = {
     batch: QueryEngineRequest[];
     transaction?: boolean;
@@ -2610,8 +2534,8 @@ declare type QueryEngineConfig = {
     datasourceOverrides: Record<string, string>;
     env: Record<string, string | undefined>;
     logLevel: QueryEngineLogLevel;
+    telemetry?: QueryEngineTelemetry;
     engineProtocol: EngineProtocol;
-    enableTracing: boolean;
 };
 
 declare interface QueryEngineConstructor {
@@ -2619,20 +2543,20 @@ declare interface QueryEngineConstructor {
 }
 
 declare type QueryEngineInstance = {
-    connect(headers: string, requestId: string): Promise<void>;
-    disconnect(headers: string, requestId: string): Promise<void>;
+    connect(headers: string): Promise<void>;
+    disconnect(headers: string): Promise<void>;
     /**
      * @param requestStr JSON.stringified `QueryEngineRequest | QueryEngineBatchRequest`
      * @param headersStr JSON.stringified `QueryEngineRequestHeaders`
      */
-    query(requestStr: string, headersStr: string, transactionId: string | undefined, requestId: string): Promise<string>;
-    sdlSchema?(): Promise<string>;
-    startTransaction(options: string, traceHeaders: string, requestId: string): Promise<string>;
-    commitTransaction(id: string, traceHeaders: string, requestId: string): Promise<string>;
-    rollbackTransaction(id: string, traceHeaders: string, requestId: string): Promise<string>;
-    metrics?(options: string): Promise<string>;
-    applyPendingMigrations?(): Promise<void>;
-    trace(requestId: string): Promise<string | null>;
+    query(requestStr: string, headersStr: string, transactionId?: string): Promise<string>;
+    sdlSchema(): Promise<string>;
+    dmmf(traceparent: string): Promise<string>;
+    startTransaction(options: string, traceHeaders: string): Promise<string>;
+    commitTransaction(id: string, traceHeaders: string): Promise<string>;
+    rollbackTransaction(id: string, traceHeaders: string): Promise<string>;
+    metrics(options: string): Promise<string>;
+    applyPendingMigrations(): Promise<void>;
 };
 
 declare type QueryEngineLogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'off';
@@ -2642,8 +2566,14 @@ declare type QueryEngineRequest = {
     variables: Object;
 };
 
-declare type QueryEngineResultData<T> = {
+declare type QueryEngineResult<T> = {
     data: T;
+    elapsed: number;
+};
+
+declare type QueryEngineTelemetry = {
+    enabled: Boolean;
+    endpoint: string;
 };
 
 declare type QueryEvent = {
@@ -2656,8 +2586,6 @@ declare type QueryEvent = {
 
 declare type QueryEventType = 'query';
 
-declare type QueryIntrospectionBuiltinType = 'int' | 'bigint' | 'float' | 'double' | 'string' | 'enum' | 'bytes' | 'bool' | 'char' | 'decimal' | 'json' | 'xml' | 'uuid' | 'datetime' | 'date' | 'time' | 'int-array' | 'bigint-array' | 'float-array' | 'double-array' | 'string-array' | 'char-array' | 'bytes-array' | 'bool-array' | 'decimal-array' | 'json-array' | 'xml-array' | 'uuid-array' | 'datetime-array' | 'date-array' | 'time-array' | 'null' | 'unknown';
-
 declare type QueryMiddleware = (params: QueryMiddlewareParams, next: (params: QueryMiddlewareParams) => Promise<unknown>) => Promise<unknown>;
 
 declare type QueryMiddlewareParams = {
@@ -2701,12 +2629,6 @@ export declare type RawParameters = {
 
 export declare type RawQueryArgs = Sql | UnknownTypedSql | [query: string, ...values: RawValue[]];
 
-declare type RawResponse = {
-    columns: string[];
-    types: QueryIntrospectionBuiltinType[];
-    rows: unknown[][];
-};
-
 declare type RawTaggedValue = {
     $type: 'Raw';
     value: unknown;
@@ -2739,7 +2661,7 @@ declare type RequestBatchOptions<InteractiveTransactionPayload> = {
     traceparent?: string;
     numTry?: number;
     containsWrite: boolean;
-    customDataProxyFetch?: CustomDataProxyFetch;
+    customDataProxyFetch?: (fetch: Fetch) => Fetch;
 };
 
 declare interface RequestError {
@@ -2759,7 +2681,7 @@ declare class RequestHandler {
     private logEmitter?;
     constructor(client: Client, logEmitter?: LogEmitter);
     request(params: RequestParams): Promise<any>;
-    mapQueryEngineResult({ dataPath, unpacker }: RequestParams, response: QueryEngineResultData<any>): any;
+    mapQueryEngineResult({ dataPath, unpacker }: RequestParams, response: QueryEngineResult<any>): any;
     /**
      * Handles the error and logs it, logging the error is done synchronously waiting for the event
      * handlers to finish.
@@ -2771,12 +2693,18 @@ declare class RequestHandler {
     get [Symbol.toStringTag](): string;
 }
 
-declare type RequestOptions<InteractiveTransactionPayload> = {
+declare type RequestOptions = {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+};
+
+declare type RequestOptions_2<InteractiveTransactionPayload> = {
     traceparent?: string;
     numTry?: number;
     interactiveTransaction?: InteractiveTransactionOptions<InteractiveTransactionPayload>;
     isWrite: boolean;
-    customDataProxyFetch?: CustomDataProxyFetch;
+    customDataProxyFetch?: (fetch: Fetch) => Fetch;
 };
 
 declare type RequestParams = {
@@ -2794,7 +2722,17 @@ declare type RequestParams = {
     otelParentCtx?: Context;
     otelChildCtx?: Context;
     globalOmit?: GlobalOmitOptions;
-    customDataProxyFetch?: CustomDataProxyFetch;
+    customDataProxyFetch?: (fetch: Fetch) => Fetch;
+};
+
+declare type RequestResponse = {
+    ok: boolean;
+    url: string;
+    statusText?: string;
+    status: number;
+    headers: NodeHeaders;
+    text: () => Promise<string>;
+    json: () => Promise<any>;
 };
 
 declare type RequiredExtensionArgs = NameArgs & ResultArgs & ModelArgs & ClientArgs & QueryOptions;
@@ -3237,7 +3175,7 @@ export declare function sqltag(strings: readonly string[], ...values: readonly R
  *
  * hrtime, epoch milliseconds, performance.now() or Date
  */
-declare type TimeInput = HrTime_2 | number | Date;
+declare type TimeInput = HrTime | number | Date;
 
 export declare type ToTuple<T> = T extends any[] ? T : [T];
 
@@ -3282,7 +3220,7 @@ declare interface TraceState {
 declare interface TracingHelper {
     isEnabled(): boolean;
     getTraceParent(context?: Context): string;
-    dispatchEngineSpans(spans: EngineSpan[]): void;
+    createEngineSpan(engineSpanEvent: EngineSpanEvent): void;
     getActiveContext(): Context | undefined;
     runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
 }
@@ -3444,4 +3382,22 @@ export declare function warnEnvConflicts(envPaths: any): void;
 
 export declare const warnOnce: (key: string, message: string, ...args: unknown[]) => void;
 
+declare type WasmLoadingConfig = {
+    /**
+     * WASM-bindgen runtime for corresponding module
+     */
+    getRuntime: () => {
+        __wbg_set_wasm(exports: unknown): any;
+        QueryEngine: QueryEngineConstructor;
+    };
+    /**
+     * Loads the raw wasm module for the wasm query engine. This configuration is
+     * 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>;
+};
+
 export { }