@permute/sdk 0.6.0 → 0.8.0

package/dist/client.js

@@ -3,6 +3,7 @@ export { PermuteApiError } from './errors.js';
 import { Ajv } from 'ajv';
 import { createHash } from 'node:crypto';
 import { publicApiRoutes } from './generated/runtime-contract.js';
+import { SdkMethodFactory } from './method.js';
 const DEFAULT_BASE_URL = 'https://api.permute.ai';
 const DEFAULT_POLL_TIMEOUT_MS = 20 * 60 * 1000;
 function routeFor(operationId) {
@@ -250,11 +251,14 @@ export class PermuteFileDataset {
     }
 }
 export class PermuteClient {
+    permissions;
+    accessRequests;
     revisions;
     facts;
     skills;
     organizationSkills;
     actions;
+    emails;
     databases;
     apps;
     connectorSessions;
@@ -266,17 +270,18 @@ export class PermuteClient {
     dashboards;
     datasets;
     apiKey;
+    accessToken;
     baseUrl;
     /** Workspace selected for workspace-scoped API operations. */
     workspaceId;
     defaultHeaders;
     fetchImpl;
     constructor(options) {
-        if (!options.apiKey) {
+        if ((!options.apiKey && !options.accessToken) || (options.apiKey && options.accessToken)) {
             throw new PermuteApiError({
                 status: 0,
                 code: 'missing_api_key',
-                message: 'apiKey is required',
+                message: 'Provide apiKey or accessToken',
             });
         }
         const fetchImpl = options.fetch ?? globalThis.fetch;
@@ -288,56 +293,85 @@ export class PermuteClient {
             });
         }
         this.apiKey = options.apiKey;
+        this.accessToken = options.accessToken;
         this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
         this.workspaceId = options.workspaceId;
         this.defaultHeaders = options.headers ?? {};
         this.fetchImpl = fetchImpl.bind(globalThis);
+        this.permissions = {
+            update: this.bindMethod('permissionsUpdate', (request) => (permissionId, body, options) => request({ pathParams: { permissionId }, body }, options)),
+            list: this.bindMethod('permissionsList', (request) => (query, options) => request({ query }, options)),
+            create: this.bindMethod('permissionsCreate', (request) => (body, options) => request({ body }, options)),
+            delete: this.bindMethod('permissionsDelete', (request) => (permissionId, options) => request({ pathParams: { permissionId } }, options)),
+            inspect: this.bindMethod('permissionsInspect', (request) => (body, options) => request({ body }, options)),
+        };
+        this.accessRequests = {
+            create: this.bindMethod('accessRequestsCreate', (request) => (body, options) => request({ body }, options)),
+            list: this.bindMethod('accessRequestsList', (request) => (query, options) => request({ query }, options)),
+            get: this.bindMethod('accessRequestsGet', (request) => (requestId, options) => request({ pathParams: { requestId } }, options)),
+            decide: this.bindMethod('accessRequestsDecide', (request) => (requestId, body, options) => request({ pathParams: { requestId }, body }, options)),
+        };
         this.revisions = {
-            list: (resourceId, options) => this.request('resourceRevisionsList', { pathParams: { resourceId } }, options),
-            get: (resourceId, revisionId, options) => this.request('resourceRevisionsGet', { pathParams: { resourceId, revisionId } }, options),
-            restore: (resourceId, revisionId, body, options) => this.request('resourceRevisionsRestore', { pathParams: { resourceId, revisionId }, body }, options),
-            publish: (resourceId, body, options) => this.request('resourcesPublish', { pathParams: { resourceId }, body }, options),
+            list: this.bindMethod('resourceRevisionsList', (apiRequest) => (resourceId, options) => apiRequest({ pathParams: { resourceId } }, options)),
+            get: this.bindMethod('resourceRevisionsGet', (apiRequest) => (resourceId, revisionId, options) => apiRequest({ pathParams: { resourceId, revisionId } }, options)),
+            restore: this.bindMethod('resourceRevisionsRestore', (apiRequest) => (resourceId, revisionId, body, options) => apiRequest({ pathParams: { resourceId, revisionId }, body }, options)),
+            publish: this.bindMethod('resourcesPublish', (apiRequest) => (resourceId, body, options) => apiRequest({ pathParams: { resourceId }, body }, options)),
         };
         this.facts = {
-            list: (options) => this.request('factsList', {}, options),
-            get: (factId, options) => this.request('factsGet', { pathParams: { factId } }, options),
-            create: (body, options) => this.request('factsCreate', { body }, options),
-            update: (factId, body, options) => this.request('factsUpdate', { pathParams: { factId }, body }, options),
-            delete: (factId, options) => this.request('factsDelete', { pathParams: { factId } }, options),
+            list: this.bindMethod('factsList', (apiRequest) => (options) => apiRequest({}, options)),
+            get: this.bindMethod('factsGet', (apiRequest) => (factId, options) => apiRequest({ pathParams: { factId } }, options)),
+            create: this.bindMethod('factsCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
+            update: this.bindMethod('factsUpdate', (apiRequest) => (factId, body, options) => apiRequest({ pathParams: { factId }, body }, options)),
+            delete: this.bindMethod('factsDelete', (apiRequest) => (factId, options) => apiRequest({ pathParams: { factId } }, options)),
         };
         const skillsClient = (prefix) => ({
-            list: (options) => this.request(`${prefix}List`, {}, options),
-            get: (path, options) => this.request(`${prefix}Get`, { pathParams: { path } }, options),
-            update: (path, body, options) => this.request(`${prefix}Update`, { pathParams: { path }, body }, options),
-            delete: (path, options) => this.request(`${prefix}Delete`, { pathParams: { path } }, options),
+            list: this.bindMethod(`${prefix}List`, (apiRequest) => (options) => apiRequest({}, options)),
+            get: this.bindMethod(`${prefix}Get`, (apiRequest) => (path, options) => apiRequest({ pathParams: { path } }, options)),
+            update: this.bindMethod(`${prefix}Update`, (apiRequest) => (path, body, options) => apiRequest({ pathParams: { path }, body }, options)),
+            delete: this.bindMethod(`${prefix}Delete`, (apiRequest) => (path, options) => apiRequest({ pathParams: { path } }, options)),
         });
         this.skills = skillsClient('skills');
         this.organizationSkills = skillsClient('organizationSkills');
         this.actions = {
-            list: (options) => this.request('actionsList', {}, options),
-            create: (body, options) => this.request('actionsCreate', { body }, options),
-            get: (actionId, options) => this.request('actionsGet', { pathParams: { actionId } }, options),
-            delete: (actionId, options) => this.request('actionsDelete', { pathParams: { actionId } }, options),
-            definition: (actionId, options) => this.request('actionDefinitionGet', { pathParams: { actionId } }, options),
-            saveDefinition: (actionId, body, options) => this.request('actionDefinitionSave', { pathParams: { actionId }, body }, options),
-            invoke: (actionId, body, options) => this.request('actionsInvoke', { pathParams: { actionId }, body }, options),
+            requestPublication: this.bindMethod('actionsPublicationRequestsCreate', (apiRequest) => (actionId, body, options) => apiRequest({ pathParams: { actionId }, body }, options)),
+            publicationRequests: this.bindMethod('actionsPublicationRequestsList', (apiRequest) => (actionId, options) => apiRequest({ pathParams: { actionId } }, options)),
+            decidePublication: this.bindMethod('actionsPublicationRequestsDecide', (apiRequest) => (actionId, requestId, body, options) => apiRequest({ pathParams: { actionId, requestId }, body }, options)),
+            list: this.bindMethod('actionsList', (apiRequest) => (options) => apiRequest({}, options)),
+            create: this.bindMethod('actionsCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
+            get: this.bindMethod('actionsGet', (apiRequest) => (actionId, options) => apiRequest({ pathParams: { actionId } }, options)),
+            delete: this.bindMethod('actionsDelete', (apiRequest) => (actionId, options) => apiRequest({ pathParams: { actionId } }, options)),
+            definition: this.bindMethod('actionDefinitionGet', (apiRequest) => (actionId, options) => apiRequest({ pathParams: { actionId } }, options)),
+            saveDefinition: this.bindMethod('actionDefinitionSave', (apiRequest) => (actionId, body, options) => apiRequest({ pathParams: { actionId }, body }, options)),
+            invoke: this.bindMethod('actionsInvoke', (apiRequest) => (actionId, body, options) => apiRequest({ pathParams: { actionId }, body }, options)),
+        };
+        this.emails = {
+            get: this.bindMethod('emailsGet', (request) => (options) => request({}, options)),
+            send: this.bindMethod('emailsSend', (request) => (body, options) => request({ body }, options)),
         };
         this.databases = {
-            list: (options) => this.request('databasesList', {}, options),
-            create: (body, options) => this.request('databasesCreate', { body }, options),
-            get: (databaseId, options) => this.request('databasesGet', { pathParams: { databaseId } }, options),
-            delete: (databaseId, options) => this.request('databasesDelete', { pathParams: { databaseId } }, options),
-            definition: (databaseId, options) => this.request('databaseDefinitionGet', { pathParams: { databaseId } }, options),
-            saveDefinition: (databaseId, body, options) => this.request('databaseDefinitionSave', { pathParams: { databaseId }, body }, options),
-            tables: (databaseId, options) => this.request('databaseTablesList', { pathParams: { databaseId } }, options),
-            createTable: (databaseId, body, options) => this.request('databaseTablesCreate', { pathParams: { databaseId }, body }, options),
-            records: (databaseId, table, query = {}, options) => this.request('databaseRecordsList', { pathParams: { databaseId, table }, query }, options),
-            transact: (databaseId, body, options) => this.request('databaseTransactionsCreate', { pathParams: { databaseId }, body }, options),
+            list: this.bindMethod('databasesList', (apiRequest) => (options) => apiRequest({}, options)),
+            create: this.bindMethod('databasesCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
+            get: this.bindMethod('databasesGet', (apiRequest) => (databaseId, options) => apiRequest({ pathParams: { databaseId } }, options)),
+            delete: this.bindMethod('databasesDelete', (apiRequest) => (databaseId, options) => apiRequest({ pathParams: { databaseId } }, options)),
+            definition: this.bindMethod('databaseDefinitionGet', (apiRequest) => (databaseId, options) => apiRequest({ pathParams: { databaseId } }, options)),
+            saveDefinition: this.bindMethod('databaseDefinitionSave', (apiRequest) => (databaseId, body, options) => apiRequest({ pathParams: { databaseId }, body }, options)),
+            tables: this.bindMethod('databaseTablesList', (apiRequest) => (databaseId, options) => apiRequest({ pathParams: { databaseId } }, options)),
+            createTable: this.bindMethod('databaseTablesCreate', (apiRequest) => (databaseId, body, options) => apiRequest({ pathParams: { databaseId }, body }, options)),
+            records: this.bindMethod('databaseRecordsList', (apiRequest) => (databaseId, table, query = {}, options) => apiRequest({ pathParams: { databaseId, table }, query }, options)),
+            transact: this.bindMethod('databaseTransactionsCreate', (apiRequest) => (databaseId, body, options) => apiRequest({ pathParams: { databaseId }, body }, options)),
         };
         this.apps = {
-            listGrants: (applicationId, options) => this.request('appsGrantsList', { pathParams: { applicationId } }, options),
-            setGrant: (applicationId, resourceId, body, options) => this.request('appsGrantsSet', { pathParams: { applicationId, resourceId }, body }, options),
-            prepareUploads: (applicationId, body, options) => this.request('appsUploadsCreate', { pathParams: { applicationId }, body }, options),
+            requestPublication: this.bindMethod('appsPublicationRequestsCreate', (apiRequest) => (applicationId, body, options) => apiRequest({ pathParams: { applicationId }, body }, options)),
+            publicationRequests: this.bindMethod('appsPublicationRequestsList', (apiRequest) => (applicationId, options) => apiRequest({ pathParams: { applicationId } }, options)),
+            decidePublication: this.bindMethod('appsPublicationRequestsDecide', (apiRequest) => (applicationId, requestId, body, options) => apiRequest({ pathParams: { applicationId, requestId }, body }, options)),
+            sourceFile: this.bindMethod('appsSourceFileGet', (apiRequest) => (applicationId, query, options) => apiRequest({ pathParams: { applicationId }, query }, options)),
+            address: this.bindMethod('appsAddressGet', (apiRequest) => (applicationId, options) => apiRequest({ pathParams: { applicationId } }, options)),
+            setAddress: this.bindMethod('appsAddressSet', (apiRequest) => (applicationId, body, options) => apiRequest({ pathParams: { applicationId }, body }, options)),
+            access: this.bindMethod('appsAccessGet', (apiRequest) => (applicationId, options) => apiRequest({ pathParams: { applicationId } }, options)),
+            setAccess: this.bindMethod('appsAccessSet', (apiRequest) => (applicationId, body, options) => apiRequest({ pathParams: { applicationId }, body }, options)),
+            listGrants: this.bindMethod('appsGrantsList', (apiRequest) => (applicationId, options) => apiRequest({ pathParams: { applicationId } }, options)),
+            setGrant: this.bindMethod('appsGrantsSet', (apiRequest) => (applicationId, resourceId, body, options) => apiRequest({ pathParams: { applicationId, resourceId }, body }, options)),
+            prepareUploads: this.bindMethod('appsUploadsCreate', (apiRequest) => (applicationId, body, options) => apiRequest({ pathParams: { applicationId }, body }, options)),
             uploadFiles: async (applicationId, files, options) => {
                 const contents = await Promise.all(files.map(async (file) => ({
                     path: file.path,
@@ -373,71 +407,73 @@ export class PermuteClient {
                 }
                 return manifest;
             },
-            saveSite: (applicationId, body, options) => this.request('appsSiteUpdate', { pathParams: { applicationId }, body }, options),
-            list: (options) => this.request('appsList', {}, options),
-            create: (body, options) => this.request('appsCreate', { body }, options),
-            get: (applicationId, options) => this.request('appsGet', { pathParams: { applicationId } }, options),
-            update: (applicationId, body, options) => this.request('appsUpdate', { pathParams: { applicationId }, body }, options),
-            delete: (applicationId, options) => this.request('appsDelete', { pathParams: { applicationId } }, options),
+            saveSite: this.bindMethod('appsSiteUpdate', (apiRequest) => (applicationId, body, options) => apiRequest({ pathParams: { applicationId }, body }, options)),
+            list: this.bindMethod('appsList', (apiRequest) => (options) => apiRequest({}, options)),
+            create: this.bindMethod('appsCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
+            get: this.bindMethod('appsGet', (apiRequest) => (applicationId, options) => apiRequest({ pathParams: { applicationId } }, options)),
+            update: this.bindMethod('appsUpdate', (apiRequest) => (applicationId, body, options) => apiRequest({ pathParams: { applicationId }, body }, options)),
+            delete: this.bindMethod('appsDelete', (apiRequest) => (applicationId, options) => apiRequest({ pathParams: { applicationId } }, options)),
         };
         this.connectorSessions = {
-            create: (body, options) => this.request('connectorSessionsCreate', { body }, options),
-            get: (sessionId, options) => this.request('connectorSessionsGet', { pathParams: { sessionId } }, options),
+            create: this.bindMethod('connectorSessionsCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
+            get: this.bindMethod('connectorSessionsGet', (apiRequest) => (sessionId, options) => apiRequest({ pathParams: { sessionId } }, options)),
         };
         this.writeSyncs = {
-            list: (options) => this.request('writeSyncsList', {}, options),
-            create: (body, options) => this.request('writeSyncsCreate', { body }, options),
-            get: (writeSyncId, options) => this.request('writeSyncsGet', { pathParams: { writeSyncId } }, options),
-            update: (writeSyncId, body, options) => this.request('writeSyncsUpdate', { pathParams: { writeSyncId }, body }, options),
-            delete: (writeSyncId, options) => this.request('writeSyncsDelete', { pathParams: { writeSyncId } }, options),
-            destinations: (options) => this.request('writeSyncsDestinations', {}, options),
-            preview: (writeSyncId, options) => this.request('writeSyncsPreview', { pathParams: { writeSyncId } }, options),
-            pause: (writeSyncId, options) => this.request('writeSyncsPause', { pathParams: { writeSyncId } }, options),
-            listRuns: (writeSyncId, options) => this.request('writeSyncsListRuns', { pathParams: { writeSyncId } }, options),
-            getRun: (writeSyncId, runId, query = {}, options) => this.request('writeSyncsGetRun', { pathParams: { writeSyncId, runId }, query }, options),
-            execute: (writeSyncId, runId, options) => this.request('writeSyncsExecute', { pathParams: { writeSyncId, runId } }, options),
+            list: this.bindMethod('writeSyncsList', (apiRequest) => (options) => apiRequest({}, options)),
+            create: this.bindMethod('writeSyncsCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
+            get: this.bindMethod('writeSyncsGet', (apiRequest) => (writeSyncId, options) => apiRequest({ pathParams: { writeSyncId } }, options)),
+            update: this.bindMethod('writeSyncsUpdate', (apiRequest) => (writeSyncId, body, options) => apiRequest({ pathParams: { writeSyncId }, body }, options)),
+            delete: this.bindMethod('writeSyncsDelete', (apiRequest) => (writeSyncId, options) => apiRequest({ pathParams: { writeSyncId } }, options)),
+            destinations: this.bindMethod('writeSyncsDestinations', (apiRequest) => (options) => apiRequest({}, options)),
+            preview: this.bindMethod('writeSyncsPreview', (apiRequest) => (writeSyncId, options) => apiRequest({ pathParams: { writeSyncId } }, options)),
+            pause: this.bindMethod('writeSyncsPause', (apiRequest) => (writeSyncId, options) => apiRequest({ pathParams: { writeSyncId } }, options)),
+            listRuns: this.bindMethod('writeSyncsListRuns', (apiRequest) => (writeSyncId, options) => apiRequest({ pathParams: { writeSyncId } }, options)),
+            getRun: this.bindMethod('writeSyncsGetRun', (apiRequest) => (writeSyncId, runId, query = {}, options) => apiRequest({ pathParams: { writeSyncId, runId }, query }, options)),
+            execute: this.bindMethod('writeSyncsExecute', (apiRequest) => (writeSyncId, runId, options) => apiRequest({ pathParams: { writeSyncId, runId } }, options)),
         };
         this.workspaces = {
-            list: (requestOptions) => this.request('workspacesList', {}, requestOptions),
-            create: (request, requestOptions) => this.request('workspacesCreate', { body: request }, requestOptions),
-            get: (workspaceId, requestOptions) => this.request('workspacesGet', { pathParams: { workspaceId } }, requestOptions),
-            update: (workspaceId, request, requestOptions) => this.request('workspacesUpdate', { pathParams: { workspaceId }, body: request }, requestOptions),
-            delete: (workspaceId, requestOptions) => this.request('workspacesDelete', { pathParams: { workspaceId } }, requestOptions),
+            list: this.bindMethod('workspacesList', (apiRequest) => (requestOptions) => apiRequest({}, requestOptions)),
+            create: this.bindMethod('workspacesCreate', (apiRequest) => (request, requestOptions) => apiRequest({ body: request }, requestOptions)),
+            get: this.bindMethod('workspacesGet', (apiRequest) => (workspaceId, requestOptions) => apiRequest({ pathParams: { workspaceId } }, requestOptions)),
+            update: this.bindMethod('workspacesUpdate', (apiRequest) => (workspaceId, request, requestOptions) => apiRequest({ pathParams: { workspaceId }, body: request }, requestOptions)),
+            delete: this.bindMethod('workspacesDelete', (apiRequest) => (workspaceId, requestOptions) => apiRequest({ pathParams: { workspaceId } }, requestOptions)),
         };
         this.sources = {
-            list: (requestOptions) => this.request('sourcesList', {}, requestOptions),
-            get: (sourceId, requestOptions) => this.request('sourcesGet', { pathParams: { sourceId } }, requestOptions),
-            listTables: async (sourceId, requestOptions) => (await this.request('sourcesGet', {
+            list: this.bindMethod('sourcesList', (apiRequest) => (requestOptions) => apiRequest({}, requestOptions)),
+            get: this.bindMethod('sourcesGet', (apiRequest) => (sourceId, requestOptions) => apiRequest({ pathParams: { sourceId } }, requestOptions)),
+            listTables: this.bindMethod('sourcesGet', (apiRequest) => async (sourceId, requestOptions) => (await apiRequest({
                 pathParams: { sourceId },
                 query: { includeFields: 'false' },
-            }, requestOptions)).tables,
-            describeTable: async (sourceId, tableId, requestOptions) => (await this.request('sourcesGet', {
+            }, requestOptions)).tables),
+            describeTable: this.bindMethod('sourcesGet', (apiRequest) => async (sourceId, tableId, requestOptions) => (await apiRequest({
                 pathParams: { sourceId },
                 query: { tableId },
-            }, requestOptions)).tables[0],
+            }, requestOptions)).tables[0]),
         };
+        const listOperationRuns = this.bindMethod('operationsRunsList', (apiRequest) => (operationId, options) => apiRequest({ pathParams: { operationId } }, options));
+        const listWorkflowRuns = this.bindMethod('operationRunsList', (apiRequest) => (query, options) => apiRequest({ query }, options));
         this.operations = {
-            list: (query = {}, options) => this.request('operationsList', { query }, options),
-            get: (operationId, options) => this.request('operationsGet', { pathParams: { operationId } }, options),
-            update: (operationId, body, options) => this.request('operationsUpdate', { pathParams: { operationId }, body }, options),
-            getSource: (operationId, options) => this.request('operationsSourceGet', { pathParams: { operationId } }, options),
-            updateSource: (operationId, body, options) => this.request('operationsSourceUpdate', { pathParams: { operationId }, body }, options),
-            getRunOutput: (operationId, runId, options) => this.request('operationsRunOutput', { pathParams: { operationId, runId } }, options),
-            listRuns: ((input, options) => typeof input === 'string'
-                ? this.request('operationsRunsList', { pathParams: { operationId: input } }, options)
-                : this.request('operationRunsList', { query: input }, options)),
-            run: (operationId, body, options) => this.request('operationsRun', { pathParams: { operationId }, body }, options),
+            list: this.bindMethod('operationsList', (apiRequest) => (query = {}, options) => apiRequest({ query }, options)),
+            get: this.bindMethod('operationsGet', (apiRequest) => (operationId, options) => apiRequest({ pathParams: { operationId } }, options)),
+            update: this.bindMethod('operationsUpdate', (apiRequest) => (operationId, body, options) => apiRequest({ pathParams: { operationId }, body }, options)),
+            getSource: this.bindMethod('operationsSourceGet', (apiRequest) => (operationId, options) => apiRequest({ pathParams: { operationId } }, options)),
+            updateSource: this.bindMethod('operationsSourceUpdate', (apiRequest) => (operationId, body, options) => apiRequest({ pathParams: { operationId }, body }, options)),
+            getRunOutput: this.bindMethod('operationsRunOutput', (apiRequest) => (operationId, runId, options) => apiRequest({ pathParams: { operationId, runId } }, options)),
+            listRuns: SdkMethodFactory.compose([listOperationRuns, listWorkflowRuns], ((input, options) => typeof input === 'string'
+                ? listOperationRuns(input, options)
+                : listWorkflowRuns(input, options))),
+            run: this.bindMethod('operationsRun', (apiRequest) => (operationId, body, options) => apiRequest({ pathParams: { operationId }, body }, options)),
         };
         this.dataFlows = {
-            create: (body, options) => this.request('dataFlowsCreate', { body }, options),
-            get: (dataFlowId, options) => this.request('dataFlowsGet', { pathParams: { dataFlowId } }, options),
-            command: (dataFlowId, body, options) => this.request('dataFlowsCommand', { pathParams: { dataFlowId }, body }, options),
+            create: this.bindMethod('dataFlowsCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
+            get: this.bindMethod('dataFlowsGet', (apiRequest) => (dataFlowId, options) => apiRequest({ pathParams: { dataFlowId } }, options)),
+            command: this.bindMethod('dataFlowsCommand', (apiRequest) => (dataFlowId, body, options) => apiRequest({ pathParams: { dataFlowId }, body }, options)),
         };
         this.dashboards = {
-            getSource: (dashboardId, requestOptions) => this.request('dashboardsSourceGet', { pathParams: { dashboardId } }, requestOptions),
-            updateSource: (dashboardId, request, requestOptions) => this.request('dashboardsSourceUpdate', { pathParams: { dashboardId }, body: request }, requestOptions),
+            getSource: this.bindMethod('dashboardsSourceGet', (apiRequest) => (dashboardId, requestOptions) => apiRequest({ pathParams: { dashboardId } }, requestOptions)),
+            updateSource: this.bindMethod('dashboardsSourceUpdate', (apiRequest) => (dashboardId, request, requestOptions) => apiRequest({ pathParams: { dashboardId }, body: request }, requestOptions)),
         };
-        const readDataset = (datasetId, requestOptions) => this.request('datasetsGet', { pathParams: { datasetId } }, requestOptions);
+        const readDataset = this.bindMethod('datasetsGet', (apiRequest) => (datasetId, requestOptions) => apiRequest({ pathParams: { datasetId } }, requestOptions));
         const writeDatasetTables = async (datasetId, request, requestOptions) => {
             const encoded = encodeDatasetWrite(request);
             const body = request.mode === 'replace'
@@ -505,9 +541,9 @@ export class PermuteClient {
         const wrapDataset = (dataset) => dataset.type === 'custom'
             ? new PermuteDataset(dataset, writeDatasetTables, readDataset)
             : new PermuteFileDataset(dataset, readDataset);
-        const createDataset = async (request, requestOptions) => {
+        const createDataset = this.bindMethod('datasetsCreate', (apiRequest) => async (request, requestOptions) => {
             if (request.type === 'custom') {
-                const dataset = await this.request('datasetsCreate', { body: request }, requestOptions);
+                const dataset = await apiRequest({ body: request }, requestOptions);
                 return new PermuteDataset(requireCustomDataset(dataset), writeDatasetTables, readDataset);
             }
             const { data, headers, sizeBytes: declaredSize, ...createRequest } = request;
@@ -524,10 +560,10 @@ export class PermuteClient {
                 throw new PermuteApiError({
                     status: 0,
                     code: 'missing_file_size',
-                    message: 'sizeBytes is required when the SDK cannot determine the upload body size',
+                    message: 'sizeBytes is required without data or when the upload body size cannot be inferred',
                 });
             }
-            const response = await this.request('datasetsCreate', { body: { ...createRequest, sizeBytes } }, requestOptions);
+            const response = await apiRequest({ body: { ...createRequest, sizeBytes } }, requestOptions);
             const dataset = new PermuteFileDataset(requireFileDataset(response), readDataset);
             const target = dataset.data.upload;
             if (!target) {
@@ -537,6 +573,8 @@ export class PermuteClient {
                     message: `Dataset ${dataset.id} did not include a file upload target`,
                 });
             }
+            if (data === undefined)
+                return dataset;
             const uploadResponse = await this.fetchImpl(target.url, {
                 method: target.method,
                 headers: { ...headers, ...target.headers },
@@ -551,27 +589,28 @@ export class PermuteClient {
                 });
             }
             return dataset;
-        };
+        });
         this.datasets = {
             create: createDataset,
-            getByKey: async (key, requestOptions) => {
-                const dataset = await this.request('datasetsGetByKey', { query: { key } }, requestOptions);
+            getByKey: this.bindMethod('datasetsGetByKey', (apiRequest) => async (key, requestOptions) => {
+                const dataset = await apiRequest({ query: { key } }, requestOptions);
                 return wrapDataset(dataset);
-            },
+            }),
             get: async (datasetId, requestOptions) => {
                 const dataset = await readDataset(datasetId, requestOptions);
                 return wrapDataset(dataset);
             },
-            download: async (datasetId, requestOptions) => {
-                const { url } = await this.request('datasetsDownload', { pathParams: { datasetId } }, requestOptions);
+            download: this.bindMethod('datasetsDownload', (apiRequest) => async (datasetId, requestOptions) => {
+                const { url } = await apiRequest({ pathParams: { datasetId } }, requestOptions);
                 return url;
-            },
-            delete: (datasetId, requestOptions) => this.request('datasetsDelete', { pathParams: { datasetId } }, requestOptions),
+            }),
+            delete: this.bindMethod('datasetsDelete', (apiRequest) => (datasetId, requestOptions) => apiRequest({ pathParams: { datasetId } }, requestOptions)),
         };
+        this.apps.uploadFiles = SdkMethodFactory.compose([this.apps.prepareUploads], this.apps.uploadFiles);
+        this.datasets.get = SdkMethodFactory.compose([readDataset], this.datasets.get);
+        this.answer = SdkMethodFactory.compose([this.answerJobs, this.getAnswerJob], this.answer.bind(this));
     }
-    async search(request, options) {
-        return await this.request('searchCreate', { body: request }, options);
-    }
+    search = this.bindMethod('searchCreate', (apiRequest) => (request, options) => apiRequest({ body: request }, options));
     async answer(request, options) {
         let job = await this.answerJobs(request, options);
         const deadline = pollingDeadline(options);
@@ -594,33 +633,31 @@ export class PermuteClient {
             message: job.error ?? `Answer job ${job.status}`,
         });
     }
-    async answerJobs(request, options) {
-        return await this.request('answerJobsCreate', { body: request }, options);
-    }
-    async getAnswerJob(answerJobId, options) {
-        return await this.request('answerJobsGet', { pathParams: { answerJobId } }, options);
-    }
+    answerJobs = this.bindMethod('answerJobsCreate', (apiRequest) => (request, options) => apiRequest({ body: request }, options));
+    getAnswerJob = this.bindMethod('answerJobsGet', (apiRequest) => (answerJobId, options) => apiRequest({ pathParams: { answerJobId } }, options));
     withWorkspace(workspaceId) {
         if (!workspaceId.trim()) {
             throw new PermuteApiError({ status: 0, code: 'missing_workspace_id', message: 'workspaceId is required' });
         }
         return new PermuteClient({
             apiKey: this.apiKey,
+            accessToken: this.accessToken,
             baseUrl: this.baseUrl,
             workspaceId,
             fetch: this.fetchImpl,
             headers: this.defaultHeaders,
         });
     }
-    async query(request, options) {
-        return await this.request('queriesCreate', { body: request }, options);
+    query = this.bindMethod('queriesCreate', (apiRequest) => (request, options) => apiRequest({ body: request }, options));
+    bindMethod(operationId, create) {
+        return SdkMethodFactory.create(operationId, create((input, options) => this.request(operationId, input, options)));
     }
     async request(operationId, input, options) {
         const route = routeFor(operationId);
         const body = this.validateRequestBody(route, operationId, input.body);
         const query = this.validateRequestQuery(route, operationId, input.query);
         const headers = {
-            Authorization: `Bearer ${this.apiKey}`,
+            Authorization: `Bearer ${this.accessToken ? await this.accessToken() : this.apiKey}`,
             ...this.defaultHeaders,
             ...options?.headers,
         };

package/dist/deploy.d.ts

@@ -1,15 +1,89 @@
 import type { PermuteClient } from './client.js';
-import type { AppSiteSaveRequest, PermuteRequestOptions } from './types.js';
+import type { AppSiteSaveRequest, AppSource, PermuteRequestOptions } from './types.js';
 export interface DeployAppOptions {
     appId: string;
     directory: string;
+    /** Original project files and the instructions used to compile directory. */
+    source: {
+        directory: string;
+        build: AppSource['build'];
+    };
     /** Defaults to true. */
     spa?: boolean;
-    /** Explicitly approve replacing this exact draft. Omit to require a clean published app. */
-    expectedDraft?: AppSiteSaveRequest['expectedDraft'];
+    /** Token from checkout or a reviewed app draft. Never infer the base of local source from newer remote work. */
+    expectedDraft: AppSiteSaveRequest['expectedDraft'];
     /** Omit to preserve bindings; [] removes them. Revisions must already be published. */
     actions?: AppSiteSaveRequest['actions'];
 }
+/** Save a shared source checkpoint without compiling or publishing. */
+export declare function saveAppSource(client: PermuteClient, options: {
+    appId: string;
+    source: DeployAppOptions['source'];
+    expectedDraft: AppSiteSaveRequest['expectedDraft'];
+}, requestOptions?: PermuteRequestOptions): Promise<{
+    chat?: {
+        enabled: boolean;
+    };
+    createdAt: string;
+    deployment: {
+        error: string | null;
+        revisionId: string;
+        status: 'deploying' | 'live' | 'deleting' | 'failed' | 'deleted';
+        url: string;
+    } | null;
+    description: string;
+    draft: {
+        revisionId: string;
+        sequence: number;
+    };
+    favicon?: {
+        path: string;
+        sha256: string;
+        size: number;
+    } | null;
+    id: string;
+    login?: {
+        header?: string;
+        primaryColor?: string;
+        secondaryColor?: string;
+        sidePanelImage?: {
+            path: string;
+            sha256: string;
+            size: number;
+        };
+        subheader?: string;
+        subtitle?: string;
+        title?: string;
+    } | null;
+    name: string;
+    updatedAt: string;
+    workspaceId: string;
+}>;
+/** Materialize the draft or an exact historical source revision into a new folder. Never overwrites files. */
+export declare function checkoutApp(client: PermuteClient, options: {
+    appId: string;
+    directory: string;
+    revisionId?: string;
+}, requestOptions?: PermuteRequestOptions): Promise<{
+    revisionId: string;
+    source: {
+        build: {
+            command: string;
+            outputDirectory: string;
+            runtime: string;
+        };
+        files: {
+            executable?: boolean;
+            path: string;
+            sha256: string;
+            size: number;
+        }[];
+    };
+    expectedDraft: {
+        revisionId: string;
+        sequence: number;
+    } | null;
+}>;
 /** Upload, save, and publish an existing live app. Builds and provisions nothing; never retries mutations. */
 export declare function deployApp(client: PermuteClient, options: DeployAppOptions, requestOptions?: PermuteRequestOptions): Promise<{
     url: string;