klz-cables.com/.pnpm-store/v10/files/4b/d68e8eaf43c6c0110a85f01ac4a0c366c8ad11e3294093e7837b803b597106a96a48e2556e23551eadd77a1d006514c9d0b01a970099d7bb10f0bb813aaf55

import type { BasePostgresAdapter, GenericEnum, MigrateDownArgs, MigrateUpArgs, PostgresSchemaHook } from '@payloadcms/drizzle/postgres';
import type { DrizzleAdapter } from '@payloadcms/drizzle/types';
import type { DrizzleConfig } from 'drizzle-orm';
import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
import type { PgSchema, PgTableFn, PgTransactionConfig, PgWithReplicas } from 'drizzle-orm/pg-core';
import type { Pool, PoolConfig } from 'pg';
type PgDependency = typeof import('pg');
export type Args = {
    /**
     * Transform the schema after it's built.
     * You can use it to customize the schema with features that aren't supported by Payload.
     * Examples may include: composite indices, generated columns, vectors
     */
    afterSchemaInit?: PostgresSchemaHook[];
    /**
     * Enable this flag if you want to thread your own ID to create operation data, for example:
     * ```ts
     * // doc created with id 1
     * const doc = await payload.create({ collection: 'posts', data: {id: 1, title: "my title"}})
     * ```
     */
    allowIDOnCreate?: boolean;
    /**
     * Transform the schema before it's built.
     * You can use it to preserve an existing database schema and if there are any collissions Payload will override them.
     * To generate Drizzle schema from the database, see [Drizzle Kit introspection](https://orm.drizzle.team/kit-docs/commands#introspect--pull)
     */
    beforeSchemaInit?: PostgresSchemaHook[];
    /**
     * Store blocks as JSON column instead of storing them in relational structure.
     */
    blocksAsJSON?: boolean;
    /**
     * Pass `true` to disale auto database creation if it doesn't exist.
     * @default false
     */
    disableCreateDatabase?: boolean;
    extensions?: string[];
    /** Generated schema from payload generate:db-schema file path */
    generateSchemaOutputFile?: string;
    idType?: 'serial' | 'uuid';
    localesSuffix?: string;
    logger?: DrizzleConfig['logger'];
    migrationDir?: string;
    pg?: PgDependency;
    pool: PoolConfig;
    prodMigrations?: {
        down: (args: MigrateDownArgs) => Promise<void>;
        name: string;
        up: (args: MigrateUpArgs) => Promise<void>;
    }[];
    push?: boolean;
    readReplicas?: string[];
    relationshipsSuffix?: string;
    /**
     * The schema name to use for the database
     *
     * @experimental This only works when there are not other tables or enums of the same name in the database under a different schema. Awaiting fix from Drizzle.
     */
    schemaName?: string;
    tablesFilter?: string[];
    transactionOptions?: false | PgTransactionConfig;
    versionsSuffix?: string;
};
export interface GeneratedDatabaseSchema {
    schemaUntyped: Record<string, unknown>;
}
type ResolveSchemaType<T> = 'schema' extends keyof T ? T['schema'] : GeneratedDatabaseSchema['schemaUntyped'];
type Drizzle = NodePgDatabase<ResolveSchemaType<GeneratedDatabaseSchema>> | PgWithReplicas<NodePgDatabase<ResolveSchemaType<GeneratedDatabaseSchema>>>;
export type PostgresAdapter = {
    drizzle: Drizzle;
    pg: PgDependency;
    pool: Pool;
    poolOptions: PoolConfig;
} & BasePostgresAdapter;
declare module 'payload' {
    interface DatabaseAdapter extends Omit<Args, 'idType' | 'logger' | 'migrationDir' | 'pool'>, DrizzleAdapter {
        afterSchemaInit: PostgresSchemaHook[];
        beforeSchemaInit: PostgresSchemaHook[];
        beginTransaction: (options?: PgTransactionConfig) => Promise<null | number | string>;
        drizzle: Drizzle;
        enums: Record<string, GenericEnum>;
        extensions: Record<string, boolean>;
        /**
         * An object keyed on each table, with a key value pair where the constraint name is the key, followed by the dot-notation field name
         * Used for returning properly formed errors from unique fields
         */
        fieldConstraints: Record<string, Record<string, string>>;
        idType: Args['idType'];
        initializing: Promise<void>;
        localesSuffix?: string;
        logger: DrizzleConfig['logger'];
        /** Optionally inject your own node-postgres. This is required if you wish to instrument the driver with @payloadcms/plugin-sentry. */
        pg?: PgDependency;
        pgSchema?: {
            table: PgTableFn;
        } | PgSchema;
        pool: Pool;
        poolOptions: Args['pool'];
        prodMigrations?: {
            down: (args: MigrateDownArgs) => Promise<void>;
            name: string;
            up: (args: MigrateUpArgs) => Promise<void>;
        }[];
        push: boolean;
        rejectInitializing: () => void;
        relationshipsSuffix?: string;
        resolveInitializing: () => void;
        schema: Record<string, unknown>;
        schemaName?: Args['schemaName'];
        tableNameMap: Map<string, string>;
        tablesFilter?: string[];
        versionsSuffix?: string;
    }
}
export {};
//# sourceMappingURL=types.d.ts.map