@ferricstore/ferricstore 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1270 @@
+import tls from 'node:tls';
+
+interface Codec<T = unknown> {
+    encode(value: T | null | undefined): Buffer;
+    decode(value: Buffer | null | undefined): T | null;
+}
+declare class RawCodec implements Codec<Buffer | string | Uint8Array | null> {
+    encode(value: Buffer | string | Uint8Array | null | undefined): Buffer;
+    decode(value: Buffer | null | undefined): Buffer | null;
+}
+declare class JsonCodec<T = unknown> implements Codec<T> {
+    encode(value: T | null | undefined): Buffer;
+    decode(value: Buffer | null | undefined): T | null;
+}
+
+type CommandArgument = string | Buffer | number | boolean | null | undefined;
+type Command = readonly CommandArgument[];
+
+interface CommandExecutor {
+    executeCommand(...args: CommandArgument[]): Promise<unknown>;
+    executePipeline?(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[]>;
+    close?(): Promise<void> | void;
+}
+interface ExecutePipelineOptions {
+    throwOnItemError?: boolean;
+}
+interface NativeAdapterOptions {
+    clientName?: string;
+    connectTimeoutMs?: number;
+    maxChunkBytes?: number;
+    protocolLanes?: number;
+    timeoutMs?: number;
+    username?: string;
+    password?: string;
+    tlsOptions?: tls.ConnectionOptions;
+}
+declare class NativeAdapter implements CommandExecutor {
+    private readonly socket;
+    private readonly pending;
+    private readonly chunks;
+    private readonly chunkBytes;
+    private buffer;
+    private closed;
+    private dataLane;
+    private readonly maxChunkBytes;
+    private requestId;
+    private readonly protocolLanes;
+    private readonly timeoutMs;
+    private constructor();
+    static fromUrl(url: string, options?: NativeAdapterOptions): Promise<NativeAdapter>;
+    executeCommand(...args: CommandArgument[]): Promise<unknown>;
+    executePipeline(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[]>;
+    close(): Promise<void>;
+    private startup;
+    private auth;
+    private request;
+    private onData;
+    private handleFrame;
+    private failAll;
+    private cleanupChunksForRequest;
+    private nextRequestId;
+    private assignLane;
+}
+
+interface StoreCommandClient {
+    readonly codec: Codec;
+    command(...args: CommandArgument[]): Promise<unknown>;
+}
+interface SetOptions {
+    ex?: number;
+    px?: number;
+    exat?: number;
+    pxat?: number;
+    nx?: boolean;
+    xx?: boolean;
+    get?: boolean;
+    keepTtl?: boolean;
+}
+interface GetExOptions {
+    ex?: number;
+    px?: number;
+    exat?: number;
+    pxat?: number;
+    persist?: boolean;
+}
+interface ScanOptions {
+    match?: string;
+    count?: number;
+}
+interface ZAddMember {
+    score: number;
+    member: unknown;
+}
+interface ZAddOptions {
+    nx?: boolean;
+    xx?: boolean;
+    gt?: boolean;
+    lt?: boolean;
+    ch?: boolean;
+}
+interface RangeLimit {
+    offset: number;
+    count: number;
+}
+interface XReadStream {
+    key: string;
+    id: string;
+}
+interface GeoMember {
+    longitude: number;
+    latitude: number;
+    member: unknown;
+}
+interface GeoAddOptions {
+    nx?: boolean;
+    xx?: boolean;
+    ch?: boolean;
+}
+declare class KeyValueStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    get<T = unknown>(key: string): Promise<T | null>;
+    set(key: string, value: unknown, options?: SetOptions): Promise<unknown>;
+    del(...keys: string[]): Promise<number>;
+    exists(...keys: string[]): Promise<number>;
+    mget<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    mset(entries: Record<string, unknown> | [string, unknown][]): Promise<boolean>;
+    msetnx(entries: Record<string, unknown> | [string, unknown][]): Promise<boolean>;
+    incr(key: string): Promise<number>;
+    decr(key: string): Promise<number>;
+    incrby(key: string, increment: number): Promise<number>;
+    decrby(key: string, decrement: number): Promise<number>;
+    incrbyfloat(key: string, increment: number): Promise<string>;
+    append(key: string, value: unknown): Promise<number>;
+    strlen(key: string): Promise<number>;
+    getset<T = unknown>(key: string, value: unknown): Promise<T | null>;
+    getdel<T = unknown>(key: string): Promise<T | null>;
+    getex<T = unknown>(key: string, options?: GetExOptions): Promise<T | null>;
+    setnx(key: string, value: unknown): Promise<boolean>;
+    setex(key: string, seconds: number, value: unknown): Promise<boolean>;
+    psetex(key: string, milliseconds: number, value: unknown): Promise<boolean>;
+    getrange(key: string, start: number, end: number): Promise<Buffer | string | unknown>;
+    setrange(key: string, offset: number, value: unknown): Promise<number>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    pexpire(key: string, milliseconds: number): Promise<boolean>;
+    expireat(key: string, unixSeconds: number): Promise<boolean>;
+    pexpireat(key: string, unixMilliseconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    pttl(key: string): Promise<number>;
+    persist(key: string): Promise<boolean>;
+    expiretime(key: string): Promise<number>;
+    pexpiretime(key: string): Promise<number>;
+    type(key: string): Promise<string>;
+    unlink(...keys: string[]): Promise<number>;
+    rename(key: string, newKey: string): Promise<boolean>;
+    renamenx(key: string, newKey: string): Promise<boolean>;
+    copy(source: string, destination: string, options?: {
+        replace?: boolean;
+    }): Promise<boolean>;
+    randomkey(): Promise<string | null>;
+    keys(pattern: string): Promise<unknown[]>;
+    scan(cursor: string | number, options?: ScanOptions): Promise<unknown>;
+    dbsize(): Promise<number>;
+    flushdb(mode?: "ASYNC" | "SYNC"): Promise<boolean>;
+    flushall(mode?: "ASYNC" | "SYNC"): Promise<boolean>;
+    objectEncoding(key: string): Promise<string | null>;
+    objectHelp(): Promise<unknown[]>;
+    objectFreq(key: string): Promise<number>;
+    objectIdleTime(key: string): Promise<number>;
+    objectRefcount(key: string): Promise<number>;
+    wait(numReplicas: number, timeoutMs: number): Promise<number>;
+    waitAof(numLocal: number, numReplicas: number, timeoutMs: number): Promise<unknown[]>;
+    memoryUsage(key: string): Promise<number>;
+}
+declare class HashStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    hset(key: string, entries: Record<string, unknown> | [string, unknown][]): Promise<number>;
+    hget<T = unknown>(key: string, field: string): Promise<T | null>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    hmget<T = unknown>(key: string, fields: string[]): Promise<(T | null)[]>;
+    hgetall(key: string): Promise<unknown>;
+    hexists(key: string, field: string): Promise<boolean>;
+    hkeys(key: string): Promise<unknown[]>;
+    hvals<T = unknown>(key: string): Promise<(T | null)[]>;
+    hlen(key: string): Promise<number>;
+    hincrby(key: string, field: string, increment: number): Promise<number>;
+    hincrbyfloat(key: string, field: string, increment: number): Promise<string>;
+    hsetnx(key: string, field: string, value: unknown): Promise<boolean>;
+    hstrlen(key: string, field: string): Promise<number>;
+    hrandfield(key: string, count?: number, withValues?: boolean): Promise<unknown>;
+    hscan(key: string, cursor: string | number, options?: ScanOptions): Promise<unknown>;
+    hexpire(key: string, seconds: number, fields: string[]): Promise<unknown[]>;
+    httl(key: string, fields: string[]): Promise<unknown[]>;
+    hpersist(key: string, fields: string[]): Promise<unknown[]>;
+    hpexpire(key: string, milliseconds: number, fields: string[]): Promise<unknown[]>;
+    hpttl(key: string, fields: string[]): Promise<unknown[]>;
+    hexpiretime(key: string, fields: string[]): Promise<unknown[]>;
+    hgetdel<T = unknown>(key: string, fields: string[]): Promise<(T | null)[]>;
+    hgetex<T = unknown>(key: string, fields: string[], options?: GetExOptions): Promise<(T | null)[]>;
+    hsetex(key: string, seconds: number, entries: Record<string, unknown> | [string, unknown][]): Promise<number>;
+}
+declare class ListStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    lpush(key: string, ...elements: unknown[]): Promise<number>;
+    rpush(key: string, ...elements: unknown[]): Promise<number>;
+    lpop<T = unknown>(key: string, count?: number): Promise<T | (T | null)[] | null>;
+    rpop<T = unknown>(key: string, count?: number): Promise<T | (T | null)[] | null>;
+    lrange<T = unknown>(key: string, start: number, stop: number): Promise<(T | null)[]>;
+    llen(key: string): Promise<number>;
+    lindex<T = unknown>(key: string, index: number): Promise<T | null>;
+    lset(key: string, index: number, element: unknown): Promise<boolean>;
+    lrem(key: string, count: number, element: unknown): Promise<number>;
+    ltrim(key: string, start: number, stop: number): Promise<boolean>;
+    lpos(key: string, element: unknown, options?: {
+        rank?: number;
+        count?: number;
+        maxlen?: number;
+    }): Promise<unknown>;
+    linsert(key: string, where: "BEFORE" | "AFTER", pivot: unknown, element: unknown): Promise<number>;
+    lmove(source: string, destination: string, from: "LEFT" | "RIGHT", to: "LEFT" | "RIGHT"): Promise<unknown>;
+    rpoplpush(source: string, destination: string): Promise<unknown>;
+    lpushx(key: string, ...elements: unknown[]): Promise<number>;
+    rpushx(key: string, ...elements: unknown[]): Promise<number>;
+    blpop(keys: string[], timeoutSeconds: number): Promise<unknown>;
+    brpop(keys: string[], timeoutSeconds: number): Promise<unknown>;
+    blmove(source: string, destination: string, from: "LEFT" | "RIGHT", to: "LEFT" | "RIGHT", timeoutSeconds: number): Promise<unknown>;
+    blmpop(timeoutSeconds: number, keys: string[], from: "LEFT" | "RIGHT", options?: {
+        count?: number;
+    }): Promise<unknown>;
+}
+declare class SetStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    sadd(key: string, ...members: unknown[]): Promise<number>;
+    srem(key: string, ...members: unknown[]): Promise<number>;
+    smembers<T = unknown>(key: string): Promise<(T | null)[]>;
+    sismember(key: string, member: unknown): Promise<boolean>;
+    smismember(key: string, members: unknown[]): Promise<unknown[]>;
+    scard(key: string): Promise<number>;
+    srandmember<T = unknown>(key: string, count?: number): Promise<T | (T | null)[] | null>;
+    spop<T = unknown>(key: string, count?: number): Promise<T | (T | null)[] | null>;
+    sdiff<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    sinter<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    sunion<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    sdiffstore(destination: string, keys: string[]): Promise<number>;
+    sinterstore(destination: string, keys: string[]): Promise<number>;
+    sunionstore(destination: string, keys: string[]): Promise<number>;
+    sintercard(keys: string[], limit?: number): Promise<number>;
+    smove(source: string, destination: string, member: unknown): Promise<boolean>;
+    sscan(key: string, cursor: string | number, options?: ScanOptions): Promise<unknown>;
+}
+declare class SortedSetStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    zadd(key: string, members: ZAddMember[], options?: ZAddOptions): Promise<number>;
+    zscore(key: string, member: unknown): Promise<string | null>;
+    zrank(key: string, member: unknown): Promise<number | null>;
+    zrevrank(key: string, member: unknown): Promise<number | null>;
+    zrange(key: string, start: number, stop: number, options?: {
+        withScores?: boolean;
+    }): Promise<unknown[]>;
+    zrevrange(key: string, start: number, stop: number, options?: {
+        withScores?: boolean;
+    }): Promise<unknown[]>;
+    zcard(key: string): Promise<number>;
+    zrem(key: string, ...members: unknown[]): Promise<number>;
+    zincrby(key: string, increment: number, member: unknown): Promise<string>;
+    zcount(key: string, min: string | number, max: string | number): Promise<number>;
+    zpopmin(key: string, count?: number): Promise<unknown[]>;
+    zpopmax(key: string, count?: number): Promise<unknown[]>;
+    zrandmember(key: string, count?: number, withScores?: boolean): Promise<unknown>;
+    zmscore(key: string, members: unknown[]): Promise<unknown[]>;
+    zrangebyscore(key: string, min: string | number, max: string | number, options?: {
+        withScores?: boolean;
+        limit?: RangeLimit;
+    }): Promise<unknown[]>;
+    zrevrangebyscore(key: string, max: string | number, min: string | number, options?: {
+        withScores?: boolean;
+        limit?: RangeLimit;
+    }): Promise<unknown[]>;
+    zscan(key: string, cursor: string | number, options?: ScanOptions): Promise<unknown>;
+}
+declare class StreamStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    xadd(key: string, id: string, fields: Record<string, unknown> | [string, unknown][]): Promise<unknown>;
+    xlen(key: string): Promise<number>;
+    xrange(key: string, start?: string, end?: string, count?: number): Promise<unknown[]>;
+    xrevrange(key: string, end?: string, start?: string, count?: number): Promise<unknown[]>;
+    xread(streams: XReadStream[], options?: {
+        count?: number;
+        blockMs?: number;
+    }): Promise<unknown>;
+    xtrim(key: string, strategy: "MAXLEN" | "MINID", threshold: string | number, approximate?: boolean): Promise<number>;
+    xdel(key: string, ...ids: string[]): Promise<number>;
+    xinfoStream(key: string): Promise<unknown>;
+    xgroupCreate(key: string, group: string, id: string, mkstream?: boolean): Promise<boolean>;
+    xreadgroup(group: string, consumer: string, streams: XReadStream[], options?: {
+        count?: number;
+        blockMs?: number;
+        noack?: boolean;
+    }): Promise<unknown>;
+    xack(key: string, group: string, ...ids: string[]): Promise<number>;
+}
+declare class BitmapStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    setbit(key: string, offset: number, value: 0 | 1): Promise<number>;
+    getbit(key: string, offset: number): Promise<number>;
+    bitcount(key: string, start?: number, end?: number, unit?: "BYTE" | "BIT"): Promise<number>;
+    bitpos(key: string, bit: 0 | 1, start?: number, end?: number, unit?: "BYTE" | "BIT"): Promise<number>;
+    bitop(operation: "AND" | "OR" | "XOR" | "NOT", destination: string, ...keys: string[]): Promise<number>;
+}
+declare class HyperLogLogStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    pfadd(key: string, ...elements: unknown[]): Promise<number>;
+    pfcount(...keys: string[]): Promise<number>;
+    pfmerge(destination: string, ...sources: string[]): Promise<boolean>;
+}
+declare class GeoStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    geoadd(key: string, members: GeoMember[], options?: GeoAddOptions): Promise<number>;
+    geopos(key: string, ...members: unknown[]): Promise<unknown[]>;
+    geodist(key: string, member1: unknown, member2: unknown, unit?: "m" | "km" | "mi" | "ft"): Promise<string | null>;
+    geohash(key: string, ...members: unknown[]): Promise<unknown[]>;
+    geosearch(key: string, args: CommandArgument[]): Promise<unknown[]>;
+    geosearchstore(destination: string, source: string, args: CommandArgument[]): Promise<number>;
+}
+
+interface TopKReserveOptions {
+    width?: number;
+    depth?: number;
+    decay?: number;
+}
+interface CountMinMergeOptions {
+    weights?: number[];
+}
+interface TDigestCreateOptions {
+    compression?: number;
+}
+interface TDigestMergeOptions extends TDigestCreateOptions {
+    override?: boolean;
+}
+interface JsonSetOptions {
+    nx?: boolean;
+    xx?: boolean;
+}
+declare class BloomFilterStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    reserve(key: string, errorRate: number, capacity: number): Promise<boolean>;
+    add(key: string, element: unknown): Promise<boolean>;
+    madd(key: string, ...elements: unknown[]): Promise<number[]>;
+    exists(key: string, element: unknown): Promise<boolean>;
+    mexists(key: string, ...elements: unknown[]): Promise<number[]>;
+    card(key: string): Promise<number>;
+    info(key: string): Promise<unknown[]>;
+}
+declare class CuckooFilterStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    reserve(key: string, capacity: number): Promise<boolean>;
+    add(key: string, element: unknown): Promise<boolean>;
+    addnx(key: string, element: unknown): Promise<boolean>;
+    del(key: string, element: unknown): Promise<boolean>;
+    exists(key: string, element: unknown): Promise<boolean>;
+    mexists(key: string, ...elements: unknown[]): Promise<number[]>;
+    count(key: string, element: unknown): Promise<number>;
+    info(key: string): Promise<unknown[]>;
+}
+declare class CountMinSketchStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    initByDim(key: string, width: number, depth: number): Promise<boolean>;
+    initByProb(key: string, error: number, probability: number): Promise<boolean>;
+    incrBy(key: string, entries: [unknown, number][]): Promise<number[]>;
+    query(key: string, ...items: unknown[]): Promise<number[]>;
+    merge(destination: string, sources: string[], options?: CountMinMergeOptions): Promise<boolean>;
+    info(key: string): Promise<unknown[]>;
+}
+declare class TopKStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    reserve(key: string, k: number, options?: TopKReserveOptions): Promise<boolean>;
+    add<T = unknown>(key: string, ...elements: unknown[]): Promise<(T | null)[]>;
+    incrBy<T = unknown>(key: string, entries: [unknown, number][]): Promise<(T | null)[]>;
+    query(key: string, ...elements: unknown[]): Promise<number[]>;
+    list<T = unknown>(key: string, options?: {
+        withCount?: boolean;
+    }): Promise<(T | number | null)[]>;
+    info(key: string): Promise<unknown[]>;
+}
+declare class TDigestStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    create(key: string, options?: TDigestCreateOptions): Promise<boolean>;
+    add(key: string, ...values: number[]): Promise<boolean>;
+    reset(key: string): Promise<boolean>;
+    quantile(key: string, ...quantiles: number[]): Promise<string[]>;
+    cdf(key: string, ...values: number[]): Promise<string[]>;
+    rank(key: string, ...values: number[]): Promise<number[]>;
+    revrank(key: string, ...values: number[]): Promise<number[]>;
+    byrank(key: string, ...ranks: number[]): Promise<string[]>;
+    byrevrank(key: string, ...ranks: number[]): Promise<string[]>;
+    trimmedMean(key: string, low: number, high: number): Promise<string>;
+    min(key: string): Promise<string>;
+    max(key: string): Promise<string>;
+    info(key: string): Promise<unknown[]>;
+    merge(destination: string, sources: string[], options?: TDigestMergeOptions): Promise<boolean>;
+}
+declare class JsonStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    set(key: string, path: string, value: unknown, options?: JsonSetOptions): Promise<boolean>;
+    get<T = unknown>(key: string, paths?: string | string[]): Promise<T | null>;
+    del(key: string, path?: string): Promise<number>;
+    numIncrBy(key: string, path: string, value: number): Promise<string>;
+    type(key: string, path?: string): Promise<string | null>;
+    strlen(key: string, path?: string): Promise<number | null>;
+    objKeys(key: string, path?: string): Promise<unknown[]>;
+    objLen(key: string, path?: string): Promise<number>;
+    arrAppend(key: string, path: string, ...values: unknown[]): Promise<number>;
+    arrLen(key: string, path?: string): Promise<number>;
+    toggle(key: string, path: string): Promise<number>;
+    clear(key: string, path?: string): Promise<number>;
+    mget<T = unknown>(keys: string[], path: string): Promise<(T | null)[]>;
+}
+
+type ExceptionPolicy = "retry" | "fail" | "raise";
+type BackoffKind = "fixed" | "linear" | "exponential";
+type WorkerProfile = "latency" | "throughput";
+interface RetryPolicy {
+    maxRetries?: number;
+    backoff?: BackoffKind | string;
+    baseMs?: number;
+    maxMs?: number;
+    jitterPct?: number;
+    exhaustedTo?: string;
+}
+interface BackpressurePolicy {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitterPct?: number;
+}
+interface ValueConfig {
+    valueMaxBytes?: number;
+    localCache?: boolean;
+}
+interface WorkerConfig {
+    profile?: WorkerProfile;
+    workers?: number;
+    concurrency?: number;
+    batchSize?: number;
+    leaseMs?: number;
+    priority?: number;
+    nowMs?: number;
+    partitionKey?: string;
+    partitionKeys?: string[];
+    reclaimExpired?: boolean;
+    reclaimRatio?: number;
+    claimPayload?: boolean;
+    claimValues?: string[];
+    valueMaxBytes?: number;
+    blockMs?: number;
+    idleSleepMs?: number;
+    maxIdleSleepMs?: number;
+    exceptionPolicy?: ExceptionPolicy;
+    completeAsyncDepth?: number;
+    completeIndependent?: boolean;
+    claimDrainBatches?: number;
+    signal?: AbortSignal;
+    worker?: string;
+}
+interface ChildSpec {
+    id: string;
+    type: string;
+    payload?: unknown;
+    partitionKey?: string;
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
+}
+interface CreateItem {
+    id: string;
+    payload?: unknown;
+    partitionKey?: string;
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
+}
+declare const CLAIMED_ITEM_WIRE: unique symbol;
+interface ClaimedItemWire {
+    id: Buffer;
+    partitionKey?: Buffer | null;
+    leaseToken: Buffer;
+    fencingToken: number;
+}
+interface ClaimedItem<TPayload = unknown> {
+    id: string;
+    leaseToken: Buffer;
+    fencingToken: number;
+    partitionKey?: string;
+    type: string;
+    state: string;
+    runState?: string;
+    payload?: TPayload | null;
+    attributes?: Record<string, unknown>;
+    [CLAIMED_ITEM_WIRE]?: ClaimedItemWire;
+}
+interface FencedItem {
+    id: string;
+    fencingToken: number;
+    leaseToken?: Buffer;
+    partitionKey?: string;
+}
+interface RateLimitResult {
+    status: string;
+    count: number;
+    remaining: number;
+    resetMs: number;
+    allowed: boolean;
+}
+interface KeyInfo {
+    type: string;
+    valueSize: number;
+    ttlMs: number;
+    hotCacheStatus: string;
+    lastWriteShard: number;
+    raw: Record<string, unknown>;
+}
+interface FetchOrComputeResult<T = unknown> {
+    status: "hit" | "compute" | string;
+    value?: T | null;
+    computeToken?: Buffer;
+    hit: boolean;
+    shouldCompute: boolean;
+}
+interface FlowRecord<TPayload = unknown> {
+    id: string;
+    type: string;
+    state: string;
+    partitionKey: string;
+    runState?: string;
+    payload?: TPayload | null;
+    leaseToken: Buffer;
+    fencingToken: number;
+    version: number;
+    parentFlowId?: string;
+    rootFlowId?: string;
+    correlationId?: string;
+    valueRefs?: Record<string, unknown>;
+    values?: Record<string, unknown>;
+    valueSizes?: Record<string, unknown>;
+    valueOmitted?: Record<string, unknown>;
+    valueMissing?: Record<string, unknown>;
+    attributes?: Record<string, unknown>;
+    raw?: unknown;
+}
+
+interface AutoBatchOptions {
+    enabled?: boolean;
+    maxCommands?: number;
+    maxDelayMs?: number;
+    mode?: "safe" | "all";
+}
+interface FerricStoreClientOptions {
+    autoBatch?: boolean | AutoBatchOptions;
+    codec?: Codec;
+    backpressure?: BackpressurePolicy;
+}
+interface CreateOptions {
+    type: string;
+    state?: string;
+    payload?: unknown;
+    partitionKey?: string;
+    parentFlowId?: string;
+    rootFlowId?: string;
+    correlationId?: string;
+    runAtMs?: number;
+    nowMs?: number;
+    priority?: number;
+    idempotent?: boolean;
+    retentionTtlMs?: number;
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
+    returnRecord?: boolean;
+}
+interface CreateManyOptions extends Omit<CreateOptions, "payload" | "partitionKey" | "returnRecord"> {
+    partitionKey?: string;
+    independent?: boolean;
+}
+interface ClaimDueOptions {
+    state?: string;
+    states?: string[];
+    worker: string;
+    partitionKey?: string;
+    partitionKeys?: string[];
+    leaseMs?: number;
+    limit?: number;
+    priority?: number;
+    nowMs?: number;
+    blockMs?: number;
+    reclaimExpired?: boolean;
+    reclaimRatio?: number;
+    jobOnly?: boolean;
+    payload?: boolean;
+    payloadMaxBytes?: number;
+    values?: string[];
+    valueMaxBytes?: number;
+    includeState?: boolean;
+}
+interface ReclaimOptions extends Omit<ClaimDueOptions, "state" | "states" | "blockMs" | "reclaimExpired" | "reclaimRatio" | "includeState"> {
+    state?: "running";
+}
+interface MutateOptions {
+    partitionKey?: string;
+    payload?: unknown;
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
+    dropValues?: string[];
+    overrideValues?: string[];
+    nowMs?: number;
+    returnRecord?: boolean;
+}
+interface LeaseMutationOptions extends MutateOptions {
+    leaseToken: Buffer;
+    fencingToken: number;
+}
+interface TransitionOptions extends LeaseMutationOptions {
+    fromState: string;
+    toState: string;
+    runAtMs?: number;
+    priority?: number;
+}
+interface CompleteOptions extends LeaseMutationOptions {
+    result?: unknown;
+    ttlMs?: number;
+}
+interface RetryOptions extends LeaseMutationOptions {
+    error?: unknown;
+    runAtMs?: number;
+}
+interface FailOptions extends LeaseMutationOptions {
+    error?: unknown;
+    ttlMs?: number;
+}
+interface CancelOptions {
+    fencingToken: number;
+    leaseToken?: Buffer;
+    partitionKey?: string;
+    reason?: unknown;
+    ttlMs?: number;
+    nowMs?: number;
+    returnRecord?: boolean;
+}
+interface ReadOptions {
+    partitionKey?: string;
+    count?: number;
+    fromMs?: number;
+    toMs?: number;
+    rev?: boolean;
+    state?: string;
+    terminalOnly?: boolean;
+    includeCold?: boolean;
+    consistentProjection?: boolean;
+}
+declare class FerricStoreClient {
+    readonly executor: CommandExecutor;
+    readonly codec: Codec;
+    readonly backpressure: Required<BackpressurePolicy>;
+    readonly bitmap: BitmapStore;
+    readonly bloom: BloomFilterStore;
+    readonly cms: CountMinSketchStore;
+    readonly cuckoo: CuckooFilterStore;
+    readonly geo: GeoStore;
+    readonly hash: HashStore;
+    readonly hyperloglog: HyperLogLogStore;
+    readonly json: JsonStore;
+    readonly kv: KeyValueStore;
+    readonly lists: ListStore;
+    readonly sets: SetStore;
+    readonly stream: StreamStore;
+    readonly tdigest: TDigestStore;
+    readonly topk: TopKStore;
+    readonly zset: SortedSetStore;
+    constructor(executor: CommandExecutor, options?: FerricStoreClientOptions);
+    static fromUrl(url: string, options?: FerricStoreClientOptions & {
+        nativeOptions?: NativeAdapterOptions;
+    }): Promise<FerricStoreClient>;
+    command(...args: CommandArgument[]): Promise<unknown>;
+    pipeline(commands: readonly Command[]): Promise<unknown[]>;
+    close(): Promise<void>;
+    ping(message?: CommandArgument): Promise<unknown>;
+    echo(message: CommandArgument): Promise<unknown>;
+    serverInfo(section?: string): Promise<string>;
+    configGet(pattern: string): Promise<unknown>;
+    configSet(key: string, value: CommandArgument, options?: {
+        local?: boolean;
+    }): Promise<boolean>;
+    configGetLocal(key: string): Promise<unknown>;
+    configResetStat(): Promise<boolean>;
+    configRewrite(): Promise<boolean>;
+    slowlogGet(count?: number): Promise<unknown[]>;
+    slowlogLen(): Promise<number>;
+    slowlogReset(): Promise<boolean>;
+    commandMetadata(): Promise<unknown>;
+    commandCount(): Promise<number>;
+    commandList(): Promise<unknown[]>;
+    commandInfo(...names: string[]): Promise<unknown[]>;
+    commandDocs(...names: string[]): Promise<unknown>;
+    commandGetKeys(command: Command): Promise<unknown[]>;
+    clientId(): Promise<number>;
+    clientSetName(name: string): Promise<boolean>;
+    clientGetName(): Promise<string | null>;
+    clientInfo(): Promise<string>;
+    clientList(options?: {
+        type?: string;
+    }): Promise<string>;
+    clientTracking(mode: "ON" | "OFF", options?: {
+        redirect?: number;
+        prefixes?: string[];
+        bcast?: boolean;
+        optin?: boolean;
+        optout?: boolean;
+        noloop?: boolean;
+    }): Promise<boolean>;
+    clientCaching(mode: "YES" | "NO"): Promise<boolean>;
+    clientTrackingInfo(): Promise<unknown>;
+    clientGetRedir(): Promise<number>;
+    save(): Promise<boolean>;
+    bgsave(): Promise<boolean>;
+    lastsave(): Promise<number>;
+    lolwut(version?: number): Promise<string>;
+    moduleList(): Promise<unknown[]>;
+    publish(channel: string, message: CommandArgument): Promise<number>;
+    pubsubChannels(pattern?: string): Promise<unknown[]>;
+    pubsubNumSub(...channels: string[]): Promise<unknown[]>;
+    pubsubNumPat(): Promise<number>;
+    aclSetUser(username: string, rules: string[]): Promise<boolean>;
+    aclDelUser(...usernames: string[]): Promise<number>;
+    aclGetUser(username: string): Promise<unknown>;
+    aclList(): Promise<unknown[]>;
+    aclWhoami(): Promise<string>;
+    aclSave(): Promise<boolean>;
+    aclLoad(): Promise<boolean>;
+    auth(password: string, username?: string): Promise<boolean>;
+    cas(key: string, expected: unknown, value: unknown, options?: {
+        ex?: number;
+    }): Promise<boolean>;
+    lock(key: string, owner: string, ttlMs: number): Promise<boolean>;
+    unlock(key: string, owner: string): Promise<number>;
+    extendLock(key: string, owner: string, ttlMs: number): Promise<number>;
+    rateLimitAdd(key: string, options: {
+        windowMs: number;
+        max: number;
+        count?: number;
+    }): Promise<RateLimitResult>;
+    keyInfo(key: string): Promise<KeyInfo>;
+    fetchOrCompute<T = unknown>(key: string, options: {
+        ttlMs: number;
+        hint?: string;
+    }): Promise<FetchOrComputeResult<T>>;
+    fetchOrComputeResult(key: string, value: unknown, options: {
+        ttlMs: number;
+    }): Promise<boolean>;
+    fetchOrComputeError(key: string, message: string): Promise<boolean>;
+    clusterHealth(): Promise<Record<string, unknown>>;
+    clusterStats(): Promise<Record<string, unknown>>;
+    clusterKeyslot(key: string): Promise<number>;
+    clusterSlots(): Promise<unknown>;
+    clusterStatus(): Promise<Record<string, unknown>>;
+    clusterRole(): Promise<unknown>;
+    clusterJoin(node: string, options?: {
+        replace?: boolean;
+    }): Promise<boolean>;
+    clusterLeave(): Promise<boolean>;
+    clusterFailover(shardIndex: number, targetNode: string): Promise<boolean>;
+    clusterPromote(node: string): Promise<boolean>;
+    clusterDemote(node: string): Promise<boolean>;
+    ferricstoreConfig(...args: CommandArgument[]): Promise<unknown>;
+    ferricstoreHotness(...args: CommandArgument[]): Promise<Record<string, unknown>>;
+    ferricstoreMetrics(...args: CommandArgument[]): Promise<Record<string, unknown>>;
+    ferricstoreBlobgc(...args: CommandArgument[]): Promise<unknown>;
+    ferricstoreDoctor(...args: CommandArgument[]): Promise<unknown>;
+    create(id: string, options: CreateOptions): Promise<FlowRecord | Buffer | unknown>;
+    enqueue(id: string, options: Omit<CreateOptions, "state"> & {
+        state?: string;
+    }): Promise<FlowRecord | Buffer | unknown>;
+    enqueueMany(items: CreateItem[], options: CreateManyOptions): Promise<unknown[] | unknown>;
+    createMany(partitionKey: string | undefined, items: CreateItem[], options: CreateManyOptions): Promise<unknown[] | unknown>;
+    valuePut(value: unknown, options?: {
+        partitionKey?: string;
+        ownerFlowId?: string;
+        name?: string;
+        override?: boolean;
+        ttlMs?: number;
+        nowMs?: number;
+    }): Promise<unknown>;
+    valueMGet(refs: string[], options?: {
+        maxBytes?: number;
+    }): Promise<unknown[]>;
+    signal(id: string, options: {
+        signal: string;
+        partitionKey?: string;
+        idempotencyKey?: string;
+        ifState?: string | string[];
+        transitionTo?: string;
+        runAtMs?: number;
+        nowMs?: number;
+        priority?: number;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+        dropValues?: string[];
+        overrideValues?: string[];
+    }): Promise<unknown>;
+    flowSignal(id: string, options: Parameters<FerricStoreClient["signal"]>[1]): Promise<unknown>;
+    claimDue(type: string, options: ClaimDueOptions): Promise<(FlowRecord | ClaimedItem)[]>;
+    claimJobs(type: string, options: Omit<ClaimDueOptions, "jobOnly">): Promise<ClaimedItem[]>;
+    reclaim(type: string, options: ReclaimOptions): Promise<(FlowRecord | ClaimedItem)[]>;
+    extendLease(id: string, options: {
+        leaseToken: Buffer;
+        fencingToken: number;
+        leaseMs: number;
+        partitionKey?: string;
+        nowMs?: number;
+    }): Promise<FlowRecord>;
+    transition(id: string, options: TransitionOptions): Promise<FlowRecord | Buffer | unknown>;
+    complete(id: string, options: CompleteOptions): Promise<FlowRecord | Buffer | unknown>;
+    completeMany(partitionKey: string | undefined, items: ClaimedItem[], options?: {
+        result?: unknown;
+        payload?: unknown;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+        dropValues?: string[];
+        overrideValues?: string[];
+        ttlMs?: number;
+        nowMs?: number;
+        independent?: boolean;
+        returnOkOnSuccess?: boolean;
+    }): Promise<unknown[] | unknown>;
+    completeJobs(jobs: ClaimedItem[], options?: Parameters<FerricStoreClient["completeMany"]>[2]): Promise<unknown[] | unknown>;
+    transitionMany(partitionKey: string | undefined, options: {
+        fromState: string;
+        toState: string;
+        items: FencedItem[];
+        payload?: unknown;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+        dropValues?: string[];
+        overrideValues?: string[];
+        runAtMs?: number;
+        nowMs?: number;
+        priority?: number;
+        independent?: boolean;
+    }): Promise<unknown[] | unknown>;
+    retry(id: string, options: RetryOptions): Promise<FlowRecord | Buffer | unknown>;
+    retryMany(partitionKey: string | undefined, items: ClaimedItem[], options?: {
+        error?: unknown;
+        payload?: unknown;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+        dropValues?: string[];
+        overrideValues?: string[];
+        runAtMs?: number;
+        nowMs?: number;
+        independent?: boolean;
+    }): Promise<unknown[] | unknown>;
+    fail(id: string, options: FailOptions): Promise<FlowRecord | Buffer | unknown>;
+    failMany(partitionKey: string | undefined, items: ClaimedItem[], options?: {
+        error?: unknown;
+        payload?: unknown;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+        dropValues?: string[];
+        overrideValues?: string[];
+        ttlMs?: number;
+        nowMs?: number;
+        independent?: boolean;
+    }): Promise<unknown[] | unknown>;
+    cancel(id: string, options: CancelOptions): Promise<FlowRecord | Buffer | unknown>;
+    cancelMany(partitionKey: string | undefined, items: FencedItem[], options?: {
+        reason?: unknown;
+        ttlMs?: number;
+        nowMs?: number;
+        independent?: boolean;
+    }): Promise<unknown[] | unknown>;
+    rewind(id: string, options?: {
+        partitionKey?: string;
+        toEvent?: string;
+        expectState?: string;
+        nowMs?: number;
+        returnRecord?: boolean;
+    }): Promise<FlowRecord | Buffer | unknown>;
+    get<TPayload = unknown>(id: string, options?: {
+        partitionKey?: string;
+        full?: boolean;
+    }): Promise<FlowRecord<TPayload> | undefined>;
+    list(type: string, options?: ReadOptions): Promise<FlowRecord[]>;
+    terminals(type: string, options?: ReadOptions): Promise<FlowRecord[]>;
+    failures(type: string, options?: ReadOptions): Promise<FlowRecord[]>;
+    byParent(parentFlowId: string, options?: ReadOptions): Promise<FlowRecord[]>;
+    byRoot(rootFlowId: string, options?: ReadOptions): Promise<FlowRecord[]>;
+    byCorrelation(correlationId: string, options?: ReadOptions): Promise<FlowRecord[]>;
+    info(type: string): Promise<Record<string, unknown>>;
+    stuck(type: string, options?: {
+        partitionKey?: string;
+        count?: number;
+        olderThanMs?: number;
+        nowMs?: number;
+    }): Promise<FlowRecord[]>;
+    history(id: string, options?: {
+        partitionKey?: string;
+        count?: number;
+        fromEvent?: string;
+        rev?: boolean;
+    }): Promise<unknown[]>;
+    spawnChildren(parentId: string, children: ChildSpec[], options?: {
+        groupId?: string;
+        partitionKey?: string;
+        leaseToken?: Buffer;
+        fencingToken?: number;
+        wait?: string;
+        waitState?: string;
+        success?: string;
+        failure?: string;
+        fromState?: string;
+        nowMs?: number;
+        onChildFailed?: string;
+        onParentClosed?: string;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+    }): Promise<unknown>;
+    installPolicy(type: string, options?: {
+        state?: string;
+        retry?: RetryPolicy;
+        retentionTtlMs?: number;
+    }): Promise<unknown>;
+    policyGet(type: string, options?: {
+        state?: string;
+    }): Promise<Record<string, unknown>>;
+    retentionCleanup(): Promise<Record<string, unknown>>;
+    private executeProducerWrite;
+    private recordOrGet;
+    private records;
+    private recordsOrResponse;
+    private indexQuery;
+    private appendPartitionOptions;
+}
+
+declare class FerricStoreError extends Error {
+    readonly code: string;
+    readonly raw: unknown;
+    constructor(message: string, options?: {
+        raw?: unknown;
+        cause?: unknown;
+    });
+}
+declare class FlowNotFoundError extends FerricStoreError {
+    readonly code = "flow_not_found";
+}
+declare class FlowWrongStateError extends FerricStoreError {
+    readonly code = "flow_wrong_state";
+}
+declare class StaleLeaseError extends FerricStoreError {
+    readonly code = "stale_lease";
+}
+declare class FlowAlreadyExistsError extends FerricStoreError {
+    readonly code = "flow_already_exists";
+}
+declare class LockHeldError extends FerricStoreError {
+    readonly code = "lock_held";
+}
+declare class LockNotOwnedError extends FerricStoreError {
+    readonly code = "lock_not_owned";
+}
+declare class InvalidCommandError extends FerricStoreError {
+    readonly code = "invalid_command";
+}
+declare class OverloadedError extends FerricStoreError {
+    readonly code = "overloaded";
+    readonly retryAfterMs: number | undefined;
+    readonly reason: string | undefined;
+    constructor(message: string, options?: {
+        raw?: unknown;
+        cause?: unknown;
+        retryAfterMs?: number;
+        reason?: string;
+    });
+}
+declare function classifyServerError(message: string, raw?: unknown, cause?: unknown): FerricStoreError;
+declare function mapException(error: unknown): unknown;
+
+type Outcome = TransitionOutcome | CompleteOutcome | RetryOutcome | FailOutcome;
+interface NamedValueMutation {
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
+    dropValues?: string[];
+    overrideValues?: string[];
+}
+interface TransitionOutcome extends NamedValueMutation {
+    readonly kind: "transition";
+    readonly toState: string;
+    readonly payload?: unknown;
+    readonly priority?: number;
+    readonly runAtMs?: number;
+}
+interface CompleteOutcome extends NamedValueMutation {
+    readonly kind: "complete";
+    readonly payload?: unknown;
+    readonly result?: unknown;
+    readonly ttlMs?: number;
+}
+interface RetryOutcome extends NamedValueMutation {
+    readonly kind: "retry";
+    readonly error?: unknown;
+    readonly payload?: unknown;
+    readonly runAtMs?: number;
+}
+interface FailOutcome extends NamedValueMutation {
+    readonly kind: "fail";
+    readonly error?: unknown;
+    readonly payload?: unknown;
+    readonly ttlMs?: number;
+}
+declare function transition(toState: string, options?: Omit<TransitionOutcome, "kind" | "toState">): TransitionOutcome;
+declare function complete(options?: Omit<CompleteOutcome, "kind">): CompleteOutcome;
+declare function retry(options?: Omit<RetryOutcome, "kind">): RetryOutcome;
+declare function fail(options?: Omit<FailOutcome, "kind">): FailOutcome;
+
+type QueueJob = FlowRecord | ClaimedItem;
+type QueueHandler = (job: QueueJob) => Promise<unknown> | unknown;
+type QueueBatchHandler = (jobs: QueueJob[]) => Promise<unknown> | unknown;
+interface QueueOptions {
+    type: string;
+    state?: string;
+    worker?: string;
+}
+interface QueueWorkerResult {
+    claimed: number;
+    completed: number;
+    retried: number;
+    failed: number;
+}
+declare class QueueClient {
+    readonly flow: FerricStoreClient;
+    constructor(flow: FerricStoreClient);
+    queue(options: QueueOptions | string): Queue;
+}
+declare class Queue {
+    readonly client: FerricStoreClient;
+    readonly type: string;
+    readonly state: string;
+    readonly defaultWorker: string;
+    constructor(client: FerricStoreClient, options: QueueOptions);
+    enqueue(id: string, options?: {
+        payload?: unknown;
+        partitionKey?: string;
+        runAtMs?: number;
+        nowMs?: number;
+        priority?: number;
+        idempotent?: boolean;
+        retentionTtlMs?: number;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+        returnRecord?: boolean;
+    }): Promise<FlowRecord | Buffer | unknown>;
+    enqueueMany(items: CreateItem[], options?: {
+        partitionKey?: string;
+        runAtMs?: number;
+        nowMs?: number;
+        priority?: number;
+        idempotent?: boolean;
+        independent?: boolean;
+        retentionTtlMs?: number;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+    }): Promise<unknown[] | unknown>;
+    worker(options?: WorkerConfig): QueueWorker;
+}
+declare class QueueWorker {
+    readonly queue: Queue;
+    readonly options: WorkerConfig;
+    private readonly pendingCompletions;
+    constructor(queue: Queue, options: WorkerConfig);
+    runOnce(handler: QueueHandler): Promise<QueueWorkerResult>;
+    runBatchOnce(handler: QueueBatchHandler): Promise<QueueWorkerResult>;
+    runBatchOnceForPartitionKeys(handler: QueueBatchHandler, partitionKeys: readonly string[], options?: {
+        readonly claimCredit?: number;
+    }): Promise<QueueWorkerResult>;
+    flush(): Promise<number>;
+    private runBatchOnceWithClaim;
+    run(handler: QueueHandler): Promise<void>;
+    private claimJobs;
+    private applyJob;
+    private flushCompletions;
+    private enqueueCompletion;
+    private drainPendingCompletions;
+    private applyOutcome;
+    private applyException;
+}
+
+type WorkflowHandler = (ctx: WorkflowContext) => Promise<Outcome | void | unknown> | Outcome | void | unknown;
+interface StateOptions {
+    leaseMs?: number;
+    claimPayload?: boolean;
+    claimRecord?: boolean;
+    claimValues?: string[];
+    valueMaxBytes?: number;
+    exceptionPolicy?: ExceptionPolicy;
+    retryPolicy?: RetryPolicy;
+    returnRecord?: boolean;
+}
+interface WorkflowOptions {
+    type: string;
+    initialState?: string;
+    valueConfig?: ValueConfig;
+    worker?: string;
+}
+interface WorkflowWorkerResult {
+    claimed: number;
+    applied: number;
+    claimCalls: number;
+    emptyClaims: number;
+}
+interface StateRegistration {
+    claimValues?: string[];
+    claimPayload: boolean;
+    claimRecord: boolean;
+    exceptionPolicy: ExceptionPolicy;
+    handler: WorkflowHandler;
+    leaseMs: number;
+    name: string;
+    returnRecord: boolean;
+    retryPolicy?: RetryPolicy;
+    valueMaxBytes?: number;
+}
+declare class WorkflowClient {
+    readonly flow: FerricStoreClient;
+    constructor(flow: FerricStoreClient);
+    workflow(options: WorkflowOptions): Workflow;
+}
+declare class Workflow {
+    readonly client: FerricStoreClient;
+    readonly type: string;
+    readonly initialState: string;
+    readonly valueConfig: ValueConfig & {
+        localCache: boolean;
+    };
+    readonly defaultWorker: string;
+    private readonly states;
+    constructor(client: FerricStoreClient, options: WorkflowOptions);
+    state(name: string, handler: WorkflowHandler, options?: StateOptions): this;
+    start(id: string, options?: {
+        payload?: unknown;
+        state?: string;
+        partitionKey?: string;
+        parentFlowId?: string;
+        rootFlowId?: string;
+        correlationId?: string;
+        runAtMs?: number;
+        nowMs?: number;
+        priority?: number;
+        idempotent?: boolean;
+        retentionTtlMs?: number;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+        returnRecord?: boolean;
+    }): Promise<FlowRecord | Buffer | unknown>;
+    startMany(items: {
+        id: string;
+        payload?: unknown;
+        partitionKey?: string;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+    }[], options?: {
+        state?: string;
+        partitionKey?: string;
+        runAtMs?: number;
+        nowMs?: number;
+        priority?: number;
+        idempotent?: boolean;
+        independent?: boolean;
+        retentionTtlMs?: number;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+    }): Promise<unknown[] | unknown>;
+    signal(id: string, options: Parameters<FerricStoreClient["signal"]>[1]): Promise<unknown>;
+    get(id: string, options?: Parameters<FerricStoreClient["get"]>[1]): Promise<FlowRecord | undefined>;
+    history(id: string, options?: Parameters<FerricStoreClient["history"]>[1]): Promise<unknown[]>;
+    worker(options?: WorkerConfig & {
+        states?: string[];
+    }): WorkflowWorker;
+    stateNames(): string[];
+    stateRegistration(name: string): StateRegistration | undefined;
+}
+declare class WorkflowContext {
+    readonly workflow: Workflow;
+    readonly job: FlowRecord | ClaimedItem;
+    readonly stateName: string;
+    readonly flow: WorkflowFlowCommands;
+    private readonly valueCache;
+    constructor(workflow: Workflow, job: FlowRecord | ClaimedItem, stateName: string);
+    get client(): FerricStoreClient;
+    get id(): string;
+    get type(): string;
+    get state(): string;
+    get logicalState(): string;
+    get partitionKey(): string | undefined;
+    get payload(): unknown;
+    get values(): Record<string, unknown>;
+    get valueRefs(): Record<string, unknown>;
+    get leaseToken(): Buffer;
+    get fencingToken(): number;
+    get version(): number;
+    get parentFlowId(): string | undefined;
+    get rootFlowId(): string | undefined;
+    get correlationId(): string | undefined;
+    value(name: string, defaultValue?: unknown, options?: {
+        localCache?: boolean;
+    }): Promise<unknown>;
+    valueMany(names: string[], options?: {
+        localCache?: boolean;
+    }): Promise<Record<string, unknown>>;
+    private valueMaxBytes;
+}
+declare class WorkflowFlowCommands {
+    private readonly ctx;
+    constructor(ctx: WorkflowContext);
+    get(id?: string, options?: {
+        partitionKey?: string;
+        full?: boolean;
+    }): Promise<FlowRecord | undefined>;
+    history(id?: string, options?: Parameters<FerricStoreClient["history"]>[1]): Promise<unknown[]>;
+    create(id: string, options?: Omit<Parameters<FerricStoreClient["create"]>[1], "type"> & {
+        type?: string;
+    }): Promise<FlowRecord | Buffer | unknown>;
+    transition(toState: string, options?: Partial<Omit<Parameters<FerricStoreClient["transition"]>[1], "toState" | "fromState" | "leaseToken" | "fencingToken">> & {
+        fromState?: string;
+    }): Promise<FlowRecord | Buffer | unknown>;
+    complete(options?: Partial<Omit<Parameters<FerricStoreClient["complete"]>[1], "leaseToken" | "fencingToken">>): Promise<FlowRecord | Buffer | unknown>;
+    retry(options?: Partial<Omit<Parameters<FerricStoreClient["retry"]>[1], "leaseToken" | "fencingToken">>): Promise<FlowRecord | Buffer | unknown>;
+    fail(options?: Partial<Omit<Parameters<FerricStoreClient["fail"]>[1], "leaseToken" | "fencingToken">>): Promise<FlowRecord | Buffer | unknown>;
+    signal(signal: string, options?: Omit<Parameters<FerricStoreClient["signal"]>[1], "signal">): Promise<unknown>;
+    putValue(name: string, value: unknown, options?: Parameters<FerricStoreClient["valuePut"]>[1]): Promise<unknown>;
+    value(name: string, defaultValue?: unknown, options?: {
+        localCache?: boolean;
+    }): Promise<unknown>;
+    values(names: string[], options?: {
+        localCache?: boolean;
+    }): Promise<Record<string, unknown>>;
+    spawnChildren(children: ChildSpec[], options?: Parameters<FerricStoreClient["spawnChildren"]>[2]): Promise<unknown>;
+}
+declare class WorkflowWorker {
+    readonly workflow: Workflow;
+    readonly options: WorkerConfig & {
+        states?: string[];
+    };
+    constructor(workflow: Workflow, options: WorkerConfig & {
+        states?: string[];
+    });
+    runOnce(): Promise<WorkflowWorkerResult>;
+    run(): Promise<void>;
+    private applyJob;
+    private applyHandlerError;
+}
+
+export { type AutoBatchOptions, type BackoffKind, type BackpressurePolicy, BitmapStore, BloomFilterStore, type CancelOptions, type ChildSpec, type ClaimDueOptions, type ClaimedItem, type Codec, type Command, type CommandArgument, type CommandExecutor, type CompleteOptions, type CompleteOutcome, type CountMinMergeOptions, CountMinSketchStore, type CreateItem, type CreateManyOptions, type CreateOptions, CuckooFilterStore, type ExceptionPolicy, type ExecutePipelineOptions, type FailOptions, type FailOutcome, type FencedItem, FerricStoreClient, type FerricStoreClientOptions, FerricStoreError, type FetchOrComputeResult, FlowAlreadyExistsError, FlowNotFoundError, type FlowRecord, FlowWrongStateError, type GeoAddOptions, type GeoMember, GeoStore, type GetExOptions, HashStore, HyperLogLogStore, InvalidCommandError, JsonCodec, type JsonSetOptions, JsonStore, type KeyInfo, KeyValueStore, ListStore, LockHeldError, LockNotOwnedError, type MutateOptions, type NamedValueMutation, NativeAdapter, type NativeAdapterOptions, type Outcome, OverloadedError, Queue, type QueueBatchHandler, QueueClient, type QueueHandler, type QueueOptions, QueueWorker, type QueueWorkerResult, type RangeLimit, type RateLimitResult, RawCodec, type ReadOptions, type ReclaimOptions, type RetryOptions, type RetryOutcome, type RetryPolicy, type ScanOptions, type SetOptions, SetStore, SortedSetStore, StaleLeaseError, type StateOptions, type StateRegistration, type StoreCommandClient, StreamStore, type TDigestCreateOptions, type TDigestMergeOptions, TDigestStore, type TopKReserveOptions, TopKStore, type TransitionOptions, type TransitionOutcome, type ValueConfig, type WorkerConfig, type WorkerProfile, Workflow, WorkflowClient, WorkflowContext, WorkflowFlowCommands, type WorkflowHandler, type WorkflowOptions, WorkflowWorker, type WorkflowWorkerResult, type XReadStream, type ZAddMember, type ZAddOptions, classifyServerError, complete, fail, mapException, retry, transition };