@beeuni/sdk 0.1.0

package/dist/core/rest/platform-client/types.d.ts

@@ -0,0 +1,47 @@
+export declare const SANDBOX_PORTS: {
+    readonly DESKTOP: "6080";
+    readonly DESKTOP_HTTPS: "6081";
+    readonly PRESENTATION_VIEWER: "3210";
+    readonly STATIC_FILE_SERVER: "3211";
+    readonly BEEUNI_MASTER: "8000";
+    readonly BROWSER_STREAM: "9223";
+    readonly BROWSER_VIEWER: "9224";
+    readonly SSH: "22";
+};
+export type SandboxProviderName = 'daytona' | 'platinum' | 'e2b';
+export type ServerTypeOption = string;
+export interface SandboxCreateProgress {
+    status: 'pulling';
+    progress: number;
+    message: string;
+}
+export interface SandboxInfo {
+    sandbox_id: string;
+    external_id: string;
+    name: string;
+    provider: SandboxProviderName;
+    base_url: string;
+    status: string;
+    lifecycle_status?: string;
+    init_status?: 'pending' | 'provisioning' | 'retrying' | 'ready' | 'failed';
+    health_status?: 'healthy' | 'degraded' | 'offline' | 'unknown';
+    init_attempts?: number;
+    last_init_error?: string | null;
+    version?: string | null;
+    metadata?: Record<string, unknown>;
+    is_included?: boolean;
+    stripe_subscription_id?: string | null;
+    stripe_subscription_item_id?: string | null;
+    cancel_at_period_end?: boolean;
+    cancel_at?: string | null;
+    auto_update_enabled?: boolean;
+    auto_update_channel?: 'stable' | 'dev';
+    auto_update?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+    can_manage?: boolean;
+}
+export interface ProvidersInfo {
+    providers: SandboxProviderName[];
+    default: SandboxProviderName;
+}

package/dist/core/rest/platform-client/types.js

@@ -0,0 +1,10 @@
+export const SANDBOX_PORTS = {
+    DESKTOP: '6080',
+    DESKTOP_HTTPS: '6081',
+    PRESENTATION_VIEWER: '3210',
+    STATIC_FILE_SERVER: '3211',
+    BEEUNI_MASTER: '8000',
+    BROWSER_STREAM: '9223',
+    BROWSER_VIEWER: '9224',
+    SSH: '22',
+};

package/dist/core/rest/platform-client/updates.d.ts

@@ -0,0 +1,77 @@
+import type { SandboxInfo } from './types.js';
+export interface ChangelogChange {
+    type: 'feature' | 'fix' | 'improvement' | 'breaking' | 'upstream' | 'security' | 'deprecation';
+    text: string;
+}
+export interface ChangelogArtifact {
+    name: string;
+    target: 'npm' | 'docker-hub' | 'github-release' | 'daytona';
+}
+export interface ChangelogEntry {
+    version: string;
+    date: string;
+    title: string;
+    description: string;
+    changes: ChangelogChange[];
+    artifacts?: ChangelogArtifact[];
+    channel?: 'stable' | 'dev';
+    sha?: string;
+    author?: string;
+}
+export type VersionChannel = 'stable' | 'dev';
+export interface VersionEntry {
+    version: string;
+    channel: VersionChannel;
+    date: string;
+    title: string;
+    body?: string;
+    sha?: string;
+    current: boolean;
+}
+export interface AllVersionsResponse {
+    versions: VersionEntry[];
+    current: {
+        version: string;
+        channel: VersionChannel;
+    };
+}
+export interface SandboxVersionInfo {
+    version: string;
+    channel?: string;
+    date?: string;
+    sha?: string;
+    changelog: ChangelogEntry | null;
+}
+export interface SandboxUpdateResult {
+    success?: boolean;
+    upToDate?: boolean;
+    previousVersion?: string;
+    currentVersion: string;
+    changelog?: ChangelogEntry | null;
+    output?: string;
+    error?: string;
+}
+export type UpdatePhase = 'idle' | 'backing_up' | 'pulling' | 'patching' | 'stopping' | 'removing' | 'recreating' | 'restarting' | 'verifying' | 'starting' | 'health_check' | 'complete' | 'failed';
+export interface SandboxUpdateStatus {
+    phase: UpdatePhase;
+    progress: number;
+    message: string;
+    targetVersion: string | null;
+    previousVersion: string | null;
+    currentVersion: string | null;
+    error: string | null;
+    startedAt: string | null;
+    updatedAt: string | null;
+    backupId?: string | null;
+    cancelRequested?: boolean;
+    diagnostics?: Record<string, string | number | boolean | null>;
+}
+export declare const DESTRUCTIVE_PHASES: UpdatePhase[];
+export declare function isDestructivePhase(phase: UpdatePhase): boolean;
+export declare function getSandboxUpdateStatus(sandbox?: SandboxInfo): Promise<SandboxUpdateStatus>;
+export declare function getLatestSandboxVersion(channel?: VersionChannel): Promise<SandboxVersionInfo>;
+export declare function getFullChangelog(channel?: 'stable' | 'dev' | 'all'): Promise<ChangelogEntry[]>;
+export declare function getAllVersions(): Promise<AllVersionsResponse>;
+export declare function triggerSandboxUpdate(sandbox: SandboxInfo, version: string): Promise<SandboxUpdateResult>;
+export declare function resetSandboxUpdateStatus(sandbox?: SandboxInfo): Promise<void>;
+export declare function cancelSandboxUpdate(sandbox?: SandboxInfo): Promise<void>;

package/dist/core/rest/platform-client/updates.js

@@ -0,0 +1,54 @@
+import { sendChecked } from '../../http/transport.js';
+import { getPlatformUrl } from './shared.js';
+export const DESTRUCTIVE_PHASES = [
+    'pulling', 'patching', 'stopping', 'removing', 'recreating',
+    'restarting', 'verifying', 'starting', 'health_check',
+];
+export function isDestructivePhase(phase) {
+    return DESTRUCTIVE_PHASES.includes(phase);
+}
+export async function getSandboxUpdateStatus(sandbox) {
+    return {
+        phase: 'idle',
+        progress: 0,
+        message: 'Sandbox image updates are managed by project-session provisioning.',
+        targetVersion: null,
+        previousVersion: null,
+        currentVersion: sandbox?.version ?? null,
+        error: null,
+        startedAt: null,
+        updatedAt: null,
+    };
+}
+export async function getLatestSandboxVersion(channel) {
+    const params = channel ? `?channel=${channel}` : '';
+    const res = await sendChecked(`${getPlatformUrl()}/platform/sandbox/version/latest${params}`, { headers: { Accept: 'application/json' } }, {}, 'Version check failed');
+    const latest = await res.json();
+    try {
+        const changelogEntries = await getFullChangelog(channel || 'stable');
+        latest.changelog = changelogEntries.find((entry) => entry.version === latest.version) ?? changelogEntries[0] ?? null;
+    }
+    catch {
+        latest.changelog = null;
+    }
+    return latest;
+}
+export async function getFullChangelog(channel) {
+    const params = channel ? `?channel=${channel}` : '';
+    const res = await sendChecked(`${getPlatformUrl()}/platform/sandbox/version/changelog${params}`, { headers: { Accept: 'application/json' } }, {}, 'Changelog fetch failed');
+    const data = await res.json();
+    return data.changelog;
+}
+export async function getAllVersions() {
+    const res = await sendChecked(`${getPlatformUrl()}/platform/sandbox/version/all`, { headers: { Accept: 'application/json' } }, {}, 'All versions fetch failed');
+    return res.json();
+}
+export async function triggerSandboxUpdate(sandbox, version) {
+    throw new Error('Sandbox image updates are managed by project-session provisioning');
+}
+export async function resetSandboxUpdateStatus(sandbox) {
+    return;
+}
+export async function cancelSandboxUpdate(sandbox) {
+    return;
+}

package/dist/core/rest/platform-client/urls.d.ts

@@ -0,0 +1,3 @@
+import { type SandboxInfo } from './types.js';
+export declare function getSandboxUrl(sandbox: SandboxInfo): string;
+export declare function getSandboxPortUrl(sandbox: SandboxInfo, containerPort: string): string | null;

package/dist/core/rest/platform-client/urls.js

@@ -0,0 +1,16 @@
+import { SANDBOX_PORTS } from './types.js';
+import { getPlatformUrl } from './shared.js';
+export function getSandboxUrl(sandbox) {
+    if (!sandbox.external_id) {
+        if (sandbox.base_url)
+            return sandbox.base_url;
+        throw new Error(`Cannot build sandbox URL: missing external_id for ${sandbox.provider} sandbox "${sandbox.sandbox_id}"`);
+    }
+    return `${getPlatformUrl()}/p/${sandbox.external_id}/${SANDBOX_PORTS.BEEUNI_MASTER}`;
+}
+export function getSandboxPortUrl(sandbox, containerPort) {
+    if (sandbox.external_id) {
+        return `${getPlatformUrl()}/p/${sandbox.external_id}/${containerPort}`;
+    }
+    return null;
+}

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

@@ -0,0 +1,226 @@
+import { type ApiClientOptions } from '../../http/api-client.js';
+import { type AccountRole, type ProjectRole } from './shared.js';
+export interface ProjectGroupAccessSource {
+    group_id: string;
+    group_name: string;
+    role: ProjectRole;
+}
+export interface ProjectAccessMember {
+    user_id: string;
+    email: string | null;
+    account_role: AccountRole;
+    project_role: ProjectRole | null;
+    effective_project_role: ProjectRole | null;
+    has_implicit_access: boolean;
+    effective_source?: 'implicit' | 'direct' | 'group' | null;
+    group_sources?: ProjectGroupAccessSource[];
+    joined_at: string;
+    granted_by: string | null;
+    granted_at: string | null;
+    updated_at: string | null;
+    expires_at?: string | null;
+}
+export interface ProjectAccessResponse {
+    project_id: string;
+    account_id: string;
+    can_manage: boolean;
+    viewer_user_id: string;
+    members: ProjectAccessMember[];
+}
+export interface ProjectAccessRequest {
+    request_id: string;
+    account_id: string;
+    project_id: string;
+    requester_user_id: string;
+    requester_email: string;
+    message: string | null;
+    status: 'pending' | 'approved' | 'rejected';
+    reviewed_by: string | null;
+    reviewed_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export type RequestProjectAccessResult = {
+    status: 'created';
+    request: ProjectAccessRequest;
+} | {
+    status: 'pending';
+    request: ProjectAccessRequest;
+} | {
+    status: 'already_has_access';
+    project_id: string;
+};
+export declare function requestProjectAccess(projectId: string, message?: string): Promise<{
+    status: "created";
+    request: ProjectAccessRequest;
+} | {
+    status: "pending";
+    request: ProjectAccessRequest;
+} | {
+    status: "already_has_access";
+    project_id: string;
+}>;
+export declare function listProjectAccessRequests(projectId: string, options?: ApiClientOptions): Promise<{
+    requests: ProjectAccessRequest[];
+}>;
+export declare function approveProjectAccessRequest(projectId: string, requestId: string, role?: ProjectRole): Promise<{
+    request: ProjectAccessRequest;
+    member: ProjectAccessMember;
+}>;
+export declare function rejectProjectAccessRequest(projectId: string, requestId: string): Promise<{
+    request: ProjectAccessRequest;
+}>;
+export declare function listProjectAccess(projectId: string): Promise<ProjectAccessResponse>;
+export declare function updateProjectAccess(projectId: string, userId: string, role: ProjectRole): Promise<ProjectAccessMember>;
+export declare function revokeProjectAccess(projectId: string, userId: string): Promise<{
+    ok: boolean;
+}>;
+export type InviteProjectMemberResult = ProjectAccessMember | {
+    status: 'invited';
+    email: string;
+    invite_id: string;
+    project_role: ProjectRole;
+    message: string;
+    invite_url: string;
+    email_sent: boolean;
+    email_skip_reason: string | null;
+};
+export declare function isInviteSent(r: InviteProjectMemberResult): r is Extract<InviteProjectMemberResult, {
+    status: 'invited';
+}>;
+export declare function inviteProjectMember(projectId: string, email: string, role: ProjectRole, expiresAt?: string | null): Promise<ProjectAccessMember | {
+    status: "invited";
+    email: string;
+    invite_id: string;
+    project_role: ProjectRole;
+    message: string;
+    invite_url: string;
+    email_sent: boolean;
+    email_skip_reason: string | null;
+}>;
+export interface PendingProjectInvite {
+    invite_id: string;
+    email: string;
+    project_role: ProjectRole;
+    expires_at: string | null;
+    invited_by_email: string | null;
+    created_at: string;
+    invite_expires_at: string;
+    invite_expired: boolean;
+}
+export declare function listPendingProjectInvites(projectId: string): Promise<{
+    pending: PendingProjectInvite[];
+}>;
+export declare function revokePendingProjectInvite(projectId: string, inviteId: string): Promise<{
+    ok: boolean;
+    invitation_cancelled: boolean;
+}>;
+export interface ResendProjectInviteResult {
+    ok: boolean;
+    expires_at: string;
+    invite_url: string;
+    email_sent: boolean;
+    email_skip_reason: string | null;
+}
+export declare function resendPendingProjectInvite(projectId: string, inviteId: string): Promise<ResendProjectInviteResult>;
+export interface ProjectGroupGrant {
+    group_id: string;
+    group_name: string;
+    role: ProjectRole;
+    granted_by: string | null;
+    created_at: string;
+    expires_at?: string | null;
+    member_count?: number;
+    override_count?: number;
+}
+export declare function listProjectGroupGrants(projectId: string): Promise<{
+    grants: ProjectGroupGrant[];
+}>;
+export declare function attachGroupToProject(projectId: string, groupId: string, role: ProjectRole, expiresAt?: string | null): Promise<{
+    project_id: string;
+    group_id: string;
+    role: ProjectRole;
+}>;
+export declare function updateProjectGroupGrant(projectId: string, groupId: string, role: ProjectRole, expiresAt?: string | null): Promise<{
+    project_id: string;
+    group_id: string;
+    role: ProjectRole;
+}>;
+export declare function detachGroupFromProject(projectId: string, groupId: string): Promise<{
+    ok: boolean;
+}>;
+export type ResourceGrantType = 'agent' | 'skill' | 'secret';
+export interface ProjectResourceItem {
+    id: string;
+    name: string;
+    description: string | null;
+}
+export interface ProjectAgentResourceItem extends ProjectResourceItem {
+    declares?: {
+        secrets: string[] | 'all';
+        connectors: string[] | 'all';
+    };
+}
+export interface ProjectResourceGrant {
+    grant_id: string;
+    resource_type: ResourceGrantType;
+    resource_id: string;
+    principal_type: 'member' | 'group' | 'project';
+    principal_id: string;
+    principal_label: string;
+    granted_by: string | null;
+    created_at: string;
+    expires_at: string | null;
+    orphaned?: boolean;
+}
+export interface ProjectResourceGrantsResponse {
+    resources: {
+        agents: ProjectAgentResourceItem[];
+        skills: ProjectResourceItem[];
+        secrets?: ProjectResourceItem[];
+    };
+    grants: ProjectResourceGrant[];
+}
+export declare function listProjectResourceGrants(projectId: string): Promise<ProjectResourceGrantsResponse>;
+export declare function createProjectResourceGrant(projectId: string, input: {
+    resourceType: ResourceGrantType;
+    resourceId: string;
+    principalType: 'member' | 'group';
+    principalId: string;
+    expiresAt?: string | null;
+}): Promise<{
+    grant_id: string;
+}>;
+export declare function deleteProjectResourceGrant(projectId: string, grantId: string): Promise<{
+    ok: boolean;
+}>;
+export interface PendingApproval {
+    execution_id: string;
+    action: string;
+    risk: string | null;
+    session_id: string | null;
+    requested_by: string | null;
+    requested_by_email: string | null;
+    requested_at: string;
+    detail: Record<string, unknown> | null;
+}
+export interface PendingApprovalsResponse {
+    count: number;
+    approvals: PendingApproval[];
+}
+export declare function listPendingApprovals(projectId: string, options?: {
+    showErrors?: boolean;
+}): Promise<PendingApprovalsResponse>;
+export interface SessionsNeedingInputResponse {
+    total: number;
+    sessions: Record<string, number>;
+}
+export declare function listSessionsNeedingInput(projectId: string, options?: {
+    showErrors?: boolean;
+}): Promise<SessionsNeedingInputResponse>;
+export interface ResolveApprovalOptions {
+    note?: string | null;
+}
+export declare function resolveApproval(projectId: string, executionId: string, decision: 'approve' | 'deny', options?: ResolveApprovalOptions): Promise<{
+    ok: boolean;
+}>;

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

@@ -0,0 +1,82 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function requestProjectAccess(projectId, message) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/access-requests`, { message: message?.trim() || undefined }, { showErrors: false }));
+}
+export async function listProjectAccessRequests(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/access-requests`, options));
+}
+export async function approveProjectAccessRequest(projectId, requestId, role = 'member') {
+    return unwrap(await backendApi.post(`/projects/${projectId}/access-requests/${requestId}/approve`, { role }));
+}
+export async function rejectProjectAccessRequest(projectId, requestId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/access-requests/${requestId}/reject`, {}));
+}
+export async function listProjectAccess(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/access`));
+}
+export async function updateProjectAccess(projectId, userId, role) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/access/${userId}`, { role }));
+}
+export async function revokeProjectAccess(projectId, userId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/access/${userId}`));
+}
+export function isInviteSent(r) {
+    return 'status' in r && r.status === 'invited';
+}
+export async function inviteProjectMember(projectId, email, role, expiresAt) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/access/invite`, { email, role, ...(expiresAt !== undefined ? { expires_at: expiresAt } : {}) }));
+}
+export async function listPendingProjectInvites(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/access/pending-invites`));
+}
+export async function revokePendingProjectInvite(projectId, inviteId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/access/pending-invites/${inviteId}`));
+}
+export async function resendPendingProjectInvite(projectId, inviteId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/access/pending-invites/${inviteId}/resend`));
+}
+export async function listProjectGroupGrants(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/group-grants`));
+}
+export async function attachGroupToProject(projectId, groupId, role, expiresAt) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/group-grants`, expiresAt === undefined
+        ? { group_id: groupId, role }
+        : { group_id: groupId, role, expires_at: expiresAt }));
+}
+export async function updateProjectGroupGrant(projectId, groupId, role, expiresAt) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/group-grants/${groupId}`, expiresAt === undefined ? { role } : { role, expires_at: expiresAt }));
+}
+export async function detachGroupFromProject(projectId, groupId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/group-grants/${groupId}`));
+}
+export async function listProjectResourceGrants(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/resource-grants`));
+}
+export async function createProjectResourceGrant(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/resource-grants`, {
+        resource_type: input.resourceType,
+        resource_id: input.resourceId,
+        principal_type: input.principalType,
+        principal_id: input.principalId,
+        ...(input.expiresAt !== undefined ? { expires_at: input.expiresAt } : {}),
+    }));
+}
+export async function deleteProjectResourceGrant(projectId, grantId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/resource-grants/${grantId}`));
+}
+export async function listPendingApprovals(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/approvals`, {
+        showErrors: options?.showErrors,
+    }));
+}
+export async function listSessionsNeedingInput(projectId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/approvals/needs-input`, { showErrors: options?.showErrors }));
+}
+export async function resolveApproval(projectId, executionId, decision, options = {}) {
+    const note = options.note?.trim();
+    return unwrap(await backendApi.post(`/projects/${projectId}/approvals/${executionId}`, {
+        decision,
+        ...(note ? { note } : {}),
+    }));
+}

package/dist/core/rest/projects-client/account-lifecycle.d.ts

@@ -0,0 +1,21 @@
+export interface AccountDeletionStatus {
+    has_pending_deletion: boolean;
+    deletion_scheduled_for: string | null;
+    requested_at: string | null;
+    can_cancel: boolean;
+}
+export interface AccountDeletionMutationResult {
+    success: boolean;
+    message: string;
+    deletion_scheduled_for?: string;
+    can_cancel?: boolean;
+}
+export declare function getAccountDeletionStatus(): Promise<AccountDeletionStatus | null>;
+export declare function requestAccountDeletion(reason?: string): Promise<AccountDeletionMutationResult>;
+export declare function cancelAccountDeletion(): Promise<AccountDeletionMutationResult>;
+export declare function deleteAccountImmediately(): Promise<AccountDeletionMutationResult>;
+export interface AdminRole {
+    isAdmin: boolean;
+    role?: 'admin' | 'super_admin' | null;
+}
+export declare function getAdminRole(): Promise<AdminRole>;

package/dist/core/rest/projects-client/account-lifecycle.js

@@ -0,0 +1,25 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function getAccountDeletionStatus() {
+    const response = await backendApi.get('/account/deletion-status', {
+        showErrors: false,
+    });
+    if (response.error?.status === 404)
+        return null;
+    return unwrap(response, 'Failed to load account deletion status');
+}
+export async function requestAccountDeletion(reason = 'User requested deletion') {
+    return unwrap(await backendApi.post('/account/request-deletion', { reason }, { showErrors: false }), 'Failed to request account deletion');
+}
+export async function cancelAccountDeletion() {
+    return unwrap(await backendApi.post('/account/cancel-deletion', undefined, { showErrors: false }), 'Failed to cancel account deletion');
+}
+export async function deleteAccountImmediately() {
+    return unwrap(await backendApi.delete('/account/delete-immediately', {
+        showErrors: false,
+    }), 'Failed to delete account immediately');
+}
+export async function getAdminRole() {
+    const response = await backendApi.get('/user-roles', { showErrors: false });
+    return response.data ?? { isAdmin: false, role: null };
+}

package/dist/core/rest/projects-client/account-secret-resources.d.ts

@@ -0,0 +1,60 @@
+import type { SecretConsumer, SecretDeliveryStrategy } from './secrets.js';
+export interface AccountSecretResource {
+    secret_id: string;
+    account_id: string;
+    project_id: string | null;
+    access_mode: 'project' | 'members';
+    label: string;
+    provider_id: string | null;
+    name: string;
+    consumer: SecretConsumer;
+    strategy: SecretDeliveryStrategy;
+    active: boolean;
+    cooldown_until: string | null;
+    needs_reauth_at?: string | null;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+    granted_user_ids: string[];
+    can_use: boolean;
+}
+export interface CreateAccountSecretResourceInput {
+    project_id?: string;
+    access_mode?: 'project' | 'members';
+    user_ids?: string[];
+    label: string;
+    provider_id: string;
+    name: string;
+    value: string;
+    consumer: 'llm_gateway';
+    strategy: 'broker';
+}
+export interface SessionProviderSecretPool {
+    provider_id: string;
+    configured: boolean;
+    secret_ids: string[];
+}
+export declare function listAccountSecretResources(accountId: string, projectId?: string): Promise<{
+    secrets: AccountSecretResource[];
+}>;
+export declare function createAccountSecretResource(accountId: string, input: CreateAccountSecretResourceInput): Promise<AccountSecretResource>;
+export declare function rotateAccountSecretResource(accountId: string, secretId: string, value: string): Promise<AccountSecretResource>;
+export declare function retryAccountSecretResource(accountId: string, secretId: string): Promise<AccountSecretResource>;
+export declare function deleteAccountSecretResource(accountId: string, secretId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function grantAccountSecretResource(accountId: string, secretId: string, userId: string, options?: {
+    showErrors?: boolean;
+}): Promise<AccountSecretResource>;
+export declare function revokeAccountSecretResourceGrant(accountId: string, secretId: string, userId: string, options?: {
+    showErrors?: boolean;
+}): Promise<AccountSecretResource>;
+export declare function setAccountSecretResourceAccess(accountId: string, secretId: string, mode: 'project' | 'members', userIds: string[]): Promise<AccountSecretResource>;
+export declare function getSessionProviderSecretPool(projectId: string, sessionId: string, providerId: string): Promise<SessionProviderSecretPool>;
+export declare function listSessionProviderSecretPools(projectId: string, sessionId: string): Promise<{
+    pools: SessionProviderSecretPool[];
+    can_edit: boolean;
+    personal_user_id?: string | null;
+    personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+}>;
+export declare function setSessionProviderSecretPool(projectId: string, sessionId: string, providerId: string, secretIds: string[] | null): Promise<SessionProviderSecretPool>;

package/dist/core/rest/projects-client/account-secret-resources.js

@@ -0,0 +1,40 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+const accountPath = (accountId) => `/accounts/${encodeURIComponent(accountId)}/secret-resources`;
+const secretPath = (accountId, secretId) => `${accountPath(accountId)}/${encodeURIComponent(secretId)}`;
+const poolPath = (projectId, sessionId, providerId) => `/projects/${encodeURIComponent(projectId)}/sessions/${encodeURIComponent(sessionId)}/provider-secret-pools/${encodeURIComponent(providerId)}`;
+export async function listAccountSecretResources(accountId, projectId) {
+    const query = projectId ? `?project_id=${encodeURIComponent(projectId)}` : '';
+    return unwrap(await backendApi.get(`${accountPath(accountId)}${query}`));
+}
+export async function createAccountSecretResource(accountId, input) {
+    return unwrap(await backendApi.post(accountPath(accountId), input));
+}
+export async function rotateAccountSecretResource(accountId, secretId, value) {
+    return unwrap(await backendApi.put(`${secretPath(accountId, secretId)}/value`, { value }));
+}
+export async function retryAccountSecretResource(accountId, secretId) {
+    return unwrap(await backendApi.post(`${secretPath(accountId, secretId)}/retry`));
+}
+export async function deleteAccountSecretResource(accountId, secretId) {
+    return unwrap(await backendApi.delete(secretPath(accountId, secretId)));
+}
+export async function grantAccountSecretResource(accountId, secretId, userId, options) {
+    return unwrap(await backendApi.put(`${secretPath(accountId, secretId)}/grants/${encodeURIComponent(userId)}`, {}, options));
+}
+export async function revokeAccountSecretResourceGrant(accountId, secretId, userId, options) {
+    return unwrap(await backendApi.delete(`${secretPath(accountId, secretId)}/grants/${encodeURIComponent(userId)}`, options));
+}
+export async function setAccountSecretResourceAccess(accountId, secretId, mode, userIds) {
+    return unwrap(await backendApi.put(`${secretPath(accountId, secretId)}/access`, { mode, user_ids: userIds }));
+}
+export async function getSessionProviderSecretPool(projectId, sessionId, providerId) {
+    return unwrap(await backendApi.get(poolPath(projectId, sessionId, providerId)));
+}
+export async function listSessionProviderSecretPools(projectId, sessionId) {
+    const path = `/projects/${encodeURIComponent(projectId)}/sessions/${encodeURIComponent(sessionId)}/provider-secret-pools`;
+    return unwrap(await backendApi.get(path));
+}
+export async function setSessionProviderSecretPool(projectId, sessionId, providerId, secretIds) {
+    return unwrap(await backendApi.put(poolPath(projectId, sessionId, providerId), { secret_ids: secretIds }));
+}