import type { NullToOptional } from './helpers/NullToOptional';
import type { TupleToUnion } from './helpers/tuple';
import type { Condition, ExpressionBuilder, Row, SchemaQuery, TableBuilderWithColumns, Schema as ZeroSchema, Transaction as ZeroTransaction } from '@rocicorp/zero';
/**
 * ➗0️⃣ START OVERRIDDEN TYPES
 *
 * To get types, put the following in a .ts file that's included by your tsconfig:
 *
 *   export type Schema = typeof schema
 *
 *   declare module 'on-zero' {
 *     interface Config {
 *       schema: Schema
 *       authData: AuthData
 *     }
 *   }
 *
 * on-zero is overridden by consumers of this library to get types which is
 * needed to allow co-locating certain typed helpers like where() and
 * mutations() alongside table() because table is later used to create the Zero
 * schema, which is then needed for where/mutations
 */
export interface Config {
}
interface DefaultConfig {
    schema: ZeroSchema;
    authData: {};
    serverActions: null;
    asyncAction: never;
}
interface FinalConfig extends Omit<DefaultConfig, keyof Config>, Config {
}
export type Schema = FinalConfig['schema'];
export type TableName = keyof Schema['tables'] extends string ? keyof Schema['tables'] : string;
export type Transaction = ZeroTransaction<Schema>;
export type AuthData = FinalConfig['authData'] extends Record<string, unknown> ? FinalConfig['authData'] : Record<string, unknown>;
export type ServerActions = FinalConfig['serverActions'] extends Record<string, unknown> ? FinalConfig['serverActions'] : Record<string, unknown>;
export type AsyncActionEnvelope = {
    readonly type: string;
    readonly [field: string]: unknown;
};
export type AsyncAction = FinalConfig['asyncAction'] extends AsyncActionEnvelope ? FinalConfig['asyncAction'] : never;
export type QueryBuilder = SchemaQuery<Schema>;
export type AsyncTask = () => Promise<void>;
export type AsyncTaskOptions = {
    barrier?: boolean;
};
/**
 * ➗0️⃣ END OVERRIDDEN TYPES
 */
export type MutatorContext = {
    tx: Transaction;
    authData: AuthData | null;
    environment: 'server' | 'client';
    server?: {
        actions: ServerActions;
        /**
         * Schedules work after the mutation transaction commits. Tasks run in the
         * background by default, following Zero's async task model, so they do not
         * block the push response.
         *
         * Set `barrier: true` only when the client's next writes depend on the
         * effect, such as provisioning a namespace before the client writes
         * through a new instance. Barrier tasks finish before the push response.
         */
        enqueueTask(task: AsyncTask, opts?: AsyncTaskOptions): void;
        enqueueAction(action: AsyncAction, opts?: AsyncTaskOptions): void;
    };
    can: Can;
};
export type GetZeroMutators<Models extends GenericModels> = {
    [Key in keyof Models]: TransformMutators<GetModelMutators<Models>[Key]>;
};
type GetModelMutators<Models extends GenericModels> = {
    [Key in keyof Models]: Models[Key]['mutate'];
};
export type GenericModels = {
    [key: string]: {
        mutate?: Record<string, (ctx: MutatorContext, obj?: any) => Promise<any>>;
        permissions?: Where<any, Condition | boolean>;
    };
};
export type TransformMutators<T> = {
    [K in keyof T]: T[K] extends (ctx: MutatorContext, ...args: infer Args) => infer Return ? (tx: Transaction, ...args: Args) => Return extends unknown ? Promise<any> : Return : never;
};
export type Where<Table extends TableName = TableName, ReturnType extends Condition | boolean = Condition | boolean> = (expressionBuilder: ExpressionBuilder<Table, Schema>, auth?: AuthData | null) => ReturnType;
export type Can = <PWhere extends Where>(where: PWhere, obj: string | Record<string, unknown>) => Promise<void>;
type GenericTable = TableBuilderWithColumns<any>;
type GetTableSchema<TS extends GenericTable> = TS extends TableBuilderWithColumns<infer S> ? S : never;
export type TableInsertRow<TS extends GenericTable> = NullToOptional<Row<GetTableSchema<TS>>>;
export type TableUpdateRow<TS extends GenericTable> = Pick<Row<GetTableSchema<TS>>, TablePrimaryKeys<TS>> & Partial<TableInsertRow<TS>>;
export type TablePrimaryKeys<TS extends GenericTable> = TupleToUnion<GetTableSchema<TS>['primaryKey']>;
export type ZeroEvent = {
    type: 'error';
    reasonKey: 'connection-error' | 'connection-needs-auth';
    message: string;
} | {
    type: 'reconnect';
    status: 'trying' | 'waiting';
    reasonKey: ZeroReconnectReasonKey;
    reason: string;
} | {
    type: 'reconnect';
    status: 'connected';
} | {
    type: 'recovering';
    reasonKey: ZeroRecoveryReasonKey;
    reason: string;
} | {
    type: 'fatal';
    reasonKey: ZeroRecoveryReasonKey;
    reason: string;
};
export type ZeroEventsEmitter = {
    value: ZeroEvent | null;
    options?: {
        name: string;
        silent?: boolean;
        comparator?: (a: ZeroEvent | null, b: ZeroEvent | null) => boolean;
    };
    listen: (listener: (value: ZeroEvent | null) => void) => () => void;
    emit: (next: ZeroEvent | null) => void;
};
export type ZeroRecoveryReasonKey = 'NewClientGroup' | 'VersionNotSupported' | 'SchemaVersionNotSupported' | 'client-state-not-found' | 'indexeddb-not-found' | 'sqlite-statement-finalized' | 'store-closed-repeat' | 'mutation-desync' | 'connection-cookie-invalid' | 'client-not-found' | 'connection-userid-mismatch';
export type ZeroReconnectReasonKey = 'transport' | 'server-overloaded' | 'server-ack-timeout';
/**
 * Admin role bypass for permissions:
 * - 'all': admin bypasses both query and mutation permissions (default)
 * - 'queries': admin bypasses only query permissions
 * - 'mutations': admin bypasses only mutation permissions
 * - 'off': admin has no special bypass
 */
export type AdminRoleMode = 'all' | 'queries' | 'mutations' | 'off';
export {};
//# sourceMappingURL=types.d.ts.map