efiber-prisma-schema 2.0.6 → 2.0.8

package/prisma/generated/runtime/{client.d.ts → library.d.ts}

@@ -1,43 +1,25 @@
-import { AnyNull } from '@prisma/client-runtime-utils';
-import { DbNull } from '@prisma/client-runtime-utils';
-import { Decimal } from '@prisma/client-runtime-utils';
-import { empty } from '@prisma/client-runtime-utils';
-import { isAnyNull } from '@prisma/client-runtime-utils';
-import { isDbNull } from '@prisma/client-runtime-utils';
-import { isJsonNull } from '@prisma/client-runtime-utils';
-import { join } from '@prisma/client-runtime-utils';
-import { JsonNull } from '@prisma/client-runtime-utils';
-import { NullTypes } from '@prisma/client-runtime-utils';
-import { ObjectEnumValue } from '@prisma/client-runtime-utils';
-import { PrismaClientInitializationError } from '@prisma/client-runtime-utils';
-import { PrismaClientKnownRequestError } from '@prisma/client-runtime-utils';
-import { PrismaClientRustPanicError } from '@prisma/client-runtime-utils';
-import { PrismaClientUnknownRequestError } from '@prisma/client-runtime-utils';
-import { PrismaClientValidationError } from '@prisma/client-runtime-utils';
-import { raw } from '@prisma/client-runtime-utils';
-import { RawValue } from '@prisma/client-runtime-utils';
-import { Sql } from '@prisma/client-runtime-utils';
-import { sql as sqltag } from '@prisma/client-runtime-utils';
-import { Value } from '@prisma/client-runtime-utils';
-
 /**
  * @param this
  */
 declare function $extends(this: Client, extension: ExtensionArgs | ((client: Client) => Client)): Client;
 
-/**
- * Used by `@prisma/extension-accelerate` until we migrate it to a better API.
- */
-declare interface AccelerateEngineConfig extends EngineConfig {
-    /**
-     * Allows Accelerate to use runtime utilities from the client. These are
-     * necessary for `@prisma/extension-accelerate` to function correctly.
-     * See <https://github.com/prisma/prisma-extension-accelerate/blob/b6ffa853f038780f5ab2fc01bff584ca251f645b/src/extension.ts#L518>
-     */
-    accelerateUtils: {
-        resolveDatasourceUrl: () => string;
+declare type AccelerateEngineConfig = {
+    inlineSchema: EngineConfig['inlineSchema'];
+    inlineSchemaHash: EngineConfig['inlineSchemaHash'];
+    env: EngineConfig['env'];
+    generator?: {
+        previewFeatures: string[];
     };
-}
+    inlineDatasources: EngineConfig['inlineDatasources'];
+    overrideDatasources: EngineConfig['overrideDatasources'];
+    clientVersion: EngineConfig['clientVersion'];
+    engineVersion: EngineConfig['engineVersion'];
+    logEmitter: EngineConfig['logEmitter'];
+    logQueries?: EngineConfig['logQueries'];
+    logLevel?: EngineConfig['logLevel'];
+    tracingHelper: EngineConfig['tracingHelper'];
+    accelerateUtils?: AccelerateUtils;
+};
 
 /**
  * A stripped down interface of `fetch` that `@prisma/extension-accelerate`
@@ -62,6 +44,8 @@ declare type AccelerateExtensionFetch = (url: string, options: {
 
 declare type AccelerateExtensionFetchDecorator = (fetch: AccelerateExtensionFetch) => AccelerateExtensionFetch;
 
+declare type AccelerateUtils = EngineConfig['accelerateUtils'];
+
 export declare type Action = keyof typeof DMMF_2.ModelAction | 'executeRaw' | 'queryRaw' | 'runCommandRaw';
 
 declare type ActiveConnectorType = Exclude<ConnectorType, 'postgres' | 'prisma+postgres'>;
@@ -85,7 +69,9 @@ export declare type AllModelsToStringIndex<TypeMap extends TypeMapDef, Args exte
     [P in K]: Record<TypeMap['meta']['modelProps'], AllModels>;
 } : {};
 
-export { AnyNull }
+declare class AnyNull extends NullTypesEnumValue {
+    #private;
+}
 
 export declare type ApplyOmit<T, OmitConfig> = Compute<{
     [K in keyof T as OmitValue<OmitConfig, K> extends true ? never : K]: T[K];
@@ -169,6 +155,12 @@ declare type BatchTransactionOptions = {
     isolationLevel?: Transaction_2.IsolationLevel;
 };
 
+declare interface BinaryTargetsEnvValue {
+    fromEnvVar: string | null;
+    value: string;
+    native?: boolean;
+}
+
 /**
  * Equivalent to `Uint8Array` before TypeScript 5.7, and `Uint8Array<ArrayBuffer>` in TypeScript 5.7 and beyond.
  */
@@ -184,7 +176,7 @@ declare interface CallSite {
 
 export declare type Cast<A, W> = A extends W ? A : W;
 
-declare type Client = ReturnType<typeof getPrismaClient> extends new (optionsArg: PrismaClientOptions) => infer T ? T : never;
+declare type Client = ReturnType<typeof getPrismaClient> extends new () => infer T ? T : never;
 
 export declare type ClientArg = {
     [MethodName in string]: unknown;
@@ -384,13 +376,6 @@ declare type DatamodelEnum = ReadonlyDeep_2<{
 
 declare function datamodelEnumToSchemaEnum(datamodelEnum: DatamodelEnum): SchemaEnum;
 
-declare type DatamodelSchemaEnum = ReadonlyDeep_2<{
-    name: string;
-    values: string[];
-}>;
-
-declare function datamodelSchemaEnumToSchemaEnum(datamodelSchemaEnum: DatamodelSchemaEnum): SchemaEnum;
-
 declare type DataRule = {
     type: 'rowCountEq';
     args: number;
@@ -404,7 +389,17 @@ declare type DataRule = {
     type: 'never';
 };
 
-export { DbNull }
+declare type Datasource = {
+    url?: string;
+};
+
+declare type Datasources = {
+    [name in string]: Datasource;
+};
+
+declare class DbNull extends NullTypesEnumValue {
+    #private;
+}
 
 export declare const Debug: typeof debugCreate & {
     enable(namespace: any): void;
@@ -432,7 +427,274 @@ declare function debugCreate(namespace: string): ((...args: any[]) => void) & {
     extend: () => void;
 };
 
-export { Decimal }
+export declare function Decimal(n: Decimal.Value): Decimal;
+
+export declare namespace Decimal {
+    export type Constructor = typeof Decimal;
+    export type Instance = Decimal;
+    export type Rounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+    export type Modulo = Rounding | 9;
+    export type Value = string | number | Decimal;
+
+    // http://mikemcl.github.io/decimal.js/#constructor-properties
+    export interface Config {
+        precision?: number;
+        rounding?: Rounding;
+        toExpNeg?: number;
+        toExpPos?: number;
+        minE?: number;
+        maxE?: number;
+        crypto?: boolean;
+        modulo?: Modulo;
+        defaults?: boolean;
+    }
+}
+
+export declare class Decimal {
+    readonly d: number[];
+    readonly e: number;
+    readonly s: number;
+
+    constructor(n: Decimal.Value);
+
+    absoluteValue(): Decimal;
+    abs(): Decimal;
+
+    ceil(): Decimal;
+
+    clampedTo(min: Decimal.Value, max: Decimal.Value): Decimal;
+    clamp(min: Decimal.Value, max: Decimal.Value): Decimal;
+
+    comparedTo(n: Decimal.Value): number;
+    cmp(n: Decimal.Value): number;
+
+    cosine(): Decimal;
+    cos(): Decimal;
+
+    cubeRoot(): Decimal;
+    cbrt(): Decimal;
+
+    decimalPlaces(): number;
+    dp(): number;
+
+    dividedBy(n: Decimal.Value): Decimal;
+    div(n: Decimal.Value): Decimal;
+
+    dividedToIntegerBy(n: Decimal.Value): Decimal;
+    divToInt(n: Decimal.Value): Decimal;
+
+    equals(n: Decimal.Value): boolean;
+    eq(n: Decimal.Value): boolean;
+
+    floor(): Decimal;
+
+    greaterThan(n: Decimal.Value): boolean;
+    gt(n: Decimal.Value): boolean;
+
+    greaterThanOrEqualTo(n: Decimal.Value): boolean;
+    gte(n: Decimal.Value): boolean;
+
+    hyperbolicCosine(): Decimal;
+    cosh(): Decimal;
+
+    hyperbolicSine(): Decimal;
+    sinh(): Decimal;
+
+    hyperbolicTangent(): Decimal;
+    tanh(): Decimal;
+
+    inverseCosine(): Decimal;
+    acos(): Decimal;
+
+    inverseHyperbolicCosine(): Decimal;
+    acosh(): Decimal;
+
+    inverseHyperbolicSine(): Decimal;
+    asinh(): Decimal;
+
+    inverseHyperbolicTangent(): Decimal;
+    atanh(): Decimal;
+
+    inverseSine(): Decimal;
+    asin(): Decimal;
+
+    inverseTangent(): Decimal;
+    atan(): Decimal;
+
+    isFinite(): boolean;
+
+    isInteger(): boolean;
+    isInt(): boolean;
+
+    isNaN(): boolean;
+
+    isNegative(): boolean;
+    isNeg(): boolean;
+
+    isPositive(): boolean;
+    isPos(): boolean;
+
+    isZero(): boolean;
+
+    lessThan(n: Decimal.Value): boolean;
+    lt(n: Decimal.Value): boolean;
+
+    lessThanOrEqualTo(n: Decimal.Value): boolean;
+    lte(n: Decimal.Value): boolean;
+
+    logarithm(n?: Decimal.Value): Decimal;
+    log(n?: Decimal.Value): Decimal;
+
+    minus(n: Decimal.Value): Decimal;
+    sub(n: Decimal.Value): Decimal;
+
+    modulo(n: Decimal.Value): Decimal;
+    mod(n: Decimal.Value): Decimal;
+
+    naturalExponential(): Decimal;
+    exp(): Decimal;
+
+    naturalLogarithm(): Decimal;
+    ln(): Decimal;
+
+    negated(): Decimal;
+    neg(): Decimal;
+
+    plus(n: Decimal.Value): Decimal;
+    add(n: Decimal.Value): Decimal;
+
+    precision(includeZeros?: boolean): number;
+    sd(includeZeros?: boolean): number;
+
+    round(): Decimal;
+
+    sine() : Decimal;
+    sin() : Decimal;
+
+    squareRoot(): Decimal;
+    sqrt(): Decimal;
+
+    tangent() : Decimal;
+    tan() : Decimal;
+
+    times(n: Decimal.Value): Decimal;
+    mul(n: Decimal.Value) : Decimal;
+
+    toBinary(significantDigits?: number): string;
+    toBinary(significantDigits: number, rounding: Decimal.Rounding): string;
+
+    toDecimalPlaces(decimalPlaces?: number): Decimal;
+    toDecimalPlaces(decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+    toDP(decimalPlaces?: number): Decimal;
+    toDP(decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+
+    toExponential(decimalPlaces?: number): string;
+    toExponential(decimalPlaces: number, rounding: Decimal.Rounding): string;
+
+    toFixed(decimalPlaces?: number): string;
+    toFixed(decimalPlaces: number, rounding: Decimal.Rounding): string;
+
+    toFraction(max_denominator?: Decimal.Value): Decimal[];
+
+    toHexadecimal(significantDigits?: number): string;
+    toHexadecimal(significantDigits: number, rounding: Decimal.Rounding): string;
+    toHex(significantDigits?: number): string;
+    toHex(significantDigits: number, rounding?: Decimal.Rounding): string;
+
+    toJSON(): string;
+
+    toNearest(n: Decimal.Value, rounding?: Decimal.Rounding): Decimal;
+
+    toNumber(): number;
+
+    toOctal(significantDigits?: number): string;
+    toOctal(significantDigits: number, rounding: Decimal.Rounding): string;
+
+    toPower(n: Decimal.Value): Decimal;
+    pow(n: Decimal.Value): Decimal;
+
+    toPrecision(significantDigits?: number): string;
+    toPrecision(significantDigits: number, rounding: Decimal.Rounding): string;
+
+    toSignificantDigits(significantDigits?: number): Decimal;
+    toSignificantDigits(significantDigits: number, rounding: Decimal.Rounding): Decimal;
+    toSD(significantDigits?: number): Decimal;
+    toSD(significantDigits: number, rounding: Decimal.Rounding): Decimal;
+
+    toString(): string;
+
+    truncated(): Decimal;
+    trunc(): Decimal;
+
+    valueOf(): string;
+
+    static abs(n: Decimal.Value): Decimal;
+    static acos(n: Decimal.Value): Decimal;
+    static acosh(n: Decimal.Value): Decimal;
+    static add(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static asin(n: Decimal.Value): Decimal;
+    static asinh(n: Decimal.Value): Decimal;
+    static atan(n: Decimal.Value): Decimal;
+    static atanh(n: Decimal.Value): Decimal;
+    static atan2(y: Decimal.Value, x: Decimal.Value): Decimal;
+    static cbrt(n: Decimal.Value): Decimal;
+    static ceil(n: Decimal.Value): Decimal;
+    static clamp(n: Decimal.Value, min: Decimal.Value, max: Decimal.Value): Decimal;
+    static clone(object?: Decimal.Config): Decimal.Constructor;
+    static config(object: Decimal.Config): Decimal.Constructor;
+    static cos(n: Decimal.Value): Decimal;
+    static cosh(n: Decimal.Value): Decimal;
+    static div(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static exp(n: Decimal.Value): Decimal;
+    static floor(n: Decimal.Value): Decimal;
+    static hypot(...n: Decimal.Value[]): Decimal;
+    static isDecimal(object: any): object is Decimal;
+    static ln(n: Decimal.Value): Decimal;
+    static log(n: Decimal.Value, base?: Decimal.Value): Decimal;
+    static log2(n: Decimal.Value): Decimal;
+    static log10(n: Decimal.Value): Decimal;
+    static max(...n: Decimal.Value[]): Decimal;
+    static min(...n: Decimal.Value[]): Decimal;
+    static mod(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static mul(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static noConflict(): Decimal.Constructor;   // Browser only
+    static pow(base: Decimal.Value, exponent: Decimal.Value): Decimal;
+    static random(significantDigits?: number): Decimal;
+    static round(n: Decimal.Value): Decimal;
+    static set(object: Decimal.Config): Decimal.Constructor;
+    static sign(n: Decimal.Value): number;
+    static sin(n: Decimal.Value): Decimal;
+    static sinh(n: Decimal.Value): Decimal;
+    static sqrt(n: Decimal.Value): Decimal;
+    static sub(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static sum(...n: Decimal.Value[]): Decimal;
+    static tan(n: Decimal.Value): Decimal;
+    static tanh(n: Decimal.Value): Decimal;
+    static trunc(n: Decimal.Value): Decimal;
+
+    static readonly default?: Decimal.Constructor;
+    static readonly Decimal?: Decimal.Constructor;
+
+    static readonly precision: number;
+    static readonly rounding: Decimal.Rounding;
+    static readonly toExpNeg: number;
+    static readonly toExpPos: number;
+    static readonly minE: number;
+    static readonly maxE: number;
+    static readonly crypto: boolean;
+    static readonly modulo: Decimal.Modulo;
+
+    static readonly ROUND_UP: 0;
+    static readonly ROUND_DOWN: 1;
+    static readonly ROUND_CEIL: 2;
+    static readonly ROUND_FLOOR: 3;
+    static readonly ROUND_HALF_UP: 4;
+    static readonly ROUND_HALF_DOWN: 5;
+    static readonly ROUND_HALF_EVEN: 6;
+    static readonly ROUND_HALF_CEIL: 7;
+    static readonly ROUND_HALF_FLOOR: 8;
+    static readonly EUCLID: 9;
+}
 
 /**
  * Interface for any Decimal.js-like library
@@ -497,12 +759,10 @@ export declare type DevTypeMapFnDef = {
 export declare namespace DMMF {
     export {
         datamodelEnumToSchemaEnum,
-        datamodelSchemaEnumToSchemaEnum,
         Document_2 as Document,
         Mappings,
         OtherOperationMappings,
         DatamodelEnum,
-        DatamodelSchemaEnum,
         SchemaEnum,
         EnumValue,
         Datamodel,
@@ -533,20 +793,17 @@ export declare namespace DMMF {
         FieldRefType,
         FieldRefAllowType,
         ModelMapping,
-        ModelAction,
-        ReadonlyDeep_2 as ReadonlyDeep
+        ModelAction
     }
 }
 
 declare namespace DMMF_2 {
     export {
         datamodelEnumToSchemaEnum,
-        datamodelSchemaEnumToSchemaEnum,
         Document_2 as Document,
         Mappings,
         OtherOperationMappings,
         DatamodelEnum,
-        DatamodelSchemaEnum,
         SchemaEnum,
         EnumValue,
         Datamodel,
@@ -577,8 +834,7 @@ declare namespace DMMF_2 {
         FieldRefType,
         FieldRefAllowType,
         ModelMapping,
-        ModelAction,
-        ReadonlyDeep_2 as ReadonlyDeep
+        ModelAction
     }
 }
 
@@ -746,7 +1002,10 @@ export declare type DynamicResultExtensionNeeds<TypeMap extends TypeMapDef, M ex
     [N in keyof TypeMap['model'][M]['payload']['scalars']]?: boolean;
 };
 
-export { empty }
+/**
+ * Placeholder value for "no text".
+ */
+export declare const empty: Sql;
 
 export declare type EmptyToUnknown<T> = T;
 
@@ -762,39 +1021,87 @@ declare interface Engine<InteractiveTransactionPayload = unknown> {
     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>;
     transaction(action: 'rollback', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo<unknown>): Promise<void>;
+    metrics(options: MetricsOptionsJson): Promise<Metrics>;
+    metrics(options: MetricsOptionsPrometheus): Promise<string>;
+    applyPendingMigrations(): Promise<void>;
 }
 
 declare interface EngineConfig {
+    cwd: string;
+    dirname: string;
     enableDebugLogs?: boolean;
+    allowTriggerPanic?: boolean;
     prismaPath?: string;
+    generator?: GeneratorConfig;
+    /**
+     * @remarks this field is used internally by Policy, do not rename or remove
+     */
+    overrideDatasources: Datasources;
+    showColors?: boolean;
     logQueries?: boolean;
     logLevel?: 'info' | 'warn';
+    env: Record<string, string>;
+    flags?: string[];
     clientVersion: string;
+    engineVersion: string;
     previewFeatures?: string[];
+    engineEndpoint?: string;
     activeProvider?: string;
     logEmitter: LogEmitter;
     transactionOptions: Transaction_2.Options;
     /**
-     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
+     * 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?: SqlDriverAdapterFactory;
-    /**
-     * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
-     */
-    accelerateUrl?: string;
     /**
      * The contents of the schema encoded into a string
      */
     inlineSchema: string;
+    /**
+     * The contents of the datasource url saved in a string
+     * @remarks only used by DataProxyEngine.ts
+     * @remarks this field is used internally by Policy, do not rename or remove
+     */
+    inlineDatasources: GetPrismaClientConfig['inlineDatasources'];
+    /**
+     * The string hash that was produced for a given schema
+     * @remarks only used by DataProxyEngine.ts
+     */
+    inlineSchemaHash: string;
     /**
      * The helper for interaction with OTEL tracing
      * @remarks enabling is determined by the client and @prisma/instrumentation package
      */
     tracingHelper: TracingHelper;
+    /**
+     * Information about whether we have not found a schema.prisma file in the
+     * default location, and that we fell back to finding the schema.prisma file
+     * in the current working directory. This usually means it has been bundled.
+     */
+    isBundled?: boolean;
     /**
      * Web Assembly module loading configuration
      */
+    engineWasm?: EngineWasmLoadingConfig;
     compilerWasm?: CompilerWasmLoadingConfig;
+    /**
+     * Allows Accelerate to use runtime utilities from the client. These are
+     * necessary for the AccelerateEngine to function correctly.
+     */
+    accelerateUtils?: {
+        resolveDatasourceUrl: typeof resolveDatasourceUrl;
+        getBatchRequestPayload: typeof getBatchRequestPayload;
+        prismaGraphQLToJSError: typeof prismaGraphQLToJSError;
+        PrismaClientUnknownRequestError: typeof PrismaClientUnknownRequestError;
+        PrismaClientInitializationError: typeof PrismaClientInitializationError;
+        PrismaClientKnownRequestError: typeof PrismaClientKnownRequestError;
+        debug: (...args: any[]) => void;
+        engineVersion: string;
+        clientVersion: string;
+    };
 }
 
 declare type EngineEvent<E extends EngineEventType> = E extends QueryEventType ? QueryEvent : LogEvent;
@@ -816,15 +1123,70 @@ declare type EngineSpanId = string;
 
 declare type EngineSpanKind = 'client' | 'internal';
 
+declare type EngineWasmLoadingConfig = {
+    /**
+     * WASM-bindgen runtime for corresponding module
+     */
+    getRuntime: () => Promise<{
+        __wbg_set_wasm(exports: unknown): void;
+        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 EnumValue = ReadonlyDeep_2<{
     name: string;
     dbName: string | null;
 }>;
 
+declare type EnvPaths = {
+    rootEnvPath: string | null;
+    schemaEnvPath: string | undefined;
+};
+
+declare interface EnvValue {
+    fromEnvVar: null | string;
+    value: null | string;
+}
+
 export declare type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? 1 : 0;
 
+declare type Error_2 = MappedError & {
+    originalCode?: string;
+    originalMessage?: string;
+};
+
+declare type ErrorCapturingFunction<T> = T extends (...args: infer A) => Promise<infer R> ? (...args: A) => Promise<Result_4<ErrorCapturingInterface<R>>> : T extends (...args: infer A) => infer R ? (...args: A) => Result_4<ErrorCapturingInterface<R>> : T;
+
+declare type ErrorCapturingInterface<T> = {
+    [K in keyof T]: ErrorCapturingFunction<T[K]>;
+};
+
+declare interface ErrorCapturingSqlDriverAdapter extends ErrorCapturingInterface<SqlDriverAdapter> {
+    readonly errorRegistry: ErrorRegistry;
+}
+
 declare type ErrorFormat = 'pretty' | 'colorless' | 'minimal';
 
+declare type ErrorRecord = {
+    error: unknown;
+};
+
+declare interface ErrorRegistry {
+    consumeError(id: number): ErrorRecord | undefined;
+}
+
+declare interface ErrorWithBatchIndex {
+    batchRequestIdx?: number;
+}
+
 declare type EventCallback<E extends ExtendedEventType> = [E] extends ['beforeExit'] ? () => Promise<void> : [E] extends [LogLevel] ? (event: EngineEvent<E>) => void : never;
 
 export declare type Exact<A, W> = (A extends unknown ? (W extends A ? {
@@ -1086,12 +1448,37 @@ declare type Fragment = {
     groupSeparator: string;
 };
 
+declare interface GeneratorConfig {
+    name: string;
+    output: EnvValue | null;
+    isCustomOutput?: boolean;
+    provider: EnvValue;
+    config: {
+        /** `output` is a reserved name and will only be available directly at `generator.output` */
+        output?: never;
+        /** `provider` is a reserved name and will only be available directly at `generator.provider` */
+        provider?: never;
+        /** `binaryTargets` is a reserved name and will only be available directly at `generator.binaryTargets` */
+        binaryTargets?: never;
+        /** `previewFeatures` is a reserved name and will only be available directly at `generator.previewFeatures` */
+        previewFeatures?: never;
+    } & {
+        [key: string]: string | string[] | undefined;
+    };
+    binaryTargets: BinaryTargetsEnvValue[];
+    previewFeatures: string[];
+    envPaths?: EnvPaths;
+    sourceFilePath: string;
+}
+
 export declare type GetAggregateResult<P extends OperationPayload, A> = {
     [K in keyof A as K extends Aggregate ? K : never]: K extends '_count' ? A[K] extends true ? number : Count<A[K]> : {
         [J in keyof A[K] & string]: P['scalars'][J] | null;
     };
 };
 
+declare function getBatchRequestPayload(batch: JsonQuery[], transaction?: TransactionOptions_2<unknown>): QueryEngineBatchRequest;
+
 export declare type GetBatchResult = {
     count: number;
 };
@@ -1143,7 +1530,7 @@ export declare type GetPayloadResultExtensionObject<R extends InternalArgs['resu
 };
 
 export declare function getPrismaClient(config: GetPrismaClientConfig): {
-    new (optionsArg: PrismaClientOptions): {
+    new (optionsArg?: PrismaClientOptions): {
         _originalClient: any;
         _runtimeDataModel: RuntimeDataModel;
         _requestHandler: RequestHandler;
@@ -1264,12 +1651,14 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
          */
         _request(internalParams: InternalRequestParams): Promise<any>;
         _executeRequest({ args, clientMethod, dataPath, callsite, action, model, argsMapper, transaction, unpacker, otelParentCtx, customDataProxyFetch, }: InternalRequestParams): Promise<any>;
+        $metrics: MetricsClient;
         /**
          * Shortcut for checking a preview flag
          * @param feature preview flag
          * @returns
          */
         _hasPreviewFlag(feature: string): boolean;
+        $applyPendingMigrations(): Promise<void>;
         $extends: typeof $extends;
         readonly [Symbol.toStringTag]: string;
     };
@@ -1282,17 +1671,74 @@ export declare function getPrismaClient(config: GetPrismaClientConfig): {
  */
 export declare type GetPrismaClientConfig = {
     runtimeDataModel: RuntimeDataModel;
-    previewFeatures: string[];
+    generator?: GeneratorConfig;
+    relativeEnvPaths?: {
+        rootEnvPath?: string | null;
+        schemaEnvPath?: string | null;
+    };
+    relativePath: string;
+    dirname: string;
     clientVersion: string;
     engineVersion: string;
+    datasourceNames: string[];
     activeProvider: ActiveConnectorType;
     /**
      * The contents of the schema encoded into a string
+     * @remarks only used for the purpose of data proxy
      */
     inlineSchema: string;
+    /**
+     * A special env object just for the data proxy edge runtime.
+     * Allows bundlers to inject their own env variables (Vercel).
+     * Allows platforms to declare global variables as env (Workers).
+     * @remarks only used for the purpose of data proxy
+     */
+    injectableEdgeEnv?: () => LoadedEnv;
+    /**
+     * The contents of the datasource url saved in a string.
+     * This can either be an env var name or connection string.
+     * It is needed by the client to connect to the Data Proxy.
+     * @remarks only used for the purpose of data proxy
+     */
+    inlineDatasources: {
+        [name in string]: {
+            url: EnvValue;
+        };
+    };
+    /**
+     * The string hash that was produced for a given schema
+     * @remarks only used for the purpose of data proxy
+     */
+    inlineSchemaHash: string;
+    /**
+     * A marker to indicate that the client was not generated via `prisma
+     * generate` but was generated via `generate --postinstall` script instead.
+     * @remarks used to error for Vercel/Netlify for schema caching issues
+     */
+    postinstall?: boolean;
+    /**
+     * Information about the CI where the Prisma Client has been generated. The
+     * name of the CI environment is stored at generation time because CI
+     * information is not always available at runtime. Moreover, the edge client
+     * has no notion of environment variables, so this works around that.
+     * @remarks used to error for Vercel/Netlify for schema caching issues
+     */
+    ciName?: string;
+    /**
+     * Information about whether we have not found a schema.prisma file in the
+     * default location, and that we fell back to finding the schema.prisma file
+     * in the current working directory. This usually means it has been bundled.
+     */
+    isBundled?: boolean;
+    /**
+     * A boolean that is `false` when the client was generated with --no-engine. At
+     * runtime, this means the client will be bound to be using the Data Proxy.
+     */
+    copyEngine?: boolean;
     /**
      * Optional wasm loading configuration
      */
+    engineWasm?: EngineWasmLoadingConfig;
     compilerWasm?: CompilerWasmLoadingConfig;
 };
 
@@ -1451,7 +1897,8 @@ declare type InteractiveTransactionInfo<Payload = unknown> = {
     id: string;
     /**
      * Arbitrary payload the meaning of which depends on the `Engine` implementation.
-     * It is currently not used in `LibraryEngine`.
+     * For example, `DataProxyEngine` needs to associate different API endpoints with transactions.
+     * In `LibraryEngine` and `BinaryEngine` it is currently not used.
      */
     payload: Payload;
 };
@@ -1518,12 +1965,6 @@ declare type InternalRequestParams = {
     customDataProxyFetch?: AccelerateExtensionFetchDecorator;
 } & Omit<QueryMiddlewareParams, 'runInTransaction'>;
 
-export { isAnyNull }
-
-export { isDbNull }
-
-export { isJsonNull }
-
 declare type IsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SNAPSHOT' | 'SERIALIZABLE';
 
 declare type IsolationLevel_2 = 'ReadUncommitted' | 'ReadCommitted' | 'RepeatableRead' | 'Snapshot' | 'Serializable';
@@ -1542,7 +1983,10 @@ declare interface Job {
     request: any;
 }
 
-export { join }
+/**
+ * Create a SQL query for a list of values.
+ */
+export declare function join(values: readonly RawValue[], separator?: string, prefix?: string, suffix?: string): Sql;
 
 declare type JoinExpression = {
     child: QueryPlanNode;
@@ -1589,7 +2033,9 @@ declare type JsonFieldSelection = {
     selection: JsonSelectionSet;
 };
 
-export { JsonNull }
+declare class JsonNull extends NullTypesEnumValue {
+    #private;
+}
 
 /**
  * From https://github.com/sindresorhus/type-fest/
@@ -1627,6 +2073,13 @@ export declare type JsOutputValue = null | string | number | boolean | bigint |
 
 export declare type JsPromise<T> = Promise<T> & {};
 
+declare type KnownErrorParams = {
+    code: string;
+    clientVersion: string;
+    meta?: Record<string, unknown>;
+    batchRequestIdx?: number;
+};
+
 /**
  * A pointer from the current {@link Span} to another span in the same trace or
  * in a different trace.
@@ -1651,6 +2104,13 @@ declare interface Link {
     droppedAttributesCount?: number;
 }
 
+declare type LoadedEnv = {
+    message?: string;
+    parsed: {
+        [x: string]: string;
+    };
+} | undefined;
+
 declare type LocationInFile = {
     fileName: string;
     lineNumber: number | null;
@@ -1704,6 +2164,116 @@ export declare function makeStrictEnum<T extends Record<PropertyKey, string | nu
 
 export declare function makeTypedQueryFactory(sql: string): (...values: any[]) => TypedSql<any[], unknown>;
 
+declare type MappedError = {
+    kind: 'GenericJs';
+    id: number;
+} | {
+    kind: 'UnsupportedNativeDataType';
+    type: string;
+} | {
+    kind: 'InvalidIsolationLevel';
+    level: string;
+} | {
+    kind: 'LengthMismatch';
+    column?: string;
+} | {
+    kind: 'UniqueConstraintViolation';
+    constraint?: {
+        fields: string[];
+    } | {
+        index: string;
+    } | {
+        foreignKey: {};
+    };
+} | {
+    kind: 'NullConstraintViolation';
+    constraint?: {
+        fields: string[];
+    } | {
+        index: string;
+    } | {
+        foreignKey: {};
+    };
+} | {
+    kind: 'ForeignKeyConstraintViolation';
+    constraint?: {
+        fields: string[];
+    } | {
+        index: string;
+    } | {
+        foreignKey: {};
+    };
+} | {
+    kind: 'DatabaseNotReachable';
+    host?: string;
+    port?: number;
+} | {
+    kind: 'DatabaseDoesNotExist';
+    db?: string;
+} | {
+    kind: 'DatabaseAlreadyExists';
+    db?: string;
+} | {
+    kind: 'DatabaseAccessDenied';
+    db?: string;
+} | {
+    kind: 'ConnectionClosed';
+} | {
+    kind: 'TlsConnectionError';
+    reason: string;
+} | {
+    kind: 'AuthenticationFailed';
+    user?: string;
+} | {
+    kind: 'TransactionWriteConflict';
+} | {
+    kind: 'TableDoesNotExist';
+    table?: string;
+} | {
+    kind: 'ColumnNotFound';
+    column?: string;
+} | {
+    kind: 'TooManyConnections';
+    cause: string;
+} | {
+    kind: 'ValueOutOfRange';
+    cause: string;
+} | {
+    kind: 'MissingFullTextSearchIndex';
+} | {
+    kind: 'SocketTimeout';
+} | {
+    kind: 'InconsistentColumnData';
+    cause: string;
+} | {
+    kind: 'TransactionAlreadyClosed';
+    cause: string;
+} | {
+    kind: 'postgres';
+    code: string;
+    severity: string;
+    message: string;
+    detail: string | undefined;
+    column: string | undefined;
+    hint: string | undefined;
+} | {
+    kind: 'mysql';
+    code: number;
+    message: string;
+    state: string;
+} | {
+    kind: 'sqlite';
+    /**
+     * Sqlite extended error code: https://www.sqlite.org/rescode.html
+     */
+    extendedCode: number;
+    message: string;
+} | {
+    kind: 'mssql';
+    code: number;
+    message: string;
+};
+
 declare type Mappings = ReadonlyDeep_2<{
     modelOperations: ModelMapping[];
     otherOperations: {
@@ -1738,6 +2308,66 @@ declare class MergedExtensionsList {
 
 export declare type MergeExtArgs<TypeMap extends TypeMapDef, ExtArgs extends Record<any, any>, Args extends Record<any, any>> = ComputeDeep<ExtArgs & Args & AllModelsToStringIndex<TypeMap, Args, 'result'> & AllModelsToStringIndex<TypeMap, Args, 'model'>>;
 
+export declare type Metric<T> = {
+    key: string;
+    value: T;
+    labels: Record<string, string>;
+    description: string;
+};
+
+export declare type MetricHistogram = {
+    buckets: MetricHistogramBucket[];
+    sum: number;
+    count: number;
+};
+
+export declare type MetricHistogramBucket = [maxValue: number, count: number];
+
+export declare type Metrics = {
+    counters: Metric<number>[];
+    gauges: Metric<number>[];
+    histograms: Metric<MetricHistogram>[];
+};
+
+export declare class MetricsClient {
+    private _client;
+    constructor(client: Client);
+    /**
+     * Returns all metrics gathered up to this point in prometheus format.
+     * Result of this call can be exposed directly to prometheus scraping endpoint
+     *
+     * @param options
+     * @returns
+     */
+    prometheus(options?: MetricsOptions): Promise<string>;
+    /**
+     * Returns all metrics gathered up to this point in prometheus format.
+     *
+     * @param options
+     * @returns
+     */
+    json(options?: MetricsOptions): Promise<Metrics>;
+}
+
+declare type MetricsOptions = {
+    /**
+     * Labels to add to every metrics in key-value format
+     */
+    globalLabels?: Record<string, string>;
+};
+
+declare type MetricsOptionsCommon = {
+    globalLabels?: Record<string, string>;
+};
+
+declare type MetricsOptionsJson = {
+    format: 'json';
+} & MetricsOptionsCommon;
+
+declare type MetricsOptionsPrometheus = {
+    format: 'prometheus';
+} & MetricsOptionsCommon;
+
 declare type MiddlewareArgsMapper<RequestArgs, MiddlewareArgs> = {
     requestArgsToMiddlewareArgs(requestArgs: RequestArgs): MiddlewareArgs;
     middlewareArgsToRequestArgs(middlewareArgs: MiddlewareArgs): RequestArgs;
@@ -1839,9 +2469,32 @@ export declare type Narrowable = string | number | bigint | boolean | [];
 
 export declare type NeverToUnknown<T> = [T] extends [never] ? unknown : T;
 
-export { NullTypes }
+declare class NullTypesEnumValue extends ObjectEnumValue {
+    _getNamespace(): string;
+}
+
+/**
+ * Base class for unique values of object-valued enums.
+ */
+export declare abstract class ObjectEnumValue {
+    constructor(arg?: symbol);
+    abstract _getNamespace(): string;
+    _getName(): string;
+    toString(): string;
+}
 
-export { ObjectEnumValue }
+export declare const objectEnumValues: {
+    classes: {
+        DbNull: typeof DbNull;
+        JsonNull: typeof JsonNull;
+        AnyNull: typeof AnyNull;
+    };
+    instances: {
+        DbNull: DbNull;
+        JsonNull: JsonNull;
+        AnyNull: AnyNull;
+    };
+};
 
 declare const officialPrismaAdapters: readonly ["@prisma/adapter-planetscale", "@prisma/adapter-neon", "@prisma/adapter-libsql", "@prisma/adapter-better-sqlite3", "@prisma/adapter-d1", "@prisma/adapter-pg", "@prisma/adapter-mssql", "@prisma/adapter-mariadb"];
 
@@ -1892,6 +2545,10 @@ declare type Options = {
     isolationLevel?: IsolationLevel_2;
 };
 
+declare type Options_2 = {
+    clientVersion: string;
+};
+
 export declare type Or<A extends 1 | 0, B extends 1 | 0> = {
     0: {
         0: 0;
@@ -1958,29 +2615,36 @@ declare type PrimaryKey = ReadonlyDeep_2<{
     fields: string[];
 }>;
 
-export { PrismaClientInitializationError }
+export declare class PrismaClientInitializationError extends Error {
+    clientVersion: string;
+    errorCode?: string;
+    retryable?: boolean;
+    constructor(message: string, clientVersion: string, errorCode?: string);
+    get [Symbol.toStringTag](): string;
+}
 
-export { PrismaClientKnownRequestError }
+export declare class PrismaClientKnownRequestError extends Error implements ErrorWithBatchIndex {
+    code: string;
+    meta?: Record<string, unknown>;
+    clientVersion: string;
+    batchRequestIdx?: number;
+    constructor(message: string, { code, clientVersion, meta, batchRequestIdx }: KnownErrorParams);
+    get [Symbol.toStringTag](): string;
+}
 
-/**
- * Since Prisma 7, a PrismaClient needs either an adapter or an accelerateUrl.
- * The two options are mutually exclusive.
- */
-declare type PrismaClientMutuallyExclusiveOptions = {
+export declare type PrismaClientOptions = {
     /**
-     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
+     * Overwrites the primary datasource url from your schema.prisma file
      */
-    adapter: SqlDriverAdapterFactory;
-    accelerateUrl?: never;
-} | {
+    datasourceUrl?: string;
     /**
-     * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
+     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale.
      */
-    accelerateUrl: string;
-    adapter?: never;
-};
-
-export declare type PrismaClientOptions = PrismaClientMutuallyExclusiveOptions & {
+    adapter?: SqlDriverAdapterFactory | null;
+    /**
+     * Overwrites the datasource url from your schema.prisma file
+     */
+    datasources?: Datasources;
     /**
      * @default "colorless"
      */
@@ -2014,16 +2678,38 @@ export declare type PrismaClientOptions = PrismaClientMutuallyExclusiveOptions &
      */
     __internal?: {
         debug?: boolean;
+        engine?: {
+            cwd?: string;
+            binaryPath?: string;
+            endpoint?: string;
+            allowTriggerPanic?: boolean;
+        };
         /** This can be used for testing purposes */
         configOverride?: (config: GetPrismaClientConfig) => GetPrismaClientConfig;
     };
 };
 
-export { PrismaClientRustPanicError }
+export declare class PrismaClientRustPanicError extends Error {
+    clientVersion: string;
+    constructor(message: string, clientVersion: string);
+    get [Symbol.toStringTag](): string;
+}
 
-export { PrismaClientUnknownRequestError }
+export declare class PrismaClientUnknownRequestError extends Error implements ErrorWithBatchIndex {
+    clientVersion: string;
+    batchRequestIdx?: number;
+    constructor(message: string, { clientVersion, batchRequestIdx }: UnknownErrorParams);
+    get [Symbol.toStringTag](): string;
+}
 
-export { PrismaClientValidationError }
+export declare class PrismaClientValidationError extends Error {
+    name: string;
+    clientVersion: string;
+    constructor(message: string, { clientVersion }: Options_2);
+    get [Symbol.toStringTag](): string;
+}
+
+declare function prismaGraphQLToJSError({ error, user_facing_error }: RequestError, clientVersion: string, activeProvider: string): PrismaClientKnownRequestError | PrismaClientUnknownRequestError;
 
 declare type PrismaOperationSpec<TArgs, TAction = string> = {
     args: TArgs;
@@ -2170,6 +2856,61 @@ declare type QueryCompilerOptions = {
     connectionInfo: ConnectionInfo;
 };
 
+declare type QueryEngineBatchGraphQLRequest = {
+    batch: QueryEngineRequest[];
+    transaction?: boolean;
+    isolationLevel?: IsolationLevel_2;
+};
+
+declare type QueryEngineBatchRequest = QueryEngineBatchGraphQLRequest | JsonBatchQuery;
+
+declare type QueryEngineConfig = {
+    datamodel: string;
+    configDir: string;
+    logQueries: boolean;
+    ignoreEnvVarErrors: boolean;
+    datasourceOverrides: Record<string, string>;
+    env: Record<string, string | undefined>;
+    logLevel: QueryEngineLogLevel;
+    engineProtocol: QueryEngineProtocol;
+    enableTracing: boolean;
+};
+
+declare interface QueryEngineConstructor {
+    new (config: QueryEngineConfig, logger: (log: string) => void, adapter?: ErrorCapturingSqlDriverAdapter): QueryEngineInstance;
+}
+
+declare type QueryEngineInstance = {
+    connect(headers: string, requestId: string): Promise<void>;
+    disconnect(headers: string, requestId: string): Promise<void>;
+    /**
+     * Frees any resources allocated by the engine's WASM instance. This method is automatically created by WASM bindgen.
+     * Noop for other engines.
+     */
+    free?(): 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>;
+};
+
+declare type QueryEngineLogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'off';
+
+declare type QueryEngineProtocol = 'graphql' | 'json';
+
+declare type QueryEngineRequest = {
+    query: string;
+    variables: Object;
+};
+
 declare type QueryEngineResultData<T> = {
     data: T;
 };
@@ -2348,7 +3089,10 @@ declare type QueryPlanNode = {
     };
 };
 
-export { raw }
+/**
+ * Create raw SQL statement.
+ */
+export declare function raw(value: string): Sql;
 
 export declare type RawParameters = {
     __prismaRawParameters__: true;
@@ -2368,7 +3112,10 @@ declare type RawTaggedValue = {
     value: unknown;
 };
 
-export { RawValue }
+/**
+ * Supported value or SQL instance.
+ */
+export declare type RawValue = Value | Sql;
 
 export declare type ReadonlyDeep<T> = {
     readonly [K in keyof T]: ReadonlyDeep<T[K]>;
@@ -2395,6 +3142,17 @@ declare type RequestBatchOptions<InteractiveTransactionPayload> = {
     customDataProxyFetch?: AccelerateExtensionFetchDecorator;
 };
 
+declare interface RequestError {
+    error: string;
+    user_facing_error: {
+        is_panic: boolean;
+        message: string;
+        meta?: Record<string, unknown>;
+        error_code?: string;
+        batch_request_idx?: number;
+    };
+}
+
 declare class RequestHandler {
     client: Client;
     dataloader: DataLoader<RequestParams>;
@@ -2447,6 +3205,13 @@ export declare type RequiredKeys<O> = {
     [K in keyof O]-?: {} extends Pick_2<O, K> ? never : K;
 }[keyof O];
 
+declare function resolveDatasourceUrl({ inlineDatasources, overrideDatasources, env, clientVersion, }: {
+    inlineDatasources: GetPrismaClientConfig['inlineDatasources'];
+    overrideDatasources: Datasources;
+    env: Record<string, string | undefined>;
+    clientVersion: string;
+}): string;
+
 export declare type Result<T, A, F extends Operation> = T extends {
     [K: symbol]: {
         types: {
@@ -2482,6 +3247,17 @@ 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;
 };
@@ -2540,8 +3316,8 @@ declare type Schema = ReadonlyDeep_2<{
         prisma: OutputType[];
     };
     enumTypes: {
-        model?: DatamodelSchemaEnum[];
-        prisma: DatamodelSchemaEnum[];
+        model?: SchemaEnum[];
+        prisma: SchemaEnum[];
     };
     fieldRefTypes: {
         prisma?: FieldRefType[];
@@ -2560,10 +3336,7 @@ declare type SchemaArg = ReadonlyDeep_2<{
 
 declare type SchemaEnum = ReadonlyDeep_2<{
     name: string;
-    data: {
-        key: string;
-        value: string;
-    }[];
+    values: string[];
 }>;
 
 declare type SchemaField = ReadonlyDeep_2<{
@@ -2871,7 +3644,23 @@ declare enum SpanStatusCode {
     ERROR = 2
 }
 
-export { Sql }
+/**
+ * A SQL instance can be nested within each other to build SQL strings.
+ */
+export declare class Sql {
+    readonly values: Value[];
+    readonly strings: string[];
+    constructor(rawStrings: readonly string[], rawValues: readonly RawValue[]);
+    get sql(): string;
+    get statement(): string;
+    get text(): string;
+    inspect(): {
+        sql: string;
+        statement: string;
+        text: string;
+        values: unknown[];
+    };
+}
 
 declare interface SqlDriverAdapter extends SqlQueryable {
     /**
@@ -2927,7 +3716,10 @@ declare interface SqlResultSet {
     lastInsertId?: string;
 }
 
-export { sqltag }
+/**
+ * Create a SQL object from a template string.
+ */
+export declare function sqltag(strings: readonly string[], ...values: readonly RawValue[]): Sql;
 
 /**
  * Defines TimeInput.
@@ -3065,6 +3857,11 @@ declare type uniqueIndex = ReadonlyDeep_2<{
     fields: string[];
 }>;
 
+declare type UnknownErrorParams = {
+    clientVersion: string;
+    batchRequestIdx?: number;
+};
+
 export declare type UnknownTypedSql = TypedSql<unknown[], unknown>;
 
 declare type Unpacker = (data: any) => any;
@@ -3173,7 +3970,12 @@ declare function validator<C, M extends Exclude<keyof C, `$${string}`>, O extend
 
 declare function validator<C, M extends Exclude<keyof C, `$${string}`>, O extends keyof C[M] & Operation, P extends keyof Args<C[M], O>>(client: C, model: M, operation: O, prop: P): <S>(select: Exact<S, Args<C[M], O>[P]>) => S;
 
-export { Value }
+/**
+ * Values supported by SQL engine.
+ */
+export declare type Value = unknown;
+
+export declare function warnEnvConflicts(envPaths: any): void;
 
 export declare const warnOnce: (key: string, message: string, ...args: unknown[]) => void;