import { ZodRawShape, z, ZodString } from 'zod';

type AppletDefinition = {
    fetch: (request: Request) => Response | Promise<Response>;
};
type BunServeLike = {
    stop: (closeActiveConnections?: boolean) => void;
};
declare function defineApplet(definition: AppletDefinition): BunServeLike;

type CurrentUser = {
    id: string;
    tenantId: string;
    permissions: string[];
    requestId?: string;
};
declare const auth: {
    currentUser(): Promise<CurrentUser>;
};

type EngineCallOptions = {
    timeoutMs?: number;
};
declare const engine: {
    call<TResult = unknown>(method: string, params: unknown, options?: EngineCallOptions): Promise<TResult>;
};

declare const kv: {
    get<T = unknown>(key: string): Promise<T | null>;
    set(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
    del(key: string): Promise<boolean>;
    mget<T = unknown>(keys: string[]): Promise<Array<T | null>>;
};

type DBConstraint = {
    field: string;
    op: 'eq';
    value: unknown;
};
type DBIndexConstraint = DBConstraint & {
    name: string;
};
type DBQueryOptions = {
    index?: DBIndexConstraint;
    filters?: DBConstraint[];
    order?: 'asc' | 'desc';
    take?: number;
};
type DBQueryIndex = {
    eq(field: string, value: unknown): DBQueryIndex;
};
type DBQueryFilter = {
    eq(field: string, value: unknown): DBQueryFilter;
};
type DBQueryBuilder<T> = {
    withIndex(name: string, build: (q: DBQueryIndex) => DBQueryIndex | void): DBQueryBuilder<T>;
    filter(build: (q: DBQueryFilter) => DBQueryFilter | void): DBQueryBuilder<T>;
    order(direction: 'asc' | 'desc'): DBQueryBuilder<T>;
    take(limit: number): DBQueryBuilder<T>;
    collect(): Promise<T[]>;
    first(): Promise<T | null>;
};
type DBClient = {
    get<T = unknown>(id: string): Promise<T | null>;
    query<T = unknown>(table: string): DBQueryBuilder<T>;
    queryRaw<T = unknown>(table: string, query?: DBQueryOptions): Promise<T[]>;
    insert<T = unknown>(table: string, value: unknown): Promise<T>;
    patch<T = unknown>(id: string, value: unknown): Promise<T>;
    replace<T = unknown>(id: string, value: unknown): Promise<T>;
    delete(id: string): Promise<boolean>;
};
declare const db: DBClient;

type ScheduledJob = {
    id: string;
    type: string;
    cron: string;
    method: string;
    params: unknown;
    status: string;
    nextRunAt?: string;
    lastRunAt?: string;
    lastStatus?: string;
    lastError?: string;
    createdAt?: string;
    updatedAt?: string;
};
declare const jobs: {
    enqueue(method: string, params?: unknown): Promise<ScheduledJob>;
    schedule(cron: string, method: string, params?: unknown): Promise<ScheduledJob>;
    list(): Promise<ScheduledJob[]>;
    cancel(id: string): Promise<{
        ok: boolean;
    }>;
};

declare const secrets: {
    get(name: string): Promise<string>;
};

type StoredFile = {
    id: string;
    name: string;
    contentType?: string;
    size: number;
    path: string;
    createdAt: string;
};
declare const files: {
    store(input: {
        name: string;
        contentType?: string;
        data: Blob | ArrayBuffer | Uint8Array;
    }): Promise<StoredFile>;
    get(id: string): Promise<StoredFile | null>;
    delete(id: string): Promise<boolean>;
};

type ConnectionHandler = (connectionId: string) => void | Promise<void>;
type MessageHandler = (connectionId: string, data: Uint8Array) => void | Promise<void>;
type CloseHandler = (connectionId: string) => void | Promise<void>;
declare const ws: {
    send(connectionId: string, data: unknown): Promise<{
        ok: boolean;
    }>;
    onConnection(handler: ConnectionHandler): () => void;
    onMessage(handler: MessageHandler): () => void;
    onClose(handler: CloseHandler): () => void;
};

type TableIndex = {
    name: string;
    fields: string[];
};
type TableDefinition<T extends ZodRawShape> = {
    schema: z.ZodObject<T>;
    indexes: TableIndex[];
    index(name: string, fields: string[]): TableDefinition<T>;
};
type SchemaDefinition<Tables extends Record<string, TableDefinition<any>>> = {
    tables: Tables;
};
declare function defineTable<T extends ZodRawShape>(shape: T): TableDefinition<T>;
declare function defineSchema<Tables extends Record<string, TableDefinition<any>>>(tables: Tables): SchemaDefinition<Tables>;
declare function id(_tableName: string): ZodString;

type EngineHandler = (params: unknown) => unknown | Promise<unknown>;
type TestContextOptions = {
    appletId?: string;
    user?: Partial<CurrentUser>;
    secrets?: Record<string, string>;
    engineHandlers?: Record<string, EngineHandler>;
};
declare function createTestContext(options?: TestContextOptions): {
    auth: {
        currentUser(): Promise<CurrentUser>;
    };
    engine: {
        call<T = unknown>(method: string, params: unknown): Promise<T>;
    };
    kv: {
        get<T = unknown>(key: string): Promise<T | null>;
        set(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
        del(key: string): Promise<boolean>;
        mget<T = unknown>(keys: string[]): Promise<Array<T | null>>;
    };
    db: DBClient;
    jobs: {
        enqueue(method: string, params?: unknown): Promise<ScheduledJob>;
        schedule(cron: string, method: string, params?: unknown): Promise<ScheduledJob>;
        list(): Promise<ScheduledJob[]>;
        cancel(id: string): Promise<{
            ok: boolean;
        }>;
    };
    secrets: {
        get(name: string): Promise<string>;
    };
    files: {
        store(input: {
            name: string;
            contentType?: string;
            data: Blob | ArrayBuffer | Uint8Array;
        }): Promise<StoredFile>;
        get(id: string): Promise<StoredFile | null>;
        delete(id: string): Promise<boolean>;
    };
    setCurrentUser(nextUser: Partial<CurrentUser>): void;
};

export { type AppletDefinition, type CurrentUser, type DBClient, type DBConstraint, type DBIndexConstraint, type DBQueryBuilder, type DBQueryFilter, type DBQueryIndex, type DBQueryOptions, type ScheduledJob, type SchemaDefinition, type StoredFile, type TableDefinition, type TableIndex, type TestContextOptions, auth, createTestContext, db, defineApplet, defineSchema, defineTable, engine, files, id, jobs, kv, secrets, ws };