@opengeni/sdk 3.3.2 → 3.4.0

package/dist/embedding-client.d.ts

@@ -0,0 +1,129 @@
+import { OpenGeniClient as OpenGeniArtifactClient } from "./artifact-client.js";
+import type { AddWorkspaceMemberRequest } from "./types.js";
+import type { ExternalIdentityLink, BeginExternalIdentityLinkRequest, BeginExternalIdentityLinkResponse, ConfirmExternalIdentityLinkRequest, ExternalIdentityLinkPreview, ExternalIdentityLinkPage } from "@opengeni/contracts/external-identities";
+/** Non-secret service attribution, serialized as a flat JSON object of at most 2 KiB. */
+export type ServiceContext = Record<string, string | number | boolean>;
+/** Public product embedding administration, kept out of the native browser client. */
+export declare class OpenGeniEmbeddingClient extends OpenGeniArtifactClient {
+    /** Read configuration (null means no configured ceiling). Requires admin or organization-key read authority. */
+    getWorkspaceAllowance(workspaceId: string): Promise<import("@opengeni/contracts/usage-allowances").WorkspaceAllowance | null>;
+    /**
+     * Read the lifecycle version even after clear (config=null). version=0 means
+     * never configured. Use the returned version to recreate or reconcile a 409;
+     * do not guess a CAS version or silently retry a new mutation.
+     * Requires the same budget-read authority as getWorkspaceAllowance.
+     */
+    getWorkspaceAllowanceState(workspaceId: string): Promise<import("@opengeni/contracts/usage-allowances").WorkspaceAllowanceState>;
+    /**
+     * Set a USD-micro ceiling with exact-version CAS (0 only for first creation;
+     * after clear reuse its returned version or getWorkspaceAllowanceState). Requires
+     * organization key-control authority or account:admin, never workspace admin
+     * alone. Shares may oversubscribe the pool; actual post-call settlement can
+     * overshoot before the next admission check.
+     */
+    setWorkspaceAllowance(workspaceId: string, request: import("@opengeni/contracts/usage-allowances").SetWorkspaceAllowanceRequest): Promise<import("@opengeni/contracts/usage-allowances").WorkspaceAllowance>;
+    /**
+     * Clear with the exact version; grants and settled usage are not a billing
+     * refund. Supply operationId and replay the exact request after a lost response.
+     * Replays recheck authority and conflict after a later lifecycle change.
+     * On 409 read getWorkspaceAllowanceState before deciding on a new operation.
+     */
+    clearWorkspaceAllowance(workspaceId: string, request: import("@opengeni/contracts/usage-allowances").ClearWorkspaceAllowanceRequest): Promise<import("@opengeni/contracts/usage-allowances").ClearWorkspaceAllowanceResponse>;
+    /** Grant USD micros once. Reuse the operationId and exact request after an uncertain response. */
+    grantWorkspaceCredits(workspaceId: string, request: import("@opengeni/contracts/usage-allowances").GrantWorkspaceCreditsRequest): Promise<import("@opengeni/contracts/usage-allowances").WorkspaceCreditGrant>;
+    /**
+     * Administer an existing member by canonical subject or external identity.
+     * null restores memberDefault; shares >1 are valid ceilings, not reservations.
+     * Concurrent calls may exceed the ceiling until their actual cost settles.
+     */
+    setMemberAllowance(workspaceId: string, member: string | {
+        source: string;
+        externalId: string;
+    }, request: import("@opengeni/contracts/usage-allowances").SetMemberAllowanceRequest): Promise<import("@opengeni/contracts/usage-allowances").MemberAllowance>;
+    /** Paginated settled usage, current or YYYY-MM. Requires admin or organization-key read authority. */
+    getUsage(workspaceId: string, query?: import("@opengeni/contracts/usage-allowances").GetUsageRequest, options?: import("./client.js").OpenGeniRequestOptions): Promise<import("@opengeni/contracts/usage-allowances").WorkspaceUsageResponse>;
+    /** Own usage only. On your backend use asUser(authenticatedUser); subject selectors are not accepted. */
+    getMyUsage(workspaceId: string, query?: import("@opengeni/contracts/usage-allowances").GetMyUsageRequest, options?: import("./client.js").OpenGeniRequestOptions): Promise<import("@opengeni/contracts/usage-allowances").WorkspaceUsageResponse>;
+    /** Recover this actor's connection creation result without resending secrets.
+     * A 404 means no visible committed result, not proof that an in-flight write failed. */
+    getConnectionCreationResult(workspaceId: string, operationId: string): Promise<import("./types.js").ConnectionMetadata>;
+    /** Rotate existing inline credentials only while no credential-consuming work
+     * is pending or active. Reuse the operation key and exact request to reconcile
+     * a lost response. This operation never schedules or retries model work. */
+    rotateSessionMcpCredentials(workspaceId: string, sessionId: string, request: import("./types.js").RotateSessionMcpCredentialsRequest): Promise<import("./types.js").RotateSessionMcpCredentialsReceipt>;
+    /** Contract-checked successful JSON GET with its headers intact, for same-origin
+     * proxies that must forward paging metadata. Non-2xx responses throw. */
+    requestJsonResponse(path: string, query?: Record<string, string>, options?: import("./client.js").OpenGeniRequestOptions): Promise<import("./client.js").FetchResponse>;
+    /** Server-side organization-key client scoped to one host-authenticated user.
+     * Does not mutate this client, provision workspace membership, or link native
+     * identities. The API verifies key and membership authority on each request. */
+    asUser(externalId: string, options?: {
+        source?: string;
+    }): this;
+    /** Server-side automation attribution under this client's existing credential.
+     * Returns a new client of the same class; grants no permissions or human/personal
+     * resource authority. Cannot be combined with asUser or asLinkedUser.
+     * Reapplying asService replaces the name and context rather than merging them. */
+    asService(name: string, context?: ServiceContext): this;
+    /** Explicitly use a confirmed native delegation. Unlike asUser, new resources
+     * belong to the native user. Existing external resources are never reassigned.
+     * A stale, expired or revoked link is rejected by the server on every request. */
+    asLinkedUser(externalId: string, options: {
+        source?: string;
+        linkId: string;
+        expectedLinkRevision: number;
+    }): this;
+    /** Optional native-account delegation. Invoke on a server-side asUser client.
+     * Pass the one-time challenge to the native consent screen, never a URL query
+     * or analytics event. Ordinary external embedding needs none of this. */
+    beginIdentityLink(workspaceId: string, input: BeginExternalIdentityLinkRequest): Promise<BeginExternalIdentityLinkResponse>;
+    getIdentityLink(workspaceId: string, linkId: string): Promise<ExternalIdentityLink>;
+    /** Only links belonging to the effective participant; no organization-wide directory. */
+    listIdentityLinks(workspaceId: string, cursor?: string): Promise<ExternalIdentityLinkPage>;
+    /** Requires a canonical native browser session, not an organization API key. */
+    previewIdentityLink(workspaceId: string, linkId: string, challenge: string): Promise<ExternalIdentityLinkPreview>;
+    confirmIdentityLink(workspaceId: string, linkId: string, input: ConfirmExternalIdentityLinkRequest): Promise<ExternalIdentityLink>;
+    revokeIdentityLink(workspaceId: string, linkId: string, expectedRevision: number): Promise<ExternalIdentityLink>;
+    /** Service-only lifecycle for an external actor's organization membership.
+     * A successful reactivation does not restore revoked workspace grants. */
+    updateExternalIdentityMembership(organizationId: string, membershipId: string, request: import("@opengeni/contracts/external-identities").UpdateExternalIdentityMembershipRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<import("@opengeni/contracts").OrganizationMember>;
+    /** Non-provisioning, content-free service lookup, including inactive identities. */
+    lookupExternalIdentity(organizationId: string, identity: import("@opengeni/contracts/external-identities").ExternalIdentityReference): Promise<import("@opengeni/contracts/external-identities").ExternalIdentityLookup>;
+    /** Withdraw an external member's shared-workspace access and fence an exact
+     * pending keyed grant. Reuse the exact cancellation body after response loss. */
+    cancelExternalWorkspaceMemberGrant(organizationId: string, workspaceId: string, membershipId: string, request: import("@opengeni/contracts/external-identities").CancelExternalWorkspaceMemberGrantRequest): Promise<import("@opengeni/contracts/external-identities").CancelExternalWorkspaceMemberGrantResponse>;
+    /** Replace an existing external member's permissions in one shared
+     * workspace. Keyed by `operationId`: reuse the exact body after response
+     * loss. Narrowing makes live authority re-check; nothing is cancelled. */
+    updateExternalWorkspaceMember(organizationId: string, workspaceId: string, membershipId: string, request: import("@opengeni/contracts/external-identities").UpdateExternalWorkspaceMemberRequest): Promise<import("@opengeni/contracts/external-identities").UpdateExternalWorkspaceMemberResponse>;
+    listConnectProviders(workspaceId: string): Promise<import("@opengeni/contracts/connect").ConnectProvider[]>;
+    listConnectAccounts(workspaceId: string): Promise<import("@opengeni/contracts/connect").ConnectAccount[]>;
+    getConnectAttempt(workspaceId: string, attemptId: string): Promise<import("@opengeni/contracts/connect").ConnectAttempt>;
+    listPendingConnectAttempts(workspaceId: string): Promise<import("@opengeni/contracts/connect").ConnectAttempt[]>;
+    advanceConnectAttempt(workspaceId: string, attemptId: string, request: {
+        expectedRevision: number;
+        idempotencyKey: string;
+        action: import("@opengeni/contracts/connect").ConnectAdvance;
+    }): Promise<import("@opengeni/contracts/connect").ConnectAttempt>;
+    /** Stops setup; does not revoke already committed provider credentials. */
+    cancelConnectAttempt(workspaceId: string, attemptId: string, request: {
+        expectedRevision: number;
+        idempotencyKey: string;
+    }): Promise<import("@opengeni/contracts/connect").ConnectAttempt>;
+    /**
+     * Explicit organization-service-key onboarding with chosen permissions. Not
+     * needed for the default path: an `asUser` request through a key with
+     * `members:manage` adds a missing member with conversation permissions on
+     * first use. Change an existing member with `updateExternalWorkspaceMember`.
+     */
+    addExternalWorkspaceMember(workspaceId: string, request: {
+        identity: {
+            externalId: string;
+            source?: string;
+        };
+        permissions: AddWorkspaceMemberRequest["permissions"];
+        operationId?: string;
+    }): Promise<import("@opengeni/contracts/external-identities").ExternalIdentity>;
+}

package/dist/errors.d.ts

@@ -1,4 +1,5 @@
-/** Error for a non-2xx OpenGeni API response. */
+import { type ParsedSessionUsageLimitReachedRefusal } from "@opengeni/contracts/session-usage-limit-refusal";
+/** Error for a non-2xx Opengeni API response. */
 export declare class OpenGeniApiError extends Error {
     readonly status: number;
     readonly code: string | undefined;
@@ -17,6 +18,74 @@ export declare class OpenGeniApiError extends Error {
         mutation?: boolean | undefined;
     });
 }
+/** Deployment or organization setup must be completed before private chats can be created. */
+export declare class OpenGeniSetupError extends OpenGeniApiError {
+    constructor(error: OpenGeniApiError);
+}
+/** A settled usage ceiling refuses the next call; retry after reset or an authorized grant. */
+export declare class OpenGeniAllowanceExhaustedError extends OpenGeniApiError {
+    readonly scope: "workspace" | "member";
+    readonly resetsAt: string | null;
+    readonly subjectId: string | undefined;
+    constructor(status: number, body: string, options?: ConstructorParameters<typeof OpenGeniApiError>[2]);
+}
+/**
+ * The task's root usage limit is reached: recorded API-equivalent model usage
+ * is at or above the limit. Not a credit or billing failure and not retryable
+ * by waiting; a person can raise or remove the limit, then send again.
+ */
+export declare class OpenGeniSessionUsageLimitReachedError extends OpenGeniApiError {
+    readonly rootSessionId: string | undefined;
+    readonly limitMicros: number | undefined;
+    readonly usedMicros: number | undefined;
+    constructor(status: number, body: string, options?: ConstructorParameters<typeof OpenGeniApiError>[2]);
+}
+/**
+ * The server did not accept or confirm a requested task usage limit, so it
+ * predates usage limits (or limits are not enabled there). `sessionId` is null
+ * when the server rejected the create before creating anything; otherwise the
+ * session exists without a confirmed limit and no initial work was started by
+ * this SDK's request (an older server rejects it up front).
+ */
+export declare class OpenGeniSessionUsageLimitUnsupportedError extends Error {
+    readonly code = "session_usage_limit_unsupported";
+    readonly sessionId: string | null;
+    constructor(message: string, options?: {
+        sessionId?: string | null;
+        cause?: unknown;
+    });
+}
+/**
+ * True only when a create was refused because the server rejected the
+ * `startMode` field itself: servers that predate usage limits accept only
+ * `realtime` there. Matches the session create route's 422 validation
+ * envelope (`Invalid session create request: <fields> failed schema
+ * validation`) and a 400 request-body envelope whose issues name `startMode`.
+ * Any other validation error stays an ordinary API error.
+ */
+export declare function rejectsStartModeField(error: OpenGeniApiError): boolean;
+/** The committed limit differs from the one requested: never report success. */
+export declare function sessionUsageLimitNotConfirmed(sessionId: string): OpenGeniSessionUsageLimitUnsupportedError;
+/** Parse a session usage limit refusal from an API error envelope body. */
+export declare function sessionUsageLimitReachedFields(body: string): ParsedSessionUsageLimitReachedRefusal | null;
+/** Accept both the API error envelope and the standalone admission refusal. */
+export declare function allowanceExhaustedFields(body: string): {
+    scope: "workspace" | "member";
+    resetsAt: string | null;
+    subjectId?: string;
+} | null;
+export type OpenGeniSecureContextRequiredReason = "insecure_context" | "web_crypto_unavailable";
+/**
+ * A browser operation requires secure-context-only platform capabilities.
+ * Callers may key UI behavior on the stable `secure_context_required` code;
+ * `reason` exists only to keep the human guidance truthful.
+ */
+export declare class OpenGeniSecureContextRequiredError extends Error {
+    readonly code: "secure_context_required";
+    readonly retryable = false;
+    readonly reason: OpenGeniSecureContextRequiredReason;
+    constructor(reason: OpenGeniSecureContextRequiredReason);
+}
 /** A legacy short-lived session-list snapshot cursor can no longer be continued. */
 export declare class OpenGeniSessionListCursorError extends OpenGeniApiError {
 }
@@ -30,6 +99,12 @@ export declare class OpenGeniApiContractMismatchError extends Error {
 export declare class OpenGeniStreamError extends Error {
     constructor(message: string);
 }
+/**
+ * Brand-neutral end-user copy for a failed SDK operation. Error.message, body,
+ * details and typed fields remain unchanged for diagnostics and host policy.
+ * Never use this to rewrite user, assistant or tool content.
+ */
+export declare function formatErrorMessage(error: unknown, fallback?: string): string;
 export declare function isAbortError(error: unknown): boolean;
 /**
  * Transient conditions worth a reconnect: network-level failures (`fetch`

package/dist/external-vault-receiver.d.ts

@@ -0,0 +1,203 @@
+import { VaultProviderWireFreshness, VaultProviderWireRequest, type VaultProviderWireAuthority, type VaultProviderWireErrorCode, type VaultProviderWireOperationName, type VaultProviderWirePage, type VaultProviderWireProvider, type VaultProviderWireResult, type VaultProviderWireWriteItem } from "@opengeni/contracts/vault-provider-wire";
+export { VAULT_PROVIDER_WIRE_ERROR_CODES, VAULT_PROVIDER_WIRE_LIMITS, VAULT_PROVIDER_WIRE_RESPONSE_SIGNATURE_HEADER, VAULT_PROVIDER_WIRE_VERSION, vaultProviderWireResponseKey, } from "@opengeni/contracts/vault-provider-wire";
+export type { VaultProviderWireAuthority, VaultProviderWireDescribeResult, VaultProviderWireErrorCode, VaultProviderWireFieldMeta, VaultProviderWireFieldValue, VaultProviderWireFreshness, VaultProviderWireItemMeta, VaultProviderWireOperation, VaultProviderWireOperationName, VaultProviderWirePage, VaultProviderWireProvider, VaultProviderWireRequest, VaultProviderWireResponse, VaultProviderWireResult, VaultProviderWireVault, VaultProviderWireWriteField, VaultProviderWireWriteItem, } from "@opengeni/contracts/vault-provider-wire";
+/** A definite, safe receiver failure. Its message is never sent to Opengeni. */
+export declare class ExternalVaultReceiverError extends Error {
+    readonly code: VaultProviderWireErrorCode;
+    readonly retryAfterMs: number | null;
+    readonly freshness: VaultProviderWireFreshness | null;
+    constructor(code: VaultProviderWireErrorCode, options?: {
+        retryAfterMs?: number;
+        freshness?: VaultProviderWireFreshness;
+        message?: string;
+    });
+}
+export interface ExternalVaultReceiverConnection<TConnection> {
+    provider: VaultProviderWireProvider;
+    /**
+     * Accepted signing secrets: the current one first, then a previous one
+     * during rotation. Responses are signed with the secret that verified.
+     */
+    signingSecrets: readonly string[];
+    /** When set, requests for any other Opengeni account are refused. */
+    accountId?: string;
+    /** When set, requests for a connection owned by another workspace are refused. */
+    connectionWorkspaceId?: string;
+    /** Host data for this connection: its fixed inventory scope, not a user. */
+    context: TConnection;
+}
+export type ExternalVaultMutationClaim = {
+    state: "claimed";
+} | {
+    state: "completed";
+    result: unknown;
+}
+/** In flight, or uncertain after a failure: report an unknown outcome. */
+ | {
+    state: "pending";
+}
+/** Same key, different operation or caller. */
+ | {
+    state: "mismatch";
+};
+/**
+ * Caller-owned replay and idempotency storage. Use durable shared storage
+ * (for example a database table with unique keys) when the receiver runs in
+ * more than one process or must survive restarts.
+ */
+export interface ExternalVaultReceiverStore {
+    /** Atomically record a request id. False when it was already recorded. */
+    rememberRequest(input: {
+        connectionId: string;
+        requestId: string;
+        expiresAt: Date;
+    }): Promise<boolean>;
+    /** Atomically claim a mutation key, or report its existing state. */
+    claimMutation(input: {
+        connectionId: string;
+        idempotencyKey: string;
+        digest: string;
+        expiresAt: Date;
+    }): Promise<ExternalVaultMutationClaim>;
+    /** Record the metadata-only result of a confirmed mutation. */
+    completeMutation(input: {
+        connectionId: string;
+        idempotencyKey: string;
+        digest: string;
+        result: unknown;
+    }): Promise<void>;
+    /** The handler definitely changed nothing: allow the key to be claimed again. */
+    releaseMutation(input: {
+        connectionId: string;
+        idempotencyKey: string;
+        digest: string;
+    }): Promise<void>;
+}
+export interface ExternalVaultHandlerOutput<R> {
+    result: R;
+    freshness?: VaultProviderWireFreshness | null;
+}
+type ReadContext = {
+    forceRefresh: boolean;
+    cacheEpoch: string | null;
+};
+export interface ExternalVaultCallContext<TConnection, TPrincipal> {
+    connectionId: string;
+    connection: TConnection;
+    /** The host principal returned by `authorize` for this exact request. */
+    principal: TPrincipal;
+    authority: VaultProviderWireAuthority;
+    requestId: string;
+    signal?: AbortSignal;
+}
+/**
+ * Inventory handlers receive the connection, not the acting principal: one
+ * connection has one fixed inventory, so listings must not vary by subject.
+ */
+export interface ExternalVaultInventoryContext<TConnection> {
+    connectionId: string;
+    connection: TConnection;
+    requestId: string;
+    signal?: AbortSignal;
+}
+export interface ExternalVaultReceiverHandlers<TConnection, TPrincipal> {
+    describe(ctx: ExternalVaultInventoryContext<TConnection>): Promise<ExternalVaultHandlerOutput<VaultProviderWireResult<"describe">>>;
+    /** Deliberate upstream refresh; omit when the store is always live. */
+    refresh?(ctx: ExternalVaultInventoryContext<TConnection>): Promise<ExternalVaultHandlerOutput<VaultProviderWireResult<"refresh">>>;
+    listVaults(ctx: ExternalVaultInventoryContext<TConnection>, input: {
+        page: VaultProviderWirePage;
+    } & ReadContext): Promise<ExternalVaultHandlerOutput<VaultProviderWireResult<"list_vaults">>>;
+    listItems(ctx: ExternalVaultInventoryContext<TConnection>, input: {
+        externalVaultId: string;
+        page: VaultProviderWirePage;
+    } & ReadContext): Promise<ExternalVaultHandlerOutput<VaultProviderWireResult<"list_items">>>;
+    readFields(ctx: ExternalVaultCallContext<TConnection, TPrincipal>, input: {
+        externalVaultId: string;
+        externalItemId: string;
+        externalFieldIds: readonly string[];
+    } & ReadContext): Promise<ExternalVaultHandlerOutput<VaultProviderWireResult<"read_fields">>>;
+    /** Omit when the connection is read-only. Throw only definite failures. */
+    writeItem?(ctx: ExternalVaultCallContext<TConnection, TPrincipal>, input: {
+        externalVaultId: string;
+        item: VaultProviderWireWriteItem;
+        idempotencyKey: string;
+    }): Promise<ExternalVaultHandlerOutput<VaultProviderWireResult<"write_item">>>;
+    archiveItem?(ctx: ExternalVaultCallContext<TConnection, TPrincipal>, input: {
+        externalVaultId: string;
+        externalItemId: string;
+        idempotencyKey: string;
+    }): Promise<ExternalVaultHandlerOutput<VaultProviderWireResult<"archive_item">>>;
+}
+export interface ExternalVaultAuthorizeInput<TConnection> {
+    connectionId: string;
+    connection: TConnection;
+    authority: VaultProviderWireAuthority;
+    operation: {
+        op: VaultProviderWireOperationName;
+        externalVaultId?: string;
+        externalItemId?: string;
+    };
+    requestId: string;
+}
+export interface ExternalVaultReceiverOptions<TConnection, TPrincipal> {
+    /** Unknown connections are indistinguishable from bad signatures. */
+    resolveConnection(connectionId: string): Promise<ExternalVaultReceiverConnection<TConnection> | null>;
+    /**
+     * Map Opengeni's native account/workspace/subject to the host tenant and
+     * user and recheck access for this operation. Return null to refuse.
+     * Called for every request, including inventory reads.
+     */
+    authorize(input: ExternalVaultAuthorizeInput<TConnection>): Promise<TPrincipal | null>;
+    handlers: ExternalVaultReceiverHandlers<TConnection, TPrincipal>;
+    store: ExternalVaultReceiverStore;
+    /** How long mutation results stay replayable. Default 24 hours. */
+    mutationRetentionMs?: number;
+    now?: () => number;
+    /** Host diagnostics. Never forward these errors to Opengeni. */
+    onError?(event: {
+        stage: "authorize" | "handler" | "store" | "output";
+        op: VaultProviderWireOperationName;
+        connectionId: string;
+        error: unknown;
+    }): void;
+}
+export interface ExternalVaultReceiverHttpRequest {
+    /** The exact raw request body; parse nothing before calling `handle`. */
+    body: string;
+    headers: Headers | Record<string, string | string[] | undefined>;
+    signal?: AbortSignal;
+}
+export interface ExternalVaultReceiverHttpResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}
+export interface ExternalVaultReceiver {
+    handle(request: ExternalVaultReceiverHttpRequest): Promise<ExternalVaultReceiverHttpResponse>;
+    /** Fetch-style adapter: POST only, bounded body, then `handle`. */
+    fetch(request: Request): Promise<Response>;
+}
+/**
+ * Keyed digest of one mutation's exact scope: connection, provider, trusted
+ * caller tuple and operation (without its idempotency key). Keyed so the
+ * store never holds a plain hash of submitted secret values.
+ */
+export declare function externalVaultMutationDigest(input: {
+    signingSecret: string;
+    request: VaultProviderWireRequest;
+}): Promise<string>;
+/** Mirrors Opengeni's secret-name rule: usable item/field names from upstream titles. */
+export declare function safeExternalVaultName(raw: string, fallback?: string): string;
+/** A safe field name, unique case-insensitively within `taken` (which it updates). */
+export declare function uniqueExternalVaultFieldName(raw: string, taken: Set<string>, fallback?: string): string;
+/**
+ * Process-local store for tests, development and a single-process bridge
+ * that accepts losing replay/idempotency memory on restart. It is not durable.
+ */
+export declare function createInMemoryExternalVaultReceiverStore(options?: {
+    maxEntries?: number;
+    now?: () => number;
+}): ExternalVaultReceiverStore & {
+    size(): number;
+};
+export declare function createExternalVaultReceiver<TConnection, TPrincipal>(options: ExternalVaultReceiverOptions<TConnection, TPrincipal>): ExternalVaultReceiver;