import type { CompiledQuery, InsertQueryBuilder, Kysely, RawBuilder, SelectQueryBuilder, UpdateObject } from 'kysely';
import type { ZodObject, ZodType, ZodTypeAny } from 'zod';
import { z } from 'zod';
import type { ApiConfig, ApiOptions, ExtractResultFromQuery, PActionBody, PHooks, Query, QueryRelations, QueryWhere, ZodSchemaToKysely } from '../types';
import type { SetOptional } from 'type-fest';
export declare abstract class PApi<Schema extends ZodObject<any, any, any>> {
    ky: Kysely<ZodSchemaToKysely<Schema>>;
    readonly config: ApiConfig;
    readonly schema: Schema;
    constructor(obj: {
        config?: ApiConfig;
        kysely: Kysely<ZodSchemaToKysely<Schema>>;
        schema: Schema;
        jsonHelpers?: {
            jsonArrayFrom: (query: any) => any;
            jsonObjectFrom: (query: any) => any;
        };
    });
    protected execQuery(body: any, options?: ApiOptions): any;
    execSql<T = any>(sqlQuery: RawBuilder<T> | {
        compile: () => CompiledQuery<T>;
    }, action?: 'run' | 'selectAll' | 'selectFirst', opts?: ApiOptions): Promise<{
        changes: number;
        lastInsertRowId: number;
        rows: T[];
    }>;
    parseOne<X = any>(data: any, table: keyof z.output<Schema>, extend?: ZodObject<any, any, any>): X;
    parseMany<X = any>(data: any[], table: keyof z.output<Schema>, extend?: ZodObject<any, any>): X[];
    param(index: number): string;
    abstract table<K extends keyof z.output<Schema> & string>(tableName: K, opts?: {
        ky?: Kysely<ZodSchemaToKysely<Schema>>;
        hooks?: PHooks[];
    }): PTable<z.output<Schema>[K], z.input<Schema>[K], K>;
    abstract batchOneSmt<V extends SelectQueryBuilder<z.output<Schema>, any, any> | InsertQueryBuilder<z.output<Schema>, any, any>>(sqlQuery: {
        compile: () => CompiledQuery<z.output<Schema>>;
    } | RawBuilder<z.output<Schema>>, batchParams: Array<any[]>, opts?: ApiOptions): Promise<{
        rows: ExtractResultFromQuery<V>[];
        error: any;
    }>;
    abstract $batchOneSmt(sqlQuery: {
        compile: () => CompiledQuery<z.output<Schema>>;
    } | RawBuilder<z.output<Schema>>, batchParams: Array<any[]>): PActionBody;
    abstract batchAllSmt(sqlQuerys: Array<{
        compile: () => CompiledQuery<z.output<Schema>>;
    }>, opts?: ApiOptions): Promise<{
        error: any;
        rows: any[];
        getOne: <X = any>(index: number) => X | undefined;
        getMany: <X = any>(index: number) => X[];
    }>;
    abstract bulk<V extends string>(operations: {
        [key in V]: PActionBody | {
            compile: () => CompiledQuery<z.output<Schema>>;
        } | RawBuilder<z.output<Schema>> | undefined;
    }, opts?: ApiOptions & {
        isTransaction: boolean;
    }): Promise<any>;
    /**
     * extend the origin zod schema
     * it similar to withTables on kysely
     *
     * ```typescript
     * const extendApi = api.withTables(
     *   {
     *     NewTable: z.object({
     *       id: z.number().optional(),
     *       name: z.string(),
     *     }),
     *   },
     *   { // option
     *     newTable: o => o.table('NewTable'),
     *   })
     * ```
     **/
    abstract withTables<T extends {
        [k: string]: ZodTypeAny;
    }, ExtendApi extends {
        [key: string]: (api: PApi<ExtendSchema>) => PTable<any, any, any>;
    }, ExtendSchema extends ZodObject<z.input<Schema> & T, any, any, z.input<Schema> & {
        [k in keyof T]: z.input<T[k]>;
    }, z.output<Schema> & {
        [k in keyof T]: z.output<T[k]>;
    }>>(schema: T, extendApi?: ExtendApi): PApi<ExtendSchema> & {
        [key in keyof ExtendApi]: ReturnType<ExtendApi[key]>;
    };
}
/**
 * prisma api similar
 */
export declare class PTable<Table extends {
    id: string | number;
}, TableInput extends {
    id: string | number;
}, TableName extends string> {
    readonly ky: Kysely<{
        [k in TableName]: Table;
    }>;
    private readonly table;
    private readonly jsonHelpers;
    private readonly schema?;
    private relations;
    private hooks;
    private hookContext;
    constructor(ky: Kysely<{
        [k in TableName]: Table;
    }>, table: TableName, jsonHelpers: {
        jsonArrayFrom: (query: any) => any;
        jsonObjectFrom: (query: any) => any;
    }, schema?: ZodObject<{ [k in keyof Table]: ZodType<Table[k]>; }> | undefined, opts?: {
        hooks: PHooks[];
    });
    selectMany(opts: QueryRelations<TableInput>): Promise<Table[]>;
    $selectMany(opts: QueryRelations<TableInput>): any;
    selectFirst(opts: QueryRelations<TableInput>): Promise<Table | undefined>;
    $selectFirst(opts: QueryRelations<TableInput>): any;
    updateMany(opts: Query<Table> & {
        data: Partial<Table>;
    }): Promise<{
        numUpdatedRows: bigint;
        numChangedRows?: bigint;
    }>;
    $updateMany(opts: Query<Table> & {
        data: Partial<Table>;
    }): import("kysely").UpdateQueryBuilder<{ [k in TableName]: Table; }, import("kysely/dist/cjs/parser/table-parser").ExtractTableAlias<{ [k in TableName]: Table; }, TableName>, import("kysely/dist/cjs/parser/table-parser").ExtractTableAlias<{ [k in TableName]: Table; }, TableName>, import("kysely").UpdateResult>;
    updateOne(opts: Query<Table> & {
        data: UpdateObject<{
            [k in TableName]: Table;
        }, TableName>;
    }): Promise<{
        numUpdatedRows: bigint;
        numChangedRows?: bigint;
    }>;
    $updateOne(opts: Query<Table> & {
        data: UpdateObject<{
            [k in TableName]: Table;
        }, TableName>;
    }): import("kysely").UpdateQueryBuilder<{ [k in TableName]: Table; }, import("kysely/dist/cjs/parser/table-parser").ExtractTableAlias<{ [k in TableName]: Table; }, TableName>, import("kysely/dist/cjs/parser/table-parser").ExtractTableAlias<{ [k in TableName]: Table; }, TableName>, import("kysely").UpdateResult>;
    insertOne(value: SetOptional<TableInput, 'id'>): Promise<Table | undefined>;
    $insertOne(value: SetOptional<TableInput, 'id'>): InsertQueryBuilder<{ [k in TableName]: Table; }, TableName, import("kysely").InsertResult> | InsertQueryBuilder<{ [k in TableName]: Table; }, TableName, import("kysely").Selection<{ [k in TableName]: Table; }, TableName, "id">>;
    /**
     * It use for a non unique key if a key is unique use InsertConflict
     * WARNING upsert will modify the data object
     */
    upsert(opts: {
        data: Partial<TableInput>;
        where?: QueryWhere<Table>;
    }): Promise<Partial<Table> | undefined>;
    /** conflicts columns should be a unique or primary key */
    insertConflict(opts: {
        create: Partial<Table>;
        update: Partial<Table>;
        conflicts: Array<keyof Table & string>;
    }): Promise<Partial<Table>>;
    /** conflicts columns should be a unique or primary key */
    $insertConflict({ create, update, conflicts, }: {
        create: Partial<Table>;
        update: Partial<Table>;
        conflicts: Array<keyof Table & string>;
    }): InsertQueryBuilder<{ [k in TableName]: Table; }, TableName, import("kysely").InsertResult>;
    insertMany(values: Array<Partial<Table>>): Promise<Table[]>;
    $insertMany(values: Array<Partial<Table>>): InsertQueryBuilder<{ [k in TableName]: Table; }, TableName, import("kysely").InsertResult> | InsertQueryBuilder<{ [k in TableName]: Table; }, TableName, import("kysely").Selection<{ [k in TableName]: Table; }, TableName, "id">>;
    deleteMany(opts: {
        where?: QueryWhere<Table>;
    }): Promise<{
        numDeletedRows: bigint;
    }>;
    $deleteMany({ where }: {
        where?: QueryWhere<Table>;
    }): import("kysely").DeleteQueryBuilder<{ [k in TableName]: Table; }, import("kysely/dist/cjs/parser/table-parser").ExtractTableAlias<{ [k in TableName]: Table; }, TableName>, import("kysely").DeleteResult>;
    count({ where }: {
        where?: QueryWhere<Table>;
    }): Promise<number>;
    selectById(id: Table['id'], select?: Readonly<{
        [k in keyof TableInput]?: boolean;
    }>): Promise<Table | undefined>;
    $selectById(id: Table['id'], select?: Readonly<{
        [k in keyof TableInput]?: boolean;
    }>): any;
    private mappingQuery;
    updateById(id: Table['id'], value: Partial<Table>): Promise<{
        numUpdatedRows: bigint;
        numChangedRows?: bigint;
    }>;
    $updateById(id: Table['id'], value: Partial<Table>): import("kysely").UpdateQueryBuilder<{ [k in TableName]: Table; }, import("kysely/dist/cjs/parser/table-parser").ExtractTableAlias<{ [k in TableName]: Table; }, TableName>, import("kysely/dist/cjs/parser/table-parser").ExtractTableAlias<{ [k in TableName]: Table; }, TableName>, import("kysely").UpdateResult>;
    deleteById(id: Table['id']): Promise<{
        numDeletedRows: bigint;
    }>;
    $deleteById(id: Table['id']): import("kysely").DeleteQueryBuilder<{ [k in TableName]: Table; }, import("kysely/dist/cjs/parser/table-parser").ExtractTableAlias<{ [k in TableName]: Table; }, TableName>, import("kysely").DeleteResult>;
}
export type InferSchemaFromPApi<T> = T extends PApi<infer K> ? (K extends Record<string, any> ? K : never) : never;
export type PTableFromSchema<Schema extends ZodObject<any, any, any>, K extends keyof z.output<Schema> & string> = PTable<z.output<Schema>[K], z.input<Schema>[K], K>;