@permute/sdk 0.5.0 → 0.7.0

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 export { PermuteApiError } from './errors.js';
 import type { BusinessAction, BusinessActionList, ActionCreateRequest, ActionDefinition, ActionDefinitionSaveRequest, ActionDefinitionSaved, ActionRequest, ActionReceipt } from './types.js';
-import type { ConnectorSession, ConnectorSessionCreated, ConnectorSessionCreateRequest, Database, AppDraft, AppDraftList, AppCreateRequest, AppUpdateRequest, AppDeleted, AppUploadsRequest, AppUploads, AppSiteSaveRequest, AppUploadFile, DatabaseList, DatabaseCreateRequest, DatabaseDefinition, DatabaseDefinitionSaveRequest, DatabaseDefinitionSaved, DatabaseTables, DatabaseTableCreateRequest, DatabaseTableCreated, DatabaseRecords, DatabaseRecordsQuery, DatabaseTransactionRequest, DatabaseTransactionReceipt, WriteSync, WriteSyncCreateRequest, WriteSyncUpdateRequest, WriteSyncDetail, WriteSyncList, WriteSyncDeleted, WriteSyncDestinations, WriteSyncRun, WriteSyncRunList, WriteSyncRunQuery, WriteSyncExecution, ResourceVersionState, ResourceRevisionList, ResourceRevision, ResourceVersionRequest, ResourcePublishRequest, Fact, FactList, FactWriteRequest, SkillList, SkillContent, SkillWriteRequest, KnowledgeWriteResponse, OperationRunGroup, OperationRunQuery, Operation, OperationList, OperationListQuery, OperationSource, OperationSourceUpdateRequest, OperationUpdateRequest, OperationRunRequest, OperationRunStarted, OperationRunList, OperationRunOutput, DataFlow, DataFlowCreateRequest, DataFlowCommandRequest, DataFlowCommandResponse, Workspace, WorkspaceCreateRequest, WorkspaceDeleteResponse, WorkspaceList, WorkspaceUpdateRequest, AnswerRequest, AnswerJobResponse, AnswerResponse, PermuteClientOptions, PermuteRequestOptions, QueryRequest, QueryResponse, SearchRequest, SearchResponse, SourceDetail, CatalogTable, SourceList, CustomDatasetCreateRequest, DatasetDeleteResponse, DatasetResponse, FileDatasetCreateRequest, FileDatasetResponse, DatasetRows, CustomDatasetResponse, DashboardSource, DashboardSourceUpdateRequest } from './types.js';
+import type { ConnectorSession, ConnectorSessionCreated, ConnectorSessionCreateRequest, Database, AppDraft, AppAccess, AppAddressSettings, AppAddressSetRequest, AppAccessSetRequest, AppDraftList, AppCreateRequest, AppUpdateRequest, AppDeleted, AppUploadsRequest, AppUploads, AppSiteSaveRequest, AppSourceFileQuery, AppSourceFileContent, AppGrants, AppGrantSetRequest, AppUploadFile, DatabaseList, DatabaseCreateRequest, DatabaseDefinition, DatabaseDefinitionSaveRequest, DatabaseDefinitionSaved, DatabaseTables, DatabaseTableCreateRequest, DatabaseTableCreated, DatabaseRecords, DatabaseRecordsQuery, DatabaseTransactionRequest, DatabaseTransactionReceipt, WriteSync, WriteSyncCreateRequest, WriteSyncUpdateRequest, WriteSyncDetail, WriteSyncList, WriteSyncDeleted, WriteSyncDestinations, WriteSyncRun, WriteSyncRunList, WriteSyncRunQuery, WriteSyncExecution, ResourceVersionState, ResourceRevisionList, ResourceRevision, ResourceVersionRequest, ResourcePublishRequest, Fact, FactList, FactWriteRequest, SkillList, SkillContent, SkillWriteRequest, KnowledgeWriteResponse, OperationRunGroup, OperationRunQuery, Operation, OperationList, OperationListQuery, OperationSource, OperationSourceUpdateRequest, OperationUpdateRequest, OperationRunRequest, OperationRunStarted, OperationRunList, OperationRunOutput, DataFlow, DataFlowCreateRequest, DataFlowCommandRequest, DataFlowCommandResponse, Workspace, WorkspaceCreateRequest, WorkspaceDeleteResponse, WorkspaceList, WorkspaceUpdateRequest, AnswerRequest, AnswerResponse, PermuteClientOptions, PermuteRequestOptions, QueryRequest, SearchRequest, SourceDetail, CatalogTable, SourceList, CustomDatasetCreateRequest, DatasetDeleteResponse, DatasetResponse, FileDatasetCreateRequest, FileDatasetMetadataCreateRequest, FileDatasetResponse, DatasetRows, CustomDatasetResponse, DashboardSource, DashboardSourceUpdateRequest } from './types.js';
 type DatasetWriteInput = {
     tables: Record<string, DatasetRows>;
     mode: 'replace';
@@ -93,6 +93,12 @@ export declare class PermuteClient {
         transact(databaseId: string, body: DatabaseTransactionRequest, options?: PermuteRequestOptions): Promise<DatabaseTransactionReceipt>;
     };
     readonly apps: {
+        address(applicationId: string, options?: PermuteRequestOptions): Promise<AppAddressSettings>;
+        setAddress(applicationId: string, body: AppAddressSetRequest, options?: PermuteRequestOptions): Promise<AppAddressSettings>;
+        access(applicationId: string, options?: PermuteRequestOptions): Promise<AppAccess>;
+        setAccess(applicationId: string, body: AppAccessSetRequest, options?: PermuteRequestOptions): Promise<AppAccess>;
+        listGrants(applicationId: string, options?: PermuteRequestOptions): Promise<AppGrants>;
+        setGrant(applicationId: string, resourceId: string, body: AppGrantSetRequest, options?: PermuteRequestOptions): Promise<AppGrants>;
         list(options?: PermuteRequestOptions): Promise<AppDraftList>;
         create(body: AppCreateRequest, options?: PermuteRequestOptions): Promise<AppDraft>;
         get(applicationId: string, options?: PermuteRequestOptions): Promise<AppDraft>;
@@ -101,6 +107,7 @@ export declare class PermuteClient {
         prepareUploads(applicationId: string, body: AppUploadsRequest, options?: PermuteRequestOptions): Promise<AppUploads>;
         uploadFiles(applicationId: string, files: AppUploadFile[], options?: PermuteRequestOptions): Promise<AppUploadsRequest['files']>;
         saveSite(applicationId: string, body: AppSiteSaveRequest, options?: PermuteRequestOptions): Promise<AppDraft>;
+        sourceFile(applicationId: string, query: AppSourceFileQuery, options?: PermuteRequestOptions): Promise<AppSourceFileContent>;
     };
     readonly connectorSessions: {
         create(request: ConnectorSessionCreateRequest, options?: PermuteRequestOptions): Promise<ConnectorSessionCreated>;
@@ -156,6 +163,7 @@ export declare class PermuteClient {
     };
     readonly datasets: {
         create: {
+            (request: FileDatasetMetadataCreateRequest, options?: PermuteRequestOptions): Promise<PermuteFileDataset>;
             (request: CustomDatasetCreateRequest, options?: PermuteRequestOptions): Promise<PermuteDataset>;
             (request: FileDatasetCreateRequest, options?: PermuteRequestOptions): Promise<PermuteFileDataset>;
         };
@@ -171,12 +179,122 @@ export declare class PermuteClient {
     private readonly defaultHeaders;
     private readonly fetchImpl;
     constructor(options: PermuteClientOptions);
-    search(request: SearchRequest, options?: PermuteRequestOptions): Promise<SearchResponse>;
+    search: (request: SearchRequest, options?: PermuteRequestOptions) => Promise<{
+        items: {
+            citation?: {
+                [key: string]: unknown;
+            };
+            content: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            score?: number;
+            sourceId?: string;
+            title?: string;
+            type: "record" | "document" | "table" | "text_block" | "unknown";
+        }[];
+        meta: {
+            candidateCount?: number;
+            reranked: boolean;
+            strategy: "semantic";
+            totalMs?: number;
+        };
+    }>;
     answer(request: AnswerRequest, options?: PermuteRequestOptions): Promise<AnswerResponse>;
-    answerJobs(request: AnswerRequest, options?: PermuteRequestOptions): Promise<AnswerJobResponse>;
-    getAnswerJob(answerJobId: string, options?: PermuteRequestOptions): Promise<AnswerJobResponse>;
+    answerJobs: (request: AnswerRequest, options?: PermuteRequestOptions) => Promise<{
+        answerJobId: string;
+        completedAt?: string | null;
+        createdAt?: string;
+        error?: string;
+        pollAfterMs?: number;
+        result?: {
+            answer: string;
+            assumptions?: {
+                [key: string]: unknown;
+            }[];
+            charts?: {
+                [key: string]: unknown;
+            }[];
+            citations: {
+                metadata?: {
+                    [key: string]: unknown;
+                };
+                ref?: string;
+                sourceId?: string;
+                title?: string;
+                type: "text" | "table" | "web" | "fact";
+                url?: string;
+            }[];
+            confidence?: {
+                queryComplexity: "high" | "medium" | "low";
+                reason: string;
+                score: number;
+            };
+            followUps?: string[];
+        };
+        startedAt?: string | null;
+        status: "queued" | "running" | "completed" | "failed" | "cancelled";
+        updatedAt?: string;
+    }>;
+    getAnswerJob: (answerJobId: string, options?: PermuteRequestOptions) => Promise<{
+        answerJobId: string;
+        completedAt?: string | null;
+        createdAt?: string;
+        error?: string;
+        pollAfterMs?: number;
+        result?: {
+            answer: string;
+            assumptions?: {
+                [key: string]: unknown;
+            }[];
+            charts?: {
+                [key: string]: unknown;
+            }[];
+            citations: {
+                metadata?: {
+                    [key: string]: unknown;
+                };
+                ref?: string;
+                sourceId?: string;
+                title?: string;
+                type: "text" | "table" | "web" | "fact";
+                url?: string;
+            }[];
+            confidence?: {
+                queryComplexity: "high" | "medium" | "low";
+                reason: string;
+                score: number;
+            };
+            followUps?: string[];
+        };
+        startedAt?: string | null;
+        status: "queued" | "running" | "completed" | "failed" | "cancelled";
+        updatedAt?: string;
+    }>;
     withWorkspace(workspaceId: string): PermuteClient;
-    query(request: QueryRequest, options?: PermuteRequestOptions): Promise<QueryResponse>;
+    query: (request: QueryRequest, options?: PermuteRequestOptions) => Promise<{
+        columns: {
+            name: string;
+            type?: string;
+        }[];
+        executionMs: number;
+        queryId: string;
+        rowCount: number;
+        rows: {
+            [key: string]: unknown;
+        }[];
+        sourceIds: string[];
+        sql: string;
+        timings?: {
+            initializationMs: number;
+            sourceLoadMs: number;
+            sourceValidationMs: number;
+            sqlExecutionMs: number;
+            totalMs: number;
+        };
+        truncated: boolean;
+    }>;
+    private bindMethod;
     private request;
     private validateRequestBody;
     private validateRequestQuery;

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) {
@@ -293,49 +294,56 @@ export class PermuteClient {
         this.defaultHeaders = options.headers ?? {};
         this.fetchImpl = fetchImpl.bind(globalThis);
         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),
+            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.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 = {
-            prepareUploads: (applicationId, body, options) => this.request('appsUploadsCreate', { pathParams: { applicationId }, 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,
@@ -371,71 +379,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'
@@ -503,9 +513,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;
@@ -522,10 +532,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) {
@@ -535,6 +545,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 },
@@ -549,27 +561,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);
@@ -592,12 +605,8 @@ 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' });
@@ -610,8 +619,9 @@ export class PermuteClient {
             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);

package/dist/deploy.d.ts

@@ -1,17 +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'];
-    /** Omit to preserve source bindings; [] removes them. */
-    sourceIds?: AppSiteSaveRequest['sourceIds'];
 }
+/** 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;