import * as Tp from 'thingpedia';
export interface AbstractRow {
    uniqueId: string;
}
export interface AppRow {
    uniqueId: string;
    code: string;
    state: string;
    name: string;
    description: string;
}
export interface ChannelRow {
    uniqueId: string;
    value: string;
}
export interface DeviceRow {
    uniqueId: string;
    state: string;
}
export interface ConversationRow {
    uniqueId: string;
    conversationId: string;
    previousId: string | null;
    dialogueId: string;
    context: string | null;
    agent: string | null;
    agentTimestamp: string | null;
    agentTarget: string | null;
    intermediateContext: string | null;
    user: string;
    userTimestamp: string | null;
    userTarget: string;
    vote: string | null;
    comment: string | null;
}
export interface ConversationStateRow {
    uniqueId: string;
    dialogueState: string | null;
    lastMessageId: number;
    recording: boolean;
}
export interface ConversationHistoryRow {
    uniqueId: string;
    conversationId: string;
    messageId: number;
    message: string;
}
export interface LocalTables {
    app: AppRow;
    channel: ChannelRow;
    conversation: ConversationRow;
    conversation_state: ConversationStateRow;
    conversation_history: ConversationHistoryRow;
}
export interface SyncTables {
    device: DeviceRow;
}
export interface SearchParams<RowType> {
    filter: Array<{
        k: keyof RowType;
        o: '=' | '>=' | '<=' | '<' | '>';
        v: string | number | boolean;
    }>;
    sort: [keyof RowType, 'asc' | 'desc'];
    limit: number;
}
export interface LocalTable<RowType extends AbstractRow> {
    name: string;
    getAll(): Promise<RowType[]>;
    getOne(uniqueId: string): Promise<RowType | undefined>;
    getBy(field: keyof RowType, value: string): Promise<RowType[]>;
    search(search: SearchParams<RowType>): Promise<RowType[]>;
    insertOne(uniqueId: string, row: Omit<RowType, "uniqueId">): Promise<void>;
    deleteOne(uniqueId: string): Promise<void>;
}
export declare type SyncRecord<RowType> = {
    [K in keyof RowType]: RowType[K] | null;
} & {
    uniqueId: string;
    lastModified: number;
};
export interface SyncAtReply<RowType> {
    lastModified: number;
    ourChanges: Array<SyncRecord<RowType>>;
    done: boolean[];
}
export interface SyncTable<RowType extends AbstractRow> {
    name: string;
    fields: ReadonlyArray<keyof RowType>;
    getAll(): Promise<RowType[]>;
    getOne(uniqueId: string): Promise<RowType | undefined>;
    insertOne(uniqueId: string, row: Omit<RowType, "uniqueId">): Promise<number>;
    deleteOne(uniqueId: string): Promise<number>;
    getRaw(): Promise<Array<SyncRecord<RowType>>>;
    getChangesAfter(lastModified: number): Promise<Array<SyncRecord<RowType>>>;
    handleChanges(changes: Array<SyncRecord<RowType>>): Promise<boolean[]>;
    syncAt(lastModified: number, pushedChanges: Array<SyncRecord<RowType>>): Promise<SyncAtReply<RowType>>;
    replaceAll(data: Array<SyncRecord<RowType>>): Promise<void>;
    insertIfRecent(uniqueId: string, lastModified: number, row: Omit<RowType, "uniqueId">): Promise<boolean>;
    deleteIfRecent(uniqueId: string, lastModified: number): Promise<boolean>;
}
export interface AbstractDatabase {
    ensureSchema(): Promise<void>;
    getLocalTable<T extends keyof LocalTables>(name: T): LocalTable<LocalTables[T]>;
    getSyncTable<T extends keyof SyncTables>(name: T): SyncTable<SyncTables[T]>;
}
export declare function createDB(platform: Tp.BasePlatform): AbstractDatabase;