@granular-software/sdk 0.4.73 → 0.4.75

package/dist/client-WJrPOw6N.d.ts

@@ -1,1379 +0,0 @@
-import { dv as WSClientOptions, ab as SessionFeedApi, bf as GranularQuotaProgress, T as ToolWithHandler, t as PublishToolsResult, cl as Job, u as ToolHandler, I as InstanceToolHandler, co as UserMessageInput, cp as UserMessageAppendResult, c8 as EffectInfo, n as Prompt, c7 as ToolInfo, ca as EffectsChangedEvent, c9 as ToolsChangedEvent, D as DomainState, ae as FeedListTransport, aX as GranularOptions, e1 as EnvironmentImporter, a_ as RecordUserOptions, aZ as User, b0 as OpenEnvironmentOptions, E as EnvironmentData, aW as AccessTokenProvider, bp as BuildPolicy, d_ as EnvironmentSetupSummary, b6 as ConversationSessionListOptions, b4 as ConversationSessionInfo, b7 as ConversationSessionListResponse, b3 as CreateSessionOptions, h as RecordObjectOptions, dN as RecordObjectResult, dP as RecordObjectsOptions, dW as RecordImport, dS as RecordImportStatus, dV as RecordImportItem, a as EnvironmentRecordImportSummary, cj as EnvironmentFeedbackRecord, m as SessionHeapSnapshot, dh as SessionDocumentResult, cq as AssistantReplyPublicationInput, cr as AssistantReplyPublicationResult, di as SessionCollectionListOptions, dk as SessionCollectionListResult, cu as SessionTimelineEvent, dj as SessionJobListOptions, da as SessionJobRecord, bT as SessionMutationView, cN as SessionArtifactListOptions, r as SessionArtifactRecord, cP as SessionArtifactRelationshipOptionsInput, cR as SessionArtifactRelationshipOptionsResult, cS as SessionArtifactRelationshipCreateInput, cO as SessionArtifactValidationResult, cU as SessionArtifactExecutionOptions, cT as SessionArtifactExecutionResult, cV as SessionArtifactApprovalOptions, d3 as RecordManualActionInput, d5 as ManualActionRecordResult, d6 as ManualActionListOptions, d4 as ManualActionOccurrence, d8 as ManualActionSuggestionOptions, d7 as ManualActionSuggestion, cY as ArtifactApprovalTaskListOptions, cX as ArtifactApprovalTask, cZ as ArtifactApprovalDecisionInput, c_ as ArtifactApprovalDecisionResult, cy as SessionFileRecord, d9 as SessionFileUploadOptions, S as SessionHeapEntry, k as SessionHeapList, dd as SessionHeapVariable, o as SessionTranscriptEntry, ev as GraphQLResult, df as RecordSearchOptions, de as RecordSearchResult, dg as RecordMentionInput, dG as DefineRelationshipOptions, dF as RelationshipInfo, dE as ModelRef, i as ManifestContent, dK as EnvironmentStateUpdateInput, dI as EnvironmentStateTarget, dM as EnvironmentStateProxy, dR as RecordImportOptions, dr as UserEnvironmentStateOptions, dq as UserEnvironmentState, ds as MarkUserEnvironmentReadOptions, d as ProjectionMapper, bM as EffectProjectionResult, bR as ExternalCommitOptions, C as CommitReceipt, bN as TransitionProjectionResult, bS as ObservationReceipt, b1 as AdoptEnvironmentOptions, b2 as ConnectOptions, dY as RunEnvironmentImporterOptions, aJ as OpenAIUsageSpendEvent, aI as GranularSpendContext, aL as RecordOpenAIUsageSpendResult, bi as SandboxListResponse, bg as Sandbox, bh as CreateSandboxData, ex as DeleteResponse, bk as PermissionProfile, bl as CreatePermissionProfileData, bs as CreateEnvironmentData, ey as StreamEvent, ez as StreamSubscription, eA as StreamStats, a$ as Subject, bo as AssignmentListResponse } from './spend-k8V2Y1Tt.js';
-import * as Automerge from '@automerge/automerge';
-import { Doc } from '@automerge/automerge/slim';
-
-interface CanonicalDocumentQuarantine {
-    documentEpoch: number;
-    documentRevision: number;
-    error: Error;
-}
-declare class WSClient {
-    private ws;
-    private url;
-    private sessionId;
-    private token;
-    private messageQueue;
-    private pendingRpcPeriodStartedAt;
-    private rpcHandlers;
-    private eventHandlers;
-    private canonicalDocumentQuarantineHandlers;
-    private nextRpcId;
-    doc: Automerge.Doc<Record<string, unknown>>;
-    private reconnectTimer;
-    private tokenRefreshTimer;
-    private isExplicitlyDisconnected;
-    private reconnectAttempts;
-    private connectPromise;
-    private connectionEpoch;
-    private cancelConnectAttempt;
-    private documentRepairRequired;
-    private canonicalDocumentActivated;
-    private lastInboundActivityAt;
-    private options;
-    constructor(options: WSClientOptions);
-    get currentSessionId(): string;
-    isTransportOpen(): boolean;
-    hasPendingRpcRequests(): boolean;
-    hasRecentlyPendingRpcPeriod(maxAgeMs: number, now?: number): boolean;
-    private removePendingRpc;
-    /**
-     * Whether the current socket has delivered any frame recently. SessionDO
-     * broadcasts a one-way heartbeat every five seconds, so this measures the
-     * transport without adding an RPC that can be delayed by application work.
-     */
-    hasRecentInboundActivity(maxAgeMs: number, now?: number): boolean;
-    seedDocumentSnapshot(document: Record<string, unknown> | Uint8Array | null | undefined): void;
-    saveDocumentSnapshot(): Uint8Array;
-    private clearTokenRefreshTimer;
-    private decodeBase64Url;
-    private getTokenExpiryMs;
-    private scheduleTokenRefresh;
-    private refreshTokenInBackground;
-    private resolveTokenForConnect;
-    /**
-     * Connect to the WebSocket server
-     * @returns {Promise<void>} Resolves when connection is open
-     */
-    connect(options?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Mark the current transport as unusable and schedule the normal reconnect
-     * path. Browser WebSockets can remain in OPEN state after a proxy/worker
-     * restart, so a timed-out heartbeat must revoke the stale socket explicitly.
-     */
-    reportTransportFailure(reason?: unknown): void;
-    private connectAttempt;
-    private normalizeReason;
-    private rejectPending;
-    private emitReconnectErrorMessage;
-    private scheduleReconnectAttempt;
-    private buildDisconnectError;
-    private decodeDocumentBytes;
-    private rememberCanonicalActivation;
-    private canAcceptDocumentReplacement;
-    private exposeCanonicalQuarantine;
-    private canonicalReplacementError;
-    private assertIncrementalDocumentIsSafe;
-    private requireDocumentResync;
-    private handleDisconnect;
-    private handleMessage;
-    /**
-     * Make an RPC call to the server
-     * @param {string} method - RPC method name
-     * @param {unknown} params - Request parameters
-     * @returns {Promise<unknown>} Response result
-     * @throws {Error} If connection is closed or timeout occurs
-     */
-    call(method: string, params: unknown): Promise<unknown>;
-    private handleIncomingRpc;
-    /**
-     * Subscribe to client events
-     * @param {string} event - Event name
-     * @param {Function} handler - Event handler
-     */
-    on(event: string, handler: (params: unknown) => void): void;
-    /**
-     * Subscribe to rejected canonical replacement metadata without exposing the
-     * malformed document through the public sync stream.
-     *
-     * @internal Session uses this to quarantine only its feed projection.
-     */
-    onCanonicalDocumentQuarantine(handler: (quarantine: CanonicalDocumentQuarantine) => void): () => void;
-    /**
-     * Register an RPC handler for incoming server requests
-     * @param {string} method - RPC method name
-     * @param {Function} handler - Handler function
-     */
-    registerRpcHandler(method: string, handler: (params: unknown) => Promise<unknown>): void;
-    /**
-     * Unsubscribe from client events
-     * @param {string} event - Event name
-     * @param {Function} handler - Handler to remove
-     */
-    off(event: string, handler: (params: unknown) => void): void;
-    /**
-     * Emit an event locally
-     * @param {string} event - Event name
-     * @param params - Event data
-     */
-    emit(event: string, params: unknown): void;
-    /**
-     * Disconnect the WebSocket and clear state
-     */
-    disconnect(options?: {
-        reason?: string;
-    }): void;
-}
-
-declare class Session {
-    protected client: WSClient;
-    private clientId;
-    private initialQuota;
-    private jobsMap;
-    private eventListeners;
-    private toolHandlers;
-    /** Tracks which tools are instance methods (className set, not static) */
-    private instanceTools;
-    private currentDomainRevision;
-    /** Local effect registry: name → full ToolWithHandler */
-    private effects;
-    /** Last known tools for diffing */
-    private lastKnownTools;
-    /** Last seen live prompts, keyed by prompt id, for answer normalization */
-    private promptCache;
-    /** Prompt ids locally answered before the document sync catches up. */
-    private hiddenPromptIds;
-    private domainPackagePartCache;
-    private domainPackagePartPromises;
-    private domainPackageFetchQueue;
-    private readonly feedController;
-    readonly feed: SessionFeedApi;
-    constructor(client: WSClient, clientId?: string, options?: {
-        initialQuota?: GranularQuotaProgress | null;
-    });
-    private extractDomainRevisionFromDoc;
-    /**
-     * Prompt delivery is deliberately event-driven while a socket is live, but
-     * an existing session can be attached from a fresh tab/client after the
-     * event was originally sent. Rebuild that client's prompt cache from the
-     * canonical document on every sync so an open durable prompt remains
-     * actionable after reconnect without manufacturing a second prompt.
-     */
-    private reconcilePromptCacheFromCanonicalDocument;
-    private buildDirectedInvocationEffectContext;
-    private createDirectedInvocationFeedbackContext;
-    get document(): Doc<Record<string, unknown>>;
-    get quota(): GranularQuotaProgress | null;
-    getQuota(): GranularQuotaProgress | null;
-    get sessionId(): string;
-    get domainRevision(): string | null;
-    /**
-     * Make a raw RPC call to the session's Durable Object.
-     *
-     * Use this when you need to call an RPC method that doesn't have a
-     * dedicated wrapper method on the Session/Environment class.
-     *
-     * @param method - RPC method name (e.g. 'domain.fetchPackagePart')
-     * @param params - Request parameters
-     * @returns The raw RPC response
-     *
-     * @example
-     * ```typescript
-     * const result = await env.rpc('domain.fetchPackagePart', {
-     *   moduleSpecifier: '@sandbox/domain',
-     *   part: 'types',
-     * });
-     * ```
-     */
-    rpc<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>;
-    /**
-     * Send client hello to establish the session
-     */
-    hello(): Promise<{
-        ok: boolean;
-        environmentId?: string;
-        docId?: string;
-        features?: {
-            /** Whether the server sends application-level heartbeat frames. */
-            serverHeartbeat?: boolean;
-            /** Whether the server expects a hibernatable WebSocket lifecycle. */
-            hibernatingWebSocket?: boolean;
-        };
-        graphContainerStatus?: {
-            lastKeepAliveAt: number;
-            status: "warming" | "hot" | "unknown";
-        };
-    }>;
-    publishTools(tools: ToolWithHandler[], revision?: string): Promise<PublishToolsResult>;
-    publishEffect(effect: ToolWithHandler): Promise<PublishToolsResult>;
-    publishEffects(effects: ToolWithHandler[]): Promise<PublishToolsResult>;
-    unpublishEffect(name: string): Promise<PublishToolsResult>;
-    unpublishAllEffects(): Promise<PublishToolsResult>;
-    /**
-     * Submit a job to execute code in the sandbox.
-     *
-     * The code can import typed classes from Harness v3 runtime modules:
-     * ```typescript
-     * import { Author } from "@granular/domain/Author";
-     * import { Book } from "@granular/domain/Book";
-     * import { global_search } from "@granular/actions/backend";
-     *
-     * const totalAuthors = await Author.count();
-     * const firstAuthorsPage = await Author.page({ page: 1, perPage: 10, saveAs: 'recent_authors' });
-     * const authors = firstAuthorsPage.items;
-     * const tolkien = await Author.get({ path: 'author_tolkien' });
-     * const bio = await tolkien.get_bio({ detailed: true });
-     * const books = await tolkien.get_books();
-     * for await (const author of Author.iterate({ perPage: 100, maxItems: 500 })) {
-     *   console.log(author.id);
-     * }
-     * ```
-     *
-     * Effect calls (instance methods, static methods, global functions) trigger
-     * `effect.invoke` RPC back to the sandbox effect host, where the registered handlers
-     * execute locally and return the result to the sandbox.
-     */
-    submitJob(code: string, domainRevisionOrOptions?: string | {
-        domainRevision?: string;
-        metadata?: Record<string, unknown>;
-        agent?: Record<string, unknown>;
-    }): Promise<Job>;
-    /**
-     * Register a handler for a specific tool.
-     * @param isInstance - If true, handler will receive (id, params) for instance method dispatch.
-     */
-    registerToolHandler(name: string, handler: ToolHandler | InstanceToolHandler, isInstance?: boolean): void;
-    /**
-     * Respond to a prompt request from the sandbox
-     */
-    answerPrompt(promptId: string, answer: unknown): Promise<void>;
-    appendUserMessage(input: UserMessageInput): Promise<UserMessageAppendResult>;
-    /**
-     * Get the current list of available effects.
-     * Consolidates effect declarations and live availability for the session.
-     */
-    getEffects(): EffectInfo[];
-    /**
-     * Return the currently open prompt payloads known to this session.
-     *
-     * These come from live `prompt` / `prompt.request` websocket events and
-     * preserve the exact shape used by `answerPrompt(...)`.
-     */
-    getPrompts(): Prompt[];
-    getHiddenPromptIds(): string[];
-    /**
-     * Backwards-compatible alias for `getEffects()`.
-     */
-    getTools(): ToolInfo[];
-    /**
-     * Subscribe to effect changes (added, removed, updated).
-     * @param callback - Function called with change events
-     * @returns Unsubscribe function
-     */
-    onEffectsChanged(callback: (event: EffectsChangedEvent) => void): () => void;
-    /**
-     * Backwards-compatible alias for `onEffectsChanged()`.
-     */
-    onToolsChanged(callback: (event: ToolsChangedEvent) => void): () => void;
-    /**
-     * Get the current domain state and available tools
-     */
-    getDomain(): Promise<DomainState>;
-    /**
-     * Fetch a domain package part from the backend (no fallback).
-     */
-    private fetchDomainPart;
-    /**
-     * Get TypeScript class declarations for the current domain (for LLM/code gen).
-     */
-    getDomainTypes(): Promise<string>;
-    /**
-     * Get Markdown documentation for the current domain (human-readable).
-     */
-    getDomainDocs(): Promise<string>;
-    /**
-     * Get domain documentation for LLMs. Returns types (preferred) or fallback.
-     */
-    getDomainDocumentation(): Promise<string>;
-    /**
-     * Generate markdown documentation from the domain summary.
-     * Class-aware: groups tools by class with property/relationship info.
-     */
-    private generateFallbackDocs;
-    /**
-     * Close the session and disconnect from the sandbox
-     */
-    disconnect(): Promise<void>;
-    /** Stop feed repair work without detaching a reconnectable transport. */
-    protected disposeSessionFeed(): void;
-    /**
-     * Subscribe to session events
-     */
-    on(event: string, handler: (data: unknown) => void): () => void;
-    /**
-     * Unsubscribe from session events
-     */
-    off(event: string, handler: (data: unknown) => void): void;
-    protected setFeedListTransport(transport: FeedListTransport | null): void;
-    private setupToolInvokeHandler;
-    private setupEventHandlers;
-    protected emit(event: string, data: unknown): void;
-    /**
-     * Check for changes in the effect catalog and emit change events if needed.
-     */
-    private checkForToolChanges;
-}
-
-type SessionFileUploadBody = Blob | ArrayBuffer | Uint8Array | string;
-type SessionDataHeaders = any;
-type EnvironmentImporterHandler = (importer: EnvironmentImporter) => Promise<void> | void;
-declare function isGraphQLMutationDocument(query: unknown): boolean;
-/**
- * Environment is the sessionless handle for one resolved ontology environment.
- *
- * Use it to query or mutate environment data directly, or to open live runtime
- * sessions through `environment.sessions.*` when you need jobs, prompts, or a
- * synced Automerge document.
- */
-declare class Environment {
-    private granular;
-    private envData;
-    private _apiKey;
-    private _apiEndpoint;
-    private _tokenProvider?;
-    private _beforeMutationSend?;
-    constructor(granular: Granular, envData: EnvironmentData, apiKey: string, apiEndpoint: string, tokenProvider?: AccessTokenProvider, beforeMutationSend?: () => void);
-    /** The environment ID */
-    get environmentId(): string;
-    /** The sandbox ID */
-    get sandboxId(): string;
-    /** The ontology ID */
-    get ontologyId(): string;
-    /** The subject ID */
-    get subjectId(): string;
-    /** The named environment slot, such as dev or prod */
-    get envName(): string;
-    /** The named environment slot, such as dev or prod */
-    get environment(): string;
-    /** The resolved ontology version backing this environment */
-    get versionId(): string;
-    /** Internal Granular user identifier for this environment */
-    get granularId(): string;
-    /** The permission profile ID */
-    get permissionProfileId(): string;
-    /** The current build policy backing this environment */
-    get buildPolicy(): BuildPolicy;
-    /** The current update state relative to the followed tag */
-    get updateState(): EnvironmentData["updateState"];
-    /** The latest setup/import run summary for this environment, when available. */
-    get setup(): EnvironmentSetupSummary | null;
-    /** Convenience flag for whether this environment trails the current tag target */
-    get isOutdated(): boolean;
-    /** The followed tag name when this environment is tag-tracked */
-    get tag(): string | null;
-    /** The GraphQL API endpoint URL */
-    get apiEndpoint(): string;
-    /** Internal auth token used for control-plane and runtime fallback requests */
-    get authToken(): string;
-    resolveAuthToken(): string | Promise<string>;
-    /** Base runtime URL derived from the GraphQL endpoint */
-    get runtimeBaseUrl(): string;
-    syncEnvironmentData(envData: EnvironmentData): void;
-    get sessions(): {
-        list: (options?: Omit<ConversationSessionListOptions, "environmentId" | "sandboxId" | "subjectId">) => Promise<ConversationSessionInfo[]>;
-        page: (options?: Omit<ConversationSessionListOptions, "environmentId" | "sandboxId" | "subjectId">) => Promise<ConversationSessionListResponse>;
-        create: (options?: CreateSessionOptions) => Promise<EnvironmentSession>;
-        connect: (sessionId: string, options?: {
-            clientId?: string;
-        }) => Promise<EnvironmentSession>;
-        reopen: (sessionId: string, options?: {
-            clientId?: string;
-        }) => Promise<EnvironmentSession>;
-        close: (sessionId: string, session?: EnvironmentSession | null) => Promise<void>;
-        state: (options?: UserEnvironmentStateOptions) => Promise<UserEnvironmentState>;
-        markRead: (options: MarkUserEnvironmentReadOptions) => Promise<UserEnvironmentState["readThroughSequenceBySessionId"]>;
-    };
-    get userEnvironmentState(): {
-        get: (options?: UserEnvironmentStateOptions) => Promise<UserEnvironmentState>;
-        markRead: (options: MarkUserEnvironmentReadOptions) => Promise<UserEnvironmentState["readThroughSequenceBySessionId"]>;
-    };
-    get data(): {
-        record: (record: RecordObjectOptions) => Promise<RecordObjectResult>;
-        recordMany: (records: RecordObjectOptions[], options?: RecordObjectsOptions) => Promise<RecordObjectResult[]>;
-        import: (records: RecordObjectOptions[], options?: {
-            batchSize?: number;
-        }) => Promise<RecordImport>;
-        listImports: (status?: RecordImportStatus) => Promise<RecordImport[]>;
-        getImport: (importId: string) => Promise<RecordImport>;
-        listImportItems: (importId: string, status?: RecordImportItem["status"]) => Promise<RecordImportItem[]>;
-        getImportSummary: () => Promise<EnvironmentRecordImportSummary>;
-        cancelImport: (importId: string) => Promise<RecordImport>;
-        getAwaitingCount: () => Promise<number>;
-    };
-    /**
-     * Acknowledge a declared product mutation that already happened outside a
-     * Granular-run effect (for example, in a webhook consumer). These methods
-     * run the declaration's pure projection mapper; they never call its handler.
-     */
-    get commit(): {
-        effect: <TResult>(effect: ToolWithHandler & {
-            commit: {
-                kind: "effect";
-                project: ProjectionMapper<TResult, EffectProjectionResult>;
-            };
-        }, productResult: TResult, options?: ExternalCommitOptions) => Promise<CommitReceipt>;
-        transition: <TResult>(transition: {
-            from: string;
-            outcomes: Record<string, unknown>;
-            effect: ToolWithHandler & {
-                commit: {
-                    kind: "transition";
-                    project: ProjectionMapper<TResult, TransitionProjectionResult>;
-                };
-            };
-        }, productResult: TResult, options?: ExternalCommitOptions) => Promise<CommitReceipt>;
-        get: (commitId: string) => Promise<CommitReceipt>;
-        retry: (commitId: string) => Promise<CommitReceipt>;
-    };
-    /** Inspect or retry the agent synchronization of a product snapshot. */
-    get observation(): {
-        get: (observationId: string) => Promise<ObservationReceipt>;
-        retry: (observationId: string) => Promise<ObservationReceipt>;
-    };
-    private persistExternalEffect;
-    private persistExternalTransition;
-    private requireExternalIdentity;
-    /**
-     * Synchronize a versioned product snapshot without claiming an effect or
-     * lifecycle transition. This records no transition history.
-     */
-    observe<TResult>(mapper: ProjectionMapper<TResult, EffectProjectionResult>, productResult: TResult): Promise<ObservationReceipt>;
-    /**
-     * Mirror product-owned workflow state into Granular without making Granular
-     * own the customer application's state machine.
-     */
-    recordState(input: EnvironmentStateUpdateInput): Promise<RecordObjectResult>;
-    /**
-     * Mirror product-owned workflow state into Granular without making Granular
-     * own the customer application's state machine.
-     *
-     * Example:
-     * `await env.recordState({ className: "spend_request", id, machine: "lifecycle", state: "policy_review", source: "customer_backend" })`
-     */
-    state(target: EnvironmentStateTarget): EnvironmentStateProxy;
-    get feedback(): {
-        list: () => Promise<EnvironmentFeedbackRecord[]>;
-    };
-    get manualActions(): {
-        record: (input: RecordManualActionInput) => Promise<ManualActionRecordResult>;
-        list: (options?: ManualActionListOptions) => Promise<SessionCollectionListResult<ManualActionOccurrence>>;
-        suggest: (options?: ManualActionSuggestionOptions) => Promise<{
-            items: ManualActionSuggestion[];
-        }>;
-    };
-    get artifactApprovals(): {
-        list: (options?: ArtifactApprovalTaskListOptions) => Promise<SessionCollectionListResult<ArtifactApprovalTask>>;
-        decide: (approvalTaskId: string, input: ArtifactApprovalDecisionInput) => Promise<ArtifactApprovalDecisionResult>;
-    };
-    /**
-     * Sessionless environments do not own a live transport, so disconnecting the
-     * environment handle itself is a no-op. This keeps the public surface
-     * symmetric with `EnvironmentSession.disconnect()` and lets callers always
-     * clean up safely without tracking whether they currently hold an environment
-     * or a session.
-     */
-    disconnect(): Promise<void>;
-    listSessions(status?: ConversationSessionListOptions["status"]): Promise<ConversationSessionInfo[]>;
-    listSessions(options?: Omit<ConversationSessionListOptions, "environmentId" | "sandboxId" | "subjectId">): Promise<ConversationSessionInfo[]>;
-    getUserEnvironmentState(options?: UserEnvironmentStateOptions): Promise<UserEnvironmentState>;
-    markUserEnvironmentSessionsRead(options: MarkUserEnvironmentReadOptions): Promise<UserEnvironmentState["readThroughSequenceBySessionId"]>;
-    createSession(options?: CreateSessionOptions): Promise<EnvironmentSession>;
-    connectSession(sessionId: string, options?: {
-        clientId?: string;
-        maxReconnectAttempts?: number;
-        reconnectDelayMs?: number;
-    }): Promise<EnvironmentSession>;
-    reopenSession(sessionId: string, options?: {
-        clientId?: string;
-    }): Promise<EnvironmentSession>;
-    closeSession(sessionId: string, session?: EnvironmentSession | null): Promise<void>;
-    listFeedback(): Promise<EnvironmentFeedbackRecord[]>;
-    recordManualAction(input: RecordManualActionInput): Promise<ManualActionRecordResult>;
-    listManualActions(options?: ManualActionListOptions): Promise<SessionCollectionListResult<ManualActionOccurrence>>;
-    suggestManualActions(options?: ManualActionSuggestionOptions): Promise<{
-        items: ManualActionSuggestion[];
-    }>;
-    listArtifactApprovals(options?: ArtifactApprovalTaskListOptions): Promise<SessionCollectionListResult<ArtifactApprovalTask>>;
-    decideArtifactApproval(approvalTaskId: string, input: ArtifactApprovalDecisionInput): Promise<ArtifactApprovalDecisionResult>;
-    private getRuntimeBaseUrl;
-    private controlPlaneRequest;
-    private static normalizeGraphPathSegment;
-    /**
-     * Convert a class name + application record ID into Granular's graph path.
-     *
-     * This mirrors the record-write path normalization used by the control plane.
-     * Keep the original customer/system ID in `real_id`; graph paths are stable
-     * internal addresses, not the source of truth for business identity.
-     */
-    static toGraphPath(className: string, id: string): string;
-    /**
-     * Best-effort extraction of an ID-like suffix from a graph path.
-     *
-     * Prefer the record's `real_id` field whenever exact customer/system IDs
-     * matter, because graph path normalization is intentionally lossy.
-     */
-    static extractIdFromGraphPath(graphPath: string, className: string): string;
-    /**
-     * Execute a GraphQL query against the environment's graph.
-     *
-     * The query uses the Granular graph query language (based on Cypher/GraphQL).
-     * Authentication is handled automatically using the SDK's API key.
-     *
-     * @param query - The GraphQL query string
-     * @param variables - Optional variables for the query
-     * @returns The query result data
-     *
-     * @example
-     * ```typescript
-     * // Read the workspace
-     * const result = await env.graphql(
-     *   `query { model(path: "workspace") { path label submodels { path label } } }`
-     * );
-     * console.log(result.data);
-     *
-     * // Create a model
-     * const created = await env.graphql(
-     *   `mutation { at(path: "workspace") { create_submodel(subpath: "my_node", label: "My Node", prototype: "Model") { model { path label } } } }`
-     * );
-     * ```
-     */
-    graphql<T = any>(query: string, variables?: Record<string, any>): Promise<GraphQLResult<T>>;
-    searchRecords(query: string, options?: RecordSearchOptions): Promise<RecordSearchResult[]>;
-    /**
-     * Define a relationship between two model types.
-     *
-     * Creates both submodels (if they don't exist) and links them with
-     * a RelationshipDef node that encodes cardinality.
-     *
-     * @example
-     * ```typescript
-     * // Author has many Books, Book has one Author
-     * const rel = await env.defineRelationship({
-     *   model: 'author',
-     *   localSubmodel: 'books',
-     *   localIsMany: true,
-     *   foreignModel: 'book',
-     *   foreignSubmodel: 'author',
-     *   foreignIsMany: false,
-     * });
-     * console.log(rel.relationship_kind); // "one_to_many"
-     * ```
-     */
-    defineRelationship(options: DefineRelationshipOptions): Promise<RelationshipInfo>;
-    /**
-     * Get all relationships for a model type.
-     *
-     * @param modelPath - The model type path (e.g., "author")
-     * @returns Array of relationships from this model's perspective
-     *
-     * @example
-     * ```typescript
-     * const rels = await env.getRelationships('author');
-     * for (const rel of rels) {
-     *   console.log(`${rel.local_submodel.path} -> ${rel.foreign_model.path} (${rel.relationship_kind})`);
-     * }
-     * ```
-     */
-    getRelationships(modelPath: string): Promise<RelationshipInfo[]>;
-    /**
-     * Attach a target model to a relationship submodel.
-     *
-     * Handles cardinality automatically:
-     * - "One" side: sets/replaces the reference
-     * - "Many" side: adds the target to the collection
-     *
-     * If the target model doesn't exist, it's created as an instance of the foreign type.
-     * Bidirectional sync is automatic.
-     *
-     * @param modelPath - The model instance path (e.g., "tolkien")
-     * @param submodelPath - The relationship submodel (e.g., "books")
-     * @param targetPath - The target model to attach (e.g., "lord_of_the_rings")
-     *
-     * @example
-     * ```typescript
-     * // Attach a book to an author (many side)
-     * await env.attach('tolkien', 'books', 'lord_of_the_rings');
-     * // This also automatically sets lord_of_the_rings:author -> tolkien
-     * ```
-     */
-    attach(modelPath: string, submodelPath: string, targetPath: string): Promise<void>;
-    /**
-     * Detach a target model from a relationship submodel.
-     *
-     * Handles bidirectional cleanup automatically.
-     *
-     * @param modelPath - The model instance path
-     * @param submodelPath - The relationship submodel
-     * @param targetPath - The target to detach (optional for "one" side; omit on "many" side to detach all)
-     *
-     * @example
-     * ```typescript
-     * // Detach a specific book
-     * await env.detach('tolkien', 'books', 'lord_of_the_rings');
-     *
-     * // Detach all books
-     * await env.detach('tolkien', 'books');
-     * ```
-     */
-    detach(modelPath: string, submodelPath: string, targetPath?: string): Promise<void>;
-    /**
-     * List all related models through a relationship submodel.
-     *
-     * @param modelPath - The model instance path
-     * @param submodelPath - The relationship submodel
-     * @returns Array of related model references
-     *
-     * @example
-     * ```typescript
-     * const books = await env.listRelated('tolkien', 'books');
-     * console.log(books); // [{ path: "lord_of_the_rings", label: "Lord of the Rings" }, ...]
-     * ```
-     */
-    listRelated(modelPath: string, submodelPath: string): Promise<ModelRef[]>;
-    /**
-     * Apply a manifest to the current environment's graph.
-     *
-     * Translates each manifest operation into GraphQL mutations and executes them
-     * in order. This is the core mechanism for creating classes, fields, and
-     * relationships from a declarative manifest.
-     *
-     * @param manifest - The manifest content to apply
-     * @returns Summary of applied operations
-     *
-     * @example
-     * ```typescript
-     * await environment.applyManifest({
-     *   schemaVersion: 2,
-     *   name: 'my-app',
-     *   volumes: [{
-     *     name: 'schema',
-     *     scope: 'sandbox',
-     *     operations: [
-     *       { create: 'author', extends: 'class', has: { name: { type: 'string' } } },
-     *       { create: 'book', extends: 'class', has: { title: { type: 'string' } } },
-     *       { defineRelationship: {
-     *         left: 'author', right: 'book',
-     *         leftSubmodel: 'books', rightSubmodel: 'author',
-     *         leftIsMany: true, rightIsMany: false,
-     *       }},
-     *     ],
-     *   }],
-     * });
-     * ```
-     */
-    applyManifest(manifest: ManifestContent): Promise<{
-        applied: number;
-        errors: string[];
-    }>;
-    /**
-     * Resolve an alias reference like "@std/class" → "class"
-     * Strips the alias prefix, returning the bare model path.
-     */
-    private _resolveAlias;
-    private _runGraphql;
-    private _applyFieldMetamodels;
-    private _applyModelMetamodels;
-    private _ensureWorkspaceToolsRoot;
-    private _storeEffectSchemas;
-    private _applyEffectMetamodels;
-    private _ensureWorkspaceStreamsRoot;
-    private _applyEventStreamDeclaration;
-    private _applyEffectDeclaration;
-    /**
-     * Apply a single manifest operation via GraphQL
-     */
-    private _applyOperation;
-    /**
-     * Apply field definitions (has) to a model via GraphQL
-     */
-    private _applyFields;
-    /**
-     * Create or update an instance of a class in the graph.
-     *
-     * Uses `instantiate` under the hood, which has find-or-create semantics:
-     * if an instance with the given `id` already exists for the class it is
-     * returned; otherwise a new instance is created.  Fields are then set
-     * (overwriting previous values) and relationships are attached.
-     *
-     * The graph path is derived as `{className}_{id}` to ensure uniqueness
-     * across classes (two objects of different classes may share the same
-     * real-world ID).  Relationship targets are also resolved automatically
-     * using the foreign class from the relationship definition.
-     *
-     * @param options - The object specification
-     * @returns The graph path, real-world ID, and creation status
-     *
-     * @example
-     * ```typescript
-     * // Create an author with fields
-     * const result = await env.recordObject({
-     *   className: 'author',
-     *   id: 'tolkien',
-     *   label: 'J.R.R. Tolkien',
-     *   fields: { name: 'J.R.R. Tolkien', birth_year: 1892 },
-     *   relationships: { books: ['lotr', 'silmarillion'] },
-     * });
-     * // result.path → 'author_tolkien'  (internal graph path)
-     * // result.id   → 'tolkien'         (real-world ID)
-     * // result.created → true
-     * ```
-     */
-    recordObject(options: RecordObjectOptions): Promise<RecordObjectResult>;
-    /**
-     * Batch version of `recordObject()`.
-     *
-     * Sends rows through the control-plane **`/records/batch`** endpoint in **chunks** (default
-     * **100** records per HTTP request) so individual requests stay bounded and gateway timeouts are
-     * unlikely. Each chunk is retried on transient network / worker errors.
-     *
-     * Use the optional second argument to:
-     * - **`batchSize`** — rows per POST (smaller = more progress events; larger = fewer round trips).
-     * - **`concurrency`** — run up to N chunk POSTs in parallel (capped at 16) when you want lower wall time.
-     * - **`onChunkComplete`** — hook for UIs after each chunk succeeds (row order in the returned array
-     *   always matches `records`; chunk **completion** order may differ when `concurrency > 1`).
-     *
-     * For **asynchronous** ingestion with worker-side batching and aggregate counters (`queued`,
-     * `completed`, …), use **`enqueueRecordImport`** and poll **`getRecordImport`** /
-     * **`getRecordImportSummary`** — best for very large fire-and-forget loads when immediate
-     * synchronous commit of every row is not required.
-     */
-    recordObjects(records: RecordObjectOptions[], options?: RecordObjectsOptions): Promise<RecordObjectResult[]>;
-    private executeRecordObjectsChunk;
-    /**
-     * Queue a background record import for this environment (async worker pipeline).
-     *
-     * **vs `recordObjects`:** this path accepts the full payload in one request, returns an
-     * **`importId`**, and processes rows in the background — use **`getRecordImport`** /
-     * **`getRecordImportSummary`** for progress. Choose it for large bulk loads where you do not
-     * need every row committed before the HTTP call returns. Use **`recordObjects`** when you need
-     * synchronous upserts and fine-grained chunk progress via **`onChunkComplete`**.
-     */
-    enqueueRecordImport(records: RecordObjectOptions[], options?: RecordImportOptions): Promise<RecordImport>;
-    /**
-     * List queued or completed record imports for this environment.
-     */
-    listRecordImports(status?: RecordImportStatus): Promise<RecordImport[]>;
-    /**
-     * Fetch the latest aggregate import counters for this environment.
-     */
-    getRecordImportSummary(): Promise<EnvironmentRecordImportSummary>;
-    /**
-     * Convenience helper returning queued + processing records for this environment.
-     */
-    getAwaitingRecordCount(): Promise<number>;
-    /**
-     * Fetch a single record import by id.
-     */
-    getRecordImport(importId: string): Promise<RecordImport>;
-    /**
-     * List the individual records persisted for one asynchronous import. This
-     * makes terminal import failures diagnosable without database access.
-     */
-    listRecordImportItems(importId: string, status?: RecordImportItem["status"]): Promise<RecordImportItem[]>;
-    /**
-     * Cancel a queued/background record import.
-     */
-    cancelRecordImport(importId: string): Promise<RecordImport>;
-}
-/**
- * Live runtime session attached to one opened environment.
- *
- * This is the object returned by `environment.sessions.create()` and friends.
- * It owns websocket state, prompts, job execution, and the synced Automerge
- * document while delegating environment-level data APIs back to
- * `session.environment`.
- */
-declare class EnvironmentSession extends Session {
-    readonly environment: Environment;
-    private readonly sessionDataRoutePrefix;
-    private readonly sessionDataHeaders;
-    private readonly beforeMutationSend?;
-    private heartbeatTimer;
-    private heartbeatProbeInFlight;
-    /** The last known graph container status, updated by checkReadiness(). */
-    graphContainerStatus: {
-        lastKeepAliveAt: number;
-        status: "warming" | "hot" | "unknown";
-    } | null;
-    constructor(client: WSClient, environment: Environment, clientId: string, options?: {
-        sessionDataRoutePrefix?: string;
-        /**
-         * Browser-only request metadata forwarded with session-data mutations.
-         * This lets a session direct a frontend effect to the exact Dock client
-         * that initiated a user action when multiple tabs are connected.
-         */
-        sessionDataHeaders?: SessionDataHeaders;
-        /** Browser-only readiness guard checked immediately before each write. */
-        beforeMutationSend?: () => void;
-        initialQuota?: GranularQuotaProgress | null;
-    });
-    /**
-     * Keep the browser session transport observable from the client side.
-     * SessionDO already broadcasts a heartbeat every five seconds. Treat that
-     * and all other inbound frames as proof of life instead of issuing an RPC:
-     * an application RPC may be delayed by Durable Object work even while the
-     * underlying WebSocket is healthy.
-     */
-    private startHeartbeat;
-    private stopHeartbeat;
-    hello(): Promise<{
-        ok: boolean;
-        environmentId?: string;
-        docId?: string;
-        features?: {
-            serverHeartbeat?: boolean;
-            hibernatingWebSocket?: boolean;
-        };
-        graphContainerStatus?: {
-            lastKeepAliveAt: number;
-            status: "warming" | "hot" | "unknown";
-        };
-    }>;
-    get environmentId(): string;
-    get sandboxId(): string;
-    get ontologyId(): string;
-    get subjectId(): string;
-    get envName(): string;
-    get tag(): string | null;
-    get versionId(): string;
-    get granularId(): string;
-    get permissionProfileId(): string;
-    get apiEndpoint(): string;
-    get data(): {
-        record: (record: RecordObjectOptions) => Promise<RecordObjectResult>;
-        recordMany: (records: RecordObjectOptions[], options?: RecordObjectsOptions) => Promise<RecordObjectResult[]>;
-        import: (records: RecordObjectOptions[], options?: {
-            batchSize?: number;
-        } | undefined) => Promise<RecordImport>;
-        listImports: (status?: RecordImportStatus) => Promise<RecordImport[]>;
-        getImport: (importId: string) => Promise<RecordImport>;
-        listImportItems: (importId: string, status?: RecordImportItem["status"]) => Promise<RecordImportItem[]>;
-        getImportSummary: () => Promise<EnvironmentRecordImportSummary>;
-        cancelImport: (importId: string) => Promise<RecordImport>;
-        getAwaitingCount: () => Promise<number>;
-    };
-    get feedback(): {
-        list: () => Promise<EnvironmentFeedbackRecord[]>;
-    };
-    /**
-     * Return a plain JS copy of the synced session heap.
-     */
-    getHeap(): SessionHeapSnapshot;
-    private buildSessionDataUrl;
-    private sessionDataFetch;
-    private sessionDataRequest;
-    /**
-     * Fetch the live session document from the runtime DO.
-     *
-     * For presentation history use `feed.list()` or `transcript.list()`.
-     * Timeline and job collections are diagnostic/execution data only.
-     */
-    getDocument(): Promise<SessionDocumentResult>;
-    /**
-     * Publish one terminal assistant reply from a trusted server integration.
-     *
-     * This uses the API-key-authenticated HTTP session boundary. Delegated
-     * browser sessions cannot use it and never receive assistant feed-authoring
-     * capability through their WebSocket.
-     */
-    publishAssistantReply(input: AssistantReplyPublicationInput): Promise<AssistantReplyPublicationResult>;
-    get timeline(): {
-        list: (options?: SessionCollectionListOptions) => Promise<SessionCollectionListResult<SessionTimelineEvent>>;
-    };
-    get jobs(): {
-        list: (options?: SessionJobListOptions) => Promise<SessionCollectionListResult<SessionJobRecord>>;
-        get: (jobId: string) => Promise<SessionJobRecord>;
-        latest: (options?: Pick<SessionJobListOptions, "status">) => Promise<SessionJobRecord | null>;
-    };
-    get mutations(): {
-        list: (options?: {
-            limit?: number;
-            compact?: boolean;
-        }) => Promise<{
-            items: SessionMutationView[];
-        }>;
-    };
-    get artifacts(): {
-        list: (options?: SessionArtifactListOptions) => Promise<{
-            items: SessionArtifactRecord[];
-            nextCursor: string | null;
-            totalCount: number;
-        }>;
-        listForLatestJob: (options?: Omit<SessionArtifactListOptions, "jobId" | "latestJob">) => Promise<{
-            items: SessionArtifactRecord[];
-            nextCursor: string | null;
-            totalCount: number;
-        }>;
-        get: (artifactId: string) => Promise<SessionArtifactRecord>;
-        create: (artifact: Partial<SessionArtifactRecord> & {
-            label: string;
-        }) => Promise<SessionArtifactRecord>;
-        acceptSuggestion: (sequence: number) => Promise<SessionArtifactRecord>;
-        updateInputs: (artifactId: string, patch: {
-            inputValues?: Record<string, unknown>;
-            relationships?: Record<string, string | string[] | null>;
-            /** Field paths whose current assistant value the user kept. */
-            confirmFields?: string[];
-            relationshipLabels?: Record<string, Record<string, string>>;
-            expectedUpdatedAt?: number;
-        }) => Promise<SessionArtifactRecord>;
-        relationshipOptions: (artifactId: string, input: SessionArtifactRelationshipOptionsInput) => Promise<SessionArtifactRelationshipOptionsResult>;
-        relationshipCreate: (artifactId: string, input: SessionArtifactRelationshipCreateInput) => Promise<SessionArtifactRecord>;
-        validate: (artifactId: string) => Promise<SessionArtifactValidationResult>;
-        execute: (artifactId: string, options: SessionArtifactExecutionOptions) => Promise<SessionArtifactExecutionResult>;
-        approve: (artifactId: string, options: SessionArtifactApprovalOptions) => Promise<SessionArtifactExecutionResult>;
-        cancel: (artifactId: string) => Promise<SessionArtifactRecord>;
-    };
-    get manualActions(): {
-        record: (input: RecordManualActionInput) => Promise<ManualActionRecordResult>;
-        list: (options?: ManualActionListOptions) => Promise<SessionCollectionListResult<ManualActionOccurrence>>;
-        suggest: (options?: ManualActionSuggestionOptions) => Promise<{
-            items: ManualActionSuggestion[];
-        }>;
-    };
-    get artifactApprovals(): {
-        list: (options?: ArtifactApprovalTaskListOptions) => Promise<SessionCollectionListResult<ArtifactApprovalTask>>;
-        decide: (approvalTaskId: string, input: ArtifactApprovalDecisionInput) => Promise<ArtifactApprovalDecisionResult>;
-    };
-    get files(): {
-        list: (options?: SessionCollectionListOptions & {
-            status?: string | null;
-            source?: string | null;
-        }) => Promise<SessionCollectionListResult<SessionFileRecord>>;
-        get: (fileId: string) => Promise<SessionFileRecord>;
-        upload: (body: SessionFileUploadBody, options?: SessionFileUploadOptions) => Promise<SessionFileRecord>;
-        download: (fileId: string) => Promise<ArrayBuffer>;
-        delete: (fileId: string) => Promise<{
-            deleted: boolean;
-            fileId: string;
-        }>;
-    };
-    get heap(): {
-        entries: {
-            list: (options?: SessionCollectionListOptions) => Promise<SessionCollectionListResult<SessionHeapEntry>>;
-            get: (path: string) => Promise<SessionHeapEntry>;
-        };
-        lists: {
-            list: (options?: SessionCollectionListOptions) => Promise<SessionCollectionListResult<SessionHeapList>>;
-            get: (name: string) => Promise<SessionHeapList>;
-        };
-        variables: {
-            list: (options?: SessionCollectionListOptions) => Promise<SessionCollectionListResult<SessionHeapVariable>>;
-            get: (name: string) => Promise<SessionHeapVariable>;
-            delete: (name: string) => Promise<{
-                deleted: boolean;
-                name: string;
-            }>;
-        };
-    };
-    get transcript(): {
-        list: (options?: SessionCollectionListOptions) => Promise<SessionCollectionListResult<SessionTranscriptEntry>>;
-    };
-    graphql<T = any>(query: string, variables?: Record<string, any>): Promise<GraphQLResult<T>>;
-    searchRecords(query: string, options?: RecordSearchOptions): Promise<RecordSearchResult[]>;
-    mentionRecord(input: RecordMentionInput): Promise<SessionHeapEntry>;
-    defineRelationship(options: DefineRelationshipOptions): Promise<RelationshipInfo>;
-    getRelationships(modelPath: string): Promise<RelationshipInfo[]>;
-    attach(modelPath: string, submodelPath: string, targetPath: string): Promise<void>;
-    detach(modelPath: string, submodelPath: string, targetPath?: string): Promise<void>;
-    listRelated(modelPath: string, submodelPath: string): Promise<ModelRef[]>;
-    applyManifest(manifest: ManifestContent): Promise<{
-        applied: number;
-        errors: string[];
-    }>;
-    recordObject(options: RecordObjectOptions): Promise<RecordObjectResult>;
-    recordState(input: EnvironmentStateUpdateInput): Promise<RecordObjectResult>;
-    state(target: EnvironmentStateTarget): EnvironmentStateProxy;
-    recordObjects(records: RecordObjectOptions[], options?: RecordObjectsOptions): Promise<RecordObjectResult[]>;
-    enqueueRecordImport(records: RecordObjectOptions[], options?: RecordImportOptions): Promise<RecordImport>;
-    listRecordImports(status?: RecordImportStatus): Promise<RecordImport[]>;
-    getRecordImportSummary(): Promise<EnvironmentRecordImportSummary>;
-    getAwaitingRecordCount(): Promise<number>;
-    getRecordImport(importId: string): Promise<RecordImport>;
-    cancelRecordImport(importId: string): Promise<RecordImport>;
-    listFeedback(): Promise<EnvironmentFeedbackRecord[]>;
-    /**
-     * Close the session and disconnect from the sandbox.
-     *
-     * Sends `client.goodbye` over WebSocket first, then issues an HTTP fallback
-     * to the runtime goodbye endpoint if no definitive WS-side runtime notify
-     * acknowledgement was observed.
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Close only the socket transport without sending `client.goodbye`.
-     */
-    disconnectTransport(): void;
-    /**
-     * Backwards-compatible alias for `disconnect()`.
-     */
-    close(): Promise<void>;
-    /**
-     * Check if the graph container is ready and warm.
-     */
-    checkReadiness(): Promise<{
-        lastKeepAliveAt: number;
-        status: "warming" | "hot" | "unknown";
-    }>;
-}
-declare class OntologyHandle {
-    private granular;
-    private ontologyNameOrId;
-    constructor(granular: Granular, ontologyNameOrId: string);
-    get effects(): {
-        register: (effect: ToolWithHandler) => Promise<void>;
-        registerMany: (effects: ToolWithHandler[]) => Promise<void>;
-        unregister: (name: string) => Promise<void>;
-        clear: () => Promise<void>;
-        disconnect: () => Promise<void>;
-    };
-    get importer(): {
-        onEnvironmentCreate: (handler: EnvironmentImporterHandler) => void;
-        clear: () => void;
-    };
-}
-declare class Granular {
-    private apiKey;
-    private apiUrl;
-    private httpUrl;
-    private tokenProvider?;
-    private WebSocketCtor?;
-    private onUnexpectedClose?;
-    private onReconnectError?;
-    private effectHostUrl?;
-    private debugHttp;
-    /** Sandbox-level effect registry: sandboxId → (effectKey@selector → ToolWithHandler) */
-    private sandboxEffects;
-    /** Live sandbox-scoped effect hosts keyed by sandboxId */
-    private sandboxEffectHosts;
-    /** In-flight host connection promises to avoid duplicate concurrent connects */
-    private sandboxEffectHostPromises;
-    /** Ontology-bound environment importer hooks keyed by the caller's ontology identifier. */
-    private ontologyImporters;
-    /** Resolved importer hooks keyed by sandboxId for fast lookups during openEnvironment(). */
-    private sandboxImporters;
-    /**
-     * Create a new Granular client
-     * @param options - Client configuration
-     */
-    constructor(options: GranularOptions);
-    /**
-     * Return an ontology-scoped handle for effects and other ontology-level APIs.
-     */
-    ontology(ontologyNameOrId: string): OntologyHandle;
-    registerEnvironmentImporter(ontologyNameOrId: string, handler: EnvironmentImporterHandler): void;
-    clearEnvironmentImporter(ontologyNameOrId: string): void;
-    /**
-     * Records/upserts a user and prepares them for sandbox connections
-     *
-     * @param options - User options
-     * @returns The recorded user with both `userId` and `granularId`
-     *
-     * @example
-     * ```typescript
-     * const user = await granular.recordUser({
-     *   userId: 'user_123',
-     *   name: 'John Doe',
-     *   permissions: ['agent'],
-     * });
-     * ```
-     */
-    recordUser(options: RecordUserOptions): Promise<User>;
-    /**
-     * Alias for `recordUser()` with user-facing naming that matches upsert semantics.
-     */
-    upsertUser(options: RecordUserOptions): Promise<User>;
-    private resolveConnectUser;
-    /**
-     * Open or resolve an ontology environment for one user without opening a session.
-     *
-     * @example
-     * ```typescript
-     * const environment = await granular.openEnvironment({
-     *   ontology: 'my-ontology',
-     *   tag: 'dev',
-     *   userId: 'user_123',
-     *   permissions: ['agent'],
-     * });
-     *
-     * await environment.data.record({
-     *   className: 'customer',
-     *   id: 'acme',
-     *   fields: { name: 'Acme' },
-     * });
-     *
-     * const session = await environment.sessions.create();
-     * const job = await session.submitJob(`return "hello";`);
-     * console.log(await job.result);
-     * ```
-     */
-    openEnvironment(options: OpenEnvironmentOptions): Promise<Environment>;
-    /**
-     * Read the active environment selected by Granular for an already-recorded
-     * external user. This is intentionally read-only: browser/login code must
-     * not create subjects or environments as a side effect.
-     */
-    getActiveEnvironmentForUser(options: {
-        sandboxId: string;
-        tag: string;
-        userId: string;
-        slot?: string;
-    }): Promise<Environment | null>;
-    /**
-     * Resolve one exact environment only when Granular confirms that it belongs
-     * to the given external user in the requested sandbox (and, optionally,
-     * tag). This is deliberately read-only: callers use it to keep an already
-     * opened delegated workspace stable while a newer active environment is
-     * being prepared in the background.
-     */
-    getEnvironmentForUser(options: {
-        sandboxId: string;
-        userId: string;
-        environmentId: string;
-        tag?: string;
-    }): Promise<Environment | null>;
-    /**
-     * Register one reviewed, pre-existing environment as the active workspace
-     * for an external user. This is for a controlled migration only: it does
-     * not create an environment and it does not run an importer.
-     */
-    adoptEnvironmentForUser(options: AdoptEnvironmentOptions): Promise<Environment>;
-    /**
-     * Deprecated compatibility alias for `openEnvironment()`.
-     *
-     * `connect()` no longer opens a runtime session automatically.
-     */
-    connect(options: ConnectOptions): Promise<Environment>;
-    /**
-     * Run a registered environment importer against an environment that was
-     * opened outside this SDK instance, for example by a delegated browser flow.
-     *
-     * This uses the same setup-run and queued record-import plumbing as
-     * `openEnvironment()`: importer stages, expected object counts, and queued
-     * import counters remain visible through `environment.setup` and
-     * `getRecordImportSummary()`.
-     */
-    runEnvironmentImporterForEnvironment(environmentId: string, options?: RunEnvironmentImporterOptions): Promise<EnvironmentSetupSummary | null>;
-    private resolveRequestedTag;
-    private buildManagedEnvironmentName;
-    private isManagedEnvironmentName;
-    private sortEnvironmentsByRecency;
-    private resolveOpenEnvironmentData;
-    /**
-     * List indexed sessions using ownership filters and bounded pagination.
-     */
-    listSessions(options: ConversationSessionListOptions): Promise<ConversationSessionInfo[]>;
-    listSessionsPage(options: ConversationSessionListOptions): Promise<ConversationSessionListResponse>;
-    /**
-     * List active (open) sessions for an environment.
-     */
-    listOpenSessions(filters: Omit<ConversationSessionListOptions, "status"> & {
-        environmentId: string;
-    }): Promise<ConversationSessionInfo[]>;
-    /**
-     * List closed sessions for an environment (conversations that have disconnected).
-     */
-    listClosedSessions(filters: Omit<ConversationSessionListOptions, "status"> & {
-        environmentId: string;
-    }): Promise<ConversationSessionInfo[]>;
-    getUserEnvironmentState(options: UserEnvironmentStateOptions & {
-        environmentId: string;
-    }): Promise<UserEnvironmentState>;
-    markUserEnvironmentSessionsRead(options: MarkUserEnvironmentReadOptions & {
-        environmentId: string;
-    }): Promise<UserEnvironmentState["readThroughSequenceBySessionId"]>;
-    private normalizeConversationSession;
-    private normalizeUserEnvironmentState;
-    private static coerceIsoDate;
-    /**
-     * Create a new session (conversation) for an existing environment and connect to it.
-     * The runtime graph is shared across all sessions for the same environment.
-     */
-    createSession(options: {
-        environmentId: string;
-        clientId?: string;
-        sessionScope?: CreateSessionOptions["sessionScope"];
-        initialHeap?: CreateSessionOptions["initialHeap"];
-    }): Promise<EnvironmentSession>;
-    /**
-     * Connect to an existing open session (same conversation thread) using a freshly minted WebSocket token.
-     */
-    connectSession(options: {
-        sessionId: string;
-        clientId?: string;
-        maxReconnectAttempts?: number;
-        reconnectDelayMs?: number;
-    }): Promise<EnvironmentSession>;
-    recordOpenAIUsageSpend(usage: OpenAIUsageSpendEvent, context?: GranularSpendContext | null, options?: {
-        metadata?: Record<string, unknown> | null;
-    }): Promise<RecordOpenAIUsageSpendResult>;
-    /** End a session through the runtime, or disconnect its connected handle. */
-    closeSession(sessionId: string, environment?: EnvironmentSession | null): Promise<void>;
-    /**
-     * Re-open a closed session in the index and connect to its existing runtime document.
-     */
-    reopenSession(sessionId: string, options?: {
-        clientId?: string;
-    }): Promise<EnvironmentSession>;
-    private resolveEnvironmentImporter;
-    private maybeRunEnvironmentImporter;
-    private runEnvironmentImporter;
-    private bindEnvironmentHandle;
-    private bindWebSocketEnvironmentSession;
-    private activateEnvironment;
-    private getSandboxEffectMap;
-    private serializeEffect;
-    private publishSandboxEffectCatalog;
-    private syncSandboxEffectCatalog;
-    private recoverEffectHost;
-    private startEffectHostHeartbeat;
-    private stopEffectHostHeartbeat;
-    private synchronizeEffectHost;
-    private ensureSandboxEffectHost;
-    private disconnectSandboxEffectHost;
-    /**
-     * Register an effect (tool) for a specific sandbox.
-     *
-     * @param sandboxNameOrId - The name or ID of the sandbox
-     * @param effect - The tool definition and handler
-     */
-    registerEffect(sandboxNameOrId: string, effect: ToolWithHandler): Promise<void>;
-    /**
-     * Register multiple effects (tools) for a specific sandbox.
-     *
-     * batch version of `registerEffect`.
-     */
-    registerEffects(sandboxNameOrId: string, effects: ToolWithHandler[]): Promise<void>;
-    /**
-     * Unregister an effect from a sandbox.
-     *
-     * Removes it from the local sandbox registry and updates the
-     * sandbox-scoped live catalog.
-     */
-    unregisterEffect(sandboxNameOrId: string, name: string): Promise<void>;
-    /**
-     * Disconnect one sandbox-scoped effect host, or all of them when no sandbox is provided.
-     *
-     * This is primarily useful for long-lived helper processes such as generated
-     * `granular-effects.ts` scripts that need to shut down cleanly on SIGINT/SIGTERM.
-     */
-    disconnectEffects(sandboxNameOrId?: string): Promise<void>;
-    /**
-     * Unregister all effects for a sandbox.
-     */
-    unregisterAllEffects(sandboxNameOrId: string): Promise<void>;
-    /**
-     * Find a sandbox by name or create it if it doesn't exist
-     */
-    private findOrCreateSandbox;
-    /**
-     * Resolve an existing permission profile by exact name or ID.
-     *
-     * `allow-all` is the sole compatibility profile that the SDK may provision
-     * automatically. Every other missing reference fails closed so a typo or
-     * untrusted role value cannot become an allow-default profile.
-     */
-    private ensurePermissionProfile;
-    /**
-     * Ensure an assignment exists for a subject in a sandbox with a permission profile
-     */
-    private ensureAssignment;
-    /**
-     * Sandbox management API
-     */
-    get sandboxes(): {
-        list: () => Promise<SandboxListResponse>;
-        get: (id: string) => Promise<Sandbox>;
-        create: (data: CreateSandboxData) => Promise<Sandbox>;
-        update: (id: string, data: Partial<CreateSandboxData>) => Promise<Sandbox>;
-        delete: (id: string) => Promise<DeleteResponse>;
-    };
-    /**
-     * Permission Profile management for sandboxes
-     */
-    get permissionProfiles(): {
-        list: (sandboxId: string) => Promise<PermissionProfile[]>;
-        get: (sandboxId: string, profileId: string) => Promise<PermissionProfile>;
-        create: (sandboxId: string, data: CreatePermissionProfileData) => Promise<PermissionProfile>;
-        delete: (_sandboxId: string, _profileId: string) => Promise<DeleteResponse>;
-    };
-    /**
-     * Environment management
-     */
-    get environments(): {
-        list: (sandboxId: string) => Promise<EnvironmentData[]>;
-        get: (environmentId: string) => Promise<EnvironmentData>;
-        create: (sandboxId: string, data: CreateEnvironmentData) => Promise<EnvironmentData>;
-        delete: (environmentId: string) => Promise<DeleteResponse>;
-    };
-    /**
-     * Event stream operations: query, subscribe, and acknowledge stream events
-     */
-    get streams(): {
-        getEvents: (params: {
-            ontology: string;
-            stream: string;
-            environment?: string;
-            session?: string;
-            eventTypes?: string[];
-            since?: Date;
-            until?: Date;
-            isAcked?: boolean;
-            limit?: number;
-            offset?: number;
-        }) => Promise<StreamEvent[]>;
-        subscribe: (params: {
-            ontology: string;
-            stream: string;
-            environment?: string;
-            session?: string;
-            eventTypes?: string[];
-            since?: Date;
-            onEvent: (event: StreamEvent) => void;
-            onError?: (err: Error) => void;
-            pollIntervalMs?: number;
-        }) => StreamSubscription;
-        ack: (eventId: string) => Promise<void>;
-        ackBatch: (eventIds: string[]) => Promise<void>;
-        getStats: (params: {
-            ontology: string;
-            environment?: string;
-        }) => Promise<StreamStats[]>;
-    };
-    /**
-     * Subject management
-     */
-    get subjects(): {
-        get: (subjectId: string) => Promise<Subject>;
-        listAssignments: (subjectId: string) => Promise<AssignmentListResponse>;
-    };
-    /**
-     * @deprecated Use recordUser() instead
-     */
-    get users(): {
-        create: (data: {
-            id: string;
-            name?: string;
-            email?: string;
-        }) => Promise<Subject>;
-        get: (id: string) => Promise<Subject>;
-    };
-    private _resolveSandboxId;
-    /**
-     * Make an authenticated API request
-     */
-    private request;
-}
-
-export { Environment as E, Granular as G, OntologyHandle as O, Session as S, WSClient as W, EnvironmentSession as a, isGraphQLMutationDocument as i };