import type { ControlTransport } from './types.js';
import { type ControlReadOptions } from './ControlRead.js';
import { type ControlWriteOptions } from './ControlWrite.js';
import type { ControlReadState, ControlReadEvent, ControlWriteState, ControlWriteEvent } from './Lifecycle.js';
export type DataScalar = 'string' | 'integer' | 'number' | 'boolean' | 'timestamp' | 'json';
export interface FieldDefinition {
    type: DataScalar;
    required?: boolean;
    nullable?: boolean;
    default?: unknown;
}
export interface TableDefinition {
    name: string;
    fields: Record<string, FieldDefinition>;
    indexes: string[][];
    unique: string[][];
}
export interface GameDataSchema {
    gameId: string;
    tables: Record<string, TableDefinition>;
}
declare class TableBuilder {
    private readonly definition;
    constructor(fields: Record<string, FieldDefinition>);
    index(...fields: string[] | [string[]]): this;
    unique(...fields: string[] | [string[]]): this;
    toDefinition(name: string): TableDefinition;
}
export declare const table: (fields: Record<string, FieldDefinition>) => TableBuilder;
export declare const stringId: () => FieldDefinition;
export declare const string: () => FieldDefinition;
export declare const int: () => FieldDefinition;
export declare const number: () => FieldDefinition;
export declare const boolean: () => FieldDefinition;
export declare const timestamp: () => FieldDefinition;
export declare const json: () => FieldDefinition;
export declare const required: (definition: FieldDefinition) => FieldDefinition;
export declare const nullable: (definition: FieldDefinition) => FieldDefinition;
export declare const defaultValue: (definition: FieldDefinition, value: unknown) => FieldDefinition;
export declare function defineGameData(input: {
    gameId: string;
    tables: Record<string, TableBuilder>;
}): GameDataSchema;
export declare const physicalTableName: (gameId: string, tableName: string) => string;
/** Render an offline migration. It never runs from the H5/runtime client. */
export declare function renderPostgresMigration(schema: GameDataSchema): {
    up: string;
    down: string;
};
export type QueryExpression = {
    op: string;
    field?: string;
    value?: unknown;
    args?: QueryExpression[];
};
export declare const eq: (field: string, value: unknown) => QueryExpression;
export declare const neq: (field: string, value: unknown) => QueryExpression;
export declare const gt: (field: string, value: unknown) => QueryExpression;
export declare const gte: (field: string, value: unknown) => QueryExpression;
export declare const lt: (field: string, value: unknown) => QueryExpression;
export declare const lte: (field: string, value: unknown) => QueryExpression;
export declare const inArray: (field: string, value: unknown[]) => QueryExpression;
export declare const isNull: (field: string) => QueryExpression;
export declare const and: (...args: QueryExpression[]) => QueryExpression;
export declare const or: (...args: QueryExpression[]) => QueryExpression;
export declare const not: (arg: QueryExpression) => QueryExpression;
export interface OrderBy {
    field: string;
    direction: 'asc' | 'desc';
}
export declare const asc: (field: string) => OrderBy;
export declare const desc: (field: string) => OrderBy;
export interface FindManyOptions {
    where?: QueryExpression;
    orderBy?: OrderBy | OrderBy[];
    limit?: number;
    cursor?: string;
}
export interface DataPage<T = Record<string, unknown>> {
    items: T[];
    nextCursor: string | null;
    total: number | null;
    raw: unknown;
}
export interface DataReadOptions extends ControlReadOptions {
}
export interface DataWriteOptions extends ControlWriteOptions {
}
type RecordValue = Record<string, unknown>;
export declare class DataTable<T extends RecordValue = RecordValue> {
    private readonly transport;
    readonly gameId: string;
    readonly tableName: string;
    private readonly schema?;
    private readId;
    private latestReadIdValue;
    private reads;
    private readHistories;
    private writeId;
    private latestWriteIdValue;
    private writes;
    private writeHistories;
    constructor(transport: ControlTransport, gameId: string, tableName: string, schema?: GameDataSchema | undefined);
    get latestReadId(): number;
    readHistory(id?: number): {
        from: ControlReadState;
        event: ControlReadEvent;
        to: ControlReadState;
    }[];
    get latestWriteId(): number;
    writeHistory(id?: number): {
        from: ControlWriteState;
        event: ControlWriteEvent;
        to: ControlWriteState;
    }[];
    insert(value: T, options?: DataWriteOptions): Promise<T>;
    update(where: QueryExpression, value: Partial<T>, options?: DataWriteOptions): Promise<T | null>;
    upsert(value: T, conflict?: string[], options?: DataWriteOptions): Promise<T>;
    delete(where: QueryExpression, options?: DataWriteOptions): Promise<{
        deleted: number;
    }>;
    findOne(options?: Omit<FindManyOptions, 'limit'>, readOptions?: DataReadOptions): Promise<T | null>;
    findMany(options?: FindManyOptions, readOptions?: DataReadOptions): Promise<DataPage<T>>;
    count(where?: QueryExpression, options?: DataReadOptions): Promise<number>;
    exists(where: QueryExpression, options?: DataReadOptions): Promise<boolean>;
    private write;
    private read;
}
export declare class GameDataStore {
    private readonly transport;
    readonly gameId: string;
    readonly schema?: GameDataSchema | undefined;
    private readonly tables;
    constructor(transport: ControlTransport, gameId: string, schema?: GameDataSchema | undefined);
    table<T extends RecordValue = RecordValue>(name: string): DataTable<T>;
}
export {};