@ferricstore/ferricstore 0.1.6 → 0.2.0

package/dist/index.d.ts

@@ -1,6 +1,81 @@
-import tls from 'node:tls';
+import { ConnectionOptions } from 'node:tls';
 import { Buffer as Buffer$1 } from 'node:buffer';
 
+declare class FerricStoreError extends Error {
+    readonly code: string;
+    readonly raw: unknown;
+    readonly retryable: boolean | undefined;
+    readonly safeToRetry: boolean | undefined;
+    readonly retryAfterMs: number | undefined;
+    constructor(message: string, options?: {
+        raw?: unknown;
+        cause?: unknown;
+        retryable?: boolean;
+        safeToRetry?: boolean;
+        retryAfterMs?: number;
+    });
+}
+type RequestDisposition = "unsent" | "possibly_sent";
+/** Connection closure annotated with whether the current request may have reached the server. */
+declare class ConnectionClosedError extends FerricStoreError {
+    readonly code = "connection_closed";
+    readonly requestDisposition: RequestDisposition;
+    constructor(requestDisposition: RequestDisposition, options?: {
+        raw?: unknown;
+        cause?: unknown;
+        message?: string;
+    });
+}
+/** Request timeout annotated with whether the request may have reached the server. */
+declare class RequestTimeoutError extends FerricStoreError {
+    readonly code = "request_timeout";
+    readonly requestDisposition: RequestDisposition;
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number, requestDisposition: RequestDisposition, 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 reason: string | undefined;
+    constructor(message: string, options?: {
+        raw?: unknown;
+        cause?: unknown;
+        retryAfterMs?: number;
+        reason?: string;
+        retryable?: boolean;
+        safeToRetry?: boolean;
+    });
+}
+/** The contacted endpoint cannot serve this route and topology should be refreshed. */
+declare class RerouteError extends FerricStoreError {
+    readonly code = "reroute";
+}
+declare function classifyServerError(message: string, raw?: unknown, cause?: unknown, status?: number | string): FerricStoreError;
+declare function mapException(error: unknown): unknown;
+
 interface Codec<T = unknown> {
     encode(value: T | null | undefined): Buffer;
     decode(value: Buffer | null | undefined): T | null;
@@ -14,18 +89,26 @@ declare class JsonCodec<T = unknown> implements Codec<T> {
     decode(value: Buffer | null | undefined): T | null;
 }
 
-type CommandArgument = string | Buffer | number | boolean | Record<string, unknown> | null | undefined;
+type CommandArgument = string | Buffer | number | bigint | boolean | readonly CommandArgument[] | Record<string, unknown> | null | undefined;
 type Command = readonly CommandArgument[];
 
-type EndpointPolicy = "seed_hosts" | "any" | "none" | {
-    readonly allowHosts: readonly string[];
-};
+interface ExecutePipelineOptions {
+    /** @internal Earlier command indexes that must settle before each individual fallback command starts. */
+    fallbackDependencies?: readonly (readonly number[])[];
+    /** Maximum concurrent requests when a native pipeline is unavailable. Defaults to 64. */
+    fallbackConcurrency?: number;
+    /** Preserve command execution order when a native pipeline is unavailable. */
+    ordered?: boolean;
+    throwOnItemError?: boolean;
+}
+
 interface RoutingEndpoint {
     readonly node: string;
     readonly host: string;
     readonly nativePort: number;
     readonly nativeTlsPort?: number;
 }
+
 interface RoutingRoute {
     readonly shard: number;
     readonly laneId: number;
@@ -42,35 +125,137 @@ declare class RoutingTopology {
     private constructor();
     static empty(): RoutingTopology;
     static build(payload: unknown): RoutingTopology;
-    static slotForKey(key: string | Buffer$1): number;
-    routeKey(key: string | Buffer$1): RoutingRoute;
+    static slotForKey(key: string | Buffer): number;
+    routeKey(key: string | Buffer): RoutingRoute;
 }
+
+/** Trust policy for endpoints learned from SHARDS topology responses. */
+type EndpointPolicy = "seed_hosts" | "any" | "none" | {
+    readonly allowHosts: readonly string[];
+};
+
 declare class TopologyNativeAdapterPool implements CommandExecutor {
     private readonly adapterOptions;
-    private readonly adapters;
-    private readonly endpointPolicy;
-    private readonly endpointValidator?;
-    private readonly seedEndpointKeys;
+    private readonly seedAdapterOptions;
+    private closed;
+    private readonly adapterRegistry;
+    private closePromise?;
+    private readonly endpointTrust;
+    private readonly seedUrlByEndpointKey;
     private readonly seedUrls;
     private readonly tls;
-    private readonly trustedHosts;
+    private readonly topologyConcurrency;
+    private readonly pipelineExecutor;
+    private readonly scatterExecutor;
     private readonly warmConnections;
+    private eventRefreshPromise?;
+    private lastSuccessfulRefreshKey?;
+    private refreshPromise?;
+    private refreshRequested;
     private topologyValue;
     private constructor();
-    static fromUrls(urls: readonly string[], options?: NativeAdapterOptions): Promise<TopologyNativeAdapterPool>;
+    static fromUrls(urls: readonly string[], options?: TopologyNativeAdapterOptions): Promise<TopologyNativeAdapterPool>;
     get topology(): RoutingTopology;
+    private requestTopologyRefresh;
+    private drainTopologyRefreshRequests;
     refreshTopology(): Promise<RoutingTopology>;
+    private loadTopology;
     route(key: string | Buffer$1): RoutingRoute;
     executeCommand(...args: CommandArgument[]): Promise<unknown>;
+    executeCommandArgs(args: readonly CommandArgument[]): Promise<unknown>;
     executePipeline(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[]>;
+    executeFusedPipeline(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[] | undefined>;
+    private refreshAndCanRetrySafeReroute;
+    private executePipelineOnRoute;
+    private executeSplitPipeline;
     close(): Promise<void>;
     private routeData;
-    private singleRouteForCommands;
+    private executeOnRoute;
     private controlAdapter;
-    private adapterForUrl;
+    private adapterForSeedUrl;
     private adapterForEndpoint;
-    private validateEndpoint;
-    private refreshCandidateUrls;
+    private adapterForCurrentRoute;
+    private retireRemovedAdapters;
+    private refreshCandidates;
+    private assertOpen;
+}
+
+interface CommandExecutor {
+    executeCommand(...args: CommandArgument[]): Promise<unknown>;
+    /** Execute an already-built command without a JavaScript variadic-call limit. */
+    executeCommandArgs?(args: readonly CommandArgument[]): Promise<unknown>;
+    executePipeline?(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[]>;
+    /**
+     * Execute all commands in one native transport request. Returning undefined
+     * guarantees that no command was submitted, so the caller may fall back.
+     */
+    executeFusedPipeline?(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[] | undefined>;
+    refreshTopology?(): Promise<RoutingTopology>;
+    route?(key: string | Buffer): Promise<RoutingRoute> | RoutingRoute;
+    close?(): Promise<void> | void;
+}
+interface NativeProtocolEvent {
+    readonly flags: number;
+    readonly laneId: number;
+    readonly opcode: number;
+    readonly value: unknown;
+}
+interface NativeAdapterOptions {
+    clientName?: string;
+    connectTimeoutMs?: number;
+    /** Cancels connection, STARTUP, or AUTH while the native adapter is being created. */
+    signal?: AbortSignal;
+    heartbeatIntervalMs?: number;
+    keepAlive?: boolean;
+    keepAliveInitialDelayMs?: number;
+    /** Maximum source bytes buffered across chunked responses, including final assembly. */
+    maxChunkBytes?: number;
+    /** Maximum source frames buffered across chunked responses, including final assembly. */
+    maxChunkFrames?: number;
+    /** Maximum body bytes declared by any single native frame. */
+    maxFrameBytes?: number;
+    /** Maximum decoded response body bytes, including all chunks. */
+    maxResponseBytes?: number;
+    /** Maximum correlated control requests awaiting responses on one native connection. */
+    maxPendingControlRequests?: number;
+    /** Maximum requests waiting locally for native flow-control credit. */
+    maxQueuedRequests?: number;
+    /** Maximum encoded request bytes waiting locally for socket backpressure. */
+    maxQueuedWriteBytes?: number;
+    /** Native management events requested during STARTUP. */
+    events?: readonly string[];
+    /** Non-blocking callback for unsolicited native management frames. */
+    onEvent?: (event: NativeProtocolEvent) => unknown;
+    protocolLanes?: number;
+    timeoutMs?: number;
+    username?: string;
+    password?: string;
+    tlsOptions?: ConnectionOptions;
+}
+interface TopologyNativeAdapterOptions extends NativeAdapterOptions {
+    /** Learned endpoint trust policy; defaults to exact seeds plus `trustedHosts`. */
+    endpointPolicy?: EndpointPolicy;
+    endpointValidator?: (endpoint: RoutingEndpoint) => boolean | void;
+    /** Additional learned hosts allowed by the default `seed_hosts` policy. */
+    trustedHosts?: readonly string[];
+    /** Maximum concurrent per-route fan-out operations; defaults to 16. */
+    topologyConcurrency?: number;
+    warmConnections?: boolean;
+}
+/** Options accepted by FerricStoreClient.fromUrl(s), including client-side HA and reconnect policy. */
+interface NativeClientOptions extends TopologyNativeAdapterOptions {
+    autoReconnect?: boolean | ReconnectOptions;
+    haRouting?: boolean;
+    seeds?: readonly string[];
+}
+interface ReconnectOptions {
+    /** Base delay after a failed reconnect attempt. Defaults to 25ms. */
+    baseDelayMs?: number;
+    /** Percentage of positive random jitter added to reconnect delays. Defaults to 20. */
+    jitterPct?: number;
+    /** Maximum reconnect delay. Defaults to 1,000ms. */
+    maxDelayMs?: number;
+    maxRetries?: number;
 }
 
 declare const COMMAND_OPCODES: {
@@ -218,599 +403,435 @@ interface ProtocolCommand {
     readonly payload: unknown;
     readonly flags?: number;
     readonly laneId?: number;
+    /** @internal Correlated compact claim shape used to decode a direct response without guessing. */
+    readonly compactClaimMode?: CompactClaimMode;
+    /** @internal Correlated compact claim shapes for native pipeline response items. */
+    readonly pipelineClaimModes?: readonly (CompactClaimMode | undefined)[];
+    /** @internal Parsed routing metadata retained when a command uses COMMAND_EXEC. */
+    readonly routing?: ProtocolRoutingHints;
+    /** @internal Server-side blocking duration used to derive a safe response timeout. */
+    readonly serverBlockMs?: number;
+}
+type CompactClaimMode = "base" | "attrs" | "state" | "stateAttrs";
+interface ProtocolRoutingHints {
+    readonly flowPartitionKey?: unknown;
+    readonly flowPartitionKeys?: readonly unknown[];
 }
 
-interface CommandExecutor {
-    executeCommand(...args: CommandArgument[]): Promise<unknown>;
-    executePipeline?(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[]>;
-    refreshTopology?(): Promise<RoutingTopology>;
-    route?(key: string | Buffer$1): Promise<RoutingRoute> | RoutingRoute;
-    close?(): Promise<void> | void;
-}
-interface ExecutePipelineOptions {
-    throwOnItemError?: boolean;
-}
-interface NativeAdapterOptions {
-    autoReconnect?: boolean | ReconnectOptions;
-    clientName?: string;
-    connectTimeoutMs?: number;
-    endpointPolicy?: EndpointPolicy;
-    endpointValidator?: (endpoint: RoutingEndpoint) => boolean | void;
-    haRouting?: boolean;
-    heartbeatIntervalMs?: number;
-    keepAlive?: boolean;
-    keepAliveInitialDelayMs?: number;
-    maxChunkBytes?: number;
-    protocolLanes?: number;
-    seeds?: readonly string[];
-    timeoutMs?: number;
-    trustedHosts?: readonly string[];
-    username?: string;
-    password?: string;
-    tlsOptions?: tls.ConnectionOptions;
-    warmConnections?: boolean;
-}
-interface ReconnectOptions {
-    maxRetries?: number;
-}
 declare class NativeAdapter implements CommandExecutor {
     private readonly socket;
     private readonly pending;
-    private readonly chunks;
-    private readonly chunkBytes;
-    private buffer;
+    private readonly flowControl;
+    private readonly closedWaiters;
+    private readonly chunkAssembler;
     private closed;
-    private dataLane;
-    private readonly maxChunkBytes;
-    private requestId;
-    private readonly protocolLanes;
-    private readonly heartbeatIntervalMs?;
-    private heartbeatInFlight;
-    private heartbeatTimer?;
-    private lastActivityMs;
+    private readonly capabilities;
+    private protocolLanes;
+    private maxPipelineCommands;
+    private pendingControlRequests;
+    private readonly maxPendingControlRequests;
+    private readonly heartbeat;
+    private readonly heartbeatIntervalMs;
+    private readonly responseHandler;
+    private readonly requestScheduler;
     private readonly timeoutMs;
+    private draining;
+    private readonly writeQueue;
     private constructor();
     static fromUrl(url: string, options?: NativeAdapterOptions): Promise<NativeAdapter>;
+    /** @internal Closed and GOAWAY-draining adapters must not receive new work. */
+    get isUnavailable(): boolean;
     executeCommand(...args: CommandArgument[]): Promise<unknown>;
+    executeCommandArgs(args: readonly CommandArgument[]): Promise<unknown>;
+    /** @internal Execute raw command arguments on a topology-selected lane. */
+    executeCommandOnLane(args: readonly CommandArgument[], laneId: number): Promise<unknown>;
     executeProtocolCommand(command: ProtocolCommand, laneId?: number): Promise<unknown>;
     executePipeline(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[]>;
+    /** @internal Attempt one physical pipeline request without splitting or fallback. */
+    executeFusedPipeline(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[] | undefined>;
+    /** @internal Attempt one physical pipeline request on a topology-selected lane. */
+    executeFusedPipelineOnLane(commands: readonly Command[], laneId: number | undefined, options?: ExecutePipelineOptions): Promise<unknown[] | undefined>;
+    /** @internal Execute an ordered pipeline on a topology-selected lane. */
+    executePipelineOnLane(commands: readonly Command[], laneId: number | undefined, options?: ExecutePipelineOptions): Promise<unknown[]>;
     close(): Promise<void>;
     private startup;
-    private auth;
     private request;
-    private startHeartbeat;
-    private stopHeartbeat;
-    private sendHeartbeat;
-    private onData;
-    private handleFrame;
+    private waitForCreditAndSend;
+    private sendAcquiredRequest;
+    private timeoutPending;
+    private finishDrainIfIdle;
     private failAll;
-    private cleanupChunksForRequest;
-    private nextRequestId;
-    private assignLane;
+    /** @internal Gracefully stop new requests and close after correlated requests settle. */
+    retire(): Promise<void>;
+    private beginDraining;
+    private resolveClosedWaiters;
+    private takePending;
+    private applyFlowControlLimits;
+    private applyStartupLimits;
 }
+
 declare class ReconnectingExecutor implements CommandExecutor {
     private readonly createExecutor;
+    private readonly baseDelayMs;
     private closed;
+    private closePromise?;
+    private readonly jitterPct;
+    private readonly maxDelayMs;
     private readonly maxRetries;
+    private readonly retryAbortController;
     private executorPromise;
     private reconnectPromise?;
-    constructor(createExecutor: () => Promise<CommandExecutor>, options?: ReconnectOptions);
+    constructor(createExecutor: (signal?: AbortSignal) => Promise<CommandExecutor>, options?: ReconnectOptions);
     executeCommand(...args: CommandArgument[]): Promise<unknown>;
+    executeCommandArgs(args: readonly CommandArgument[]): Promise<unknown>;
+    ready(): Promise<void>;
     executePipeline(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[]>;
+    executeFusedPipeline(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[] | undefined>;
     refreshTopology(): Promise<RoutingTopology>;
     route(key: string | Buffer$1): Promise<RoutingRoute>;
     close(): Promise<void>;
     private withReconnect;
+    private waitBeforeReconnect;
     private reconnect;
 }
 declare function isReconnectableClosedConnectionError(error: unknown): boolean;
 
-interface StoreCommandClient {
-    readonly codec: Codec;
-    command(...args: CommandArgument[]): Promise<unknown>;
+type ExceptionPolicy = "retry" | "fail" | "raise";
+type BackoffKind = "fixed" | "linear" | "exponential";
+type WorkerProfile = "latency" | "throughput";
+type WorkerRefillStrategy = "continuous" | "wave";
+interface RetryPolicy {
+    maxRetries?: number;
+    backoff?: BackoffKind | string;
+    baseMs?: number;
+    maxMs?: number;
+    jitterPct?: number;
+    exhaustedTo?: string;
 }
-interface SetOptions {
-    ex?: number;
-    px?: number;
-    exat?: number;
-    pxat?: number;
-    nx?: boolean;
-    xx?: boolean;
-    get?: boolean;
-    keepTtl?: boolean;
+interface BackpressurePolicy {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitterPct?: number;
 }
-interface GetExOptions {
-    ex?: number;
-    px?: number;
-    exat?: number;
-    pxat?: number;
-    persist?: boolean;
+interface ValueConfig {
+    valueMaxBytes?: number;
+    localCache?: boolean;
 }
-interface ScanOptions {
-    match?: string;
-    count?: number;
+interface WorkerConfig {
+    profile?: WorkerProfile;
+    /** Alias for concurrency when concurrency is omitted. */
+    workers?: number;
+    /** Maximum simultaneously running per-job handlers and claim credit. */
+    concurrency?: number;
+    /** Refill free per-job slots continuously or wait for the current wave. Defaults to continuous in run(). */
+    refillStrategy?: WorkerRefillStrategy;
+    /** Additional slot-refill coalescing delay in milliseconds. Zero still coalesces one event-loop turn. */
+    refillDelayMs?: number;
+    /** Pipeline batchable completions with replacement claims when routes match. Defaults to true. */
+    fuseCompleteClaim?: boolean;
+    /** Claim and terminal mutation batch size, capped at the server Flow limit of 1,000. */
+    batchSize?: number;
+    leaseMs?: number;
+    /** Automatically extend leases while handlers run. Defaults to true. */
+    leaseRenewal?: boolean;
+    /** Lease-renewal interval in milliseconds. Defaults to half of leaseMs. */
+    leaseRenewIntervalMs?: number;
+    priority?: number;
+    nowMs?: number;
+    partitionKey?: string;
+    partitionKeys?: string[];
+    reclaimExpired?: boolean;
+    reclaimRatio?: number;
+    claimPayload?: boolean;
+    claimValues?: string[];
+    /** Include Flow attributes in compact worker claims. Defaults to false. */
+    claimAttributes?: boolean;
+    valueMaxBytes?: number;
+    blockMs?: number;
+    /** Maximum server block interval while signal is present, bounding safe shutdown latency. */
+    abortPollMs?: number;
+    idleSleepMs?: number;
+    maxIdleSleepMs?: number;
+    exceptionPolicy?: ExceptionPolicy;
+    /** Persist handler Error.stack for diagnostics. Defaults to false because stacks can expose paths or secrets. */
+    includeErrorStack?: boolean;
+    /** Maximum asynchronous terminal batches; non-finite values use the worker-mode default. */
+    completeAsyncDepth?: number;
+    completeIndependent?: boolean;
+    /** Maximum sequential non-blocking claims performed by one runOnce call. */
+    claimDrainBatches?: number;
+    signal?: AbortSignal;
+    worker?: string;
 }
-interface ZAddMember {
-    score: number;
-    member: unknown;
+
+type MaxActiveMs = number | "infinity";
+/** An exact Flow fencing token; bigint is used beyond JavaScript's safe integer range. */
+type FencingToken = number | bigint;
+interface ChildSpec {
+    id: string;
+    type: string;
+    payload?: unknown;
+    partitionKey?: string;
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
 }
-interface ZAddOptions {
-    nx?: boolean;
-    xx?: boolean;
-    gt?: boolean;
-    lt?: boolean;
-    ch?: boolean;
+type StateMetaValue = string | number | boolean | Buffer;
+type StateMeta = Record<string, StateMetaValue>;
+interface CreateItem {
+    id: string;
+    payload?: unknown;
+    partitionKey?: string;
+    attributes?: Record<string, CommandArgument>;
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
+    stateMeta?: StateMeta;
 }
-interface RangeLimit {
-    offset: number;
-    count: number;
+/** @internal */
+declare const CLAIMED_ITEM_WIRE: unique symbol;
+/** @internal */
+interface ClaimedItemWire {
+    id: Buffer;
+    partitionKey?: Buffer | null;
+    leaseToken: Buffer;
+    fencingToken: FencingToken;
 }
-interface XReadStream {
-    key: string;
+interface ClaimedItem<TPayload = unknown> {
     id: string;
+    leaseToken: Buffer;
+    fencingToken: FencingToken;
+    partitionKey?: string;
+    /** Present when supplied by a full response or known compact-claim context. */
+    type?: string;
+    state: string;
+    runState?: string;
+    payload?: TPayload | null;
+    attributes?: Record<string, unknown>;
+    /** @internal */
+    [CLAIMED_ITEM_WIRE]?: ClaimedItemWire;
 }
-interface GeoMember {
-    longitude: number;
-    latitude: number;
-    member: unknown;
-}
-interface GeoAddOptions {
-    nx?: boolean;
-    xx?: boolean;
-    ch?: boolean;
+interface FencedItem {
+    id: string;
+    fencingToken: FencingToken;
+    leaseToken?: Buffer;
+    partitionKey?: string;
 }
-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>;
+interface RateLimitResult {
+    status: string;
+    count: number;
+    remaining: number;
+    resetMs: number;
+    allowed: boolean;
 }
-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>;
+interface KeyInfo {
+    type: string;
+    valueSize: number;
+    ttlMs: number;
+    hotCacheStatus: string;
+    lastWriteShard: number;
+    raw: Record<string, unknown>;
 }
-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>;
+interface FetchOrComputeHitResult<T = unknown> {
+    readonly computeMode: "hit";
+    readonly hit: true;
+    readonly shouldCompute: false;
+    readonly status: "hit";
+    readonly value: T | null;
+}
+interface FetchOrComputeComputeResult {
+    /** Opaque application hint echoed for the process elected to compute. */
+    readonly computeHint: Buffer;
+    readonly computeMode: "fenced";
+    /** Fencing token required when publishing the computed result or error. */
+    readonly computeToken: Buffer;
+    readonly hit: false;
+    readonly shouldCompute: true;
+    readonly status: "compute";
+}
+type FetchOrComputeFencedResult = FetchOrComputeComputeResult;
+type FetchOrComputeResult<T = unknown> = FetchOrComputeHitResult<T> | FetchOrComputeComputeResult;
+interface FlowMaxActiveFailure {
+    readonly maxActiveMs: number;
+    readonly reason: "max_active_ms";
 }
-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>;
+interface FlowRecord<TPayload = unknown> {
+    id: string;
+    type: string;
+    state: string;
+    partitionKey: string;
+    runState?: string;
+    payload?: TPayload | null;
+    leaseToken: Buffer;
+    fencingToken: FencingToken;
+    version: number;
+    parentFlowId?: string;
+    rootFlowId?: string;
+    correlationId?: string;
+    maxActiveMs?: number;
+    error?: unknown;
+    failureReason?: 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>;
+    stateMeta?: Record<string, unknown>;
+    indexedStateMeta?: string;
+    raw?: 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>;
+
+type FlowAdminRecord = Record<string, unknown>;
+interface FlowStatsOptions {
+    state?: string;
+    partitionKey?: string;
+    count?: number;
+    attributes?: Record<string, CommandArgument>;
+    consistentProjection?: boolean;
 }
-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>;
+interface AttributeQueryOptions {
+    state?: string;
+    partitionKey?: string;
+    count?: number;
+    consistentProjection?: boolean;
 }
-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>;
+interface ScheduleOptions {
+    target: Record<string, unknown>;
+    kind?: string;
+    atMs?: number;
+    delayMs?: number;
+    startAtMs?: number;
+    everyMs?: number;
+    cron?: string;
+    timezone?: string;
+    overlapPolicy?: string;
+    overlapRetryMs?: number;
+    maxFires?: number;
+    endAtMs?: number;
+    overwrite?: boolean;
+    nowMs?: number;
+    extraOptions?: Record<string, CommandArgument>;
 }
-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>;
+interface ScheduleListOptions {
+    kind?: string;
+    state?: string;
+    timezone?: string;
+    targetType?: string;
+    fromMs?: number;
+    toMs?: number;
+    count?: number;
+    rev?: 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 ScheduleFireDueOptions {
+    nowMs?: number;
+    worker?: string;
+    blockMs?: number;
+    limit?: number;
 }
-
-interface TopKReserveOptions {
-    width?: number;
-    depth?: number;
-    decay?: number;
+interface EffectReserveOptions {
+    partitionKey?: string;
+    leaseToken?: Buffer;
+    fencingToken?: FencingToken;
+    operationDigest: string;
+    idempotencyKey?: string;
+    governanceScope?: string;
+    nowMs?: number;
 }
-interface CountMinMergeOptions {
-    weights?: number[];
+interface EffectStatusOptions {
+    partitionKey?: string;
+    leaseToken?: Buffer;
+    fencingToken?: FencingToken;
+    nowMs?: number;
 }
-interface TDigestCreateOptions {
-    compression?: number;
+interface EffectConfirmOptions extends EffectStatusOptions {
+    externalId?: string;
+    latencyMs?: number;
+}
+interface EffectFailOptions extends EffectStatusOptions {
+    error?: string;
+    reason?: string;
+    latencyMs?: number;
+}
+interface EffectCompensateOptions extends EffectStatusOptions {
+    externalId?: string;
+    reason?: string;
+}
+interface ApprovalRequestOptions {
+    flowId: string;
+    scope: string;
+    reason?: string;
+    requestedBy?: string;
+    assignees?: readonly string[];
+    policyHash?: string;
+    policyVersion?: string | number;
+    timeoutMs?: number;
+    expiresAtMs?: number;
+    nowMs?: number;
 }
-interface TDigestMergeOptions extends TDigestCreateOptions {
-    override?: boolean;
+interface ApprovalListOptions {
+    status?: string;
+    scope?: string;
+    partitionKey?: string;
+    flowId?: string;
+    limit?: number;
 }
-interface JsonSetOptions {
-    nx?: boolean;
-    xx?: boolean;
+interface CircuitOpenOptions {
+    openMs?: number;
+    failureThreshold?: number;
+    nowMs?: number;
 }
-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[]>;
+interface BudgetReserveOptions {
+    limit?: number;
+    windowMs?: number;
+    reservationId?: string;
+    nowMs?: number;
 }
-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[]>;
+interface BudgetCommitOptions {
+    usage?: Record<string, unknown>;
+    nowMs?: number;
 }
-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[]>;
+interface AdminListOptions {
+    scope?: string;
+    partitionKey?: string;
+    limit?: number;
 }
-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;
+interface LimitListOptions extends AdminListOptions {
     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 LimitLeaseOptions {
+    shardId: number;
+    amount: number;
+    ttlMs: number;
+    limit?: number;
+    nowMs?: number;
 }
-type StateMetaValue = string | number | boolean | Buffer;
-type StateMeta = Record<string, StateMetaValue>;
-interface CreateItem {
-    id: string;
-    payload?: unknown;
-    partitionKey?: string;
-    values?: Record<string, unknown>;
-    valueRefs?: Record<string, string>;
-    stateMeta?: StateMeta;
+interface LimitAmountOptions {
+    shardId: number;
+    amount: number;
+    nowMs?: number;
 }
-/** @internal */
-declare const CLAIMED_ITEM_WIRE: unique symbol;
-/** @internal */
-interface ClaimedItemWire {
-    id: Buffer;
-    partitionKey?: Buffer | null;
-    leaseToken: Buffer;
-    fencingToken: number;
+interface LimitReleaseOptions {
+    shardId: number;
+    reservationIds: readonly string[];
+    amount?: number;
 }
-interface ClaimedItem<TPayload = unknown> {
-    id: string;
-    leaseToken: Buffer;
-    fencingToken: number;
+interface GovernanceLedgerOptions {
     partitionKey?: string;
-    type: string;
-    state: string;
-    runState?: string;
-    payload?: TPayload | null;
-    attributes?: Record<string, unknown>;
-    /** @internal */
-    [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>;
+    limit?: number;
+    fromMs?: number;
+    toMs?: number;
+    rev?: boolean;
 }
-interface FetchOrComputeResult<T = unknown> {
-    status: "hit" | "compute" | string;
-    value?: T | null;
-    computeToken?: Buffer;
-    hit: boolean;
-    shouldCompute: boolean;
+
+interface FlowBatchCompletedItem {
+    readonly index: number;
+    readonly value: unknown;
 }
-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>;
-    stateMeta?: Record<string, unknown>;
-    indexedStateMeta?: string;
-    raw?: unknown;
+interface ClaimHydrationItem {
+    readonly index: number;
+    readonly record: FlowRecord;
 }
-
+/** A legacy compact claim leased jobs successfully, but one or more fallback reads failed. */
 interface AutoBatchOptions {
     enabled?: boolean;
     maxCommands?: number;
@@ -821,9 +842,13 @@ interface FerricStoreClientOptions {
     autoBatch?: boolean | AutoBatchOptions;
     codec?: Codec;
     backpressure?: BackpressurePolicy;
+    /** Maximum items per Flow `*_MANY` server request. Must match `flow_max_batch_items`; defaults to 1,000. */
+    flowManyBatchLimit?: number;
+    /** Maximum concurrent FLOW.GET fallbacks for legacy compact full-claim responses. Defaults to 16. */
+    legacyClaimHydrationConcurrency?: number;
 }
 interface FerricStoreClientFromUrlOptions extends FerricStoreClientOptions {
-    nativeOptions?: NativeAdapterOptions;
+    nativeOptions?: NativeClientOptions;
     reconnect?: boolean | ReconnectOptions;
 }
 interface CreateOptions {
@@ -839,6 +864,10 @@ interface CreateOptions {
     priority?: number;
     idempotent?: boolean;
     retentionTtlMs?: number;
+    /** Maximum active lifetime from creation, or "infinity" to disable a type policy timeout. */
+    maxActiveMs?: MaxActiveMs;
+    /** Attribute values stored on the Flow and available to configured attribute indexes. */
+    attributes?: Record<string, CommandArgument>;
     values?: Record<string, unknown>;
     valueRefs?: Record<string, string>;
     stateMeta?: StateMeta;
@@ -847,6 +876,30 @@ interface CreateOptions {
 interface CreateManyOptions extends Omit<CreateOptions, "payload" | "partitionKey" | "returnRecord"> {
     partitionKey?: string;
     independent?: boolean;
+    /** Maximum auto-partition batches sent concurrently. Defaults to 8. */
+    autoPartitionConcurrency?: number;
+    /** Maximum items per auto-partition request, capped by the client's `flowManyBatchLimit`. */
+    autoPartitionBatchSize?: number;
+}
+interface StartAndClaimOptions {
+    type: string;
+    initialState: string;
+    worker: string;
+    leaseMs?: number;
+    payload?: unknown;
+    partitionKey?: string;
+    parentFlowId?: string;
+    rootFlowId?: string;
+    correlationId?: string;
+    nowMs?: number;
+    priority?: number;
+    retentionTtlMs?: number;
+    /** Maximum active lifetime from creation, or "infinity" to disable a type policy timeout. */
+    maxActiveMs?: MaxActiveMs;
+    attributes?: Record<string, CommandArgument>;
+    stateMeta?: StateMeta;
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
 }
 interface ClaimDueOptions {
     state?: string;
@@ -864,9 +917,38 @@ interface ClaimDueOptions {
     jobOnly?: boolean;
     payload?: boolean;
     payloadMaxBytes?: number;
-    values?: string[];
+    values?: readonly string[];
     valueMaxBytes?: number;
     includeState?: boolean;
+    /** Include Flow attributes in compact job-only claims. Defaults to false to minimize wire size. */
+    includeAttributes?: boolean;
+}
+interface CompleteManyOptions {
+    result?: unknown;
+    payload?: unknown;
+    values?: Record<string, unknown>;
+    valueRefs?: Record<string, string>;
+    dropValues?: string[];
+    overrideValues?: string[];
+    attributesMerge?: Record<string, CommandArgument>;
+    attributesDelete?: string[];
+    stateMeta?: StateMeta;
+    ttlMs?: number;
+    nowMs?: number;
+    independent?: boolean;
+    returnOkOnSuccess?: boolean;
+}
+interface CompleteJobsAndClaimJobsResult {
+    /** Raw FLOW.COMPLETE_MANY result, retained even when an item failed. */
+    readonly completion: unknown;
+    /** Any replacement leases returned by the claim half of the operation. */
+    readonly claimed: (FlowRecord | ClaimedItem)[];
+    /** Completion validation failure; replacement leases must still be handled. */
+    readonly completionError?: Error;
+    /** Claim command failure after the completion command was submitted. */
+    readonly claimError?: Error;
+    /** True when both commands shared one ordered transport pipeline. */
+    readonly fused: boolean;
 }
 interface ReclaimOptions extends Omit<ClaimDueOptions, "state" | "states" | "blockMs" | "reclaimExpired" | "reclaimRatio" | "includeState"> {
     state?: "running";
@@ -883,6 +965,10 @@ interface FlowPolicyOptions {
     retry?: RetryPolicy;
     states?: Record<string, FlowStatePolicyLike>;
     retentionTtlMs?: number;
+    /** Type-level maximum active lifetime for newly created Flows. */
+    maxActiveMs?: MaxActiveMs;
+    /** Type-level attribute names projected for FLOW.SEARCH. An empty array clears the index list. */
+    indexedAttributes?: readonly string[];
     indexedStateMeta?: string;
 }
 interface RequestContext {
@@ -904,13 +990,23 @@ interface MutateOptions {
     valueRefs?: Record<string, string>;
     dropValues?: string[];
     overrideValues?: string[];
+    attributesMerge?: Record<string, CommandArgument>;
+    attributesDelete?: string[];
     stateMeta?: StateMeta;
     nowMs?: number;
     returnRecord?: boolean;
 }
 interface LeaseMutationOptions extends MutateOptions {
     leaseToken: Buffer;
-    fencingToken: number;
+    fencingToken: FencingToken;
+}
+interface ExtendLeaseOptions {
+    leaseToken: Buffer;
+    fencingToken: FencingToken;
+    leaseMs: number;
+    partitionKey?: string;
+    nowMs?: number;
+    returnOkOnSuccess?: boolean;
 }
 interface TransitionOptions extends LeaseMutationOptions {
     fromState: string;
@@ -918,6 +1014,31 @@ interface TransitionOptions extends LeaseMutationOptions {
     runAtMs?: number;
     priority?: number;
 }
+interface StepContinueOptions extends Omit<LeaseMutationOptions, "returnRecord"> {
+    fromState: string;
+    toState: string;
+    leaseMs?: number;
+    worker?: string;
+    returnJob?: boolean;
+    /** Flow type to retain when returnJob requests a compact response. */
+    type?: string;
+}
+interface RunStepsItem {
+    id: string;
+    partitionKey?: string;
+}
+interface RunStepsManyOptions {
+    type: string;
+    states?: readonly string[];
+    steps?: number;
+    worker: string;
+    leaseMs?: number;
+    nowMs?: number;
+    payload?: unknown;
+    result?: unknown;
+    partitionKey?: string;
+    retentionTtlMs?: number;
+}
 interface CompleteOptions extends LeaseMutationOptions {
     result?: unknown;
     ttlMs?: number;
@@ -930,37 +1051,613 @@ interface FailOptions extends LeaseMutationOptions {
     error?: unknown;
     ttlMs?: number;
 }
-interface CancelOptions {
-    fencingToken: number;
-    leaseToken?: Buffer;
-    partitionKey?: string;
-    reason?: unknown;
-    ttlMs?: number;
-    nowMs?: number;
-    stateMeta?: StateMeta;
-    returnRecord?: boolean;
+interface CancelOptions extends Omit<MutateOptions, "payload"> {
+    fencingToken: FencingToken;
+    leaseToken?: Buffer;
+    reason?: unknown;
+    ttlMs?: number;
+}
+interface ReadOptions {
+    partitionKey?: string;
+    count?: number;
+    fromMs?: number;
+    toMs?: number;
+    rev?: boolean;
+    state?: string;
+    terminalOnly?: boolean;
+    includeCold?: boolean;
+    consistentProjection?: boolean;
+}
+interface HistoryOptions {
+    partitionKey?: string;
+    count?: number;
+    fromEvent?: string;
+    toEvent?: string;
+    fromMs?: number;
+    toMs?: number;
+    fromVersion?: number;
+    toVersion?: number;
+    rev?: boolean;
+    event?: string;
+    worker?: string;
+    includeCold?: boolean;
+    consistentProjection?: boolean;
+    values?: boolean;
+    payloadMaxBytes?: number;
+}
+type SearchStateMeta = StateMeta | Record<string, StateMeta>;
+interface SearchOptions extends ReadOptions {
+    attributes?: Record<string, CommandArgument>;
+    stateMeta?: SearchStateMeta;
+}
+type ManagementPairs = Record<string, CommandArgument>;
+
+declare class ClaimHydrationError extends FerricStoreError {
+    readonly code = "flow_claim_hydration_partial";
+    readonly claimed: readonly ClaimedItem[];
+    readonly failedIndex: number;
+    readonly hydratedItems: readonly ClaimHydrationItem[];
+    constructor(cause: unknown, claimed: readonly ClaimedItem[], hydratedItems: readonly ClaimHydrationItem[], failedIndex: number);
+}
+/** A chunked independent Flow operation failed after zero or more item results were confirmed. */
+declare class FlowBatchError extends FerricStoreError {
+    readonly code = "flow_batch_partial";
+    readonly completed: number;
+    readonly completedItems: readonly FlowBatchCompletedItem[];
+    readonly operation: string;
+    constructor(operation: string, cause: unknown, completedItems: readonly FlowBatchCompletedItem[]);
+}
+
+declare class FerricStoreClientBase {
+    readonly executor: CommandExecutor;
+    readonly codec: Codec;
+    readonly backpressure: Required<BackpressurePolicy>;
+    readonly flowManyBatchLimit: number;
+    readonly legacyClaimHydrationConcurrency: number;
+    private readonly closeAbortController;
+    private closePromise?;
+    constructor(executor: CommandExecutor, options?: FerricStoreClientOptions);
+    command(...args: CommandArgument[]): Promise<unknown>;
+    /** Execute an already-built command without a JavaScript variadic-call limit. */
+    commandArgs(args: readonly CommandArgument[]): Promise<unknown>;
+    pipeline(commands: readonly Command[], options?: ExecutePipelineOptions): Promise<unknown[]>;
+    close(): Promise<void>;
+    protected get closeSignal(): AbortSignal;
+    refreshTopology(): Promise<RoutingTopology>;
+    route(key: string | Buffer$1): Promise<RoutingRoute>;
+}
+
+/** Cluster, FerricStore administration, telemetry, and invocation commands. */
+declare class FerricStoreAdministrationClient extends FerricStoreClientBase {
+    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<string>;
+    ferricstoreBlobgc(...args: CommandArgument[]): Promise<unknown>;
+    ferricstoreDoctor(...args: CommandArgument[]): Promise<unknown>;
+    capabilities(): Promise<Record<string, unknown>>;
+    ensureNamespace(prefix: string, attrs?: ManagementPairs): Promise<unknown>;
+    getNamespace(prefix: string): Promise<unknown>;
+    listNamespaces(): Promise<unknown>;
+    deleteNamespace(prefix: string): Promise<unknown>;
+    setQuota(namespace: string, quotaSpec?: ManagementPairs): Promise<unknown>;
+    getQuota(namespace: string): Promise<unknown>;
+    quotaUsage(namespace: string): Promise<unknown>;
+    clusterInfo(): Promise<Record<string, unknown>>;
+    namespaceUsage(prefix: string): Promise<Record<string, unknown>>;
+    flowQuery(attrs?: ManagementPairs): Promise<unknown[]>;
+    flowHistory(id: string, attrs?: ManagementPairs): Promise<unknown[]>;
+    invocationDefinitionPut(definition: Record<string, unknown> | string, options?: RequestContextOptions): Promise<unknown>;
+    invocationDefinitionGet(name: string, options?: RequestContextOptions): Promise<unknown>;
+    invocationDefinitionList(options?: RequestContextOptions): Promise<unknown[]>;
+    invocationCreate(name: string, attrs: Record<string, unknown>, options?: InvocationCreateOptions): Promise<unknown>;
+    invocationGet(id: string, options?: RequestContextOptions): Promise<unknown>;
+    invocationPartitionList(name: string, options?: RequestContextOptions & {
+        scope?: string;
+    }): Promise<unknown[]>;
+}
+
+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: readonly string[]): Promise<number>;
+    del(key: string, ...keys: string[]): Promise<number>;
+    exists(keys: readonly string[]): Promise<number>;
+    exists(key: string, ...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<IntegerReply>;
+    decr(key: string): Promise<IntegerReply>;
+    incrby(key: string, increment: number | bigint): Promise<IntegerReply>;
+    decrby(key: string, decrement: number | bigint): Promise<IntegerReply>;
+    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, condition?: ExpiryCondition): Promise<boolean>;
+    pexpire(key: string, milliseconds: number, condition?: ExpiryCondition): Promise<boolean>;
+    expireat(key: string, unixSeconds: number, condition?: ExpiryCondition): Promise<boolean>;
+    pexpireat(key: string, unixMilliseconds: number, condition?: ExpiryCondition): Promise<boolean>;
+    ttl(key: string): Promise<IntegerReply>;
+    pttl(key: string): Promise<IntegerReply>;
+    persist(key: string): Promise<boolean>;
+    expiretime(key: string): Promise<IntegerReply>;
+    pexpiretime(key: string): Promise<IntegerReply>;
+    type(key: string): Promise<string>;
+    unlink(keys: readonly string[]): Promise<number>;
+    unlink(key: string, ...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<string[]>;
+    scan(cursor: string | number, options?: ScanOptions): Promise<[string, string[]]>;
+    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<[IntegerReply, IntegerReply]>;
+    memoryUsage(key: string): Promise<number | null>;
+}
+
+declare class GeoStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    geoadd(key: string, members: GeoMember[], options?: GeoAddOptions): Promise<number>;
+    geopos(key: string, member: unknown, ...members: unknown[]): Promise<([string, string] | null)[]>;
+    geoposMany(key: string, members: readonly unknown[]): Promise<([string, string] | null)[]>;
+    geodist(key: string, member1: unknown, member2: unknown, unit?: "m" | "km" | "mi" | "ft"): Promise<string | null>;
+    geohash(key: string, member: unknown, ...members: unknown[]): Promise<(string | null)[]>;
+    geohashMany(key: string, members: readonly unknown[]): Promise<(string | null)[]>;
+    geosearch(key: string, args: CommandArgument[]): Promise<unknown[]>;
+    geosearchstore(destination: string, source: string, args: CommandArgument[]): Promise<number>;
+}
+
+declare class ListStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    lpush(key: string, element: unknown, ...elements: unknown[]): Promise<number>;
+    lpushMany(key: string, elements: readonly unknown[]): Promise<number>;
+    rpush(key: string, element: unknown, ...elements: unknown[]): Promise<number>;
+    rpushMany(key: string, elements: readonly 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<number | number[] | null>;
+    linsert(key: string, where: "BEFORE" | "AFTER", pivot: unknown, element: unknown): Promise<number>;
+    lmove<T = unknown>(source: string, destination: string, from: "LEFT" | "RIGHT", to: "LEFT" | "RIGHT"): Promise<T | null>;
+    rpoplpush<T = unknown>(source: string, destination: string): Promise<T | null>;
+    lpushx(key: string, element: unknown, ...elements: unknown[]): Promise<number>;
+    lpushxMany(key: string, elements: readonly unknown[]): Promise<number>;
+    rpushx(key: string, element: unknown, ...elements: unknown[]): Promise<number>;
+    rpushxMany(key: string, elements: readonly unknown[]): Promise<number>;
+    blpop(keys: string[], timeoutSeconds: number): Promise<unknown>;
+    brpop(keys: string[], timeoutSeconds: number): Promise<unknown>;
+    blmove<T = unknown>(source: string, destination: string, from: "LEFT" | "RIGHT", to: "LEFT" | "RIGHT", timeoutSeconds: number): Promise<T | null>;
+    blmpop(timeoutSeconds: number, keys: string[], from: "LEFT" | "RIGHT", options?: {
+        count?: number;
+    }): 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, member: unknown, ...members: unknown[]): Promise<number>;
+    zremMany(key: string, members: readonly 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<T = unknown>(key: string): Promise<T | null>;
+    zrandmember<T = unknown>(key: string, count: number, withScores?: false): Promise<(T | null)[]>;
+    zrandmember(key: string, count: number, withScores: boolean): Promise<unknown[]>;
+    zmscore(key: string, members: unknown[]): Promise<(string | null)[]>;
+    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<T = unknown>(key: string, cursor: string | number, options?: CollectionScanOptions): Promise<SortedSetScanResult<T>>;
+}
+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: readonly string[]): Promise<number>;
+    xdel(key: string, id: 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: readonly string[]): Promise<number>;
+    xack(key: string, group: string, id: 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): Promise<number>;
+    bitcount(key: string, start: number, end: number, unit?: "BYTE" | "BIT"): Promise<number>;
+    bitpos(key: string, bit: 0 | 1): Promise<number>;
+    bitpos(key: string, bit: 0 | 1, start: number): 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: readonly string[]): 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>;
+    pfaddMany(key: string, elements: readonly unknown[]): Promise<number>;
+    pfcount(keys: readonly string[]): Promise<IntegerReply>;
+    pfcount(key: string, ...keys: string[]): Promise<IntegerReply>;
+    pfmerge(destination: string, sources: readonly string[]): Promise<boolean>;
+    pfmerge(destination: string, source: string, ...sources: string[]): Promise<boolean>;
+}
+
+declare class SetStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    sadd(key: string, member: unknown, ...members: unknown[]): Promise<number>;
+    saddMany(key: string, members: readonly unknown[]): Promise<number>;
+    srem(key: string, member: unknown, ...members: unknown[]): Promise<number>;
+    sremMany(key: string, members: readonly unknown[]): Promise<number>;
+    smembers<T = unknown>(key: string): Promise<(T | null)[]>;
+    sismember(key: string, member: unknown): Promise<boolean>;
+    smismember(key: string, members: unknown[]): Promise<number[]>;
+    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<T = unknown>(key: string, cursor: string | number, options?: CollectionScanOptions): Promise<SetScanResult<T>>;
+}
+
+interface StoreCommandClient {
+    readonly codec: Codec;
+    command(...args: CommandArgument[]): Promise<unknown>;
+    commandArgs?(args: readonly CommandArgument[]): Promise<unknown>;
+}
+/** An exact integer reply: safe values are numbers and larger int64 values are bigints. */
+type IntegerReply = number | bigint;
+/** Flat field/value pairs returned with a scan cursor. */
+type HashScanResult<T = unknown> = [cursor: string, entries: (string | T | null)[]];
+/** Decoded set members returned with a scan cursor. */
+type SetScanResult<T = unknown> = [cursor: string, members: (T | null)[]];
+/** Flat member/score pairs returned with a scan cursor. */
+type SortedSetScanResult<T = unknown> = [cursor: string, entries: (T | null | string)[]];
+/** SET accepts one condition and at most one expiry mode. */
+type SetOptions = {
+    get?: boolean;
+} & ({
+    nx?: boolean;
+    xx?: false;
+} | {
+    nx?: false;
+    xx?: boolean;
+}) & ({
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    keepTtl?: boolean;
+} | {
+    ex?: number;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    keepTtl?: false;
+} | {
+    ex?: never;
+    px?: number;
+    exat?: never;
+    pxat?: never;
+    keepTtl?: false;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: number;
+    pxat?: never;
+    keepTtl?: false;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat?: number;
+    keepTtl?: false;
+});
+/** GETEX/HGETEX accept at most one expiry mutation. */
+type GetExOptions = {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    persist?: false;
+} | {
+    ex: number;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    persist?: false;
+} | {
+    ex?: never;
+    px: number;
+    exat?: never;
+    pxat?: never;
+    persist?: false;
+} | {
+    ex?: never;
+    px?: never;
+    exat: number;
+    pxat?: never;
+    persist?: false;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat: number;
+    persist?: false;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    persist: true;
+};
+interface ScanOptions {
+    match?: string;
+    count?: number;
+    /** Filter keys by the server-reported data type. */
+    type?: string;
+}
+/** MATCH/COUNT options supported by collection-specific scan commands. */
+type CollectionScanOptions = Omit<ScanOptions, "type">;
+type ExpiryCondition = "NX" | "XX" | "GT" | "LT";
+interface ZAddMember {
+    score: number;
+    member: unknown;
+}
+/** ZADD condition and comparison flags must form a valid server grammar. */
+type ZAddOptions = {
+    ch?: boolean;
+} & ({
+    nx?: boolean;
+    xx?: false;
+    gt?: false;
+    lt?: false;
+} | ({
+    nx?: false;
+    xx?: boolean;
+} & ({
+    gt?: boolean;
+    lt?: false;
+} | {
+    gt?: false;
+    lt?: boolean;
+})));
+interface RangeLimit {
+    offset: number;
+    count: number;
+}
+interface XReadStream {
+    key: string;
+    id: string;
+}
+interface GeoMember {
+    longitude: number;
+    latitude: number;
+    member: unknown;
+}
+/** GEOADD NX and XX are mutually exclusive. */
+type GeoAddOptions = {
+    ch?: boolean;
+} & ({
+    nx?: boolean;
+    xx?: false;
+} | {
+    nx?: false;
+    xx?: boolean;
+});
+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: readonly string[]): Promise<number>;
+    hdel(key: string, field: string, ...fields: string[]): Promise<number>;
+    hmget<T = unknown>(key: string, fields: string[]): Promise<(T | null)[]>;
+    hgetall<T = unknown>(key: string): Promise<Record<string, T | null>>;
+    hexists(key: string, field: string): Promise<boolean>;
+    hkeys(key: string): Promise<string[]>;
+    hvals<T = unknown>(key: string): Promise<(T | null)[]>;
+    hlen(key: string): Promise<number>;
+    hincrby(key: string, field: string, increment: number | bigint): Promise<IntegerReply>;
+    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): Promise<string | null>;
+    hrandfield(key: string, count: number, withValues?: false): Promise<string[]>;
+    hrandfield<T = unknown>(key: string, count: number, withValues: true): Promise<(string | T | null)[]>;
+    hrandfield<T = unknown>(key: string, count: number, withValues: boolean): Promise<string[] | (string | T | null)[]>;
+    hscan<T = unknown>(key: string, cursor: string | number, options?: CollectionScanOptions): Promise<HashScanResult<T>>;
+    hexpire(key: string, seconds: number, fields: string[]): Promise<number[]>;
+    httl(key: string, fields: string[]): Promise<IntegerReply[]>;
+    hpersist(key: string, fields: string[]): Promise<number[]>;
+    hpexpire(key: string, milliseconds: number, fields: string[]): Promise<number[]>;
+    hpttl(key: string, fields: string[]): Promise<IntegerReply[]>;
+    hexpiretime(key: string, fields: string[]): Promise<IntegerReply[]>;
+    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>;
+}
+
+type TopKReserveOptions = {
+    width?: never;
+    depth?: never;
+} | {
+    width: number;
+    depth: number;
+};
+interface CountMinMergeOptions {
+    weights?: readonly (number | bigint)[];
+}
+interface TDigestCreateOptions {
+    compression?: number;
+}
+interface TDigestMergeOptions extends TDigestCreateOptions {
+    override?: 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, element: unknown, ...elements: unknown[]): Promise<number[]>;
+    maddMany(key: string, elements: readonly unknown[]): Promise<number[]>;
+    exists(key: string, element: unknown): Promise<boolean>;
+    mexists(key: string, element: unknown, ...elements: unknown[]): Promise<number[]>;
+    mexistsMany(key: string, elements: readonly unknown[]): Promise<number[]>;
+    card(key: string): Promise<IntegerReply>;
+    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, element: unknown, ...elements: unknown[]): Promise<number[]>;
+    mexistsMany(key: string, elements: readonly unknown[]): Promise<number[]>;
+    count(key: string, element: unknown): Promise<IntegerReply>;
+    info(key: string): Promise<unknown[]>;
 }
-interface ReadOptions {
-    partitionKey?: string;
-    count?: number;
-    fromMs?: number;
-    toMs?: number;
-    rev?: boolean;
-    state?: string;
-    terminalOnly?: boolean;
-    includeCold?: boolean;
-    consistentProjection?: boolean;
+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 | bigint][]): Promise<IntegerReply[]>;
+    query(key: string, item: unknown, ...items: unknown[]): Promise<IntegerReply[]>;
+    queryMany(key: string, items: readonly unknown[]): Promise<IntegerReply[]>;
+    merge(destination: string, sources: readonly string[], options?: CountMinMergeOptions): Promise<boolean>;
+    info(key: string): Promise<unknown[]>;
 }
-type SearchStateMeta = StateMeta | Record<string, StateMeta>;
-interface SearchOptions extends ReadOptions {
-    attributes?: Record<string, CommandArgument>;
-    stateMeta?: SearchStateMeta;
+declare class TopKStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    reserve(key: string, k: number, options?: TopKReserveOptions): Promise<boolean>;
+    add<T = unknown>(key: string, element: unknown, ...elements: unknown[]): Promise<(T | null)[]>;
+    addMany<T = unknown>(key: string, elements: readonly unknown[]): Promise<(T | null)[]>;
+    incrBy<T = unknown>(key: string, entries: [unknown, number | bigint][]): Promise<(T | null)[]>;
+    query(key: string, element: unknown, ...elements: unknown[]): Promise<number[]>;
+    queryMany(key: string, elements: readonly unknown[]): Promise<number[]>;
+    count(key: string, element: unknown, ...elements: unknown[]): Promise<IntegerReply[]>;
+    countMany(key: string, elements: readonly unknown[]): Promise<IntegerReply[]>;
+    list<T = unknown>(key: string, options?: {
+        withCount?: boolean;
+    }): Promise<(T | IntegerReply | null)[]>;
+    info(key: string): Promise<unknown[]>;
 }
-type ManagementPairs = Record<string, CommandArgument>;
-declare class FerricStoreClient {
-    readonly executor: CommandExecutor;
-    readonly codec: Codec;
-    readonly backpressure: Required<BackpressurePolicy>;
+declare class TDigestStore {
+    private readonly client;
+    constructor(client: StoreCommandClient);
+    create(key: string, options?: TDigestCreateOptions): Promise<boolean>;
+    add(key: string, values: readonly number[]): Promise<boolean>;
+    add(key: string, value: number, ...values: number[]): Promise<boolean>;
+    reset(key: string): Promise<boolean>;
+    quantile(key: string, quantiles: readonly number[]): Promise<string[]>;
+    quantile(key: string, quantile: number, ...quantiles: number[]): Promise<string[]>;
+    cdf(key: string, values: readonly number[]): Promise<string[]>;
+    cdf(key: string, value: number, ...values: number[]): Promise<string[]>;
+    rank(key: string, values: readonly number[]): Promise<IntegerReply[]>;
+    rank(key: string, value: number, ...values: number[]): Promise<IntegerReply[]>;
+    revrank(key: string, values: readonly number[]): Promise<IntegerReply[]>;
+    revrank(key: string, value: number, ...values: number[]): Promise<IntegerReply[]>;
+    byrank(key: string, ranks: readonly number[]): Promise<string[]>;
+    byrank(key: string, rank: number, ...ranks: number[]): Promise<string[]>;
+    byrevrank(key: string, ranks: readonly number[]): Promise<string[]>;
+    byrevrank(key: string, rank: number, ...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 FerricStoreClientCore extends FerricStoreAdministrationClient {
+    protected extendLeaseOkResponseSupport?: boolean | "probing";
     readonly bitmap: BitmapStore;
     readonly bloom: BloomFilterStore;
     readonly cms: CountMinSketchStore;
@@ -968,7 +1665,6 @@ declare class FerricStoreClient {
     readonly geo: GeoStore;
     readonly hash: HashStore;
     readonly hyperloglog: HyperLogLogStore;
-    readonly json: JsonStore;
     readonly kv: KeyValueStore;
     readonly lists: ListStore;
     readonly sets: SetStore;
@@ -977,13 +1673,6 @@ declare class FerricStoreClient {
     readonly topk: TopKStore;
     readonly zset: SortedSetStore;
     constructor(executor: CommandExecutor, options?: FerricStoreClientOptions);
-    static fromUrl(url: string, options?: FerricStoreClientFromUrlOptions): Promise<FerricStoreClient>;
-    static fromUrls(urls: readonly string[], options?: FerricStoreClientFromUrlOptions): Promise<FerricStoreClient>;
-    command(...args: CommandArgument[]): Promise<unknown>;
-    pipeline(commands: readonly Command[]): Promise<unknown[]>;
-    close(): Promise<void>;
-    refreshTopology(): Promise<RoutingTopology>;
-    route(key: string | Buffer): Promise<RoutingRoute>;
     ping(message?: CommandArgument): Promise<unknown>;
     echo(message: CommandArgument): Promise<unknown>;
     serverInfo(section?: string): Promise<string>;
@@ -1010,7 +1699,7 @@ declare class FerricStoreClient {
     clientList(options?: {
         type?: string;
     }): Promise<string>;
-    clientTracking(mode: "ON" | "OFF", options?: {
+    clientTracking(_mode: "ON" | "OFF", _options?: {
         redirect?: number;
         prefixes?: string[];
         bcast?: boolean;
@@ -1018,7 +1707,7 @@ declare class FerricStoreClient {
         optout?: boolean;
         noloop?: boolean;
     }): Promise<boolean>;
-    clientCaching(mode: "YES" | "NO"): Promise<boolean>;
+    clientCaching(_mode: "YES" | "NO"): Promise<boolean>;
     clientTrackingInfo(): Promise<unknown>;
     clientGetRedir(): Promise<number>;
     save(): Promise<boolean>;
@@ -1057,119 +1746,156 @@ declare class FerricStoreClient {
     }): Promise<FetchOrComputeResult<T>>;
     fetchOrComputeResult(key: string, value: unknown, options: {
         ttlMs: number;
+        computeToken: Buffer$1;
     }): 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;
+    fetchOrComputeError(key: string, message: string, options: {
+        computeToken: Buffer$1;
     }): 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>;
-    capabilities(): Promise<Record<string, unknown>>;
-    ensureNamespace(prefix: string, attrs?: ManagementPairs): Promise<unknown>;
-    getNamespace(prefix: string): Promise<unknown>;
-    listNamespaces(): Promise<unknown>;
-    deleteNamespace(prefix: string): Promise<unknown>;
-    setQuota(namespace: string, quotaSpec?: ManagementPairs): Promise<unknown>;
-    getQuota(namespace: string): Promise<unknown>;
-    quotaUsage(namespace: string): Promise<unknown>;
-    clusterInfo(): Promise<Record<string, unknown>>;
-    namespaceUsage(prefix: string): Promise<Record<string, unknown>>;
-    flowQuery(attrs?: ManagementPairs): Promise<unknown[]>;
-    flowHistory(id: string, attrs?: ManagementPairs): Promise<unknown[]>;
-    invocationDefinitionPut(definition: Record<string, unknown> | string, options?: RequestContextOptions): Promise<unknown>;
-    invocationDefinitionGet(name: string, options?: RequestContextOptions): Promise<unknown>;
-    invocationDefinitionList(options?: RequestContextOptions): Promise<unknown[]>;
-    invocationCreate(name: string, attrs: Record<string, unknown>, options?: InvocationCreateOptions): Promise<unknown>;
-    invocationGet(id: string, options?: RequestContextOptions): Promise<unknown>;
-    invocationPartitionList(name: string, options?: RequestContextOptions & {
-        scope?: string;
-    }): 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?: {
+}
+
+/** @internal Administrative and governance commands kept off the primary Flow client surface. */
+declare class FerricStoreManagementClient extends FerricStoreClientCore {
+    stats(type: string, options?: FlowStatsOptions): Promise<FlowAdminRecord>;
+    countByState(type: string, state: string, options?: Omit<FlowStatsOptions, "state" | "count">): Promise<number>;
+    attributes(type: string, options?: AttributeQueryOptions): Promise<FlowAdminRecord[]>;
+    attributeValues(type: string, attribute: string, options?: AttributeQueryOptions): Promise<FlowAdminRecord[]>;
+    scheduleCreate(id: string, options: ScheduleOptions): Promise<FlowAdminRecord>;
+    scheduleGet(id: string, options?: {
+        nowMs?: number;
+    }): Promise<FlowAdminRecord | null>;
+    scheduleFire(id: string, options?: {
+        nowMs?: number;
+    }): Promise<FlowAdminRecord>;
+    schedulePause(id: string, options?: {
+        nowMs?: number;
+    }): Promise<FlowAdminRecord>;
+    scheduleResume(id: string, options?: {
+        nowMs?: number;
+    }): Promise<FlowAdminRecord>;
+    scheduleDelete(id: string, options?: {
+        nowMs?: number;
+    }): Promise<FlowAdminRecord>;
+    scheduleFireDue(options?: ScheduleFireDueOptions): Promise<FlowAdminRecord>;
+    scheduleList(options?: ScheduleListOptions): Promise<FlowAdminRecord[]>;
+    private scheduleStatus;
+    effectReserve(id: string, effectKey: string, effectType: string, options: EffectReserveOptions): Promise<FlowAdminRecord>;
+    effectConfirm(id: string, effectKey: string, options?: EffectConfirmOptions): Promise<FlowAdminRecord>;
+    effectFail(id: string, effectKey: string, options?: EffectFailOptions): Promise<FlowAdminRecord>;
+    effectCompensate(id: string, effectKey: string, options?: EffectCompensateOptions): Promise<FlowAdminRecord>;
+    effectGet(id: string, effectKey: string, options?: {
         partitionKey?: string;
-        ownerFlowId?: string;
-        name?: string;
-        override?: boolean;
-        ttlMs?: number;
+    }): Promise<FlowAdminRecord | null>;
+    private effectStatus;
+    approvalRequest(id: string, options: ApprovalRequestOptions): Promise<FlowAdminRecord>;
+    approvalApprove(id: string, options: {
+        approver: string;
+        reason?: string;
         nowMs?: number;
-    }): Promise<unknown>;
-    valueMGet(refs: string[], options?: {
-        maxBytes?: number;
-    }): Promise<unknown[]>;
-    signal(id: string, options: {
-        signal: string;
+    }): Promise<FlowAdminRecord>;
+    approvalReject(id: string, options: {
+        approver: string;
+        reason?: string;
+        nowMs?: number;
+    }): Promise<FlowAdminRecord>;
+    private approvalStatus;
+    approvalGet(id: string): Promise<FlowAdminRecord | null>;
+    approvalList(options?: ApprovalListOptions): Promise<FlowAdminRecord[]>;
+    governanceOverview(options?: ApprovalListOptions): Promise<FlowAdminRecord>;
+    circuitOpen(scope: string, options?: CircuitOpenOptions): Promise<FlowAdminRecord>;
+    circuitClose(scope: string, options?: {
+        nowMs?: number;
+    }): Promise<FlowAdminRecord>;
+    circuitGet(scope: string): Promise<FlowAdminRecord | null>;
+    budgetReserve(scope: string, amount: number, options?: BudgetReserveOptions): Promise<FlowAdminRecord>;
+    budgetCommit(scope: string, reservationId: string, actualAmount: number, options?: BudgetCommitOptions): Promise<FlowAdminRecord>;
+    budgetRelease(scope: string, reservationId: string, options?: {
+        nowMs?: number;
+    }): Promise<FlowAdminRecord>;
+    budgetGet(scope: string): Promise<FlowAdminRecord | null>;
+    budgetList(options?: AdminListOptions): Promise<FlowAdminRecord[]>;
+    limitLease(scope: string, options: LimitLeaseOptions): Promise<FlowAdminRecord>;
+    limitSpend(scope: string, options: LimitAmountOptions): Promise<FlowAdminRecord>;
+    limitRelease(scope: string, options: LimitReleaseOptions): Promise<FlowAdminRecord>;
+    limitGet(scope: string, options?: {
+        nowMs?: number;
+    }): Promise<FlowAdminRecord | null>;
+    limitList(options?: LimitListOptions): Promise<FlowAdminRecord[]>;
+    governanceLedger(id: string, options?: GovernanceLedgerOptions): Promise<FlowAdminRecord[]>;
+}
+
+/** @internal Read, policy, and shared Flow helpers kept off the primary implementation module. */
+declare class FerricStoreFlowSupportClient extends FerricStoreManagementClient {
+    rewind(id: string, options?: {
         partitionKey?: string;
-        idempotencyKey?: string;
-        ifState?: string | string[];
-        transitionTo?: string;
-        runAtMs?: number;
+        toEvent?: string;
+        expectState?: string;
         nowMs?: number;
-        priority?: number;
+        returnRecord?: boolean;
+    }): Promise<FlowRecord | Buffer$1 | unknown>;
+    get<TPayload = unknown>(id: string, options?: {
+        partitionKey?: string;
+        full?: boolean;
+        payload?: boolean;
+        payloadMaxBytes?: number;
+        values?: readonly string[];
+        valueMaxBytes?: number;
+    }): Promise<FlowRecord<TPayload> | undefined>;
+    list(type: string, options?: ReadOptions): Promise<FlowRecord[]>;
+    search(type: string, options?: SearchOptions): 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?: HistoryOptions): Promise<unknown[]>;
+    spawnChildren(parentId: string, children: ChildSpec[], options?: {
+        groupId?: string;
+        partitionKey?: string;
+        leaseToken?: Buffer$1;
+        fencingToken?: FencingToken;
+        wait?: string;
+        waitState?: string;
+        success?: string;
+        failure?: string;
+        fromState?: string;
+        nowMs?: number;
+        onChildFailed?: string;
+        onParentClosed?: string;
+        maxActiveMs?: MaxActiveMs;
         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;
+    installPolicy(type: string, options?: FlowPolicyOptions): Promise<unknown>;
+    policyGet(type: string, options?: {
+        state?: string;
+    }): Promise<Record<string, unknown>>;
+    retentionCleanup(): Promise<Record<string, unknown>>;
+    protected executeProducerWrite(args: CommandArgument[]): Promise<unknown>;
+    protected recordOrGet(response: unknown, id: string, partitionKey: string | undefined): Promise<FlowRecord>;
+    protected records(values: unknown[]): FlowRecord[];
+    protected recordsOrResponse(value: unknown): unknown[] | unknown;
+    protected flowManyLimitError(operation: string): Error;
+    protected executeIndependentManyChunks<T>(operation: string, items: readonly T[], capture: (item: T) => T, execute: (batchItems: T[]) => Promise<unknown[] | unknown>): Promise<unknown[]>;
+    private indexQuery;
+    protected appendPartitionOptions(args: CommandArgument[], options: {
         partitionKey?: string;
-        nowMs?: number;
-    }): Promise<FlowRecord>;
+        partitionKeys?: string[];
+    }): void;
+}
+
+declare class FerricStoreMutationClient extends FerricStoreFlowSupportClient {
     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[];
-        stateMeta?: StateMeta;
-        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[];
-        stateMeta?: StateMeta;
-        runAtMs?: number;
-        nowMs?: number;
-        priority?: number;
-        independent?: boolean;
-    }): Promise<unknown[] | unknown>;
+    completeMany(partitionKey: string | undefined, items: ClaimedItem[], options?: CompleteManyOptions): Promise<unknown[] | unknown>;
+    protected completeManyRequest(partitionKey: string | undefined, items: ClaimedItem[], options: CompleteManyOptions): CommandArgument[];
+    completeJobs(jobs: ClaimedItem[], options?: CompleteManyOptions): Promise<unknown[] | unknown>;
     retry(id: string, options: RetryOptions): Promise<FlowRecord | Buffer | unknown>;
     retryMany(partitionKey: string | undefined, items: ClaimedItem[], options?: {
         error?: unknown;
@@ -1178,10 +1904,13 @@ declare class FerricStoreClient {
         valueRefs?: Record<string, string>;
         dropValues?: string[];
         overrideValues?: string[];
+        attributesMerge?: Record<string, CommandArgument>;
+        attributesDelete?: string[];
         stateMeta?: StateMeta;
         runAtMs?: number;
         nowMs?: number;
         independent?: boolean;
+        returnOkOnSuccess?: boolean;
     }): Promise<unknown[] | unknown>;
     fail(id: string, options: FailOptions): Promise<FlowRecord | Buffer | unknown>;
     failMany(partitionKey: string | undefined, items: ClaimedItem[], options?: {
@@ -1191,121 +1920,112 @@ declare class FerricStoreClient {
         valueRefs?: Record<string, string>;
         dropValues?: string[];
         overrideValues?: string[];
+        attributesMerge?: Record<string, CommandArgument>;
+        attributesDelete?: string[];
         stateMeta?: StateMeta;
         ttlMs?: number;
         nowMs?: number;
         independent?: boolean;
+        returnOkOnSuccess?: boolean;
     }): Promise<unknown[] | unknown>;
     cancel(id: string, options: CancelOptions): Promise<FlowRecord | Buffer | unknown>;
     cancelMany(partitionKey: string | undefined, items: FencedItem[], options?: {
         reason?: unknown;
+        values?: Record<string, unknown>;
+        valueRefs?: Record<string, string>;
+        dropValues?: string[];
+        overrideValues?: string[];
+        attributesMerge?: Record<string, CommandArgument>;
+        attributesDelete?: string[];
         stateMeta?: StateMeta;
         ttlMs?: number;
         nowMs?: number;
         independent?: boolean;
     }): Promise<unknown[] | unknown>;
-    rewind(id: string, options?: {
-        partitionKey?: string;
-        toEvent?: string;
-        expectState?: string;
-        nowMs?: number;
-        returnRecord?: boolean;
+}
+
+declare class FerricStoreClaimClient extends FerricStoreMutationClient {
+    claimDue(type: string, options: ClaimDueOptions): Promise<(FlowRecord | ClaimedItem)[]>;
+    private claimDueRequest;
+    private claimDueResponse;
+    claimJobs(type: string, options: Omit<ClaimDueOptions, "jobOnly">): Promise<ClaimedItem[]>;
+    reclaim(type: string, options: ReclaimOptions): Promise<(FlowRecord | ClaimedItem)[]>;
+    private claimedItems;
+    extendLease(id: string, options: ExtendLeaseOptions & {
+        readonly returnOkOnSuccess: true;
+    }): Promise<boolean>;
+    extendLease(id: string, options: ExtendLeaseOptions & {
+        readonly returnOkOnSuccess?: false;
+    }): Promise<FlowRecord>;
+    extendLease(id: string, options: ExtendLeaseOptions): Promise<FlowRecord | boolean>;
+    /**
+     * Complete leased jobs and claim replacements through one ordered pipeline
+     * when both commands can use the same route. Item errors are returned beside
+     * any newly leased jobs so callers cannot accidentally discard those leases.
+     */
+    completeJobsAndClaimJobs(jobs: ClaimedItem[], type: string, claimOptions: ClaimDueOptions, completeOptions?: Omit<CompleteManyOptions, "returnOkOnSuccess">): Promise<CompleteJobsAndClaimJobsResult>;
+    completeFlowsAndClaimFlows(jobs: ClaimedItem[], type: string, claimOptions: ClaimDueOptions, completeOptions?: Omit<CompleteManyOptions, "returnOkOnSuccess">): Promise<CompleteJobsAndClaimJobsResult>;
+}
+
+/** Producer-oriented Flow commands, separated from mutation and claim APIs. */
+declare class FerricStoreProducerClient extends FerricStoreClaimClient {
+    create(id: string, options: CreateOptions): Promise<FlowRecord | Buffer | unknown>;
+    enqueue(id: string, options: Omit<CreateOptions, "state"> & {
+        state?: string;
     }): 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[]>;
-    search(type: string, options?: SearchOptions): 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?: {
+    enqueueMany(items: CreateItem[], options: CreateManyOptions): Promise<unknown[] | unknown>;
+    createMany(partitionKey: string | undefined, items: CreateItem[], options: CreateManyOptions): Promise<unknown[] | unknown>;
+}
+
+declare class FerricStoreClient extends FerricStoreProducerClient {
+    static fromUrl(url: string, options?: FerricStoreClientFromUrlOptions): Promise<FerricStoreClient>;
+    static fromUrls(urls: readonly string[], options?: FerricStoreClientFromUrlOptions): Promise<FerricStoreClient>;
+    valuePut(value: unknown, options?: {
         partitionKey?: string;
-        count?: number;
-        olderThanMs?: number;
+        ownerFlowId?: string;
+        name?: string;
+        override?: boolean;
+        ttlMs?: number;
         nowMs?: number;
-    }): Promise<FlowRecord[]>;
-    history(id: string, options?: {
-        partitionKey?: string;
-        count?: number;
-        fromEvent?: string;
-        rev?: boolean;
+    }): Promise<unknown>;
+    valueMGet(refs: string[], options?: {
+        maxBytes?: number;
     }): Promise<unknown[]>;
-    spawnChildren(parentId: string, children: ChildSpec[], options?: {
-        groupId?: string;
+    signal(id: string, options: {
+        signal: string;
         partitionKey?: string;
-        leaseToken?: Buffer;
-        fencingToken?: number;
-        wait?: string;
-        waitState?: string;
-        success?: string;
-        failure?: string;
-        fromState?: string;
+        idempotencyKey?: string;
+        ifState?: string | string[];
+        transitionTo?: string;
+        runAtMs?: number;
         nowMs?: number;
-        onChildFailed?: string;
-        onParentClosed?: string;
         values?: Record<string, unknown>;
         valueRefs?: Record<string, string>;
+        dropValues?: string[];
+        overrideValues?: string[];
     }): Promise<unknown>;
-    installPolicy(type: string, options?: FlowPolicyOptions): 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;
-    });
+    flowSignal(id: string, options: Parameters<FerricStoreClient["signal"]>[1]): Promise<unknown>;
+    startAndClaim(id: string, options: StartAndClaimOptions): Promise<FlowRecord>;
+    stepContinue(id: string, options: StepContinueOptions): Promise<FlowRecord | ClaimedItem>;
+    runStepsMany(items: readonly (string | RunStepsItem)[], options: RunStepsManyOptions): Promise<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[];
+        attributesMerge?: Record<string, CommandArgument>;
+        attributesDelete?: string[];
+        stateMeta?: StateMeta;
+        runAtMs?: number;
+        nowMs?: number;
+        priority?: number;
+        independent?: boolean;
+    }): Promise<unknown[] | unknown>;
 }
-declare function classifyServerError(message: string, raw?: unknown, cause?: unknown): FerricStoreError;
-declare function mapException(error: unknown): unknown;
 
 type Outcome = TransitionOutcome | CompleteOutcome | RetryOutcome | FailOutcome;
 interface NamedValueMutation {
@@ -1313,6 +2033,8 @@ interface NamedValueMutation {
     valueRefs?: Record<string, string>;
     dropValues?: string[];
     overrideValues?: string[];
+    attributesMerge?: Record<string, CommandArgument>;
+    attributesDelete?: string[];
     stateMeta?: StateMeta;
 }
 interface TransitionOutcome extends NamedValueMutation {
@@ -1344,6 +2066,40 @@ declare function transition(toState: string, options?: Omit<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;
+declare function isOutcome(value: unknown): value is Outcome;
+
+/** Raised when a worker loses the ability to renew a claimed job's lease. */
+declare class LeaseRenewalError extends Error {
+    constructor(cause: unknown);
+}
+
+declare class QueueWorker {
+    readonly queue: Queue;
+    readonly options: WorkerConfig;
+    private readonly pendingCompletions;
+    constructor(queue: Queue, options: WorkerConfig);
+    runOnce(handler: QueueHandler): Promise<QueueWorkerResult>;
+    private runHandlerClaimOnce;
+    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 runContinuously;
+    private claimJobs;
+    private applyJob;
+    private applyContinuousJob;
+    private guardContinuousJob;
+    private flushCompletions;
+}
+
+/** Async terminal-write failure with the number of durable successes drained first. */
+declare class QueueCompletionError extends Error {
+    readonly completed: number;
+    constructor(cause: unknown, completed: number);
+}
 
 type QueueJob = FlowRecord | ClaimedItem;
 type QueueHandler = (job: QueueJob) => Promise<unknown> | unknown;
@@ -1371,6 +2127,7 @@ declare class Queue {
     readonly defaultWorker: string;
     constructor(client: FerricStoreClient, options: QueueOptions);
     enqueue(id: string, options?: {
+        attributes?: Record<string, CommandArgument>;
         payload?: unknown;
         partitionKey?: string;
         runAtMs?: number;
@@ -1378,45 +2135,93 @@ declare class Queue {
         priority?: number;
         idempotent?: boolean;
         retentionTtlMs?: number;
+        maxActiveMs?: MaxActiveMs;
         values?: Record<string, unknown>;
         valueRefs?: Record<string, string>;
         stateMeta?: StateMeta;
         returnRecord?: boolean;
     }): Promise<FlowRecord | Buffer | unknown>;
     enqueueMany(items: CreateItem[], options?: {
+        attributes?: Record<string, CommandArgument>;
         partitionKey?: string;
+        autoPartitionBatchSize?: number;
+        autoPartitionConcurrency?: number;
         runAtMs?: number;
         nowMs?: number;
         priority?: number;
         idempotent?: boolean;
         independent?: boolean;
         retentionTtlMs?: number;
+        maxActiveMs?: MaxActiveMs;
         values?: Record<string, unknown>;
         valueRefs?: Record<string, string>;
         stateMeta?: StateMeta;
     }): 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;
+
+declare class WorkflowContext {
+    readonly workflow: Workflow;
+    readonly job: FlowRecord | ClaimedItem;
+    readonly stateName: string;
+    readonly flow: WorkflowFlowCommands;
+    private readonly leaseJob;
+    private readonly valueCache;
+    constructor(workflow: Workflow, job: FlowRecord | ClaimedItem, stateName: string, leaseJob?: ClaimedItem);
+    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 stateMeta(): Record<string, unknown>;
+    get indexedStateMeta(): string | undefined;
+    get valueRefs(): Record<string, unknown>;
+    get leaseToken(): Buffer;
+    get fencingToken(): FencingToken;
+    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>;
+    stepContinue(toState: string, options?: Partial<Omit<StepContinueOptions, "toState" | "fromState" | "leaseToken" | "fencingToken">> & {
+        fromState?: string;
+    }): Promise<FlowRecord | ClaimedItem>;
+    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>;
 }
 
 type WorkflowHandler = (ctx: WorkflowContext) => Promise<Outcome | void | unknown> | Outcome | void | unknown;
@@ -1425,7 +2230,7 @@ interface StateOptions {
     leaseMs?: number;
     claimPayload?: boolean;
     claimRecord?: boolean;
-    claimValues?: string[];
+    claimValues?: readonly string[];
     valueMaxBytes?: number;
     exceptionPolicy?: ExceptionPolicy;
     retryPolicy?: RetryPolicy;
@@ -1444,18 +2249,19 @@ interface WorkflowWorkerResult {
     emptyClaims: number;
 }
 interface StateRegistration {
-    claimValues?: string[];
-    claimPayload: boolean;
-    claimRecord: boolean;
-    exceptionPolicy: ExceptionPolicy;
-    handler: WorkflowHandler;
-    leaseMs: number;
-    mode?: FlowStateMode;
-    name: string;
-    returnRecord: boolean;
-    retryPolicy?: RetryPolicy;
-    valueMaxBytes?: number;
+    readonly claimValues?: readonly string[];
+    readonly claimPayload: boolean;
+    readonly claimRecord: boolean;
+    readonly exceptionPolicy: ExceptionPolicy;
+    readonly handler: WorkflowHandler;
+    readonly leaseMs: number;
+    readonly mode?: FlowStateMode;
+    readonly name: string;
+    readonly returnRecord: boolean;
+    readonly retryPolicy?: Readonly<RetryPolicy>;
+    readonly valueMaxBytes?: number;
 }
+
 declare class WorkflowClient {
     readonly flow: FerricStoreClient;
     constructor(flow: FerricStoreClient);
@@ -1473,6 +2279,7 @@ declare class Workflow {
     constructor(client: FerricStoreClient, options: WorkflowOptions);
     state(name: string, handler: WorkflowHandler, options?: StateOptions): this;
     start(id: string, options?: {
+        attributes?: Record<string, CommandArgument>;
         payload?: unknown;
         state?: string;
         partitionKey?: string;
@@ -1484,19 +2291,26 @@ declare class Workflow {
         priority?: number;
         idempotent?: boolean;
         retentionTtlMs?: number;
+        maxActiveMs?: MaxActiveMs;
         values?: Record<string, unknown>;
         valueRefs?: Record<string, string>;
         stateMeta?: StateMeta;
         returnRecord?: boolean;
     }): Promise<FlowRecord | Buffer | unknown>;
+    startAndClaim(id: string, options: Omit<StartAndClaimOptions, "type" | "initialState"> & {
+        initialState?: string;
+    }): Promise<FlowRecord>;
+    runStepsMany(items: readonly (string | RunStepsItem)[], options: Omit<RunStepsManyOptions, "type">): Promise<unknown>;
     startMany(items: {
         id: string;
         payload?: unknown;
         partitionKey?: string;
+        attributes?: Record<string, CommandArgument>;
         values?: Record<string, unknown>;
         valueRefs?: Record<string, string>;
         stateMeta?: StateMeta;
     }[], options?: {
+        attributes?: Record<string, CommandArgument>;
         state?: string;
         partitionKey?: string;
         runAtMs?: number;
@@ -1505,6 +2319,7 @@ declare class Workflow {
         idempotent?: boolean;
         independent?: boolean;
         retentionTtlMs?: number;
+        maxActiveMs?: MaxActiveMs;
         values?: Record<string, unknown>;
         valueRefs?: Record<string, string>;
         stateMeta?: StateMeta;
@@ -1519,65 +2334,6 @@ declare class Workflow {
     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 stateMeta(): Record<string, unknown>;
-    get indexedStateMeta(): string | undefined;
-    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 & {
@@ -1588,8 +2344,22 @@ declare class WorkflowWorker {
     });
     runOnce(): Promise<WorkflowWorkerResult>;
     run(): Promise<void>;
+    private runInWaves;
+    private runContinuously;
+    private resolveStates;
+    private claimState;
     private applyJob;
     private applyHandlerError;
 }
 
-export { type AutoBatchOptions, type BackoffKind, type BackpressurePolicy, BitmapStore, BloomFilterStore, COMMAND_OPCODES, 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 EndpointPolicy, type ExceptionPolicy, type ExecutePipelineOptions, type FailOptions, type FailOutcome, type FencedItem, FerricStoreClient, type FerricStoreClientFromUrlOptions, type FerricStoreClientOptions, FerricStoreError, type FetchOrComputeResult, FlowAlreadyExistsError, FlowNotFoundError, type FlowPolicyOptions, type FlowRecord, type FlowStateMode, type FlowStatePolicy, type FlowStatePolicyLike, FlowWrongStateError, type GeoAddOptions, type GeoMember, GeoStore, type GetExOptions, HashStore, HyperLogLogStore, InvalidCommandError, type InvocationCreateOptions, JsonCodec, type JsonSetOptions, JsonStore, type KeyInfo, KeyValueStore, ListStore, LockHeldError, LockNotOwnedError, type ManagementPairs, type MutateOptions, type NamedValueMutation, NativeAdapter, type NativeAdapterOptions, type Outcome, OverloadedError, type ProtocolCommand, Queue, type QueueBatchHandler, QueueClient, type QueueHandler, type QueueJob, type QueueOptions, QueueWorker, type QueueWorkerResult, type RangeLimit, type RateLimitResult, RawCodec, type ReadOptions, type ReclaimOptions, type ReconnectOptions, ReconnectingExecutor, type RequestContext, type RequestContextOptions, type RetryOptions, type RetryOutcome, type RetryPolicy, type RoutingEndpoint, type RoutingRoute, RoutingTopology, type ScanOptions, type SearchOptions, type SearchStateMeta, type SetOptions, SetStore, SortedSetStore, StaleLeaseError, type StateMeta, type StateMetaValue, type StateOptions, type StateRegistration, type StoreCommandClient, StreamStore, type TDigestCreateOptions, type TDigestMergeOptions, TDigestStore, type TopKReserveOptions, TopKStore, TopologyNativeAdapterPool, 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, isReconnectableClosedConnectionError, mapException, retry, transition };
+/** TypeScript SDK package version. */
+declare const FERRICSTORE_SDK_VERSION = "0.2.0";
+/** Oldest FerricStore server supported by this breaking beta contract. */
+declare const FERRICSTORE_MINIMUM_SERVER_VERSION = "0.8.0";
+/** Native framing and opcode ABI version; unchanged by FerricStore 0.8. */
+declare const FERRICSTORE_NATIVE_PROTOCOL_VERSION = 1;
+
+/** @deprecated Use RequestDisposition; retained for source compatibility. */
+type ConnectionRequestDisposition = RequestDisposition;
+
+export { type AdminListOptions, type ApprovalListOptions, type ApprovalRequestOptions, type AttributeQueryOptions, type AutoBatchOptions, type BackoffKind, type BackpressurePolicy, BitmapStore, BloomFilterStore, type BudgetCommitOptions, type BudgetReserveOptions, COMMAND_OPCODES, type CancelOptions, type ChildSpec, type CircuitOpenOptions, type ClaimDueOptions, ClaimHydrationError, type ClaimHydrationItem, type ClaimedItem, type Codec, type CollectionScanOptions, type Command, type CommandArgument, type CommandExecutor, type CompleteJobsAndClaimJobsResult, type CompleteManyOptions, type CompleteOptions, type CompleteOutcome, ConnectionClosedError, type ConnectionRequestDisposition, type CountMinMergeOptions, CountMinSketchStore, type CreateItem, type CreateManyOptions, type CreateOptions, CuckooFilterStore, type EffectCompensateOptions, type EffectConfirmOptions, type EffectFailOptions, type EffectReserveOptions, type EffectStatusOptions, type EndpointPolicy, type ExceptionPolicy, type ExecutePipelineOptions, type ExpiryCondition, type ExtendLeaseOptions, FERRICSTORE_MINIMUM_SERVER_VERSION, FERRICSTORE_NATIVE_PROTOCOL_VERSION, FERRICSTORE_SDK_VERSION, type FailOptions, type FailOutcome, type FencedItem, type FencingToken, FerricStoreClient, type FerricStoreClientFromUrlOptions, type FerricStoreClientOptions, FerricStoreError, type FetchOrComputeComputeResult, type FetchOrComputeFencedResult, type FetchOrComputeHitResult, type FetchOrComputeResult, type FlowAdminRecord, FlowAlreadyExistsError, type FlowBatchCompletedItem, FlowBatchError, type FlowMaxActiveFailure, FlowNotFoundError, type FlowPolicyOptions, type FlowRecord, type FlowStateMode, type FlowStatePolicy, type FlowStatePolicyLike, type FlowStatsOptions, FlowWrongStateError, type GeoAddOptions, type GeoMember, GeoStore, type GetExOptions, type GovernanceLedgerOptions, type HashScanResult, HashStore, type HistoryOptions, HyperLogLogStore, type IntegerReply, InvalidCommandError, type InvocationCreateOptions, JsonCodec, type KeyInfo, KeyValueStore, type LeaseMutationOptions, LeaseRenewalError, type LimitAmountOptions, type LimitLeaseOptions, type LimitListOptions, type LimitReleaseOptions, ListStore, LockHeldError, LockNotOwnedError, type ManagementPairs, type MaxActiveMs, type MutateOptions, type NamedValueMutation, NativeAdapter, type NativeAdapterOptions, type NativeClientOptions, type NativeProtocolEvent, type Outcome, OverloadedError, type ProtocolCommand, Queue, type QueueBatchHandler, QueueClient, QueueCompletionError, type QueueHandler, type QueueJob, type QueueOptions, QueueWorker, type QueueWorkerResult, type RangeLimit, type RateLimitResult, RawCodec, type ReadOptions, type ReclaimOptions, type ReconnectOptions, ReconnectingExecutor, type RequestContext, type RequestContextOptions, type RequestDisposition, RequestTimeoutError, RerouteError, type RetryOptions, type RetryOutcome, type RetryPolicy, type RoutingEndpoint, type RoutingRoute, RoutingTopology, type RunStepsItem, type RunStepsManyOptions, type ScanOptions, type ScheduleFireDueOptions, type ScheduleListOptions, type ScheduleOptions, type SearchOptions, type SearchStateMeta, type SetOptions, type SetScanResult, SetStore, type SortedSetScanResult, SortedSetStore, StaleLeaseError, type StartAndClaimOptions, type StateMeta, type StateMetaValue, type StateOptions, type StateRegistration, type StepContinueOptions, type StoreCommandClient, StreamStore, type TDigestCreateOptions, type TDigestMergeOptions, TDigestStore, type TopKReserveOptions, TopKStore, type TopologyNativeAdapterOptions, TopologyNativeAdapterPool, type TransitionOptions, type TransitionOutcome, type ValueConfig, type WorkerConfig, type WorkerProfile, type WorkerRefillStrategy, Workflow, WorkflowClient, WorkflowContext, WorkflowFlowCommands, type WorkflowHandler, type WorkflowOptions, WorkflowWorker, type WorkflowWorkerResult, type XReadStream, type ZAddMember, type ZAddOptions, classifyServerError, complete, fail, isOutcome, isReconnectableClosedConnectionError, mapException, retry, transition };