@beeuni/sdk 0.1.0

package/dist/core/client/beeuni.d.ts

@@ -0,0 +1,1216 @@
+export { SessionNotReadyError } from './session-shared.js';
+export type { SessionModel } from './session-shared.js';
+import type { RuntimeClient } from '../runtime/client.js';
+import { type BeeuniPlatformConfig } from '../http/config.js';
+import * as P from '../rest/projects-client/index.js';
+declare function runtime(): RuntimeClient;
+export declare function createBeeuni(config: BeeuniPlatformConfig, opts?: {
+    global?: boolean;
+}): {
+    config: BeeuniPlatformConfig;
+    auth: import("../../index.js").HeadlessAuthApi;
+    accounts: {
+        list: typeof P.listAccounts;
+        get: typeof P.getAccount;
+        create: typeof P.createAccount;
+        secretResources: {
+            list: typeof P.listAccountSecretResources;
+            create: typeof P.createAccountSecretResource;
+            rotate: typeof P.rotateAccountSecretResource;
+            retry: typeof P.retryAccountSecretResource;
+            remove: typeof P.deleteAccountSecretResource;
+            grant: typeof P.grantAccountSecretResource;
+            revoke: typeof P.revokeAccountSecretResourceGrant;
+            setAccess: typeof P.setAccountSecretResourceAccess;
+        };
+        updateName: typeof P.updateAccountName;
+        branding: {
+            get: typeof P.getAccountBranding;
+            update: typeof P.updateAccountBranding;
+            uploadAsset: typeof P.uploadAccountBrandingAsset;
+            removeAsset: typeof P.removeAccountBrandingAsset;
+            reset: typeof P.resetAccountBranding;
+        };
+        leave: typeof P.leaveAccount;
+        members: typeof P.listAccountMembers;
+        invite: typeof P.inviteAccountMember;
+        removeMember: typeof P.removeAccountMember;
+        updateMemberRole: typeof P.updateAccountMemberRole;
+        invites: typeof P.listAccountInvites;
+        cancelInvite: typeof P.cancelAccountInvite;
+        resendInvite: typeof P.resendAccountInvite;
+        tokens: {
+            list: typeof P.listAccountTokens;
+            create: typeof P.createAccountToken;
+            revoke: typeof P.revokeAccountToken;
+        };
+        connectedApps: {
+            list: typeof P.listOAuthGrants;
+            revoke: typeof P.revokeOAuthGrant;
+        };
+        audit: {
+            log: typeof P.listAccountAudit;
+            export: typeof P.exportAccountAudit;
+            webhooks: {
+                list: typeof P.listAccountAuditWebhooks;
+                create: typeof P.createAccountAuditWebhook;
+                update: typeof P.updateAccountAuditWebhook;
+                remove: typeof P.removeAccountAuditWebhook;
+            };
+        };
+    };
+    providerConnections: {
+        list: typeof P.listUserProviderConnections;
+        saveApiKey: typeof P.saveUserProviderApiKey;
+        remove: typeof P.deleteUserProviderConnection;
+        startOAuth: typeof P.startUserProviderOAuth;
+        pollOAuth: typeof P.pollUserProviderOAuth;
+        listProject: typeof P.listProjectPersonalProviders;
+        setProject: typeof P.setProjectPersonalProvider;
+    };
+    iam: {
+        assignments: {
+            list: typeof P.listAssignments;
+            create: typeof P.createAssignment;
+            revoke: typeof P.revokeAssignment;
+        };
+        permissions: {
+            list: typeof P.listPermissions;
+            forRole: typeof P.getRolePermissions;
+        };
+        roles: {
+            list: typeof P.listRoles;
+            create: typeof P.createRole;
+            update: typeof P.updateRole;
+            setPermissions: typeof P.updateRolePermissions;
+            remove: typeof P.deleteRole;
+            usage: typeof P.getRoleUsage;
+        };
+        groups: {
+            list: typeof P.listGroups;
+            get: typeof P.getGroup;
+            create: typeof P.createGroup;
+            update: typeof P.updateGroup;
+            remove: typeof P.deleteGroup;
+            members: {
+                list: typeof P.listGroupMembers;
+                add: typeof P.addGroupMembers;
+                remove: typeof P.removeGroupMember;
+            };
+        };
+        agentIdentities: typeof P.listAgentIdentities;
+        oauthClients: {
+            list: typeof P.listOAuthClients;
+            get: typeof P.getOAuthClient;
+            create: typeof P.createOAuthClient;
+            update: typeof P.updateOAuthClient;
+            rotateSecret: typeof P.rotateOAuthClientSecret;
+            remove: typeof P.deleteOAuthClient;
+        };
+        can: typeof P.probeEffectivePermission;
+        canBatch: typeof P.probeEffectivePermissions;
+    };
+    accountInvites: {
+        listMine: typeof P.listMyAccountInvites;
+        describe: typeof P.describeAccountInvite;
+        accept: typeof P.acceptAccountInvite;
+        decline: typeof P.declineAccountInvite;
+    };
+    projects: {
+        list: typeof P.listProjects;
+        listForAccount: typeof P.listProjectsForAccount;
+        get: typeof P.getProject;
+        detail: typeof P.getProjectDetail;
+        create: typeof P.createProject;
+        createRepo: typeof P.createProjectRepo;
+        provision: typeof P.provisionProject;
+        update: typeof P.updateProject;
+        archive: typeof P.archiveProject;
+        llmCatalog: typeof P.getProjectLlmCatalog;
+        modelPicker: typeof P.getProjectModelPicker;
+        modelAccess: typeof P.getProjectModelAccess;
+        setModelAccess: typeof P.setProjectModelAccess;
+        sandboxHealth: typeof P.getProjectSandboxHealth;
+        sandboxTemplates: typeof P.listProjectSandboxTemplates;
+        sessions: typeof P.listProjectSessions;
+        createSession: typeof P.createProjectSession;
+    };
+    connectors: {
+        catalog: (options?: Parameters<typeof P.getConnectorCatalog>[1]) => Promise<P.ConnectorCatalogEntry[]>;
+        tools: () => Promise<P.ConnectorTool[]>;
+        search: (query?: string | undefined, options?: {
+            limit?: number;
+        } | undefined) => Promise<P.ConnectorTool[]>;
+        describe: (tool: string) => Promise<P.ConnectorTool | null>;
+        call: <T = unknown>(tool: string, args?: Record<string, unknown> | undefined, options?: P.ConnectorCallOptions | undefined) => Promise<P.ConnectorCallResult<T, unknown>>;
+        callAction: <S extends string, A extends string>(slug: S, action: A, args: P.ConnectorArgs<S, A>, options?: P.ConnectorCallOptions) => Promise<P.ConnectorCallResult<unknown, P.ConnectorResult<S, A>>>;
+        accounts: (slug: string) => Promise<P.ConnectorAccount[]>;
+        uploadAttachment: (content: Blob | ArrayBuffer | Uint8Array<ArrayBufferLike>, input: P.ConnectorAttachmentUploadInput) => Promise<P.ConnectorAttachmentUploadResult>;
+    };
+    connector: <S extends string>(slug: S) => P.ConnectorHandle<S>;
+    project: (projectId: string) => {
+        connector: <S extends string>(slug: S) => P.ConnectorHandle<S>;
+        session: (sessionId: string) => {
+            runtime: RuntimeClient;
+            messages: (options?: {
+                conversationId?: string;
+                limit?: number;
+                before?: string;
+                signal?: AbortSignal;
+            }) => Promise<import("../session/index.js").TranscriptPage>;
+            pending: () => Promise<import("../session/index.js").PendingInteractions>;
+            answerPermission: (requestId: string, reply: import("../../index.js").RuntimePermissionReply, message?: string) => Promise<void>;
+            answerQuestion: (requestId: string, answers: import("../../index.js").RuntimeQuestionAnswer[] | null) => Promise<void>;
+            compact: (model?: {
+                providerID: string;
+                modelID: string;
+            }) => Promise<{
+                providerID: string;
+                modelID: string;
+            }>;
+            files: {
+                list: (dirPath: string) => Promise<import("../../index.js").FileNode[]>;
+                read: (filePath: string) => Promise<import("../../index.js").FileContent>;
+                readBlob: (filePath: string) => Promise<Blob>;
+                status: () => Promise<import("../../index.js").GitFileStatus[]>;
+                findFiles: (query: string, options?: {
+                    type?: "file" | "directory";
+                    limit?: number;
+                }) => Promise<string[]>;
+                findText: (pattern: string) => Promise<import("../../index.js").FindMatch[]>;
+                upload: (file: File | Blob, targetPath?: string, filename?: string, options?: import("../../index.js").UploadFileOptions) => Promise<import("../../index.js").UploadResult[]>;
+                write: (filePath: string, content: Blob | File) => Promise<import("../../index.js").WriteFileResult>;
+                create: (filePath: string) => Promise<import("../../index.js").UploadResult[]>;
+                copy: (sourcePath: string, destPath: string) => Promise<import("../../index.js").UploadResult[]>;
+                remove: (filePath: string) => Promise<boolean>;
+                mkdir: (dirPath: string) => Promise<boolean>;
+                rename: (from: string, to: string) => Promise<boolean>;
+            };
+            abort: () => Promise<({
+                data: undefined;
+                error: unknown;
+            } | {
+                data: boolean;
+                error: undefined;
+            }) & {
+                request: Request;
+                response: Response;
+            }>;
+            rewind: (messageId: string) => Promise<({
+                data: undefined;
+                error: unknown;
+            } | {
+                data: import("../../index.js").Session;
+                error: undefined;
+            }) & {
+                request: Request;
+                response: Response;
+            }>;
+            restoreRewind: () => Promise<({
+                data: undefined;
+                error: unknown;
+            } | {
+                data: import("../../index.js").Session;
+                error: undefined;
+            }) & {
+                request: Request;
+                response: Response;
+            }>;
+            stream: (opts: {
+                onEvent: (event: import("../../index.js").RuntimeEvent) => void;
+                onGapRehydrate?: (gapMs: number) => void;
+                signal?: AbortSignal;
+            }) => Promise<import("../../index.js").EventStreamHandle>;
+            scope: () => Promise<P.SessionScope>;
+            providerSecretPool: {
+                list: () => Promise<{
+                    pools: P.SessionProviderSecretPool[];
+                    can_edit: boolean;
+                    personal_user_id?: string | null;
+                    personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+                }>;
+                get: (providerId: string) => Promise<P.SessionProviderSecretPool>;
+                set: (providerId: string, secretIds: string[] | null) => Promise<P.SessionProviderSecretPool>;
+            };
+            rescope: (scope: P.SessionScopeInput) => Promise<P.SessionScope>;
+            setAgent: (agent: string | undefined) => void;
+            send: (text: string, opts?: {
+                model?: import("./session-shared.js").SessionModel;
+                agent?: string;
+            }) => Promise<P.CreateSessionPromptResult>;
+            setModel: (model: import("./session-shared.js").SessionModel | undefined) => void;
+            changeModel: (model: string) => Promise<P.SessionModelChangeResult>;
+            health: (init?: RequestInit) => Promise<import("../session/index.js").SessionHealthResult>;
+            previewUrl: (port: number, path?: string) => string;
+            proxyUrl: (url?: string) => string | undefined;
+            sandboxPortUrl: (port: number) => string;
+            reminders: {
+                list: () => Promise<{
+                    reminders: P.SessionReminder[];
+                }>;
+                create: (input: Parameters<typeof P.createSessionReminder>[2]) => Promise<P.SessionReminder>;
+                update: (reminderId: string, input: Parameters<typeof P.updateSessionReminder>[3]) => Promise<P.SessionReminder>;
+                remove: (reminderId: string) => Promise<{
+                    ok: boolean;
+                }>;
+            };
+            audit: (limit?: number, options?: Parameters<typeof P.getSessionAudit>[3]) => Promise<P.SessionAudit>;
+            attachments: {
+                upload: (file: File, options?: Parameters<typeof P.uploadSessionAttachment>[3]) => Promise<P.SessionAttachment>;
+                read: (attachmentId: string, signal?: AbortSignal) => Promise<Blob>;
+            };
+            transcript: (options?: Parameters<typeof P.getSessionTranscript>[2]) => Promise<P.SessionTranscript>;
+            messageAuthors: () => Promise<P.SessionMessageAuthors>;
+            modelUsage: () => Promise<P.SessionModelUsage>;
+            transcriptSync: (options?: Parameters<typeof P.getSessionTranscriptSync>[2]) => Promise<P.SessionTranscriptSyncEnvelope>;
+            turn: () => Promise<P.SessionTurnStatus>;
+            prompts: {
+                create: (input: P.CreateSessionPromptInput) => Promise<P.CreateSessionPromptResult>;
+                list: () => Promise<{
+                    prompts: P.SessionPrompt[];
+                    observed_at?: string;
+                }>;
+                remove: (promptId: string) => Promise<P.RemovedSessionPrompt>;
+                retry: (promptId: string) => Promise<P.SessionPrompt>;
+                edit: (promptId: string, text: string) => Promise<P.SessionPrompt>;
+                interrupt: (promptId: string) => Promise<P.SessionPrompt>;
+                hold: (held: boolean) => Promise<{
+                    prompts: P.SessionPrompt[];
+                    observed_at?: string;
+                }>;
+            };
+            ensureReady: (opts?: {
+                readyTimeoutMs?: number;
+            }) => Promise<import("../../index.js").SessionRuntimeEntry>;
+            get: (opts?: {
+                showErrors?: boolean;
+            }) => Promise<P.ProjectSession>;
+            presence: (input: {
+                tab_id: string;
+                active: boolean;
+                alerts?: boolean;
+            }, options?: {
+                keepalive?: boolean;
+            }) => Promise<import("../../index.js").ApiResponse<{
+                ok: boolean;
+            }>>;
+            cost: () => Promise<P.SessionCostDetail>;
+            update: (input: Parameters<typeof P.updateProjectSession>[2]) => Promise<P.ProjectSession>;
+            delete: () => Promise<{
+                ok: boolean;
+            }>;
+            start: (options?: (number | {
+                waitMs?: number;
+                repositoryMode?: "previous";
+                keepStopped?: boolean;
+                intentAgeMs?: number;
+            }) | undefined) => Promise<P.SessionStartResult | null>;
+            startOrThrow: (options?: (number | {
+                waitMs?: number;
+                repositoryMode?: "previous";
+                keepStopped?: boolean;
+                intentAgeMs?: number;
+            }) | undefined) => Promise<P.SessionStartResult>;
+            restart: () => Promise<{
+                ok: boolean;
+                session_id: string;
+                status: string;
+                state_carried?: boolean | null;
+                warning?: string;
+            }>;
+            stop: () => Promise<{
+                ok: boolean;
+                session_id: string;
+                status: string;
+            }>;
+            configState: () => Promise<P.SessionConfigState>;
+            reloadConfig: (input?: Parameters<typeof P.reloadProjectSessionConfig>[2]) => Promise<P.SessionReloadResult>;
+            reloadConfigStream: (input: {
+                refresh_repo?: boolean;
+                force?: boolean;
+            }, onEvent: (event: P.SessionReloadStreamEvent) => void, options?: import("../../index.js").ApiClientOptions | undefined) => Promise<P.SessionReloadResult>;
+            setSharing: (intent: Parameters<typeof P.setProjectSessionSharing>[2]) => Promise<P.ProjectSession>;
+            previews: () => Promise<{
+                candidates: P.SessionPreviewCandidate[];
+            }>;
+            participants: () => Promise<P.SessionParticipants>;
+            watch: () => Promise<{
+                watching: boolean;
+            }>;
+            setWatch: (watching: boolean) => Promise<{
+                watching: boolean;
+            }>;
+            commit: (input?: Parameters<typeof P.commitSessionChanges>[2]) => Promise<P.CommitSessionResult>;
+            publicShares: {
+                list: () => Promise<{
+                    shares: P.SessionPublicShare[];
+                }>;
+                create: (input: P.CreateSessionPublicShareInput) => Promise<{
+                    share: P.SessionPublicShare;
+                }>;
+                revoke: (shareId: string) => Promise<{
+                    share: P.SessionPublicShare;
+                }>;
+            };
+        };
+        modelDefaults: {
+            get: () => Promise<P.ModelDefaultsResponse>;
+            set: (input: Parameters<typeof P.setModelDefault>[1]) => Promise<{
+                ok: boolean;
+                scope: string;
+                agentName?: string;
+                model: string;
+            }>;
+            clear: (params: Parameters<typeof P.clearModelDefault>[1]) => Promise<{
+                ok: boolean;
+            }>;
+        };
+        setDefaultAgent: (agentName: string) => Promise<P.UpdateProjectDefaultAgentResponse>;
+        sandbox: {
+            list: () => Promise<P.SandboxTemplatesResponse>;
+            snapshots: () => Promise<P.ProjectSnapshotsResponse>;
+            rebuildSnapshot: (slug?: string) => Promise<P.RebuildSnapshotResponse>;
+            fixWithAgent: () => Promise<{
+                session_id: string;
+            }>;
+            createTemplate: (input: Parameters<typeof P.createSandboxTemplate>[1]) => Promise<{
+                template_id: string;
+                slug: string;
+            }>;
+            updateTemplate: (templateId: string, input: P.UpdateSandboxTemplateInput) => Promise<{
+                template_id: string;
+                slug: string;
+            }>;
+            removeTemplate: (templateId: string) => Promise<null>;
+            buildTemplate: (templateId: string) => Promise<{
+                status: "started";
+                template_id: string;
+                slug: string;
+                providers?: Array<"daytona" | "platinum" | "e2b">;
+            }>;
+            setProvider: (provider: Parameters<typeof P.updateProjectSandboxProvider>[1]) => Promise<P.UpdateProjectSandboxProviderResult>;
+        };
+        setAgentScope: (agentName: string, scope: {
+            env?: P.AgentGrantSet;
+            connectors?: P.AgentGrantSet;
+            connectors_required?: string[];
+            connectors_personal?: string[];
+        }) => Promise<{
+            ok: boolean;
+            agent: string;
+            env: P.AgentGrantSet;
+            connectors: P.AgentGrantSet;
+            connectors_required: string[];
+        }>;
+        channels: {
+            slack: {
+                installation: () => Promise<P.SlackInstallation | null>;
+                connect: (input: Parameters<typeof P.connectSlack>[1]) => Promise<P.SlackInstallation>;
+                mode: () => Promise<P.SlackMode>;
+                completeInstall: (input: Parameters<typeof P.completeSlackInstall>[1]) => Promise<P.ChannelInstallCompletion>;
+                manifest: () => Promise<Record<string, unknown>>;
+                disconnect: () => Promise<void>;
+                getFile: (url: string) => Promise<Blob>;
+                uploadFile: (input: Parameters<typeof P.uploadSlackChannelFile>[1]) => Promise<P.UploadSlackChannelFileResult>;
+            };
+            teams: {
+                completeInstall: (input: Parameters<typeof P.completeTeamsInstall>[1]) => Promise<P.ChannelInstallCompletion>;
+            };
+            email: {
+                installation: (connectorSlug?: string | null) => Promise<P.EmailInstallation | null>;
+                mode: () => Promise<P.EmailMode>;
+                connect: (input: Parameters<typeof P.connectEmail>[1]) => Promise<P.EmailInstallation>;
+                disconnect: (connectorSlug?: string | null) => Promise<void>;
+                updatePolicy: (connectorSlug: string | null | undefined, senderPolicy: P.EmailSenderPolicy) => Promise<P.EmailInstallation>;
+            };
+        };
+        updateFeatureFlag: (feature: P.FeatureFlagKey, enabled: boolean | null) => Promise<P.BeeuniProject>;
+        updateExperimentalFeature: (feature: P.FeatureFlagKey, enabled: boolean | null) => Promise<P.BeeuniProject>;
+        gateway: {
+            logs: (opts?: Parameters<typeof P.listGatewayLogs>[1]) => Promise<P.GatewayLogsResponse>;
+            log: (logId: string) => Promise<P.GatewayLogDetail>;
+            overview: (days?: number) => Promise<P.GatewayOverview>;
+            series: (days?: number) => Promise<P.GatewaySeries>;
+            breakdown: (days?: number) => Promise<P.GatewayBreakdown>;
+            sessions: (days?: number) => Promise<P.GatewaySessions>;
+            errors: (days?: number) => Promise<P.GatewayErrorsResponse>;
+            budgets: () => Promise<P.GatewayBudgetsResponse>;
+            setBudget: (input: Parameters<typeof P.setGatewayBudget>[1]) => Promise<{
+                ok: boolean;
+            }>;
+            deleteBudget: (budgetId: string) => Promise<{
+                ok: boolean;
+            }>;
+            keys: () => Promise<{
+                keys: P.GatewayKeyRow[];
+                gateway_url?: string | null;
+            }>;
+            createKey: (name: string) => Promise<P.CreatedGatewayKey>;
+            revokeKey: (keyId: string) => Promise<{
+                ok: boolean;
+            }>;
+            routing: {
+                get: () => Promise<P.GatewayRoutingPolicyDocument>;
+                set: (policy: Parameters<typeof P.setGatewayRoutingPolicy>[1]) => Promise<P.GatewayRoutingPolicyDocument>;
+                reset: () => Promise<P.GatewayRoutingPolicyDocument>;
+                preview: (input: Parameters<typeof P.previewGatewayRoute>[1]) => Promise<P.GatewayRoutePreview>;
+            };
+            playground: (prompt: string, models: string[], system?: string) => Promise<P.GatewayPlaygroundResponse>;
+        };
+        sessions: {
+            list: (options?: Parameters<typeof P.listProjectSessions>[1]) => Promise<P.ProjectSession[]>;
+            listPage: (options?: Parameters<typeof P.listProjectSessionsPage>[1]) => Promise<P.ProjectSessionPage>;
+            create: (input?: Parameters<typeof P.createProjectSession>[1]) => Promise<P.ProjectSession>;
+            ensureWarm: () => Promise<P.WarmProjectSessionResult>;
+            claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
+        };
+        review: {
+            list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
+                review_items: P.ApiReviewItem[];
+            }>;
+            get: (reviewItemId: string) => Promise<{
+                review_item: P.ApiReviewItem;
+            }>;
+            submit: (input: Parameters<typeof P.submitReviewItem>[1]) => Promise<P.ApiReviewItem>;
+            act: (reviewItemId: string, input: {
+                verdict: P.ReviewVerdict;
+                feedback?: string;
+            }) => Promise<P.ApiReviewItem>;
+            bulkAct: (input: Parameters<typeof P.bulkActReviewItems>[1]) => Promise<{
+                updated: number;
+                review_items: P.ApiReviewItem[];
+            }>;
+        };
+        approvals: {
+            list: (options?: Parameters<typeof P.listPendingApprovals>[1]) => Promise<P.PendingApprovalsResponse>;
+            resolve: (executionId: string, decision: "deny" | "approve", options?: P.ResolveApprovalOptions | undefined) => Promise<{
+                ok: boolean;
+            }>;
+            sessionsNeedingInput: (options?: Parameters<typeof P.listSessionsNeedingInput>[1]) => Promise<P.SessionsNeedingInputResponse>;
+        };
+        files: {
+            list: (options?: Parameters<typeof P.listProjectFiles>[1]) => Promise<P.ProjectFileEntry[]>;
+            listDirectory: (options?: Parameters<typeof P.listProjectDirectory>[1]) => Promise<P.ProjectDirectoryListing>;
+            read: (path: string, ref?: string) => Promise<{
+                path: string;
+                ref: string;
+                content: string;
+            }>;
+            search: (query: string, options?: {
+                content?: boolean;
+                ref?: string;
+                limit?: number;
+            } | undefined) => Promise<P.ProjectFileSearchResponse>;
+            archive: (ref: string, path?: string | undefined) => Promise<Blob>;
+            archiveRequest: (ref: string, path?: string | undefined) => Promise<import("../../index.js").AuthenticatedRequest>;
+            history: (path: string, options?: {
+                ref?: string;
+                limit?: number;
+                skip?: number;
+            } | undefined) => Promise<P.ProjectFileHistoryResponse>;
+        };
+        git: {
+            commits: () => Promise<P.ProjectCommitsResponse>;
+            commit: (sha: string) => Promise<P.ProjectCommitDetail>;
+            commitDiff: (sha: string) => Promise<P.ProjectCommitDiffResponse>;
+            branches: () => Promise<P.ProjectBranchesResponse>;
+            versionDiff: (input: {
+                from: string;
+                into: string;
+            }) => Promise<P.VersionDiffPreview>;
+            inviteCollaborator: (githubUsername: string, permission?: "read" | "write" | undefined) => Promise<P.RepoCollaboratorInvite>;
+        };
+        changeRequests: {
+            list: () => Promise<{
+                change_requests: P.ChangeRequest[];
+            }>;
+            get: (crId: string) => Promise<P.ChangeRequestDetailResponse>;
+            update: (crId: string, input: {
+                title?: string;
+                description?: string;
+            }) => Promise<P.ChangeRequest>;
+            diff: (crId: string) => Promise<P.ChangeRequestDiffResponse>;
+            mergePreview: (crId: string) => Promise<P.ChangeRequestMergePreview>;
+            open: (input: {
+                title: string;
+                description?: string;
+                head_ref: string;
+                base_ref?: string;
+                session_id?: string;
+            }) => Promise<P.ChangeRequest>;
+            merge: (crId: string, input?: {
+                message?: string;
+            } | undefined) => Promise<P.ChangeRequestMergeResponse>;
+            close: (crId: string) => Promise<P.ChangeRequest>;
+            reopen: (crId: string) => Promise<P.ChangeRequest>;
+            requestChanges: (crId: string, feedback: string) => Promise<{
+                change_request: P.ChangeRequest;
+                delivering: boolean;
+            }>;
+        };
+        policies: {
+            list: () => Promise<P.ProjectPoliciesResponse>;
+            set: (policies: P.ProjectPolicy[], defaultMode: P.PolicyDefaultMode) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+        };
+        reminders: {
+            list: () => Promise<{
+                reminders: P.ProjectReminder[];
+            }>;
+            updateMany: (reminders: readonly P.SessionReminderRef[], input: P.UpdateSessionReminderInput) => Promise<P.SessionReminderBatchResult>;
+            removeMany: (reminders: readonly P.SessionReminderRef[]) => Promise<P.SessionReminderBatchResult>;
+        };
+        triggers: {
+            list: () => Promise<P.ProjectTriggerListing>;
+            eventApps: () => Promise<P.ProjectTriggerEventApps>;
+            eventTypes: (params: {
+                connector: string;
+            } | {
+                app: string;
+                source?: string;
+            }) => Promise<P.ProjectTriggerEventTypes>;
+            create: (input: P.CreateProjectTriggerInput) => Promise<P.ProjectTriggerListing>;
+            update: (slug: string, input: P.UpdateProjectTriggerInput) => Promise<P.ProjectTriggerListing>;
+            remove: (slug: string) => Promise<{
+                ok: boolean;
+            }>;
+            fire: (slug: string) => Promise<P.FireProjectTriggerResponse>;
+            setActivation: (paused: boolean) => Promise<P.ProjectTriggerListing>;
+        };
+        connectors: {
+            list: () => Promise<P.ConnectorsResponse>;
+            config: (slug: string) => Promise<P.ConnectorConfig>;
+            create: (draft: P.ConnectorDraftInput) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+                authDiscovery?: P.ConnectorAuthDiscovery;
+            }>;
+            remove: (slug: string) => Promise<{
+                ok: boolean;
+            }>;
+            sync: () => Promise<P.ConnectorSyncResult>;
+            auth: {
+                discover: (draft: P.ConnectorDraftInput) => Promise<P.ConnectorAuthDiscovery>;
+            };
+            setName: (slug: string, name: string) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+            setCredentialMode: (slug: string, mode: "shared") => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+            setAuthorizationStrategy: (slug: string, authorizationStrategy: P.ConnectorAuthorizationStrategy) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+            setCredential: (slug: string, credential: string | P.ConnectionCredentialInput) => Promise<{
+                ok: boolean;
+            }>;
+            deleteCredential: (slug: string) => Promise<{
+                ok: boolean;
+            }>;
+            setSensitive: (slug: string, sensitive: boolean) => Promise<{
+                ok: boolean;
+                sync?: P.ConnectorSyncResult;
+            }>;
+            connections: {
+                list: () => Promise<{
+                    connections: P.Connection[];
+                }>;
+                listAll: () => Promise<{
+                    connections: P.ConnectionRoster[];
+                }>;
+                reconcile: (input: P.ReconcileConnectionInput) => Promise<P.Connection>;
+                reconcileMember: (input: P.ReconcileMemberConnectionInput) => Promise<P.Connection>;
+                updateCredential: (connectionId: string, input: P.ConnectionCredentialInput) => Promise<{
+                    ok: true;
+                }>;
+                revoke: (connectionId: string) => Promise<{
+                    ok: true;
+                }>;
+                activate: (connectionId: string) => Promise<{
+                    ok: true;
+                }>;
+                setDefault: (connectionId: string) => Promise<{
+                    ok: true;
+                }>;
+                rename: (connectionId: string, label: string) => Promise<P.Connection>;
+                share: (connectionId: string, principals?: P.ConnectionSharePrincipal[] | undefined) => Promise<P.Connection>;
+                addComputer: (input: {
+                    tunnelId: string;
+                    share?: P.ConnectorConnectOwner;
+                }) => Promise<P.Connection>;
+                pipedreamConnect: (connectionId: string, input?: P.ConnectionConnectInput | undefined) => Promise<P.ConnectorConnectResult>;
+                pipedreamFinalize: (connectionId: string) => Promise<P.ConnectorFinalizeResult>;
+            };
+            policies: {
+                get: (slug: string) => Promise<{
+                    policies: P.ConnectorPolicyRule[];
+                    effective?: P.ConnectorEffectivePolicy[];
+                    project_policies?: P.ConnectorPolicyRule[];
+                    default_mode?: "risk" | "allow_all";
+                }>;
+                set: (slug: string, policies: P.ConnectorPolicyRule[]) => Promise<{
+                    ok: boolean;
+                    sync?: P.ConnectorSyncResult;
+                }>;
+            };
+            pipedream: {
+                listApps: (qOrQuery?: string | P.PipedreamCatalogQuery | undefined, cursor?: string | undefined) => Promise<P.PipedreamCatalogPage>;
+                listSections: (opts?: {
+                    perCategory?: number;
+                    maxCategories?: number;
+                } | undefined) => Promise<{
+                    sections: P.PipedreamSection[];
+                    categories: P.PipedreamCategory[];
+                    indexReady?: boolean;
+                }>;
+                connect: (slug: string, options?: P.ConnectorConnectOptions | undefined) => Promise<P.ConnectorConnectResult>;
+                finalize: (slug: string, options?: P.ConnectorFinalizeOptions | undefined) => Promise<P.ConnectorFinalizeResult>;
+            };
+            discover: {
+                list: (qOrQuery?: string | P.DiscoverConnectorsQuery | undefined, cursor?: string | undefined) => Promise<P.DiscoverConnectorsPage>;
+                sections: (opts?: {
+                    perCategory?: number;
+                    maxCategories?: number;
+                } | undefined) => Promise<P.DiscoverSectionsPage>;
+                detail: (id: string) => Promise<P.DiscoverConnectorDetail>;
+            };
+            catalog: (options?: Parameters<typeof P.getConnectorCatalog>[1]) => Promise<P.ConnectorCatalogEntry[]>;
+            tools: () => Promise<P.ConnectorTool[]>;
+            search: (query?: string | undefined, options?: {
+                limit?: number;
+            } | undefined) => Promise<P.ConnectorTool[]>;
+            describe: (tool: string) => Promise<P.ConnectorTool | null>;
+            call: <T = unknown>(tool: string, args?: Record<string, unknown> | undefined, options?: P.ConnectorCallOptions | undefined) => Promise<P.ConnectorCallResult<T, unknown>>;
+            callAction: <S extends string, A extends string>(slug: S, action: A, args: P.ConnectorArgs<S, A>, options?: P.ConnectorCallOptions) => Promise<P.ConnectorCallResult<unknown, P.ConnectorResult<S, A>>>;
+            accounts: (slug: string) => Promise<P.ConnectorAccount[]>;
+            uploadAttachment: (content: Blob | ArrayBuffer | Uint8Array<ArrayBufferLike>, input: P.ConnectorAttachmentUploadInput) => Promise<P.ConnectorAttachmentUploadResult>;
+        };
+        tokens: {
+            list: () => Promise<P.ProjectCliTokenListResponse>;
+            create: (input?: Parameters<typeof P.createProjectCliToken>[1]) => Promise<P.CreatedProjectCliToken>;
+            revoke: (tokenId: string) => Promise<{
+                ok: boolean;
+            }>;
+        };
+        setupLinks: {
+            requestSecret: (input: Parameters<typeof P.requestProjectSecret>[1]) => Promise<P.SecretRequestLink>;
+            requestConnector: (input: Parameters<typeof P.requestProjectConnector>[1]) => Promise<P.ConnectorRequestLink>;
+        };
+        validateManifest: (raw: string) => Promise<P.ManifestValidationResult>;
+        gitToken: () => Promise<P.ProjectGitToken>;
+        agentIdentities: () => Promise<P.AgentIdentity[]>;
+        secrets: {
+            list: () => Promise<P.ProjectSecretsResponse>;
+            upsert: (input: Parameters<typeof P.upsertProjectSecret>[1]) => Promise<P.ProjectSecret>;
+            setStrategy: (identifier: string, strategy: P.SecretDeliveryStrategy, options?: P.UpdateSecretStrategyOptions | undefined) => Promise<P.ProjectSecret>;
+            broker: (identifier: string, input: P.SecretBrokerRequest) => Promise<P.SecretBrokerResponse>;
+            remove: (name: string) => Promise<{
+                ok: boolean;
+            }>;
+            setPersonal: (name: string, input: {
+                value?: string;
+                active?: boolean;
+            }) => Promise<P.ProjectSecret>;
+            removePersonal: (name: string) => Promise<{
+                ok: boolean;
+            }>;
+            setGitCredential: (input: Parameters<typeof P.upsertProjectGitCredential>[1]) => Promise<{
+                configured: boolean;
+                provider: string;
+                git_connection: P.ProjectGitConnection;
+            }>;
+            listProviderOAuth: () => Promise<P.ProviderOAuthCredential[]>;
+            startProviderOAuth: (provider: string, input?: {
+                sharing?: P.ConnectorSharing;
+                resourceLabel?: string;
+                resourceId?: string;
+            } | undefined) => Promise<P.ProviderOAuthStart>;
+            pollProviderOAuth: (provider: string, flowId: string) => Promise<P.ProviderOAuthPoll>;
+            removeProviderOAuth: (provider: string) => Promise<{
+                ok: boolean;
+            }>;
+        };
+        access: {
+            list: () => Promise<P.ProjectAccessResponse>;
+            invite: (email: string, role: P.ProjectRole, expiresAt?: string | null | undefined) => Promise<P.ProjectAccessMember | {
+                status: "invited";
+                email: string;
+                invite_id: string;
+                project_role: P.ProjectRole;
+                message: string;
+                invite_url: string;
+                email_sent: boolean;
+                email_skip_reason: string | null;
+            }>;
+            update: (userId: string, role: P.ProjectRole) => Promise<P.ProjectAccessMember>;
+            revoke: (userId: string) => Promise<{
+                ok: boolean;
+            }>;
+            pendingInvites: () => Promise<{
+                pending: P.PendingProjectInvite[];
+            }>;
+            resendInvite: (inviteId: string) => Promise<P.ResendProjectInviteResult>;
+            revokeInvite: (inviteId: string) => Promise<{
+                ok: boolean;
+                invitation_cancelled: boolean;
+            }>;
+            requests: () => Promise<{
+                requests: P.ProjectAccessRequest[];
+            }>;
+            approveRequest: (requestId: string, role?: P.ProjectRole | undefined) => Promise<{
+                request: P.ProjectAccessRequest;
+                member: P.ProjectAccessMember;
+            }>;
+            rejectRequest: (requestId: string) => Promise<{
+                request: P.ProjectAccessRequest;
+            }>;
+            groupGrants: () => Promise<{
+                grants: P.ProjectGroupGrant[];
+            }>;
+            attachGroupGrant: (groupId: string, role: P.ProjectRole, expiresAt?: string | null | undefined) => Promise<{
+                project_id: string;
+                group_id: string;
+                role: P.ProjectRole;
+            }>;
+            updateGroupGrant: (groupId: string, role: P.ProjectRole, expiresAt?: string | null | undefined) => Promise<{
+                project_id: string;
+                group_id: string;
+                role: P.ProjectRole;
+            }>;
+            detachGroupGrant: (groupId: string) => Promise<{
+                ok: boolean;
+            }>;
+            resourceGrants: {
+                list: () => Promise<P.ProjectResourceGrantsResponse>;
+                create: (input: Parameters<typeof P.createProjectResourceGrant>[1]) => Promise<{
+                    grant_id: string;
+                }>;
+                remove: (grantId: string) => Promise<{
+                    ok: boolean;
+                }>;
+            };
+        };
+        apps: {
+            list: () => Promise<P.App[]>;
+            create: (input: Parameters<typeof P.createApp>[1]) => Promise<P.App>;
+            get: (appId: string) => Promise<P.App>;
+            update: (appId: string, input: P.UpdateAppInput) => Promise<P.App>;
+            access: {
+                get: (appId: string) => Promise<P.AppAccessConfig>;
+                update: (appId: string, input: P.UpdateAppAccessInput) => Promise<P.AppAccessConfig>;
+                session: (appId: string) => Promise<P.AppAccessSession>;
+                agents: (appId: string) => Promise<P.AppAgentAccess[]>;
+            };
+            remove: (appId: string) => Promise<{
+                ok: boolean;
+                images?: P.AppImageRelease;
+            }>;
+            token: (appId: string) => Promise<P.AppToken>;
+            authEnv: (appId: string) => Promise<P.AppAuthEnv>;
+            artifacts: {
+                register: (input: Parameters<typeof P.registerAppArtifact>[1]) => Promise<P.RegisterAppArtifactResponse>;
+                uploadArchive: (input: Blob | Uint8Array<ArrayBufferLike>, options?: P.UploadAppArtifactOptions | undefined) => Promise<P.AppArtifact>;
+                finalize: (artifactId: string, input: P.FinalizeAppArtifactInput) => Promise<P.AppArtifact>;
+            };
+            deployments: {
+                create: (appId: string, input: P.CreateAppBuildInput) => Promise<P.AppDeployment>;
+                list: (appId: string) => Promise<P.AppDeployment[]>;
+                get: (appId: string, deploymentId: string) => Promise<P.AppDeploymentDetail>;
+                logs: (appId: string, deploymentId: string, options?: P.AppLogsOptions | undefined) => Promise<P.AppLogsResponse>;
+                remove: (appId: string, deploymentId: string) => Promise<P.DeleteAppDeploymentResult>;
+            };
+            start: (appId: string) => Promise<P.App>;
+            stop: (appId: string) => Promise<P.App>;
+            rollback: (appId: string, deploymentId: string) => Promise<P.AppRollback>;
+            machines: {
+                list: (appId: string) => Promise<P.AppMachine[]>;
+                start: (appId: string, machineId: string) => Promise<P.AppMachine[]>;
+                stop: (appId: string, machineId: string) => Promise<P.AppMachine[]>;
+                restart: (appId: string, machineId: string) => Promise<P.AppMachine[]>;
+                destroy: (appId: string, machineId: string) => Promise<P.AppMachine[]>;
+            };
+            scale: (appId: string, count: Record<string, number>) => Promise<{
+                scale: Record<string, number>;
+                machines: P.AppMachine[];
+            }>;
+            exec: (appId: string, input: P.AppExecInput) => Promise<P.AppExecResult>;
+            volumes: {
+                list: (appId: string) => Promise<P.AppVolume[]>;
+                create: (appId: string, input: P.CreateAppVolumeInput) => Promise<P.AppVolume>;
+                update: (appId: string, volumeId: string, input: {
+                    size_gb?: number;
+                    snapshot_retention_days?: number;
+                }) => Promise<P.AppVolume>;
+                destroy: (appId: string, volumeId: string, confirmName: string) => Promise<void>;
+                snapshots: (appId: string, volumeId: string) => Promise<P.AppVolumeSnapshot[]>;
+                snapshot: (appId: string, volumeId: string) => Promise<P.AppVolumeSnapshot>;
+                restore: (appId: string, volumeId: string, snapshotId: string) => Promise<P.AppVolume>;
+                fork: (appId: string, volumeId: string, input: {
+                    name: string;
+                    snapshot_id?: string;
+                }) => Promise<P.AppVolume>;
+            };
+        };
+        attachments: {
+            upload: (file: File, options?: P.PromptAttachmentUploadOptions | undefined) => Promise<P.PromptAttachment>;
+            delete: (attachmentId: string, options?: {
+                signal?: AbortSignal;
+            } | undefined) => Promise<void>;
+            createController: (options?: Parameters<typeof import("../../index.js").createPromptAttachmentController>[1]) => import("../../index.js").PromptAttachmentController;
+        };
+        get: (opts?: Parameters<typeof P.getProject>[1]) => Promise<P.BeeuniProject>;
+        detail: () => Promise<{
+            config: {
+                default_agent: string | null;
+                is_beeuni_repo: boolean;
+                signals: Record<string, boolean>;
+                manifest_raw: string | null;
+                open_code_raw: string | null;
+                open_code_default_agent: string | null;
+                agent_discovery: "opencode" | "declarative";
+                agents: Array<{
+                    name: string;
+                    path: string;
+                    description: string | null;
+                    mode: string | null;
+                    model?: string | null;
+                    source?: "opencode" | "beeuni.toml";
+                    enabled?: boolean;
+                    platform?: boolean;
+                    sandbox?: string | null;
+                    scope?: {
+                        env: string[] | "all";
+                        connectors: string[] | "all";
+                        beeuni_permissions?: string[] | "all";
+                        beeuni_cli: string[] | "all";
+                        apps?: string[] | "all";
+                    };
+                }>;
+                skills: Array<{
+                    name: string;
+                    path: string;
+                    description: string | null;
+                }>;
+                commands: Array<{
+                    name: string;
+                    path: string;
+                    description: string | null;
+                }>;
+                env: {
+                    required: string[];
+                    optional: string[];
+                };
+            };
+            project: P.BeeuniProject;
+            git_connection?: P.ProjectGitConnection | null;
+            file_count: number;
+            files: P.ProjectFileEntry[];
+        }>;
+        skills: {
+            create: (input: P.CreateProjectSkillInput, options?: import("../../index.js").ApiClientOptions | undefined) => Promise<P.CreatedProjectSkill>;
+        };
+        audit: (options?: Parameters<typeof P.listProjectAudit>[1]) => Promise<P.AuditEventList>;
+        update: (input: Parameters<typeof P.updateProject>[1]) => Promise<P.BeeuniProject>;
+        archive: () => Promise<{
+            ok: boolean;
+        }>;
+        llmCatalog: () => Promise<P.ProjectLlmCatalogResponse>;
+        modelPicker: () => Promise<P.ProjectLlmCatalogResponse>;
+        modelAccess: () => Promise<P.ProjectModelAccess>;
+        setModelAccess: (change: P.ProjectModelAccessChange) => Promise<P.ProjectModelAccess>;
+        sandboxHealth: () => Promise<P.ProjectSandboxHealth>;
+        onboardingComplete: (completed: boolean) => Promise<P.BeeuniProject>;
+    };
+    session: (projectId: string, sessionId: string) => {
+        runtime: RuntimeClient;
+        messages: (options?: {
+            conversationId?: string;
+            limit?: number;
+            before?: string;
+            signal?: AbortSignal;
+        }) => Promise<import("../session/index.js").TranscriptPage>;
+        pending: () => Promise<import("../session/index.js").PendingInteractions>;
+        answerPermission: (requestId: string, reply: import("../../index.js").RuntimePermissionReply, message?: string) => Promise<void>;
+        answerQuestion: (requestId: string, answers: import("../../index.js").RuntimeQuestionAnswer[] | null) => Promise<void>;
+        compact: (model?: {
+            providerID: string;
+            modelID: string;
+        }) => Promise<{
+            providerID: string;
+            modelID: string;
+        }>;
+        files: {
+            list: (dirPath: string) => Promise<import("../../index.js").FileNode[]>;
+            read: (filePath: string) => Promise<import("../../index.js").FileContent>;
+            readBlob: (filePath: string) => Promise<Blob>;
+            status: () => Promise<import("../../index.js").GitFileStatus[]>;
+            findFiles: (query: string, options?: {
+                type?: "file" | "directory";
+                limit?: number;
+            }) => Promise<string[]>;
+            findText: (pattern: string) => Promise<import("../../index.js").FindMatch[]>;
+            upload: (file: File | Blob, targetPath?: string, filename?: string, options?: import("../../index.js").UploadFileOptions) => Promise<import("../../index.js").UploadResult[]>;
+            write: (filePath: string, content: Blob | File) => Promise<import("../../index.js").WriteFileResult>;
+            create: (filePath: string) => Promise<import("../../index.js").UploadResult[]>;
+            copy: (sourcePath: string, destPath: string) => Promise<import("../../index.js").UploadResult[]>;
+            remove: (filePath: string) => Promise<boolean>;
+            mkdir: (dirPath: string) => Promise<boolean>;
+            rename: (from: string, to: string) => Promise<boolean>;
+        };
+        abort: () => Promise<({
+            data: undefined;
+            error: unknown;
+        } | {
+            data: boolean;
+            error: undefined;
+        }) & {
+            request: Request;
+            response: Response;
+        }>;
+        rewind: (messageId: string) => Promise<({
+            data: undefined;
+            error: unknown;
+        } | {
+            data: import("../../index.js").Session;
+            error: undefined;
+        }) & {
+            request: Request;
+            response: Response;
+        }>;
+        restoreRewind: () => Promise<({
+            data: undefined;
+            error: unknown;
+        } | {
+            data: import("../../index.js").Session;
+            error: undefined;
+        }) & {
+            request: Request;
+            response: Response;
+        }>;
+        stream: (opts: {
+            onEvent: (event: import("../../index.js").RuntimeEvent) => void;
+            onGapRehydrate?: (gapMs: number) => void;
+            signal?: AbortSignal;
+        }) => Promise<import("../../index.js").EventStreamHandle>;
+        scope: () => Promise<P.SessionScope>;
+        providerSecretPool: {
+            list: () => Promise<{
+                pools: P.SessionProviderSecretPool[];
+                can_edit: boolean;
+                personal_user_id?: string | null;
+                personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+            }>;
+            get: (providerId: string) => Promise<P.SessionProviderSecretPool>;
+            set: (providerId: string, secretIds: string[] | null) => Promise<P.SessionProviderSecretPool>;
+        };
+        rescope: (scope: P.SessionScopeInput) => Promise<P.SessionScope>;
+        setAgent: (agent: string | undefined) => void;
+        send: (text: string, opts?: {
+            model?: import("./session-shared.js").SessionModel;
+            agent?: string;
+        }) => Promise<P.CreateSessionPromptResult>;
+        setModel: (model: import("./session-shared.js").SessionModel | undefined) => void;
+        changeModel: (model: string) => Promise<P.SessionModelChangeResult>;
+        health: (init?: RequestInit) => Promise<import("../session/index.js").SessionHealthResult>;
+        previewUrl: (port: number, path?: string) => string;
+        proxyUrl: (url?: string) => string | undefined;
+        sandboxPortUrl: (port: number) => string;
+        reminders: {
+            list: () => Promise<{
+                reminders: P.SessionReminder[];
+            }>;
+            create: (input: Parameters<typeof P.createSessionReminder>[2]) => Promise<P.SessionReminder>;
+            update: (reminderId: string, input: Parameters<typeof P.updateSessionReminder>[3]) => Promise<P.SessionReminder>;
+            remove: (reminderId: string) => Promise<{
+                ok: boolean;
+            }>;
+        };
+        audit: (limit?: number, options?: Parameters<typeof P.getSessionAudit>[3]) => Promise<P.SessionAudit>;
+        attachments: {
+            upload: (file: File, options?: Parameters<typeof P.uploadSessionAttachment>[3]) => Promise<P.SessionAttachment>;
+            read: (attachmentId: string, signal?: AbortSignal) => Promise<Blob>;
+        };
+        transcript: (options?: Parameters<typeof P.getSessionTranscript>[2]) => Promise<P.SessionTranscript>;
+        messageAuthors: () => Promise<P.SessionMessageAuthors>;
+        modelUsage: () => Promise<P.SessionModelUsage>;
+        transcriptSync: (options?: Parameters<typeof P.getSessionTranscriptSync>[2]) => Promise<P.SessionTranscriptSyncEnvelope>;
+        turn: () => Promise<P.SessionTurnStatus>;
+        prompts: {
+            create: (input: P.CreateSessionPromptInput) => Promise<P.CreateSessionPromptResult>;
+            list: () => Promise<{
+                prompts: P.SessionPrompt[];
+                observed_at?: string;
+            }>;
+            remove: (promptId: string) => Promise<P.RemovedSessionPrompt>;
+            retry: (promptId: string) => Promise<P.SessionPrompt>;
+            edit: (promptId: string, text: string) => Promise<P.SessionPrompt>;
+            interrupt: (promptId: string) => Promise<P.SessionPrompt>;
+            hold: (held: boolean) => Promise<{
+                prompts: P.SessionPrompt[];
+                observed_at?: string;
+            }>;
+        };
+        ensureReady: (opts?: {
+            readyTimeoutMs?: number;
+        }) => Promise<import("../../index.js").SessionRuntimeEntry>;
+        get: (opts?: {
+            showErrors?: boolean;
+        }) => Promise<P.ProjectSession>;
+        presence: (input: {
+            tab_id: string;
+            active: boolean;
+            alerts?: boolean;
+        }, options?: {
+            keepalive?: boolean;
+        }) => Promise<import("../../index.js").ApiResponse<{
+            ok: boolean;
+        }>>;
+        cost: () => Promise<P.SessionCostDetail>;
+        update: (input: Parameters<typeof P.updateProjectSession>[2]) => Promise<P.ProjectSession>;
+        delete: () => Promise<{
+            ok: boolean;
+        }>;
+        start: (options?: (number | {
+            waitMs?: number;
+            repositoryMode?: "previous";
+            keepStopped?: boolean;
+            intentAgeMs?: number;
+        }) | undefined) => Promise<P.SessionStartResult | null>;
+        startOrThrow: (options?: (number | {
+            waitMs?: number;
+            repositoryMode?: "previous";
+            keepStopped?: boolean;
+            intentAgeMs?: number;
+        }) | undefined) => Promise<P.SessionStartResult>;
+        restart: () => Promise<{
+            ok: boolean;
+            session_id: string;
+            status: string;
+            state_carried?: boolean | null;
+            warning?: string;
+        }>;
+        stop: () => Promise<{
+            ok: boolean;
+            session_id: string;
+            status: string;
+        }>;
+        configState: () => Promise<P.SessionConfigState>;
+        reloadConfig: (input?: Parameters<typeof P.reloadProjectSessionConfig>[2]) => Promise<P.SessionReloadResult>;
+        reloadConfigStream: (input: {
+            refresh_repo?: boolean;
+            force?: boolean;
+        }, onEvent: (event: P.SessionReloadStreamEvent) => void, options?: import("../../index.js").ApiClientOptions | undefined) => Promise<P.SessionReloadResult>;
+        setSharing: (intent: Parameters<typeof P.setProjectSessionSharing>[2]) => Promise<P.ProjectSession>;
+        previews: () => Promise<{
+            candidates: P.SessionPreviewCandidate[];
+        }>;
+        participants: () => Promise<P.SessionParticipants>;
+        watch: () => Promise<{
+            watching: boolean;
+        }>;
+        setWatch: (watching: boolean) => Promise<{
+            watching: boolean;
+        }>;
+        commit: (input?: Parameters<typeof P.commitSessionChanges>[2]) => Promise<P.CommitSessionResult>;
+        publicShares: {
+            list: () => Promise<{
+                shares: P.SessionPublicShare[];
+            }>;
+            create: (input: P.CreateSessionPublicShareInput) => Promise<{
+                share: P.SessionPublicShare;
+            }>;
+            revoke: (shareId: string) => Promise<{
+                share: P.SessionPublicShare;
+            }>;
+        };
+    };
+    github: {
+        linkRepository: typeof P.linkRepository;
+        replaceProjectRepository: typeof P.replaceProjectRepository;
+        getInstallation: typeof P.getGitHubInstallation;
+        listInstallations: typeof P.listGitHubInstallations;
+        listLinkableInstallations: typeof P.listLinkableGitHubInstallations;
+        listRepositories: typeof P.listGitHubRepositories;
+        listRepositoryBranches: typeof P.listGitHubRepositoryBranches;
+        linkInstallation: typeof P.linkGitHubInstallation;
+        saveInstallation: typeof P.saveGitHubInstallation;
+        deleteInstallation: typeof P.deleteGitHubInstallation;
+        storeUserToken: typeof P.storeGitHubUserToken;
+    };
+    gitBackend: {
+        get: typeof P.getManagedGitBackend;
+        repositories: typeof P.listManagedGitRepositories;
+    };
+    billing: {
+        accountState: typeof P.getAccountState;
+        accountStateMinimal: typeof P.getAccountStateMinimal;
+        transactions: typeof P.listBillingTransactions;
+        transactionsSummary: typeof P.getBillingTransactionsSummary;
+        creditBreakdown: typeof P.getBillingCreditBreakdown;
+        usageHistory: typeof P.getBillingUsageHistory;
+        usageRollup: typeof P.getUsageRollup;
+        sessionCosts: {
+            list: typeof P.listSessionCosts;
+            get: typeof P.getSessionCostRecord;
+        };
+        tierConfigurations: typeof P.getBillingTierConfigurations;
+        checkout: {
+            createSession: (input: Parameters<typeof P.createCheckoutSession>[0]) => Promise<P.CheckoutSessionResult>;
+            confirmSession: (sessionId: string, accountId?: string) => Promise<P.ConfirmCheckoutSessionResult>;
+        };
+        subscription: {
+            createPortalSession: (returnUrl: string, accountId?: string) => Promise<P.PortalSessionResult>;
+            cancel: (feedback?: string, accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            reactivate: (accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            scheduleDowngrade: (targetTierKey: string, commitmentType?: string, accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            cancelScheduledChange: (accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            prorationPreview: (newPriceId: string, accountId?: string) => Promise<P.ProrationPreviewResult>;
+        };
+        credits: {
+            purchase: (input: Parameters<typeof P.purchaseCredits>[0]) => Promise<P.PurchaseCreditsResult>;
+            autoTopupSettings: (accountId?: string) => Promise<P.AutoTopupSettings>;
+            configureAutoTopup: (input: Parameters<typeof P.configureAutoTopup>[0]) => Promise<P.AutoTopupSettings>;
+        };
+    };
+    sandboxShares: {
+        list: typeof P.listSandboxShares;
+        create: typeof P.createSandboxShare;
+        revoke: typeof P.revokeSandboxShare;
+    };
+    connectStatus: typeof P.getConnectStatus;
+    marketplace: {
+        items: (options?: Parameters<typeof P.listMarketplaceCatalogItems>[0]) => Promise<P.MarketplaceItemsResponse>;
+        item: (id: string) => Promise<Record<string, unknown>>;
+        itemFile: (id: string, path: string) => Promise<P.MarketplaceItemFile>;
+        marketplaces: () => Promise<P.MarketplacesResponse>;
+        featured: () => Promise<P.FeaturedMarketplacesResponse>;
+        sources: {
+            list: () => Promise<P.MarketplaceSourcesResponse>;
+            add: (input: Parameters<typeof P.addMarketplaceSource>[0]) => Promise<P.AddMarketplaceSourceResponse>;
+            remove: (id: string) => Promise<{
+                ok: boolean;
+            }>;
+        };
+    };
+    notifications: {
+        registerDeviceToken: typeof P.registerDeviceToken;
+        unregisterDeviceToken: typeof P.unregisterDeviceToken;
+        list: typeof P.listNotifications;
+        markRead: typeof P.markNotificationsRead;
+        preferences: typeof P.getNotificationPreferences;
+        updatePreferences: typeof P.updateNotificationPreferences;
+        webPushPublicKey: typeof P.getWebPushPublicKey;
+        registerWebPushSubscription: typeof P.registerWebPushSubscription;
+        unregisterWebPushSubscription: typeof P.unregisterWebPushSubscription;
+    };
+    validateToken: typeof P.validateToken;
+    runtime: typeof runtime;
+};
+export type Beeuni = ReturnType<typeof createBeeuni>;
+export type ProjectHandle = ReturnType<Beeuni['project']>;
+export type SessionHandle = ReturnType<Beeuni['session']>;