import { RevisionRecoveryInput, RevisionRecoveryResult } from './revision-recovery.js';
/** Transport types for the Rust-owned FeltDB state contract. */
export type PrimitiveType = 'string' | 'integer' | 'number' | 'boolean' | 'timestamp' | 'date' | 'time' | 'json' | 'uuid' | 'decimal' | 'money' | 'bigint' | 'email' | 'url' | 'phone' | 'binary' | 'file' | 'geo_point' | 'object';
export type FieldType = {
    kind: 'primitive';
    primitive: PrimitiveType;
} | {
    kind: 'enum';
    values: string[];
} | {
    kind: 'reference';
    collection: string;
} | {
    kind: 'array';
    items: FieldType;
} | {
    kind: 'map';
    values: FieldType;
} | {
    kind: 'vector';
    dimensions?: number;
};
export interface StateField {
    name: string;
    field_type: FieldType;
    nullable?: boolean;
    required?: boolean;
    default?: unknown;
    constraints?: {
        minimum?: number;
        maximum?: number;
        min_length?: number;
        max_length?: number;
        pattern?: string;
    };
    computed?: string;
}
export interface StateSchema {
    contract_version: number;
    schema_version: number;
    application_id: string;
    revision_id: string;
    collections: {
        name: string;
        version: number;
        fields: StateField[];
        indexes: {
            name: string;
            fields: string[];
            unique?: boolean;
            sparse?: boolean;
            version: number;
        }[];
    }[];
}
export type QueryFilter = {
    operator: 'eq' | 'neq' | 'lt' | 'lte' | 'gt' | 'gte';
    field: string;
    value: unknown;
} | {
    operator: 'in';
    field: string;
    values: unknown[];
} | {
    operator: 'contains';
    field: string;
    value: unknown;
} | {
    operator: 'startsWith' | 'endsWith';
    field: string;
    value: string;
} | {
    operator: 'exists';
    field: string;
    exists: boolean;
} | {
    operator: 'and' | 'or';
    filters: QueryFilter[];
} | {
    operator: 'not';
    filter: QueryFilter;
};
export interface CanonicalQuery {
    collection: string;
    filter?: QueryFilter;
    order_by?: {
        field: string;
        direction: 'asc' | 'desc';
    }[];
    limit?: number;
    offset?: number;
    cursor?: string;
    projection?: string[];
    group_by?: string[];
    aggregates?: {
        name: string;
        function: 'count' | 'sum' | 'avg' | 'min' | 'max';
        field?: string;
    }[];
    references?: {
        field: string;
        collection: string;
        projection?: string[];
        as_name: string;
    }[];
}
export interface QueryResult<T = Record<string, unknown>> {
    query_id: string;
    query_hash: string;
    application_revision: string;
    schema_version: number;
    state_version: number;
    causal_cursor: Record<string, number>;
    records: T[];
    aggregates: Record<string, unknown>[];
    next_cursor?: string;
    plan: {
        implementation: string;
        collection: string;
        index?: string;
        scan_fallback: boolean;
    };
}
export interface TransactionOperation {
    kind: 'insert' | 'update' | 'delete';
    collection: string;
    id: string;
    value?: unknown;
    if_version?: number;
}
export interface TransactionResult {
    transaction_id: string;
    base_revision: number;
    commit_revision: number;
    status: "committed";
    state_before: number;
    state_after: number;
    causal_cursor: Record<string, number>;
    duplicate: boolean;
    audit: unknown;
}
export interface StateFailure {
    code: 'VALIDATION_FAILED' | 'PRECONDITION_FAILED' | 'AUTHORIZATION_DENIED' | 'SCHEMA_MISMATCH' | 'CONFLICT' | 'STORAGE_FAILURE' | 'INVALID_QUERY' | 'UNKNOWN_FIELD' | 'UNKNOWN_COLLECTION' | 'UNAUTHORIZED_PROJECTION' | 'INVALID_CURSOR' | 'STATE_UNAVAILABLE';
    message: string;
    expected?: unknown;
    actual?: unknown;
    resource?: string;
    transaction?: string;
    causal_position?: number;
}
declare class TransactionBuilder {
    readonly operations: TransactionOperation[];
    collection(name: string): {
        insert: (id: string, value: unknown) => string;
        update: (id: string, value: unknown, options?: {
            ifVersion?: number;
        }) => void;
        delete: (id: string, options?: {
            ifVersion?: number;
        }) => void;
    };
}
export declare class StateContractClient {
    private readonly target;
    private readonly baseUrl;
    constructor(target: {
        applicationId: string;
        revisionId: string;
        environment?: string;
    }, baseUrl?: string);
    private request;
    schema(): Promise<{
        schema: StateSchema;
    }>;
    stateVersion(): Promise<unknown>;
    query<T = Record<string, unknown>>(query: CanonicalQuery): Promise<QueryResult<T>>;
    transaction(work: (tx: TransactionBuilder) => void | Promise<void>, options?: {
        transactionId?: string;
        baseRevision?: number;
    }): Promise<TransactionResult>;
    recoverApplicationRevision(input: RevisionRecoveryInput): Promise<RevisionRecoveryResult>;
}
export {};
//# sourceMappingURL=state-contract.d.ts.map