@beeuni/sdk 0.1.0

package/dist/core/client/project-access-resources.d.ts

@@ -0,0 +1,65 @@
+import * as P from '../rest/projects-client/index.js';
+import type { DropFirst } from './binding-types.js';
+export declare function bindProjectAccessResources(projectId: string): {
+    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>;
+        };
+    };
+};

package/dist/core/client/project-access-resources.js

@@ -0,0 +1,54 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindProjectAccessResources(projectId) {
+    return {
+        apps: {
+            list: () => P.listApps(projectId),
+            create: (input) => P.createApp(projectId, input),
+            get: (appId) => P.getApp(projectId, appId),
+            update: (...a) => P.updateApp(projectId, ...a),
+            access: {
+                get: (...a) => P.getAppAccess(projectId, ...a),
+                update: (...a) => P.updateAppAccess(projectId, ...a),
+                session: (...a) => P.createAppAccessSession(projectId, ...a),
+                agents: (appId) => P.listAppAgents(projectId, appId),
+            },
+            remove: (appId) => P.deleteApp(projectId, appId),
+            token: (appId) => P.createAppToken(projectId, appId),
+            authEnv: (appId) => P.getAppAuthEnv(projectId, appId),
+            artifacts: {
+                register: (input) => P.registerAppArtifact(projectId, input),
+                uploadArchive: (...a) => P.uploadAppArtifactArchive(projectId, ...a),
+                finalize: (...a) => P.finalizeAppArtifact(projectId, ...a),
+            },
+            deployments: {
+                create: (...a) => P.createAppDeployment(projectId, ...a),
+                list: (appId) => P.listAppDeployments(projectId, appId),
+                get: (...a) => P.getAppDeployment(projectId, ...a),
+                logs: (...a) => P.getAppDeploymentLogs(projectId, ...a),
+                remove: (...a) => P.deleteAppDeployment(projectId, ...a),
+            },
+            start: (appId) => P.startApp(projectId, appId),
+            stop: (appId) => P.stopApp(projectId, appId),
+            rollback: (...a) => P.rollbackApp(projectId, ...a),
+            machines: {
+                list: (appId) => P.listAppMachines(projectId, appId),
+                start: (appId, machineId) => P.startAppMachine(projectId, appId, machineId),
+                stop: (appId, machineId) => P.stopAppMachine(projectId, appId, machineId),
+                restart: (appId, machineId) => P.restartAppMachine(projectId, appId, machineId),
+                destroy: (appId, machineId) => P.destroyAppMachine(projectId, appId, machineId),
+            },
+            scale: (appId, count) => P.scaleApp(projectId, appId, count),
+            exec: (...a) => P.execInApp(projectId, ...a),
+            volumes: {
+                list: (appId) => P.listAppVolumes(projectId, appId),
+                create: (...a) => P.createAppVolume(projectId, ...a),
+                update: (...a) => P.updateAppVolume(projectId, ...a),
+                destroy: (...a) => P.destroyAppVolume(projectId, ...a),
+                snapshots: (...a) => P.listAppVolumeSnapshots(projectId, ...a),
+                snapshot: (...a) => P.createAppVolumeSnapshot(projectId, ...a),
+                restore: (...a) => P.restoreAppVolume(projectId, ...a),
+                fork: (...a) => P.forkAppVolume(projectId, ...a),
+            },
+        },
+    };
+}

package/dist/core/client/project-access-security.d.ts

@@ -0,0 +1,109 @@
+import * as P from '../rest/projects-client/index.js';
+import type { DropFirst } from './binding-types.js';
+export declare function bindProjectAccessSecurity(projectId: string): {
+    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;
+            }>;
+        };
+    };
+};

package/dist/core/client/project-access-security.js

@@ -0,0 +1,33 @@
+import * as P from '../rest/projects-client/index.js';
+import { bindProjectMembership } from './project-membership.js';
+export function bindProjectAccessSecurity(projectId) {
+    return {
+        tokens: {
+            list: () => P.listProjectCliTokens(projectId),
+            create: (input) => P.createProjectCliToken(projectId, input),
+            revoke: (tokenId) => P.revokeProjectCliToken(projectId, tokenId),
+        },
+        setupLinks: {
+            requestSecret: (input) => P.requestProjectSecret(projectId, input),
+            requestConnector: (input) => P.requestProjectConnector(projectId, input),
+        },
+        validateManifest: (raw) => P.validateProjectManifest(projectId, raw),
+        gitToken: () => P.getProjectGitToken(projectId),
+        agentIdentities: () => P.listProjectAgentIdentities(projectId),
+        secrets: {
+            list: () => P.listProjectSecrets(projectId),
+            upsert: (input) => P.upsertProjectSecret(projectId, input),
+            setStrategy: (...a) => P.setProjectSecretStrategy(projectId, ...a),
+            broker: (...a) => P.brokerProjectSecretRequest(projectId, ...a),
+            remove: (name) => P.deleteProjectSecret(projectId, name),
+            setPersonal: (...a) => P.setPersonalProjectSecret(projectId, ...a),
+            removePersonal: (name) => P.deletePersonalProjectSecret(projectId, name),
+            setGitCredential: (input) => P.upsertProjectGitCredential(projectId, input),
+            listProviderOAuth: () => P.listProjectProviderOAuth(projectId),
+            startProviderOAuth: (...a) => P.startProjectProviderOAuth(projectId, ...a),
+            pollProviderOAuth: (...a) => P.pollProjectProviderOAuth(projectId, ...a),
+            removeProviderOAuth: (provider) => P.deleteProjectProviderOAuth(projectId, provider),
+        },
+        access: bindProjectMembership(projectId),
+    };
+}

package/dist/core/client/project-connections.d.ts

@@ -0,0 +1,32 @@
+import * as P from '../rest/projects-client/index.js';
+import type { DropFirst } from './binding-types.js';
+export declare function projectConnections(projectId: string): {
+    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>;
+};

package/dist/core/client/project-connections.js

@@ -0,0 +1,18 @@
+import * as P from '../rest/projects-client/index.js';
+export function projectConnections(projectId) {
+    return {
+        list: () => P.listConnections(projectId),
+        listAll: () => P.listAllConnections(projectId),
+        reconcile: (...a) => P.reconcileConnection(projectId, ...a),
+        reconcileMember: (...a) => P.reconcileMemberConnection(projectId, ...a),
+        updateCredential: (...a) => P.updateConnectionCredential(projectId, ...a),
+        revoke: (...a) => P.revokeConnection(projectId, ...a),
+        activate: (...a) => P.activateConnection(projectId, ...a),
+        setDefault: (...a) => P.setDefaultConnection(projectId, ...a),
+        rename: (...a) => P.renameConnection(projectId, ...a),
+        share: (...a) => P.shareConnection(projectId, ...a),
+        addComputer: (...a) => P.addComputerToProject(projectId, ...a),
+        pipedreamConnect: (...a) => P.pipedreamConnectConnection(projectId, ...a),
+        pipedreamFinalize: (...a) => P.pipedreamFinalizeConnection(projectId, ...a),
+    };
+}

package/dist/core/client/project-connectors.d.ts

@@ -0,0 +1,15 @@
+import * as P from '../rest/projects-client/index.js';
+import type { DropFirst } from './binding-types.js';
+export declare function connectorDataPlane(projectId?: string): {
+    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>;
+};
+export declare function connectorHandle<S extends string>(projectId: string | undefined, slug: S): P.ConnectorHandle<S>;

package/dist/core/client/project-connectors.js

@@ -0,0 +1,34 @@
+import * as P from '../rest/projects-client/index.js';
+export function connectorDataPlane(projectId) {
+    return {
+        catalog: (options) => P.getConnectorCatalog(projectId, options),
+        tools: () => P.listConnectorTools(projectId),
+        search: (...a) => P.searchConnectorTools(projectId, ...a),
+        describe: (...a) => P.describeConnectorTool(projectId, ...a),
+        call: (...a) => P.callConnector(projectId, ...a),
+        callAction: (slug, action, args, options) => P.callConnector(projectId, `${slug}.${action}`, args, options),
+        accounts: (...a) => P.listConnectorAccounts(projectId, ...a),
+        uploadAttachment: (...a) => P.uploadConnectorAttachment(projectId, ...a),
+    };
+}
+export function connectorHandle(projectId, slug) {
+    const describe = async (action) => {
+        if (action !== undefined)
+            return P.describeConnectorTool(projectId, `${slug}.${action}`);
+        const entries = await P.getConnectorCatalog(projectId, {
+            slug,
+            includeSchemas: true,
+            includeOutputSchemas: true,
+        });
+        return entries.find((entry) => entry.slug === slug) ?? null;
+    };
+    return {
+        slug,
+        run: (action, args, options) => P.runConnector(projectId, slug, action, args, options),
+        call: (action, args, options) => P.callConnector(projectId, `${slug}.${action}`, args, options),
+        describe,
+        accounts: () => P.listConnectorAccounts(projectId, slug),
+        paginate: (action, args, options) => P.paginateConnector(projectId, slug, action, args, options),
+        uploadAttachment: (content, input) => P.uploadConnectorAttachment(projectId, content, { ...input, connector: slug }),
+    };
+}

package/dist/core/client/project-core.d.ts

@@ -0,0 +1,74 @@
+import { createPromptAttachmentController } from '../attachments/prompt-attachments.js';
+import * as P from '../rest/projects-client/index.js';
+import type { DropFirst } from './binding-types.js';
+export declare function bindProjectCore(projectId: string): {
+    attachments: {
+        upload: (file: File, options?: P.PromptAttachmentUploadOptions | undefined) => Promise<P.PromptAttachment>;
+        delete: (attachmentId: string, options?: {
+            signal?: AbortSignal;
+        } | undefined) => Promise<void>;
+        createController: (options?: Parameters<typeof 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>;
+};

package/dist/core/client/project-core.js

@@ -0,0 +1,25 @@
+import { createPromptAttachmentController } from '../attachments/prompt-attachments.js';
+import * as P from '../rest/projects-client/index.js';
+export function bindProjectCore(projectId) {
+    return {
+        attachments: {
+            upload: (...args) => P.uploadPromptAttachment(projectId, ...args),
+            delete: (...args) => P.deletePromptAttachment(projectId, ...args),
+            createController: (options) => createPromptAttachmentController(projectId, options),
+        },
+        get: (opts) => P.getProject(projectId, opts),
+        detail: () => P.getProjectDetail(projectId),
+        skills: {
+            create: (...a) => P.createProjectSkill(projectId, ...a),
+        },
+        audit: (options) => P.listProjectAudit(projectId, options),
+        update: (input) => P.updateProject(projectId, input),
+        archive: () => P.archiveProject(projectId),
+        llmCatalog: () => P.getProjectLlmCatalog(projectId),
+        modelPicker: () => P.getProjectModelPicker(projectId),
+        modelAccess: () => P.getProjectModelAccess(projectId),
+        setModelAccess: (change) => P.setProjectModelAccess(projectId, change),
+        sandboxHealth: () => P.getProjectSandboxHealth(projectId),
+        onboardingComplete: (...a) => P.setProjectOnboardingComplete(projectId, ...a),
+    };
+}

package/dist/core/client/project-membership.d.ts

@@ -0,0 +1,62 @@
+import * as P from '../rest/projects-client/index.js';
+import type { DropFirst } from './binding-types.js';
+export declare function bindProjectMembership(projectId: string): {
+    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;
+        }>;
+    };
+};

package/dist/core/client/project-membership.js

@@ -0,0 +1,24 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindProjectMembership(projectId) {
+    return {
+        list: () => P.listProjectAccess(projectId),
+        invite: (...a) => P.inviteProjectMember(projectId, ...a),
+        update: (...a) => P.updateProjectAccess(projectId, ...a),
+        revoke: (userId) => P.revokeProjectAccess(projectId, userId),
+        pendingInvites: () => P.listPendingProjectInvites(projectId),
+        resendInvite: (...a) => P.resendPendingProjectInvite(projectId, ...a),
+        revokeInvite: (...a) => P.revokePendingProjectInvite(projectId, ...a),
+        requests: () => P.listProjectAccessRequests(projectId),
+        approveRequest: (...a) => P.approveProjectAccessRequest(projectId, ...a),
+        rejectRequest: (...a) => P.rejectProjectAccessRequest(projectId, ...a),
+        groupGrants: () => P.listProjectGroupGrants(projectId),
+        attachGroupGrant: (...a) => P.attachGroupToProject(projectId, ...a),
+        updateGroupGrant: (...a) => P.updateProjectGroupGrant(projectId, ...a),
+        detachGroupGrant: (groupId) => P.detachGroupFromProject(projectId, groupId),
+        resourceGrants: {
+            list: () => P.listProjectResourceGrants(projectId),
+            create: (input) => P.createProjectResourceGrant(projectId, input),
+            remove: (grantId) => P.deleteProjectResourceGrant(projectId, grantId),
+        },
+    };
+}