@beeuni/sdk 0.1.0

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

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

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

@@ -0,0 +1,26 @@
+import * as P from '../rest/projects-client/index.js';
+import { bindProjectOperationsWorkspace } from './project-operations-workspace.js';
+export function bindProjectOperationsAdmin(projectId) {
+    return {
+        policies: {
+            list: () => P.listProjectPolicies(projectId),
+            set: (...a) => P.setProjectPolicies(projectId, ...a),
+        },
+        reminders: {
+            list: () => P.listProjectReminders(projectId),
+            updateMany: (...a) => P.updateSessionReminders(projectId, ...a),
+            removeMany: (...a) => P.deleteSessionReminders(projectId, ...a),
+        },
+        triggers: {
+            list: () => P.listProjectTriggers(projectId),
+            eventApps: () => P.listProjectTriggerEventApps(projectId),
+            eventTypes: (...a) => P.listProjectTriggerEventTypes(projectId, ...a),
+            create: (...a) => P.createProjectTrigger(projectId, ...a),
+            update: (...a) => P.updateProjectTrigger(projectId, ...a),
+            remove: (...a) => P.deleteProjectTrigger(projectId, ...a),
+            fire: (...a) => P.fireProjectTrigger(projectId, ...a),
+            setActivation: (...a) => P.setProjectTriggersActivation(projectId, ...a),
+        },
+        ...bindProjectOperationsWorkspace(projectId),
+    };
+}

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

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

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

@@ -0,0 +1,24 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindProjectOperationsReview(projectId) {
+    return {
+        sessions: {
+            list: (options) => P.listProjectSessions(projectId, options),
+            listPage: (options) => P.listProjectSessionsPage(projectId, options),
+            create: (input) => P.createProjectSession(projectId, input),
+            ensureWarm: () => P.ensureWarmProjectSession(projectId),
+            claimWarm: (input) => P.claimWarmProjectSession(projectId, input),
+        },
+        review: {
+            list: (params) => P.listReviewItems(projectId, params),
+            get: (reviewItemId) => P.getReviewItem(projectId, reviewItemId),
+            submit: (input) => P.submitReviewItem(projectId, input),
+            act: (...a) => P.actReviewItem(projectId, ...a),
+            bulkAct: (input) => P.bulkActReviewItems(projectId, input),
+        },
+        approvals: {
+            list: (options) => P.listPendingApprovals(projectId, options),
+            resolve: (...a) => P.resolveApproval(projectId, ...a),
+            sessionsNeedingInput: (options) => P.listSessionsNeedingInput(projectId, options),
+        },
+    };
+}

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

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

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

@@ -0,0 +1,36 @@
+import * as P from '../rest/projects-client/index.js';
+import { bindProjectOperationsReview } from './project-operations-review.js';
+export function bindProjectOperationsWorkspace(projectId) {
+    return {
+        files: {
+            list: (options) => P.listProjectFiles(projectId, options),
+            listDirectory: (options) => P.listProjectDirectory(projectId, options),
+            read: (path, ref) => P.readProjectFile(projectId, path, ref),
+            search: (...a) => P.searchProjectFiles(projectId, ...a),
+            archive: (...a) => P.fetchProjectArchive(projectId, ...a),
+            archiveRequest: (...a) => P.projectArchiveRequest(projectId, ...a),
+            history: (...a) => P.getProjectFileHistory(projectId, ...a),
+        },
+        git: {
+            commits: () => P.listProjectCommits(projectId),
+            commit: (sha) => P.getProjectCommit(projectId, sha),
+            commitDiff: (sha) => P.getProjectCommitDiff(projectId, sha),
+            branches: () => P.listProjectBranches(projectId),
+            versionDiff: (...a) => P.getVersionDiff(projectId, ...a),
+            inviteCollaborator: (...a) => P.inviteRepoCollaborator(projectId, ...a),
+        },
+        changeRequests: {
+            list: () => P.listChangeRequests(projectId),
+            get: (crId) => P.getChangeRequest(projectId, crId),
+            update: (...a) => P.updateChangeRequest(projectId, ...a),
+            diff: (crId) => P.getChangeRequestDiff(projectId, crId),
+            mergePreview: (crId) => P.getChangeRequestMergePreview(projectId, crId),
+            open: (...a) => P.openChangeRequest(projectId, ...a),
+            merge: (...a) => P.mergeChangeRequest(projectId, ...a),
+            close: (...a) => P.closeChangeRequest(projectId, ...a),
+            reopen: (...a) => P.reopenChangeRequest(projectId, ...a),
+            requestChanges: (...a) => P.requestChangesOnChangeRequest(projectId, ...a),
+        },
+        ...bindProjectOperationsReview(projectId),
+    };
+}

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

@@ -0,0 +1,237 @@
+import * as P from '../rest/projects-client/index.js';
+import type { projectConnections } from './project-connections.js';
+export declare function bindProjectOperations(projectId: string, connections: ReturnType<typeof projectConnections>): {
+    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>;
+    };
+};

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

@@ -0,0 +1,41 @@
+import * as P from '../rest/projects-client/index.js';
+import { bindProjectOperationsAdmin } from './project-operations-admin.js';
+import { connectorDataPlane } from './project-connectors.js';
+export function bindProjectOperations(projectId, connections) {
+    return {
+        connectors: {
+            ...connectorDataPlane(projectId),
+            list: () => P.listConnectors(projectId),
+            config: (...a) => P.getConnectorConfig(projectId, ...a),
+            create: (...a) => P.createConnector(projectId, ...a),
+            remove: (...a) => P.deleteConnector(projectId, ...a),
+            sync: () => P.syncConnectors(projectId),
+            auth: {
+                discover: (...a) => P.discoverConnectorAuth(projectId, ...a),
+            },
+            setName: (...a) => P.setConnectorName(projectId, ...a),
+            setCredentialMode: (...a) => P.setConnectorCredentialMode(projectId, ...a),
+            setAuthorizationStrategy: (...a) => P.setConnectorAuthorizationStrategy(projectId, ...a),
+            setCredential: (...a) => P.setConnectorCredential(projectId, ...a),
+            deleteCredential: (...a) => P.deleteConnectorCredential(projectId, ...a),
+            setSensitive: (...a) => P.setConnectorSensitive(projectId, ...a),
+            connections,
+            policies: {
+                get: (...a) => P.getConnectorPolicies(projectId, ...a),
+                set: (...a) => P.setConnectorPolicies(projectId, ...a),
+            },
+            pipedream: {
+                listApps: (...a) => P.listPipedreamApps(projectId, ...a),
+                listSections: (...a) => P.listPipedreamSections(projectId, ...a),
+                connect: (...a) => P.pipedreamConnect(projectId, ...a),
+                finalize: (...a) => P.pipedreamFinalize(projectId, ...a),
+            },
+            discover: {
+                list: (...a) => P.listDiscoverConnectors(projectId, ...a),
+                sections: (...a) => P.listDiscoverSections(projectId, ...a),
+                detail: (...a) => P.getDiscoverConnector(projectId, ...a),
+            },
+        },
+        ...bindProjectOperationsAdmin(projectId),
+    };
+}

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

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