@abloatai/ablo 0.27.0 → 0.29.0

package/dist/client/ApiClient.d.ts

@@ -1,177 +0,0 @@
-/**
- * The stateless API client behind `Ablo({ apiKey })`. It carries no schema,
- * object pool, local database, or WebSocket, and maps the public Model, Claim,
- * and Commit nouns directly to HTTP routes on the server. This is the transport
- * used for server-side agents, workers, and serverless code.
- */
-import type { AbloOptions } from './options.js';
-import type { CommitResource, ClaimCreateOptions, ClaimWaitOptions, ModelClient, ModelClaim, ModelTarget, CreateSessionParams, AbloSession } from './resourceTypes.js';
-import type { SchemaRecord } from '../schema/schema.js';
-import type { Duration } from '../utils/duration.js';
-import type { Claim, ClaimHeartbeat } from '../types/streams.js';
-import type { SyncObservabilityProvider } from '../interfaces/index.js';
-export type AbloApiClientOptions = Omit<AbloOptions, 'schema'> & {
-    readonly schema?: null | undefined;
-    readonly bootstrapBaseUrl?: string | undefined;
-    /**
-     * The observability provider forwarded from `Ablo({ observability })`. The HTTP
-     * transport emits the same claim and conflict events as the WebSocket transport,
-     * so a `ClaimLog` works identically for headless server-agent evaluations.
-     */
-    readonly observability?: SyncObservabilityProvider;
-    /**
-     * Per-request deadline in milliseconds for the stateless HTTP transport.
-     * Every request this client issues is aborted after this long and surfaces
-     * as a retryable connection error — without it a black-holed server hangs
-     * a headless agent forever (browsers never time fetch out on their own).
-     * Pass `0` to disable the deadline.
-     *
-     * @default 30_000
-     */
-    readonly timeoutMs?: number;
-};
-/** Default per-request deadline for the stateless HTTP transport. */
-export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
-export interface AbloApiClaims {
-    create(options: ClaimCreateOptions): Promise<Claim>;
-    list(target?: Partial<ModelTarget>): Promise<readonly ModelClaim[]>;
-    waitFor(target: Partial<ModelTarget>, options?: ClaimWaitOptions): Promise<void>;
-    /**
-     * The batched beat — extend every lease this credential holds in one
-     * request (`POST /v1/claims/heartbeat`), the stateless twin of the
-     * WebSocket keepalive. One round trip per cadence for a worker holding
-     * many rows. Returns one {@link ClaimHeartbeat} per extended lease,
-     * tagged with its claim id — no separate result type to learn.
-     */
-    heartbeatAll(options?: {
-        ttl?: Duration;
-    }): Promise<readonly (ClaimHeartbeat & {
-        readonly claimId: string;
-    })[]>;
-}
-export type CapabilityParticipantKind = 'agent' | 'system';
-export interface CapabilityCreateBaseOptions {
-    readonly participantKind?: CapabilityParticipantKind;
-    readonly participantId?: string;
-    readonly syncGroups: readonly string[];
-    readonly operations: readonly string[];
-    readonly label?: string;
-    readonly wideScope?: boolean;
-    readonly userMeta?: Record<string, unknown>;
-}
-export interface CapabilityCreateOptions extends CapabilityCreateBaseOptions {
-    /**
-     * Preferred public name. A capability is a lease; the SDK and server
-     * clean it up when the run finishes or when the lease expires.
-     */
-    readonly lease?: Duration;
-    readonly leaseSeconds?: number;
-    /** @deprecated Use `lease`. */
-    readonly ttl?: Duration;
-    /** @deprecated Use `leaseSeconds`. */
-    readonly ttlSeconds?: number;
-}
-export interface CapabilityScope {
-    readonly organizationId: string;
-    readonly syncGroups: readonly string[];
-    readonly operations: readonly string[];
-    readonly participantKind: CapabilityParticipantKind;
-    readonly participantId: string;
-}
-export interface Capability {
-    readonly id: string;
-    readonly token: string;
-    readonly expiresAt: string;
-    readonly organizationId: string;
-    readonly scope: CapabilityScope;
-    readonly userMeta?: Record<string, unknown>;
-    client(): AbloApi;
-}
-export interface CapabilityRecord {
-    readonly id: string;
-    readonly organizationId: string;
-    readonly participantKind: CapabilityParticipantKind;
-    readonly participantId: string;
-    readonly label: string | null;
-    readonly status: 'active' | 'expired' | 'revoked';
-    readonly issuedAt: string;
-    readonly expiresAt: string;
-    readonly revokedAt: string | null;
-    readonly lastUsedAt: string | null;
-    readonly operations: readonly string[];
-    readonly syncGroups: readonly string[];
-}
-export interface CapabilityRevocation {
-    readonly id: string;
-    readonly deleted: boolean;
-    readonly activeSessionsClosed?: number;
-}
-export interface CapabilityRotateOptions {
-    /**
-     * The overlap window — the old token keeps authenticating for this long after
-     * rotation, so you can deploy the replacement with zero downtime. Defaults to
-     * 24h on the server.
-     */
-    readonly grace?: Duration;
-    readonly graceSeconds?: number;
-    /**
-     * The lifetime of the replacement capability. Omit to inherit the original's
-     * lifetime.
-     */
-    readonly lease?: Duration;
-    readonly leaseSeconds?: number;
-}
-/** The fresh capability returned by `rotate`, plus a pointer to the old one. */
-export interface RotatedCapability extends Capability {
-    /**
-     * The capability that was rotated out. Its token keeps working until
-     * `expiresAt` (the end of the grace window), then expires.
-     */
-    readonly rotatedFrom: {
-        readonly id: string;
-        readonly expiresAt: string;
-    };
-}
-export interface CapabilityResource {
-    create(options: CapabilityCreateOptions): Promise<Capability>;
-    retrieve(id: string): Promise<CapabilityRecord>;
-    revoke(id: string): Promise<CapabilityRevocation>;
-    /**
-     * Rotate with overlap: mint a fresh capability that carries the same scope, and
-     * keep the old token working for a grace window so you can roll out the
-     * replacement without downtime.
-     */
-    rotate(id: string, options?: CapabilityRotateOptions): Promise<RotatedCapability>;
-    /**
-     * Alias for `create`. Kept because "mint" is common capability-token
-     * language, but `create` is the canonical SDK verb.
-     */
-    mint(options: CapabilityCreateOptions): Promise<Capability>;
-}
-export interface AbloApi {
-    ready(): Promise<void>;
-    waitForFlush(): Promise<void>;
-    dispose(): Promise<void>;
-    purge(): Promise<void>;
-    readonly capabilities: CapabilityResource;
-    readonly claims: AbloApiClaims;
-    readonly commits: CommitResource;
-    model<T = Record<string, unknown>>(name: string): ModelClient<T>;
-    /**
-     * Resolve the active bearer credential this client authenticates with — the
-     * same token its own requests carry in `Authorization`. Returns `null` when
-     * no credential is configured. Async because the API key may be supplied as
-     * an async setter. Use it to authenticate a side-band request to the same
-     * server with the credential this client already holds — no re-mint.
-     */
-    getAuthToken(): Promise<string | null>;
-    /**
-     * Mint a short-lived scoped session. Minting is a control-plane HTTP call (no
-     * socket), so it lives on this stateless client too, not only the realtime one.
-     * `{ user }` mints an `ek_`; `{ agent, can }` mints an `rk_`.
-     */
-    readonly sessions: {
-        create(params: CreateSessionParams<SchemaRecord>): Promise<AbloSession>;
-    };
-}
-export declare function createProtocolClient(options: AbloApiClientOptions): AbloApi;