@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/sessions.js

@@ -0,0 +1,321 @@
+import { ApiError, backendApi } from '../../http/api-client.js';
+import { markSessionFresh } from '../../http/fresh-sessions.js';
+import { currentSavedCopyStore } from '../../session-sync/saved-copy-store.js';
+import { noteSessionStopped } from '../../http/session-stopped.js';
+import { unwrap } from './shared.js';
+export function sessionParentId(session) {
+    const parent = typeof session.parent_session_id === 'string'
+        ? session.parent_session_id
+        : session.metadata?.spawned_by_session;
+    if (typeof parent !== 'string')
+        return null;
+    const trimmed = parent.trim();
+    if (!trimmed || trimmed === session.session_id)
+        return null;
+    return trimmed;
+}
+export const PROJECT_SESSION_PAGE_DEFAULT_LIMIT = 50;
+export const PROJECT_SESSION_PAGE_MAX_LIMIT = 200;
+export const PROJECT_SESSION_NAME_LOOKUP_LIMIT = PROJECT_SESSION_PAGE_MAX_LIMIT;
+function projectSessionListQuery(options) {
+    const params = new URLSearchParams();
+    if (options?.scope && options.scope !== 'visible')
+        params.set('scope', options.scope);
+    if (options?.limit !== undefined)
+        params.set('limit', String(options.limit));
+    if (options?.cursor)
+        params.set('cursor', options.cursor);
+    if (options?.parent)
+        params.set('parent', options.parent);
+    if (options?.startedBy)
+        params.set('started_by', options.startedBy);
+    const q = options?.q?.trim();
+    if (q)
+        params.set('q', q);
+    for (const label of options?.labels ?? [])
+        params.append('label', label);
+    return params.size > 0 ? `?${params}` : '';
+}
+export async function listProjectSessionsPage(projectId, options) {
+    const response = await backendApi.get(`/projects/${projectId}/sessions${projectSessionListQuery(options)}`);
+    const items = unwrap(response);
+    return {
+        items,
+        next_cursor: response.headers?.get('x-next-cursor') ?? null,
+    };
+}
+export async function listProjectSessions(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions${projectSessionListQuery(options)}`));
+}
+export async function setProjectSessionSharing(projectId, sessionId, intent) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/sessions/${sessionId}/sharing`, intent));
+}
+export async function getSessionParticipants(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/participants`, { showErrors: false }));
+}
+export async function getSessionWatch(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/watch`, {
+        showErrors: false,
+    }));
+}
+export async function setSessionWatch(projectId, sessionId, watching) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/sessions/${sessionId}/watch`, {
+        watching,
+    }));
+}
+export function resolvePublicShareUrl(share, origin) {
+    const raw = share.public_url ?? share.public_path ?? share.proxy_path ?? share.public_token ?? '';
+    if (!raw)
+        return '';
+    if (/^https?:\/\//.test(raw))
+        return raw;
+    if (origin) {
+        try {
+            return new URL(raw, origin).toString();
+        }
+        catch {
+            return raw;
+        }
+    }
+    return raw;
+}
+export function findActiveTranscriptShare(shares, now = new Date()) {
+    let found = null;
+    for (const share of shares) {
+        if (share.resource_type !== 'transcript' || share.revoked_at)
+            continue;
+        if (share.expires_at && Date.parse(share.expires_at) <= now.getTime())
+            continue;
+        if (!found || Date.parse(share.created_at) > Date.parse(found.created_at))
+            found = share;
+    }
+    return found;
+}
+export async function getSessionPreviewCandidates(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/previews`));
+}
+export async function listSessionPublicShares(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/public-shares`, { showErrors: false }));
+}
+export async function createSessionPublicShare(projectId, sessionId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/public-shares`, input));
+}
+export async function revokeSessionPublicShare(projectId, sessionId, shareId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/sessions/${sessionId}/public-shares/${shareId}`));
+}
+export async function createProjectSession(projectId, input) {
+    const session = unwrap(await backendApi.post(`/projects/${projectId}/sessions`, input ?? {}));
+    if (!input?.initial_prompt) {
+        markSessionFresh(session?.session_id);
+    }
+    return session;
+}
+export async function ensureWarmProjectSession(projectId, options) {
+    const body = options?.excludeSessionId ? { exclude_session_id: options.excludeSessionId } : {};
+    const result = unwrap(await backendApi.post(`/projects/${projectId}/sessions/warm`, body, {
+        showErrors: false,
+    }));
+    if (!result.reused)
+        markSessionFresh(result.session.session_id);
+    return result;
+}
+export async function claimWarmProjectSession(projectId, input) {
+    const session = unwrap(await backendApi.post(`/projects/${projectId}/sessions/warm/claim`, input, {
+        showErrors: false,
+    }));
+    markSessionFresh(session.session_id);
+    return session;
+}
+export async function getProjectSession(projectId, sessionId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}`, {
+        showErrors: options?.showErrors,
+    }));
+}
+export async function getSessionAudit(projectId, sessionId, limit, options) {
+    const search = new URLSearchParams();
+    if (limit)
+        search.set('limit', String(limit));
+    if (options?.cursor)
+        search.set('cursor', options.cursor);
+    if (options?.includeEvents != null)
+        search.set('include_events', String(options.includeEvents));
+    const qs = search.toString();
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/audit${qs ? `?${qs}` : ''}`, {
+        showErrors: options?.showErrors,
+    }));
+}
+export async function getSessionTranscript(projectId, sessionId, options) {
+    const search = new URLSearchParams();
+    if (options?.limit != null)
+        search.set('limit', String(options.limit));
+    if (options?.chars != null)
+        search.set('chars', String(options.chars));
+    const qs = search.toString();
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/transcript${qs ? `?${qs}` : ''}`));
+}
+export async function getSessionTranscriptSync(projectId, sessionId, options) {
+    const search = new URLSearchParams({ shape: 'sync' });
+    if (options?.limit != null)
+        search.set('limit', String(options.limit));
+    if (options?.history)
+        search.set('history', 'true');
+    if (options?.before)
+        search.set('before', options.before);
+    if (options?.child)
+        search.set('child', options.child);
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/transcript?${search.toString()}`, { showErrors: false, signal: options?.signal }));
+}
+export async function getSessionTurn(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/turn`));
+}
+export async function getSessionOpenBundle(projectId, sessionId, options) {
+    const search = new URLSearchParams();
+    if (options?.transcript != null)
+        search.set('transcript', String(options.transcript));
+    const qs = search.toString();
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/snapshot${qs ? `?${qs}` : ''}`, { signal: options?.signal, showErrors: false }));
+}
+function placementForDelivery(delivery) {
+    if (!delivery)
+        return undefined;
+    return delivery === 'interrupt' ? 'transcript' : 'composer';
+}
+export async function createSessionPrompt(projectId, sessionId, input) {
+    const placement = input.placement ?? placementForDelivery(input.delivery);
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/prompts`, {
+        client_message_id: input.clientMessageId,
+        message_id: input.messageId,
+        parts: input.parts,
+        ...(placement ? { placement } : {}),
+        ...(input.delivery ? { delivery: input.delivery } : {}),
+        ...(input.overrides ? { overrides: input.overrides } : {}),
+        ...(input.remintOnDelivery ? { remint_on_delivery: true } : {}),
+        ...(typeof input.clientSentAtMs === 'number'
+            ? { client_sent_at_ms: Math.trunc(input.clientSentAtMs) }
+            : {}),
+    }));
+}
+export async function listSessionPrompts(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/prompts`, { showErrors: false }));
+}
+export async function deleteSessionPrompt(projectId, sessionId, promptId) {
+    const body = unwrap(await backendApi.delete(`/projects/${projectId}/sessions/${sessionId}/prompts/${promptId}`, { showErrors: false }));
+    return body.removed;
+}
+export async function editSessionPrompt(projectId, sessionId, promptId, text) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/sessions/${sessionId}/prompts/${promptId}`, { text }, { showErrors: false }));
+}
+export async function interruptSessionPrompt(projectId, sessionId, promptId) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/sessions/${sessionId}/prompts/${promptId}`, { delivery: 'interrupt' }, { showErrors: false }));
+}
+export async function retrySessionPrompt(projectId, sessionId, promptId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/prompts/${promptId}/retry`, {}, { showErrors: false }));
+}
+export async function holdSessionPrompts(projectId, sessionId, held) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/prompts/hold`, { held }, { showErrors: false }));
+}
+export async function updateProjectSession(projectId, sessionId, input) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/sessions/${sessionId}`, input));
+}
+export async function deleteProjectSession(projectId, sessionId) {
+    const result = unwrap(await backendApi.delete(`/projects/${projectId}/sessions/${sessionId}`));
+    void currentSavedCopyStore()?.remove(projectId, sessionId);
+    return result;
+}
+export async function restartProjectSession(projectId, sessionId, opts = {}) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/restart`, opts.reset_machine ? { reset_machine: true, ...(opts.discard_state ? { discard_state: true } : {}) } : {}));
+}
+export async function stopProjectSession(projectId, sessionId) {
+    const stopped = unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/stop`, {}));
+    noteSessionStopped(sessionId);
+    return stopped;
+}
+export async function getProjectSessionConfigState(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${encodeURIComponent(sessionId)}/config`, { showErrors: false }));
+}
+function parseSessionReloadStreamFrame(frame) {
+    const dataLines = frame
+        .split('\n')
+        .filter((line) => line.startsWith('data:'))
+        .map((line) => line.slice(5).replace(/^ /, ''));
+    if (dataLines.length === 0)
+        return null;
+    try {
+        return JSON.parse(dataLines.join('\n'));
+    }
+    catch (cause) {
+        throw new Error('reloadProjectSessionConfigStream received an invalid SSE frame', { cause });
+    }
+}
+export async function reloadProjectSessionConfig(projectId, sessionId, input = {}) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${encodeURIComponent(sessionId)}/reload`, input, { showErrors: false }));
+}
+export async function reloadProjectSessionConfigStream(projectId, sessionId, input, onEvent, options = {}) {
+    const response = await backendApi.postStream(`/projects/${projectId}/sessions/${encodeURIComponent(sessionId)}/reload-stream`, input, options);
+    if (!response.ok) {
+        const body = (await response.json().catch(() => null));
+        throw new ApiError(body?.error || `Reload failed: HTTP ${response.status}`, {
+            status: response.status,
+            code: body?.code,
+            data: body,
+        });
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error('Reload stream is unavailable on this runtime (no response body)');
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let settled = null;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let boundary = buffer.indexOf('\n\n');
+            while (boundary !== -1) {
+                const frame = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                boundary = buffer.indexOf('\n\n');
+                const event = parseSessionReloadStreamFrame(frame);
+                if (!event)
+                    continue;
+                onEvent(event);
+                if (event.type === 'error') {
+                    throw new ApiError(event.error, {
+                        status: event.status,
+                        code: event.code,
+                        data: { reason: event.reason },
+                    });
+                }
+                if (event.type === 'done')
+                    settled = event.result;
+            }
+        }
+    }
+    finally {
+        reader.cancel().catch(() => { });
+    }
+    if (!settled)
+        throw new Error('Reload stream ended without a result');
+    return settled;
+}
+export async function getProjectSessionScope(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${encodeURIComponent(sessionId)}/scope`));
+}
+export async function setProjectSessionScope(projectId, sessionId, scope) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/sessions/${encodeURIComponent(sessionId)}/scope`, scope));
+}
+export async function setProjectSessionModel(projectId, sessionId, model) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/sessions/${encodeURIComponent(sessionId)}/model`, { model, opencode_model: model }));
+}
+export function sessionModelPin(session) {
+    const stored = session.metadata?.opencode_model;
+    return typeof stored === 'string' && stored.trim() ? stored.trim() : null;
+}
+export async function getSessionMessageAuthors(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/message-authors`, { showErrors: false }));
+}
+export async function getSessionModelUsage(projectId, sessionId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/model-usage`, { showErrors: false }));
+}

package/dist/core/rest/projects-client/setup-links.d.ts

@@ -0,0 +1,54 @@
+import type { ConnectorConnectOwner } from './connectors.js';
+export interface RequestProjectSecretInput {
+    names: string[];
+    labels?: Record<string, string>;
+    descriptions?: Record<string, string>;
+    scope?: 'runtime' | 'connector';
+    expiresInMinutes?: number;
+}
+export interface SecretRequestLink {
+    kind: 'secret';
+    url: string;
+    names: string[];
+    scope: 'runtime' | 'connector';
+    expires_at: string;
+}
+export declare function requestProjectSecret(projectId: string, input: RequestProjectSecretInput): Promise<SecretRequestLink>;
+export interface RequestProjectConnectorInput {
+    slug: string;
+    owner?: ConnectorConnectOwner;
+    label?: string;
+    expiresInMinutes?: number;
+}
+export interface ConnectorRequestLink {
+    kind: 'connector';
+    url: string;
+    slug: string;
+    app: string;
+    label?: string | null;
+    expires_at: string;
+}
+export declare function requestProjectConnector(projectId: string, input: RequestProjectConnectorInput): Promise<ConnectorRequestLink>;
+export interface ApprovalLinkDetails {
+    kind: 'approval';
+    project_id: string;
+    project_name: string;
+    execution_id: string;
+    session_id: string | null;
+    action: string;
+    connector: string | null;
+    connector_name?: string | null;
+    connector_icon_url?: string | null;
+    risk: string | null;
+    status: string;
+    pending: boolean;
+    args_preview: Record<string, unknown> | null;
+    review_complete?: boolean;
+    args_summary: string | null;
+    approval_context?: string | null;
+    policy_source: string | null;
+    requested_at: string;
+    resolved_at: string | null;
+    expires_at: string;
+}
+export declare function getApprovalLink(token: string): Promise<ApprovalLinkDetails>;

package/dist/core/rest/projects-client/setup-links.js

@@ -0,0 +1,22 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function requestProjectSecret(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/secret-requests`, {
+        names: input.names,
+        labels: input.labels,
+        descriptions: input.descriptions,
+        scope: input.scope,
+        expires_in_minutes: input.expiresInMinutes,
+    }), 'Failed to mint secret-entry link');
+}
+export async function requestProjectConnector(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/connect-requests`, {
+        slug: input.slug,
+        ...(input.owner ? { owner: input.owner } : {}),
+        ...(input.label ? { label: input.label } : {}),
+        expires_in_minutes: input.expiresInMinutes,
+    }), 'Failed to mint connect link');
+}
+export async function getApprovalLink(token) {
+    return unwrap(await backendApi.get(`/approval-links/${token}`), 'Failed to load approval');
+}

package/dist/core/rest/projects-client/shared.d.ts

@@ -0,0 +1,51 @@
+export type AccountRole = 'owner' | 'admin' | 'member';
+export type ProjectRole = 'manager' | 'member';
+export type ConnectorSharing = {
+    mode: 'project';
+} | {
+    mode: 'private';
+    ownerId: string;
+} | {
+    mode: 'members';
+    memberIds?: string[];
+    groupIds?: string[];
+};
+export interface ProjectGitConnection {
+    connection_id: string;
+    account_id: string;
+    project_id: string;
+    provider: string;
+    repo_url: string;
+    repo_owner: string | null;
+    repo_name: string | null;
+    external_repo_id: string | null;
+    default_branch: string;
+    auth_method: string;
+    installation_id: string | null;
+    managed?: boolean;
+    visibility: string | null;
+    status: string;
+    last_validated_at: string | null;
+    last_error_code: string | null;
+    last_error_message: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export interface ProjectFileEntry {
+    path: string;
+    type: 'file';
+    size: number | null;
+}
+export declare function unwrap<T>(response: {
+    data?: T;
+    success: boolean;
+    error?: Error;
+}, fallbackMessage?: string): T & ({} | null);
+export interface ServerTokenOptions {
+    backendUrl: string;
+    accessToken: string;
+    timeoutMs?: number;
+}
+export declare function normalizeServerBackendBase(backendUrl: string): string;
+export declare function serverTokenGet<T>(opts: ServerTokenOptions, path: string): Promise<T | null>;

package/dist/core/rest/projects-client/shared.js

@@ -0,0 +1,29 @@
+export function unwrap(response, fallbackMessage = 'Project request failed') {
+    if (!response.success || response.data === undefined) {
+        throw response.error ?? new Error(fallbackMessage);
+    }
+    return response.data;
+}
+export function normalizeServerBackendBase(backendUrl) {
+    return backendUrl.replace(/\/v1\/?$/, '');
+}
+export async function serverTokenGet(opts, path) {
+    if (!opts.backendUrl || !opts.accessToken)
+        return null;
+    const base = normalizeServerBackendBase(opts.backendUrl);
+    try {
+        const res = await fetch(`${base}${path}`, {
+            headers: {
+                Authorization: `Bearer ${opts.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            signal: AbortSignal.timeout(opts.timeoutMs ?? 8000),
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/rest/projects-client/skills.d.ts

@@ -0,0 +1,11 @@
+import { type ApiClientOptions } from '../../http/api-client.js';
+export interface CreateProjectSkillInput {
+    name: string;
+    description?: string;
+}
+export interface CreatedProjectSkill {
+    ok: true;
+    slug: string;
+    path: string;
+}
+export declare function createProjectSkill(projectId: string, input: CreateProjectSkillInput, options?: ApiClientOptions): Promise<CreatedProjectSkill>;

package/dist/core/rest/projects-client/skills.js

@@ -0,0 +1,8 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function createProjectSkill(projectId, input, options) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/skills`, input, {
+        showErrors: false,
+        ...options,
+    }));
+}

package/dist/core/rest/projects-client/starter-suggestions.d.ts

@@ -0,0 +1,17 @@
+export type StarterSuggestionAction = 'connectors' | 'skills' | 'schedules' | 'agent' | 'members' | 'channels';
+export interface StarterSuggestionsResponse {
+    source: 'personalized' | 'static';
+    generated_at: string | null;
+    items: Array<{
+        id: string;
+        label: string;
+        prompt: string;
+        action?: StarterSuggestionAction;
+        connector?: {
+            slug: string;
+            name: string;
+            img_src: string | null;
+        };
+    }>;
+}
+export declare function getProjectStarterSuggestions(projectId: string): Promise<StarterSuggestionsResponse>;

package/dist/core/rest/projects-client/starter-suggestions.js

@@ -0,0 +1,5 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function getProjectStarterSuggestions(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/starter-suggestions`));
+}

package/dist/core/rest/projects-client/templates.d.ts

@@ -0,0 +1,47 @@
+export interface TemplateInput {
+    key: string;
+    label: string;
+    type: 'text' | 'select' | 'cron' | 'channel';
+    default?: string;
+    help?: string;
+    required?: boolean;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+export interface TemplateRequirement {
+    kind: 'connector' | 'secret' | 'input' | 'channel';
+    key: string;
+    label: string;
+    status: 'new' | 'reused' | 'pending' | 'resolved';
+    required: boolean;
+    provider?: string;
+    input?: TemplateInput;
+}
+export interface TemplateDetail {
+    id: string;
+    title: string;
+    description: string | null;
+    inputs: TemplateInput[];
+    requirements: TemplateRequirement[];
+    installs: Array<{
+        name: string;
+        type: string;
+    }>;
+    connectors: string[];
+    secrets: string[];
+}
+export interface TemplateInstallResult {
+    ok: boolean;
+    project_id: string;
+    commit_sha: string;
+    branch: string;
+    requirements: TemplateRequirement[];
+    trigger_slugs: string[];
+}
+export declare function getTemplate(_id: string): Promise<TemplateDetail>;
+export declare function installTemplate(_id: string, _body: {
+    project_id: string;
+    inputs: Record<string, string>;
+}): Promise<TemplateInstallResult>;

package/dist/core/rest/projects-client/templates.js

@@ -0,0 +1,7 @@
+import { retiredEndpointError } from '../../http/api/errors.js';
+export async function getTemplate(_id) {
+    throw retiredEndpointError('getTemplate');
+}
+export async function installTemplate(_id, _body) {
+    throw retiredEndpointError('installTemplate');
+}

package/dist/core/rest/projects-client/tokens.d.ts

@@ -0,0 +1,94 @@
+export interface AccountToken {
+    token_id: string;
+    name: string;
+    project_id: string | null;
+    public_key: string;
+    status: string;
+    expires_at: string | null;
+    last_used_at: string | null;
+    created_at: string;
+    revoked_at: string | null;
+}
+export interface CreateAccountTokenInput {
+    name: string;
+    accountId?: string;
+    expiresAt?: string;
+    projectId?: string;
+}
+export interface CreatedAccountToken {
+    token_id: string;
+    name: string;
+    project_id: string | null;
+    public_key: string;
+    secret_key: string;
+    status: string;
+    expires_at: string | null;
+    created_at: string;
+}
+export interface ListAccountTokensOptions {
+    mine?: boolean;
+}
+export declare function listAccountTokens(accountId?: string, options?: ListAccountTokensOptions): Promise<AccountToken[]>;
+export declare function createAccountToken(input: CreateAccountTokenInput): Promise<CreatedAccountToken>;
+export declare function revokeAccountToken(tokenId: string, accountId?: string): Promise<{
+    ok: boolean;
+}>;
+export interface OAuthGrant {
+    client_id: string;
+    name: string;
+    client_type: string;
+    self_registered: boolean;
+    redirect_hosts: string[];
+    scopes: string[];
+    granted_at: string | null;
+    last_active_at: string | null;
+    active: boolean;
+}
+export declare function listOAuthGrants(): Promise<OAuthGrant[]>;
+export declare function revokeOAuthGrant(clientId: string): Promise<{
+    ok: true;
+    revoked_tokens: number;
+}>;
+export interface SignedInDevice {
+    session_id: string;
+    user_agent: string | null;
+    ip: string | null;
+    signed_in_at: string;
+    last_active_at: string;
+    current: boolean;
+}
+export declare function listSignedInDevices(): Promise<SignedInDevice[]>;
+export declare function signOutDevice(sessionId: string): Promise<{
+    ok: true;
+}>;
+export interface ProjectCliToken {
+    token_id: string;
+    name: string;
+    public_key: string;
+    status: string;
+    expires_at: string | null;
+    last_used_at: string | null;
+    created_at: string;
+    revoked_at: string | null;
+}
+export interface ProjectCliTokenListResponse {
+    items: ProjectCliToken[];
+    session_tokens: number;
+}
+export interface CreatedProjectCliToken {
+    token_id: string;
+    name: string;
+    public_key: string;
+    secret_key: string;
+    status: string;
+    project_id: string;
+    expires_at: string | null;
+    created_at: string;
+}
+export declare function listProjectCliTokens(projectId: string): Promise<ProjectCliTokenListResponse>;
+export declare function createProjectCliToken(projectId: string, input?: {
+    name?: string;
+}): Promise<CreatedProjectCliToken>;
+export declare function revokeProjectCliToken(projectId: string, tokenId: string): Promise<{
+    ok: boolean;
+}>;