@abloatai/ablo 0.35.0 → 0.37.0

package/dist/transaction/auth/sessionMint.js

@@ -1,85 +0,0 @@
-/**
- * Mints a session token. This is the single implementation behind
- * `sessions.create`, shared by the WebSocket and HTTP clients so the two never
- * disagree on how a token is produced.
- *
- * Minting is a plain control-plane HTTP call — no socket, no synced data. A
- * backend holding a secret key (`sk_`) exchanges it for a short-lived, scoped
- * token whose kind depends on the session requested:
- *
- *   `{ user }`  → POST /auth/ephemeral-keys, returning an `ek_` key that carries
- *                 full end-user authority. This is the only route that mints a
- *                 user session; the capability route rejects a `user`
- *                 participant with `invalid_participant_kind`.
- *   `{ agent }` → POST /auth/capability, returning an `rk_` key scoped to exactly
- *                 the operations named in `can`. For example
- *                 `can: { tasks: ['update'] }` becomes the wire allowlist entry
- *                 `tasks.update`, which the server matches against the model's
- *                 registered names.
- *
- * The caller supplies the already-resolved secret key and base URL in
- * {@link MintSessionContext}. Choosing which key to pass — the original secret
- * key, not a derived key that an earlier exchange may have produced — is the
- * caller's responsibility.
- */
-import { exchangeApiKey, mintUserSessionKey } from '../auth/index.js';
-import { grantedOperations } from './capability.js';
-/**
- * Mints a session token from an already-resolved secret key and base URL.
- * Routes the `{ user }` or `{ agent }` request to the matching mint endpoint
- * and reshapes the response into an {@link AbloSession}.
- */
-export async function mintSession(params, ctx) {
-    const { apiKey, baseUrl } = ctx;
-    if (params.user) {
-        const res = await mintUserSessionKey({
-            apiKey,
-            baseUrl,
-            userId: params.user.id,
-            ...(params.organizationId ? { organizationId: params.organizationId } : {}),
-            ...(params.syncGroups ? { syncGroups: [...params.syncGroups] } : {}),
-            ttlSeconds: params.ttlSeconds ?? 900,
-            ...(ctx.fetch ? { fetch: ctx.fetch } : {}),
-        });
-        return {
-            object: 'session',
-            id: res.id,
-            token: res.token,
-            expiresAt: res.expiresAt,
-            organizationId: res.organizationId,
-            // The ephemeral mint stores scope on the key row; reshape its flat
-            // response into the session resource's scope block.
-            scope: {
-                organizationId: res.organizationId,
-                syncGroups: res.syncGroups,
-                operations: [],
-                participantKind: 'user',
-                participantId: res.participantId,
-            },
-            userMeta: params.userMeta ?? { id: res.participantId },
-        };
-    }
-    // One translation from the declared grant to the wire allowlist, shared with
-    // every other door that mints — see `auth/capability.ts`.
-    const operations = grantedOperations(params.can, ctx.modelTypenames);
-    const res = await exchangeApiKey({
-        apiKey,
-        baseUrl,
-        participantKind: 'agent',
-        participantId: params.agent.id,
-        ...(params.syncGroups ? { syncGroups: [...params.syncGroups] } : {}),
-        operations,
-        ttlSeconds: params.ttlSeconds ?? 900,
-        ...(params.userMeta ? { userMeta: params.userMeta } : {}),
-        ...(ctx.fetch ? { fetch: ctx.fetch } : {}),
-    });
-    return {
-        object: 'session',
-        id: res.capabilityId,
-        token: res.token,
-        expiresAt: res.expiresAt,
-        organizationId: res.organizationId,
-        scope: res.scope,
-        userMeta: res.userMeta,
-    };
-}

package/dist/transaction/coordination/awaitClaimGrant.d.ts

@@ -1,49 +0,0 @@
-/**
- * Waits for a queued claim to reach the head of the line — the client side of
- * the fair-queue handover. When a claim is contended, the server puts it in a
- * queue and replies that it is queued (HTTP 202 on `/v1/claims`, or a
- * `claim_queued` frame over the WebSocket). The grant is delivered later, when
- * the claim reaches the head, as a `claim_granted` frame. This resolves once
- * that frame arrives for the given `claimId`, so the caller's `claim` promise
- * stays pending — event-driven, with no polling — until it is actually the
- * caller's turn. It rejects if the claim is lost (`claim_lost`: taken away by a
- * TTL lapse on disconnect, or revoked) or if an optional timeout elapses.
- *
- * It needs only a minimal `{ subscribe }` transport, so it can be tested
- * against a fake; the duplex `WsTransport` satisfies it.
- */
-import { type Logger } from '../logger.js';
-export interface GrantTransport {
-    subscribe(event: 'claim_acquired' | 'claim_granted' | 'claim_lost' | 'claim_queued' | 'claim_rejected', handler: (payload: Record<string, unknown>) => void): () => void;
-}
-export interface ClaimGrantInfo {
-    /**
-     * True when the grant arrived as `claim_granted` — the target was held when
-     * the caller asked, and the caller waited in the FIFO line behind the holder.
-     * False for the immediate `claim_acquired`, where the target was free.
-     *
-     * Callers read this to know the row may have changed while they queued. Claim
-     * visibility is scoped to the entity, so a broad, organization-wide
-     * subscription receives no presence or claim fan-out, and the local
-     * coordination snapshot cannot be trusted to tell whether the caller waited.
-     * The grant frame itself is the authoritative signal.
-     */
-    readonly waited: boolean;
-    /**
-     * The fencing token the server minted for this grant (Option B), read off the
-     * grant frame — the authoritative source, since the token is server-stamped.
-     * `undefined` when the server does not fence (no minter wired).
-     */
-    readonly fenceToken?: number;
-}
-export declare function awaitClaimGrant(transport: GrantTransport, claimId: string, options?: {
-    timeoutMs?: number;
-    /**
-     * Backpressure: reject instead of waiting if, when we join the line, the
-     * server reports `position >= maxQueueDepth` (i.e. that many claims are
-     * already ahead of us). Omit to wait however deep the queue is.
-     */
-    maxQueueDepth?: number;
-    /** Where grant transitions are logged. Defaults to silent. */
-    logger?: Logger;
-}): Promise<ClaimGrantInfo>;

package/dist/transaction/coordination/awaitClaimGrant.js

@@ -1,112 +0,0 @@
-/**
- * Waits for a queued claim to reach the head of the line — the client side of
- * the fair-queue handover. When a claim is contended, the server puts it in a
- * queue and replies that it is queued (HTTP 202 on `/v1/claims`, or a
- * `claim_queued` frame over the WebSocket). The grant is delivered later, when
- * the claim reaches the head, as a `claim_granted` frame. This resolves once
- * that frame arrives for the given `claimId`, so the caller's `claim` promise
- * stays pending — event-driven, with no polling — until it is actually the
- * caller's turn. It rejects if the claim is lost (`claim_lost`: taken away by a
- * TTL lapse on disconnect, or revoked) or if an optional timeout elapses.
- *
- * It needs only a minimal `{ subscribe }` transport, so it can be tested
- * against a fake; the duplex `WsTransport` satisfies it.
- */
-import { AbloClaimedError, formatClaimedErrorMessage, claimTargetLabel, } from '../errors.js';
-import { modelTarget } from './locator.js';
-import { noopLogger } from '../logger.js';
-/** Read the server-stamped fencing token off a grant frame, if present. */
-function readFenceToken(p) {
-    return typeof p.fenceToken === 'number' ? p.fenceToken : undefined;
-}
-export function awaitClaimGrant(transport, claimId, options) {
-    const logger = options?.logger ?? noopLogger;
-    return new Promise((resolve, reject) => {
-        const unsubs = [];
-        let timer;
-        const settle = (fn) => {
-            if (timer)
-                clearTimeout(timer);
-            for (const u of unsubs)
-                u();
-            fn();
-        };
-        // The target was free → `claim_acquired` (immediate); it was contended,
-        // we waited in line, and reached the head → `claim_granted`. Either frame
-        // means the lease is now ours; `waited` records which path it was.
-        unsubs.push(transport.subscribe('claim_acquired', (p) => {
-            if (p?.claimId === claimId) {
-                logger.debug(`claim: acquired ${claimId} (target was free)`);
-                const fenceToken = readFenceToken(p);
-                settle(() => {
-                    resolve({ waited: false, ...(fenceToken !== undefined ? { fenceToken } : {}) });
-                });
-            }
-        }));
-        unsubs.push(transport.subscribe('claim_granted', (p) => {
-            if (p?.claimId === claimId) {
-                // Promoted to the head of the line — the creator's "it's the agent's
-                // turn now" moment after waiting behind a holder.
-                logger.info(`claim: granted ${claimId} — your turn (waited in queue)`);
-                const fenceToken = readFenceToken(p);
-                settle(() => {
-                    resolve({ waited: true, ...(fenceToken !== undefined ? { fenceToken } : {}) });
-                });
-            }
-        }));
-        if (options?.maxQueueDepth !== undefined) {
-            const max = options.maxQueueDepth;
-            unsubs.push(transport.subscribe('claim_queued', (p) => {
-                if (p?.claimId !== claimId)
-                    return;
-                const position = typeof p.position === 'number' ? p.position : 0;
-                if (position >= max) {
-                    settle(() => {
-                        reject(new AbloClaimedError(`Claim queue for ${claimId} is ${position} deep (max ${max}).`, { code: 'queue_too_deep' }));
-                    });
-                }
-            }));
-        }
-        unsubs.push(transport.subscribe('claim_rejected', (p) => {
-            const rejection = p;
-            if (rejection.claimId !== claimId)
-                return;
-            const target = rejection.target
-                ? claimTargetLabel({
-                    ...modelTarget(rejection.target),
-                    field: rejection.target.field,
-                })
-                : claimId;
-            settle(() => {
-                reject(new AbloClaimedError(formatClaimedErrorMessage({
-                    targetLabel: target,
-                    heldBy: rejection.heldBy,
-                    claim: rejection.heldByClaim,
-                    policyReason: rejection.policyReason,
-                    fallback: `Claim rejected for ${target}.`,
-                }), {
-                    code: rejection.reason === 'conflict'
-                        ? 'claim_conflict'
-                        : 'claim_lease_unavailable',
-                    claims: rejection.heldByClaim ? [rejection.heldByClaim] : undefined,
-                }));
-            });
-        }));
-        unsubs.push(transport.subscribe('claim_lost', (p) => {
-            if (p?.claimId === claimId) {
-                settle(() => {
-                    reject(new AbloClaimedError(`Claim lost while queued for ${claimId}.`, {
-                        code: 'claim_lost',
-                    }));
-                });
-            }
-        }));
-        if (options?.timeoutMs && options.timeoutMs > 0) {
-            timer = setTimeout(() => {
-                settle(() => {
-                    reject(new AbloClaimedError(`Timed out waiting for the queue grant on claim ${claimId}.`, { code: 'grant_timeout' }));
-                });
-            }, options.timeoutMs);
-        }
-    });
-}

package/dist/transaction/coordination/claimHeartbeatLoop.d.ts

@@ -1,50 +0,0 @@
-/**
- * The auto-heartbeat loop behind `claim({ id, heartbeat: true })` — one
- * implementation shared by both transports (the WebSocket claim stream and the
- * private HTTP transport), so the cadence and failure semantics cannot drift.
- *
- * A beat is the "still working" signal that keeps a lease alive for the
- * duration of real work. The loop's failure handling follows the lease-system
- * convention (SQS visibility heartbeats, Kubernetes leases): a beat that fails
- * for a transient reason — the network blipped, the server was briefly
- * unavailable — is simply retried on the next tick, because the lease has
- * runway to spare by construction (the default cadence is a third of the TTL,
- * so two consecutive beats can fail before the lease is even at risk). Only a
- * definitive answer from the server — the lease lapsed and may have been
- * granted to the next in line ({@link AbloClaimedError}) — stops the loop and
- * surfaces the loss, because for a caller with no push channel the failed beat
- * IS the loss notification.
- */
-import { AbloClaimedError } from '../errors.js';
-import type { ClaimHeartbeat, ClaimHeartbeatOptions, Duration } from '../types/streams.js';
-/**
- * Normalize the public `heartbeat(options?)` argument — a bare Duration is
- * shorthand for `{ ttl }`. Shared by both transports' handle assembly so the
- * shorthand cannot drift.
- */
-export declare function resolveHeartbeatOptions(input: Duration | ClaimHeartbeatOptions | undefined): ClaimHeartbeatOptions;
-/**
- * The beat cadence for a lease of `ttlMs`: an explicit duration when the
- * caller set one, otherwise a third of the TTL (floored at 1s) — the
- * DynamoDB-lock-client rule, leaving two missed beats of runway before the
- * lease is at risk while keeping crash recovery within one beat window.
- */
-export declare function heartbeatCadenceMs(ttlMs: number, heartbeat: true | Duration): number;
-export interface ClaimHeartbeatLoopOptions {
-    /** Send one beat; resolves while the lease is still ours. */
-    beat(): Promise<ClaimHeartbeat>;
-    /** Cadence between beats. Callers default this to a third of the TTL. */
-    intervalMs: number;
-    /**
-     * Called once when a beat comes back with a definitive loss — the lease
-     * expired or was taken. The loop has already stopped by the time this runs.
-     */
-    onLost?(error: AbloClaimedError): void;
-}
-/**
- * Start beating. Returns a stop function; callers stop the loop when the
- * claim is released (all held-claim assembly sites tie this to `release`).
- * Beats never overlap: a tick that fires while the previous beat is still
- * in flight is skipped rather than stacked.
- */
-export declare function startClaimHeartbeatLoop(options: ClaimHeartbeatLoopOptions): () => void;

package/dist/transaction/coordination/claimHeartbeatLoop.js

@@ -1,88 +0,0 @@
-/**
- * The auto-heartbeat loop behind `claim({ id, heartbeat: true })` — one
- * implementation shared by both transports (the WebSocket claim stream and the
- * private HTTP transport), so the cadence and failure semantics cannot drift.
- *
- * A beat is the "still working" signal that keeps a lease alive for the
- * duration of real work. The loop's failure handling follows the lease-system
- * convention (SQS visibility heartbeats, Kubernetes leases): a beat that fails
- * for a transient reason — the network blipped, the server was briefly
- * unavailable — is simply retried on the next tick, because the lease has
- * runway to spare by construction (the default cadence is a third of the TTL,
- * so two consecutive beats can fail before the lease is even at risk). Only a
- * definitive answer from the server — the lease lapsed and may have been
- * granted to the next in line ({@link AbloClaimedError}) — stops the loop and
- * surfaces the loss, because for a caller with no push channel the failed beat
- * IS the loss notification.
- */
-import { AbloClaimedError } from '../errors.js';
-import { toMs } from '../utils/duration.js';
-/**
- * Normalize the public `heartbeat(options?)` argument — a bare Duration is
- * shorthand for `{ ttl }`. Shared by both transports' handle assembly so the
- * shorthand cannot drift.
- */
-export function resolveHeartbeatOptions(input) {
-    if (input === undefined)
-        return {};
-    if (typeof input === 'string' || typeof input === 'number') {
-        return { ttl: input };
-    }
-    return input;
-}
-/**
- * The beat cadence for a lease of `ttlMs`: an explicit duration when the
- * caller set one, otherwise a third of the TTL (floored at 1s) — the
- * DynamoDB-lock-client rule, leaving two missed beats of runway before the
- * lease is at risk while keeping crash recovery within one beat window.
- */
-export function heartbeatCadenceMs(ttlMs, heartbeat) {
-    if (heartbeat !== true)
-        return toMs(heartbeat);
-    return Math.max(Math.floor(ttlMs / 3), 1_000);
-}
-/**
- * Start beating. Returns a stop function; callers stop the loop when the
- * claim is released (all held-claim assembly sites tie this to `release`).
- * Beats never overlap: a tick that fires while the previous beat is still
- * in flight is skipped rather than stacked.
- */
-export function startClaimHeartbeatLoop(options) {
-    let stopped = false;
-    let inFlight = false;
-    const stop = () => {
-        if (stopped)
-            return;
-        stopped = true;
-        clearInterval(timer);
-    };
-    const timer = setInterval(() => {
-        if (stopped || inFlight)
-            return;
-        inFlight = true;
-        options
-            .beat()
-            .catch((error) => {
-            if (stopped)
-                return;
-            if (error instanceof AbloClaimedError) {
-                stop();
-                options.onLost?.(error);
-                return;
-            }
-            // Transient (connection, brief server unavailability): the next tick
-            // is the retry — the ttl/3 cadence leaves runway for missed beats.
-        })
-            .finally(() => {
-            inFlight = false;
-        });
-    }, options.intervalMs);
-    // The loop must never be what keeps a Node process alive — the held work
-    // is. A worker that finishes without releasing exits anyway, and the lease
-    // lapses on schedule. No-op in browsers (where setInterval returns a number
-    // without `unref`), which is why the call is optional even though the Node
-    // timer type always has it.
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    timer.unref?.();
-    return stop;
-}

package/dist/transaction/coordination/claimMeta.d.ts

@@ -1,49 +0,0 @@
-/**
- * A claim's application metadata, crossing between the wire and the shape the
- * program declared for it.
- *
- * The wire contract for `meta` is deliberately permissive — `targetRefSchema`
- * parses it as `z.record(z.string(), z.unknown())` and always will, because a
- * newer peer must be able to send a field this build has never heard of and
- * still be understood. The read surface is the opposite: `Register`'s
- * `ClaimMeta` slot names the one shape this program's claims carry, so
- * `claim.state({ id })?.target.meta` reads without a guard.
- *
- * Those two facts meet here, and only here, in both directions. A decode calls
- * {@link declaredMeta} on its way from a parsed record to a public `Claim`; the
- * locator projection calls {@link wireMeta} on the way back out, where a
- * caller's declared value is put on the socket or in the HTTP body. Between
- * them they are the one place the SDK takes the caller's word for a shape it
- * did not check — written down once, with the reason, instead of being asserted
- * at each crossing.
- *
- * The two directions are not symmetric in cost. Losing the declared shape on
- * the way out is harmless, because the wire has always accepted any record;
- * gaining it on the way in is the promise the read surface makes, so
- * `declaredMeta` is the one to audit when a claim reads back a shape its holder
- * never wrote.
- */
-import type { ResolveClaimMeta } from '../types/global.js';
-/**
- * Read a parsed `meta` as the declared shape. Call it only where a decode hands
- * a wire value to a public claim, and only for a value already known present —
- * the absent case is an omitted member, not a declared-shaped `undefined`.
- *
- * The exported names are `declaredMeta` and `wireMeta` rather than a `claimMeta`
- * pair because two claim surfaces already read a caller's `meta` back off the
- * options it passed in, and spell that local reader `claimMeta`.
- */
-export declare function declaredMeta(raw: unknown): ResolveClaimMeta;
-/**
- * Write a declared `meta` as the permissive record the wire carries. Every path
- * from a caller's target to a frame or request body goes through `subTarget`,
- * so this has exactly one caller — widening it is how the declared shape stops
- * being a compile error at the edge of the protocol instead of stopping there.
- *
- * The parameter is `unknown` rather than {@link ResolveClaimMeta} on purpose: a
- * program may register an `interface` for its claim metadata, and an interface
- * carries no implicit index signature, so a directly-typed parameter would make
- * the conversion itself unrepresentable at the one site that needs it. Widening
- * the input is what keeps the assertion single.
- */
-export declare function wireMeta(meta: unknown): Record<string, unknown>;

package/dist/transaction/coordination/claimMeta.js

@@ -1,52 +0,0 @@
-/**
- * A claim's application metadata, crossing between the wire and the shape the
- * program declared for it.
- *
- * The wire contract for `meta` is deliberately permissive — `targetRefSchema`
- * parses it as `z.record(z.string(), z.unknown())` and always will, because a
- * newer peer must be able to send a field this build has never heard of and
- * still be understood. The read surface is the opposite: `Register`'s
- * `ClaimMeta` slot names the one shape this program's claims carry, so
- * `claim.state({ id })?.target.meta` reads without a guard.
- *
- * Those two facts meet here, and only here, in both directions. A decode calls
- * {@link declaredMeta} on its way from a parsed record to a public `Claim`; the
- * locator projection calls {@link wireMeta} on the way back out, where a
- * caller's declared value is put on the socket or in the HTTP body. Between
- * them they are the one place the SDK takes the caller's word for a shape it
- * did not check — written down once, with the reason, instead of being asserted
- * at each crossing.
- *
- * The two directions are not symmetric in cost. Losing the declared shape on
- * the way out is harmless, because the wire has always accepted any record;
- * gaining it on the way in is the promise the read surface makes, so
- * `declaredMeta` is the one to audit when a claim reads back a shape its holder
- * never wrote.
- */
-/**
- * Read a parsed `meta` as the declared shape. Call it only where a decode hands
- * a wire value to a public claim, and only for a value already known present —
- * the absent case is an omitted member, not a declared-shaped `undefined`.
- *
- * The exported names are `declaredMeta` and `wireMeta` rather than a `claimMeta`
- * pair because two claim surfaces already read a caller's `meta` back off the
- * options it passed in, and spell that local reader `claimMeta`.
- */
-export function declaredMeta(raw) {
-    return raw;
-}
-/**
- * Write a declared `meta` as the permissive record the wire carries. Every path
- * from a caller's target to a frame or request body goes through `subTarget`,
- * so this has exactly one caller — widening it is how the declared shape stops
- * being a compile error at the edge of the protocol instead of stopping there.
- *
- * The parameter is `unknown` rather than {@link ResolveClaimMeta} on purpose: a
- * program may register an `interface` for its claim metadata, and an interface
- * carries no implicit index signature, so a directly-typed parameter would make
- * the conversion itself unrepresentable at the one site that needs it. Widening
- * the input is what keeps the assertion single.
- */
-export function wireMeta(meta) {
-    return meta;
-}

package/dist/transaction/coordination/createClaimStream.d.ts

@@ -1,64 +0,0 @@
-/**
- * Creates a {@link ClaimStream} over a live sync connection. A claim is a
- * short-lived, advisory lease a participant takes on an entity (or a field of
- * one) to signal "I'm working on this"; the stream lets you take claims, see
- * everyone else's, and watch the wait queue when a claim is contended.
- *
- * The stream is built directly on the sync WebSocket and shares that one
- * connection. It learns about other participants' claims from the same
- * `presence_update` frames the {@link createPresenceStream} presence stream
- * consumes — the server piggybacks each participant's `activeClaims` on every
- * presence frame — and sends its own claims as `claim_begin` and
- * `claim_abandon` frames.
- *
- * Wire frames:
- *   • Outbound `claim_begin` — announce a claim: `{ claimId, entityType,
- *       entityId, description, field?, estimatedMs? }`.
- *   • Outbound `claim_abandon` — release it: `{ claimId, entityType?,
- *       entityId? }`.
- *   • Inbound, via presence — `event.activeClaims`, each stamped with
- *       `declaredAt` and `expiresAt`.
- *   • Inbound `claim_rejected` — the server refused the claim, with conflict
- *       metadata.
- */
-import type { WsTransport } from '../transport/wsTransport.js';
-import type { ClaimOptions, Claim, ClaimStream, PresenceTarget } from '../types/streams.js';
-import { type Logger } from '../logger.js';
-/**
- * The wire capability the claim stream actually uses: subscribe to typed
- * inbound frames, check liveness, and send outbound frames. The duplex
- * `WsTransport` satisfies it, so production wiring is unchanged — but depending on the port
- * rather than the whole socket class lets a test drive it with a plain object,
- * no cast. `Pick` carries the exact (generic, typed-payload) `subscribe`
- * signature, so every handler stays fully typed.
- */
-export type ClaimTransport = Pick<WsTransport, 'subscribe' | 'isConnected' | 'send'>;
-export interface ClaimStreamConfig {
-    /** Identity used to filter our own active claims out of `others`. */
-    participantId: string;
-    /** Where the coordination trace is logged. Defaults to silent. */
-    logger?: Logger;
-}
-export interface AttachableClaimStream extends ClaimStream {
-    /**
-     * Mints a lease directly: sends the `claim_begin` frame and returns a held
-     * {@link Claim} that carries no row `data` (the resource layer reads the row
-     * and stamps it). This is an internal entry point, not part of the public
-     * {@link ClaimStream}; application code takes a claim through
-     * `ablo.<model>.claim({ id })`, which is built on this.
-     */
-    claim(target: PresenceTarget, opts?: ClaimOptions): Claim;
-    attach(transport: ClaimTransport): void;
-    /**
-     * Seeds the participant identity once the host resolves it. The stream can
-     * be built before identity is known — a hosted client learns who it is
-     * from its credential's scope during connect — and until then the
-     * construction-time id (possibly empty) would let the participant's own
-     * claims into `others`. Idempotent; later frames filter on the new id.
-     */
-    setParticipant(participant: {
-        id: string;
-    }): void;
-    dispose(): void;
-}
-export declare function createClaimStream(config: ClaimStreamConfig, transport?: ClaimTransport | null): AttachableClaimStream;