export interface ColumnType {
    _sqlType: string;
}
export declare function string(): ColumnType;
export declare function number(): ColumnType;
export declare function boolean(): ColumnType;
export declare function table<T extends Record<string, ColumnType>>(columns: T): T;
export interface CapsuleAuth {
    isGuest: boolean;
    userId: string;
    displayName?: string;
    picture?: string;
    email?: string;
}
export interface CapsuleLog {
    info(msg: string, data?: any): void;
    error(msg: string, data?: any): void;
}
export interface CapsuleDbTable {
    where(column: string, value: any): QueryBuilder;
    orderBy(column: string, dir: "asc" | "desc"): QueryBuilder;
    limit(n: number): QueryBuilder;
    offset(n: number): QueryBuilder;
    all(): any[];
    count(): number;
    get(id: string): any;
    insert(data: Record<string, any>): any;
    update(id: string, data: Record<string, any>): any;
    delete(id: string): void;
}
export interface QueryBuilder {
    orderBy(column: string, dir: "asc" | "desc"): QueryBuilder;
    limit(n: number): QueryBuilder;
    offset(n: number): QueryBuilder;
    all(): any[];
    count(): number;
}
export interface CapsuleDb {
    [tableName: string]: CapsuleDbTable;
}
export interface AiCompleteOptions {
    prompt: string;
    model?: string;
    system?: string;
    maxTokens?: number;
    temperature?: number;
}
export interface CapsuleAi {
    complete(opts: AiCompleteOptions): Promise<string>;
    stream(opts: AiCompleteOptions): AsyncIterable<string>;
}
export interface CapsuleShopify {
    graphql<T = any>(query: string, variables?: Record<string, unknown>): Promise<T>;
}
export interface CapsuleBlob {
    put(key: string, bytes: Uint8Array | ArrayBuffer | Buffer | string, options?: {
        contentType?: string;
    }): Promise<{
        key: string;
        size: number;
    }>;
    get(key: string): Promise<{
        bytes: Buffer;
        contentType: string;
    } | null>;
    delete(key: string): Promise<void>;
    list(prefix?: string): Promise<Array<{
        key: string;
        size: number;
        contentType: string;
    }>>;
}
export interface CapsuleContext {
    auth: CapsuleAuth;
    db: CapsuleDb;
    transaction<T>(fn: () => T): T;
    env: Record<string, string>;
    log: CapsuleLog;
    ai: CapsuleAi;
    blob: CapsuleBlob;
    shopify: CapsuleShopify;
}
export type QueryHandler<TArgs extends any[] = any[], TResult = any> = (ctx: CapsuleContext, ...args: TArgs) => TResult | Promise<TResult>;
export type MutationHandler<TArgs extends any[] = any[], TResult = any> = (ctx: CapsuleContext, ...args: TArgs) => TResult | Promise<TResult>;
export interface EndpointRequest {
    headers: Headers;
    query: Record<string, string>;
    json<T>(): Promise<T>;
    text(): Promise<string>;
    bytes(): Promise<ArrayBuffer>;
}
export interface EndpointResponse {
    body: string | null;
    status: number;
    headers: Record<string, string>;
}
export type EndpointHandler = (ctx: CapsuleContext, req: EndpointRequest) => EndpointResponse | Promise<EndpointResponse>;
export interface SocketLike {
    send(data: string): void;
    close(code?: number, reason?: string): void;
    on(event: "message", listener: (data: string) => void): void;
    on(event: "close", listener: () => void): void;
}
export type SocketHandler = (ctx: CapsuleContext, socket: SocketLike) => void | Promise<void>;
interface SocketDefinition {
    _kind: "socket";
    handler: SocketHandler;
}
export declare function json(body: any, init?: {
    status?: number;
    headers?: Record<string, string>;
}): EndpointResponse;
export declare function text(body: string, init?: {
    status?: number;
    headers?: Record<string, string>;
}): EndpointResponse;
export interface RouteRateLimit {
    perMinute?: number;
    perHour?: number;
    by?: "ip" | "user";
}
export interface CapsuleDefinition {
    schema: Record<string, Record<string, ColumnType>>;
    queries: Record<string, QueryHandler>;
    mutations: Record<string, MutationHandler>;
    endpoints?: Record<string, EndpointDefinition>;
    sockets?: Record<string, SocketDefinition>;
    allowedOrigins?: string[];
    rateLimit?: Record<string, RouteRateLimit>;
    public?: boolean;
    static?: boolean;
    title?: string;
    description?: string;
}
interface EndpointDefinition {
    _method: string;
    _path: string;
    handler: EndpointHandler;
}
export declare function capsule(def: {
    schema: Record<string, Record<string, ColumnType>>;
    queries: Record<string, QueryHandler>;
    mutations: Record<string, MutationHandler>;
    endpoints?: Record<string, EndpointDefinition | ((ctx: CapsuleContext, req: EndpointRequest) => EndpointResponse | Promise<EndpointResponse>)>;
    sockets?: Record<string, SocketDefinition>;
    allowedOrigins?: string[];
    rateLimit?: Record<string, RouteRateLimit>;
    public?: boolean;
    static?: boolean;
    title?: string;
    description?: string;
}): CapsuleDefinition;
export declare function query<TArgs extends any[], TResult>(handler: QueryHandler<TArgs, TResult>): QueryHandler<TArgs, TResult>;
export declare function mutation<TArgs extends any[], TResult>(handler: MutationHandler<TArgs, TResult>): MutationHandler<TArgs, TResult>;
export declare function endpoint(opts: {
    method: string;
    path: string;
}, handler: EndpointHandler): EndpointDefinition;
export declare function socket(handler: SocketHandler): SocketDefinition;
export declare function requireUser(ctx: CapsuleContext): string;
export declare function requireOwner(ctx: CapsuleContext, table: string, id: string, ownerColumn?: string): Record<string, any>;
export {};
//# sourceMappingURL=index.d.ts.map