lemma-sdk 0.2.43 → 0.2.45

package/dist/namespaces/integrations.d.ts

@@ -1,24 +1,46 @@
 import type { GeneratedClientAdapter } from "../generated.js";
+import type { HttpClient } from "../http.js";
+import type { ConnectRequestInitiateSchema } from "../openapi_client/models/ConnectRequestInitiateSchema.js";
+import type { ConnectRequestResponseSchema } from "../openapi_client/models/ConnectRequestResponseSchema.js";
+import type { AccountCreateSchema } from "../openapi_client/models/AccountCreateSchema.js";
+import type { AccountCredentialsResponseSchema } from "../openapi_client/models/AccountCredentialsResponseSchema.js";
+import type { AccountListResponseSchema } from "../openapi_client/models/AccountListResponseSchema.js";
+import type { AccountResponseSchema } from "../openapi_client/models/AccountResponseSchema.js";
+import type { AuthConfigCreateSchema } from "../openapi_client/models/AuthConfigCreateSchema.js";
+import type { AuthConfigListResponseSchema } from "../openapi_client/models/AuthConfigListResponseSchema.js";
+import type { AuthConfigResponseSchema } from "../openapi_client/models/AuthConfigResponseSchema.js";
+import type { MessageResponseSchema } from "../openapi_client/models/MessageResponseSchema.js";
+export type { AuthConfigCreateSchema, AuthConfigListResponseSchema, AuthConfigResponseSchema, };
+type ConnectRequestInput = string | ConnectRequestInitiateSchema;
+type OperationScope = {
+    organizationId: string;
+    authConfigName: string;
+};
+type EnableAppOptions = Omit<AuthConfigCreateSchema, "application_id" | "credential_config"> & {
+    credential_config?: Record<string, unknown> | null;
+    provider_config?: Record<string, unknown> | null;
+};
 export declare class IntegrationsNamespace {
     private readonly client;
-    constructor(client: GeneratedClientAdapter);
+    private readonly http;
+    constructor(client: GeneratedClientAdapter, http: HttpClient);
     list(options?: {
         limit?: number;
         pageToken?: string;
     }): Promise<import("../types.js").ApplicationListResponseSchema>;
     get(applicationId: string): Promise<import("../types.js").ApplicationDetailResponseSchema>;
     readonly operations: {
-        discover: (applicationId: string, options?: {
+        discover: (scope: OperationScope, options?: {
             query?: string;
             limit?: number;
         }) => Promise<import("../types.js").OperationDiscoverResponse>;
-        list: (applicationId: string, options?: {
+        list: (scope: OperationScope, options?: {
             query?: string;
             limit?: number;
         }) => Promise<import("../types.js").OperationSummary[]>;
-        get: (applicationId: string, operationName: string) => Promise<import("../types.js").OperationDetail>;
-        details: (applicationId: string, operationNames?: string[]) => Promise<import("../types.js").OperationDetailsBatchResponse>;
-        execute: (applicationId: string, operationName: string, payload: Record<string, unknown>, accountId?: string) => Promise<import("../types.js").OperationExecutionResponse>;
+        get: (scope: OperationScope, operationName: string) => Promise<import("../types.js").OperationDetail>;
+        details: (scope: OperationScope, operationNames?: string[]) => Promise<import("../types.js").OperationDetailsBatchResponse>;
+        execute: (scope: OperationScope, operationName: string, payload: Record<string, unknown>, accountId?: string) => Promise<import("../types.js").OperationExecutionResponse>;
     };
     helperAgent(goal: string, appNames: string[]): Promise<import("../types.js").IntegrationHelperAgentResponse>;
     readonly triggers: {
@@ -31,14 +53,34 @@ export declare class IntegrationsNamespace {
         get: (triggerId: string) => Promise<import("../types.js").AppTriggerResponseSchema>;
     };
     readonly accounts: {
-        list: (options?: {
+        list: (organizationId: string, options?: {
+            applicationId?: string;
+            limit?: number;
+            pageToken?: string;
+        }) => Promise<AccountListResponseSchema>;
+        create: (organizationId: string, payload: AccountCreateSchema) => Promise<AccountResponseSchema>;
+        get: (organizationId: string, accountId: string) => Promise<AccountResponseSchema>;
+        credentials: (organizationId: string, accountId: string) => Promise<AccountCredentialsResponseSchema>;
+        delete: (organizationId: string, accountId: string) => Promise<MessageResponseSchema>;
+        /**
+         * @deprecated Use list/get/create with an organization id. Kept only for
+         * callers that still need the response shape while migrating.
+         */
+        listOrgScoped: (organizationId: string, options?: {
             applicationId?: string;
             limit?: number;
             pageToken?: string;
-        }) => Promise<import("../types.js").AccountListResponseSchema>;
-        get: (accountId: string) => Promise<import("../types.js").AccountResponseSchema>;
-        credentials: (accountId: string) => Promise<import("../types.js").AccountCredentialsResponseSchema>;
-        delete: (accountId: string) => Promise<import("../types.js").MessageResponseSchema>;
+        }) => Promise<AccountListResponseSchema>;
+    };
+    readonly authConfigs: {
+        list: (organizationId: string, options?: {
+            limit?: number;
+            pageToken?: string;
+        }) => Promise<AuthConfigListResponseSchema>;
+        create: (organizationId: string, payload: AuthConfigCreateSchema) => Promise<AuthConfigResponseSchema>;
+        get: (organizationId: string, authConfigName: string) => Promise<AuthConfigResponseSchema>;
+        delete: (organizationId: string, authConfigName: string) => Promise<Record<string, boolean>>;
     };
-    createConnectRequest(applicationId: string): Promise<import("../types.js").ConnectRequestResponseSchema>;
+    enableApp(organizationId: string, applicationId: string, options?: EnableAppOptions): Promise<AuthConfigResponseSchema>;
+    createConnectRequest(organizationId: string, input: ConnectRequestInput): Promise<ConnectRequestResponseSchema>;
 }

package/dist/namespaces/integrations.js

@@ -1,10 +1,15 @@
 import { AgentToolsService } from "../openapi_client/services/AgentToolsService.js";
 import { ApplicationsService } from "../openapi_client/services/ApplicationsService.js";
 import { IntegrationsService } from "../openapi_client/services/IntegrationsService.js";
+function encodePath(value) {
+    return encodeURIComponent(value);
+}
 export class IntegrationsNamespace {
     client;
-    constructor(client) {
+    http;
+    constructor(client, http) {
         this.client = client;
+        this.http = http;
     }
     list(options = {}) {
         return this.client.request(() => ApplicationsService.applicationList(options.limit ?? 100, options.pageToken));
@@ -13,19 +18,19 @@ export class IntegrationsNamespace {
         return this.client.request(() => ApplicationsService.applicationGet(applicationId));
     }
     operations = {
-        discover: (applicationId, options = {}) => this.client.request(() => ApplicationsService.applicationOperationDiscover(applicationId, options.query, options.limit ?? 100)),
-        list: async (applicationId, options = {}) => {
-            const response = await this.client.request(() => ApplicationsService.applicationOperationDiscover(applicationId, options.query, options.limit ?? 100));
+        discover: (scope, options = {}) => this.client.request(() => ApplicationsService.applicationOperationDiscover(scope.organizationId, scope.authConfigName, options.query, options.limit ?? 100)),
+        list: async (scope, options = {}) => {
+            const response = await this.client.request(() => ApplicationsService.applicationOperationDiscover(scope.organizationId, scope.authConfigName, options.query, options.limit ?? 100));
             return response.items ?? [];
         },
-        get: (applicationId, operationName) => this.client.request(() => ApplicationsService.applicationOperationDetail(applicationId, operationName)),
-        details: (applicationId, operationNames) => {
+        get: (scope, operationName) => this.client.request(() => ApplicationsService.applicationOperationDetail(scope.organizationId, scope.authConfigName, operationName)),
+        details: (scope, operationNames) => {
             const body = { operation_names: operationNames };
-            return this.client.request(() => ApplicationsService.applicationOperationDetailsBatch(applicationId, body));
+            return this.client.request(() => ApplicationsService.applicationOperationDetailsBatch(scope.organizationId, scope.authConfigName, body));
         },
-        execute: (applicationId, operationName, payload, accountId) => {
+        execute: (scope, operationName, payload, accountId) => {
             const body = { payload, account_id: accountId };
-            return this.client.request(() => ApplicationsService.applicationOperationExecute(applicationId, operationName, body));
+            return this.client.request(() => ApplicationsService.applicationOperationExecute(scope.organizationId, scope.authConfigName, operationName, body));
         },
     };
     helperAgent(goal, appNames) {
@@ -40,13 +45,44 @@ export class IntegrationsNamespace {
         get: (triggerId) => this.client.request(() => ApplicationsService.applicationTriggerGet(triggerId)),
     };
     accounts = {
-        list: (options = {}) => this.client.request(() => IntegrationsService.integrationAccountList(options.applicationId, options.limit ?? 100, options.pageToken)),
-        get: (accountId) => this.client.request(() => IntegrationsService.integrationAccountGet(accountId)),
-        credentials: (accountId) => this.client.request(() => IntegrationsService.integrationAccountCredentialsGet(accountId)),
-        delete: (accountId) => this.client.request(() => IntegrationsService.integrationAccountDelete(accountId)),
+        list: (organizationId, options = {}) => this.client.request(() => IntegrationsService.integrationAccountList(organizationId, options.applicationId, options.limit ?? 100, options.pageToken)),
+        create: (organizationId, payload) => this.client.request(() => IntegrationsService.integrationAccountCreate(organizationId, payload)),
+        get: (organizationId, accountId) => this.client.request(() => IntegrationsService.integrationAccountGet(organizationId, accountId)),
+        credentials: (organizationId, accountId) => this.client.request(() => IntegrationsService.integrationAccountCredentialsGet(organizationId, accountId)),
+        delete: (organizationId, accountId) => this.client.request(() => IntegrationsService.integrationAccountDelete(organizationId, accountId)),
+        /**
+         * @deprecated Use list/get/create with an organization id. Kept only for
+         * callers that still need the response shape while migrating.
+         */
+        listOrgScoped: (organizationId, options = {}) => this.http.request("GET", `/organizations/${encodePath(organizationId)}/integrations/accounts`, {
+            params: {
+                application_id: options.applicationId,
+                limit: options.limit ?? 100,
+                page_token: options.pageToken,
+            },
+        }),
+    };
+    authConfigs = {
+        list: (organizationId, options = {}) => this.client.request(() => IntegrationsService.integrationAuthConfigList(organizationId, options.limit ?? 100, options.pageToken)),
+        create: (organizationId, payload) => this.client.request(() => IntegrationsService.integrationAuthConfigCreate(organizationId, payload)),
+        get: (organizationId, authConfigName) => this.client.request(() => IntegrationsService.integrationAuthConfigGet(organizationId, authConfigName)),
+        delete: (organizationId, authConfigName) => this.client.request(() => IntegrationsService.integrationAuthConfigDelete(organizationId, authConfigName)),
     };
-    createConnectRequest(applicationId) {
-        const payload = { application_id: applicationId };
-        return this.client.request(() => IntegrationsService.integrationConnectRequestCreate(payload));
+    async enableApp(organizationId, applicationId, options = {}) {
+        const configs = await this.authConfigs.list(organizationId, { limit: 100 });
+        const existing = configs.items.find((config) => config.application_id === applicationId && config.status === "ACTIVE");
+        if (existing)
+            return existing;
+        return this.authConfigs.create(organizationId, {
+            application_id: applicationId,
+            provider: options.provider,
+            config_source: options.config_source ?? "SYSTEM_DEFAULT",
+            credential_config: options.credential_config ?? options.provider_config,
+            name: options.name,
+        });
+    }
+    createConnectRequest(organizationId, input) {
+        const payload = typeof input === "string" ? { application_id: input } : input;
+        return this.client.request(() => IntegrationsService.integrationConnectRequestCreate(organizationId, payload));
     }
 }

package/dist/namespaces/pod-members.d.ts

@@ -14,5 +14,6 @@ export declare class PodMembersNamespace {
     lookupByEmail(podId: string, email: string): Promise<import("../types.js").PodMemberDetailResponse>;
     lookupByUserId(podId: string, userId: string): Promise<import("../types.js").PodMemberDetailResponse>;
     updateRole(podId: string, podMemberId: string, role: PodRole): Promise<import("../types.js").PodMemberResponse>;
+    updateRoles(podId: string, podMemberId: string, roles: string[]): Promise<import("../types.js").PodMemberResponse>;
     remove(podId: string, podMemberId: string): Promise<void>;
 }

package/dist/namespaces/pod-members.js

@@ -20,7 +20,10 @@ export class PodMembersNamespace {
         return this.client.request(() => PodMembersService.podMemberLookupByUserId(podId, userId));
     }
     updateRole(podId, podMemberId, role) {
-        return this.client.request(() => PodMembersService.podMemberUpdateRole(podId, podMemberId, { role }));
+        return this.client.request(() => PodMembersService.podMemberUpdateRoles(podId, podMemberId, { roles: [role] }));
+    }
+    updateRoles(podId, podMemberId, roles) {
+        return this.client.request(() => PodMembersService.podMemberUpdateRoles(podId, podMemberId, { roles }));
     }
     remove(podId, podMemberId) {
         return this.client.request(() => PodMembersService.podMemberRemove(podId, podMemberId));

package/dist/namespaces/pod-permissions.d.ts

@@ -0,0 +1,14 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { HttpClient } from "../http.js";
+export interface PodEffectivePermissionsResponse {
+    pod_id: string;
+    actions: string[];
+}
+export declare class PodPermissionsNamespace {
+    private readonly client;
+    private readonly http;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, http: HttpClient, podId: () => string);
+    catalog(podId?: string): Promise<import("../types.js").PodPermissionCatalogResponse>;
+    me(podId?: string): Promise<PodEffectivePermissionsResponse>;
+}

package/dist/namespaces/pod-permissions.js

@@ -0,0 +1,18 @@
+import { PodPermissionsService } from "../openapi_client/services/PodPermissionsService.js";
+export class PodPermissionsNamespace {
+    client;
+    http;
+    podId;
+    constructor(client, http, podId) {
+        this.client = client;
+        this.http = http;
+        this.podId = podId;
+    }
+    catalog(podId) {
+        return this.client.request(() => PodPermissionsService.podPermissionsCatalog(podId ?? this.podId()));
+    }
+    me(podId) {
+        const targetPodId = encodeURIComponent(podId ?? this.podId());
+        return this.http.request("GET", `/pods/${targetPodId}/permissions/me`);
+    }
+}

package/dist/namespaces/pod-roles.d.ts

@@ -0,0 +1,16 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { PodRoleCreateRequest } from "../openapi_client/models/PodRoleCreateRequest.js";
+import type { PodRolePermissionsReplaceRequest } from "../openapi_client/models/PodRolePermissionsReplaceRequest.js";
+export declare class PodRolesNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(podId?: string): Promise<import("../types.js").PodRoleListResponse>;
+    create(payload: PodRoleCreateRequest, podId?: string): Promise<import("../types.js").PodRoleResponse>;
+    update(roleName: string, payload: PodRoleCreateRequest, podId?: string): Promise<import("../types.js").PodRoleResponse>;
+    delete(roleName: string, podId?: string): Promise<void>;
+    readonly permissions: {
+        get: (roleName: string, podId?: string) => Promise<import("../types.js").PodRolePermissionsResponse>;
+        replace: (roleName: string, payload: PodRolePermissionsReplaceRequest, podId?: string) => Promise<import("../types.js").PodRolePermissionsResponse>;
+    };
+}

package/dist/namespaces/pod-roles.js

@@ -0,0 +1,25 @@
+import { PodRolesService } from "../openapi_client/services/PodRolesService.js";
+export class PodRolesNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(podId) {
+        return this.client.request(() => PodRolesService.podRolesList(podId ?? this.podId()));
+    }
+    create(payload, podId) {
+        return this.client.request(() => PodRolesService.podRolesCreate(podId ?? this.podId(), payload));
+    }
+    update(roleName, payload, podId) {
+        return this.client.request(() => PodRolesService.podRolesUpdate(podId ?? this.podId(), roleName, payload));
+    }
+    delete(roleName, podId) {
+        return this.client.request(() => PodRolesService.podRolesDelete(podId ?? this.podId(), roleName));
+    }
+    permissions = {
+        get: (roleName, podId) => this.client.request(() => PodRolesService.podRolePermissionsGet(podId ?? this.podId(), roleName)),
+        replace: (roleName, payload, podId) => this.client.request(() => PodRolesService.podRolePermissionsReplace(podId ?? this.podId(), roleName, payload)),
+    };
+}

package/dist/namespaces/pod-surfaces.d.ts

@@ -1,6 +1,8 @@
 import type { GeneratedClientAdapter } from "../generated.js";
 import type { CreateSurfaceRequest } from "../openapi_client/models/CreateSurfaceRequest.js";
+import type { UpdateSurfaceChannelsRequest } from "../openapi_client/models/UpdateSurfaceChannelsRequest.js";
 import type { UpdateSurfaceRequest } from "../openapi_client/models/UpdateSurfaceRequest.js";
+import type { UpsertSurfaceRequest } from "../openapi_client/models/UpsertSurfaceRequest.js";
 export declare class PodSurfacesNamespace {
     private readonly client;
     constructor(client: GeneratedClientAdapter);
@@ -10,7 +12,10 @@ export declare class PodSurfacesNamespace {
         cursor?: string;
     }): Promise<import("../types.js").AgentSurfaceListResponse>;
     create(podId: string, payload: CreateSurfaceRequest): Promise<any>;
-    get(podId: string, surfaceId: string): Promise<any>;
-    updateConfig(podId: string, surfaceId: string, payload: UpdateSurfaceRequest): Promise<any>;
-    toggle(podId: string, surfaceId: string, isActive: boolean): Promise<any>;
+    upsert(podId: string, platform: string, payload: UpsertSurfaceRequest): Promise<any>;
+    get(podId: string, surfaceRef: string): Promise<any>;
+    updateConfig(podId: string, surfaceRef: string, payload: UpdateSurfaceRequest): Promise<any>;
+    updateChannels(podId: string, surfaceRef: string, payload: UpdateSurfaceChannelsRequest): Promise<any>;
+    setupStatus(podId: string, surfaceRef: string): Promise<import("../types.js").SurfaceSetupStatusResponse>;
+    toggle(podId: string, surfaceRef: string, isEnabled: boolean): Promise<any>;
 }

package/dist/namespaces/pod-surfaces.js

@@ -10,13 +10,22 @@ export class PodSurfacesNamespace {
     create(podId, payload) {
         return this.client.request(() => AgentSurfacesService.agentSurfaceCreate(podId, payload));
     }
-    get(podId, surfaceId) {
-        return this.client.request(() => AgentSurfacesService.agentSurfaceGet(podId, surfaceId));
+    upsert(podId, platform, payload) {
+        return this.client.request(() => AgentSurfacesService.agentSurfaceUpsertByPlatform(podId, platform, payload));
     }
-    updateConfig(podId, surfaceId, payload) {
-        return this.client.request(() => AgentSurfacesService.agentSurfaceUpdate(podId, surfaceId, payload));
+    get(podId, surfaceRef) {
+        return this.client.request(() => AgentSurfacesService.agentSurfaceGet(podId, surfaceRef));
     }
-    toggle(podId, surfaceId, isActive) {
-        return this.client.request(() => AgentSurfacesService.agentSurfaceToggle(podId, surfaceId, { is_active: isActive }));
+    updateConfig(podId, surfaceRef, payload) {
+        return this.client.request(() => AgentSurfacesService.agentSurfaceUpdate(podId, surfaceRef, payload));
+    }
+    updateChannels(podId, surfaceRef, payload) {
+        return this.client.request(() => AgentSurfacesService.agentSurfaceUpdateChannels(podId, surfaceRef, payload));
+    }
+    setupStatus(podId, surfaceRef) {
+        return this.client.request(() => AgentSurfacesService.agentSurfaceSetupStatus(podId, surfaceRef));
+    }
+    toggle(podId, surfaceRef, isEnabled) {
+        return this.client.request(() => AgentSurfacesService.agentSurfaceToggle(podId, surfaceRef, { is_enabled: isEnabled }));
     }
 }

package/dist/namespaces/pods.d.ts

@@ -1,7 +1,6 @@
 import type { GeneratedClientAdapter } from "../generated.js";
 import type { HttpClient } from "../http.js";
 import type { PodCreateRequest } from "../openapi_client/models/PodCreateRequest.js";
-import type { PodListResponse } from "../openapi_client/models/PodListResponse.js";
 import type { PodUpdateRequest } from "../openapi_client/models/PodUpdateRequest.js";
 export declare class PodsNamespace {
     private readonly client;
@@ -12,12 +11,12 @@ export declare class PodsNamespace {
         limit?: number;
         pageToken?: string;
         cursor?: string;
-    }): Promise<PodListResponse>;
+    }): Promise<import("../types.js").PodListResponse>;
     listByOrganization(organizationId: string, options?: {
         limit?: number;
         pageToken?: string;
         cursor?: string;
-    }): Promise<PodListResponse>;
+    }): Promise<import("../types.js").PodListResponse>;
     get(podId: string): Promise<import("../types.js").PodResponse>;
     create(payload: PodCreateRequest): Promise<import("../types.js").PodResponse>;
     update(podId: string, payload: PodUpdateRequest): Promise<import("../types.js").PodResponse>;

package/dist/namespaces/pods.js

@@ -13,12 +13,7 @@ export class PodsNamespace {
                 pageToken: options.pageToken ?? options.cursor,
             });
         }
-        return this.http.request("GET", "/pods", {
-            params: {
-                limit: options.limit ?? 100,
-                page_token: options.pageToken ?? options.cursor,
-            },
-        });
+        throw new Error("organizationId is required for pods.list(). Use listByOrganization(organizationId).");
     }
     listByOrganization(organizationId, options = {}) {
         return this.client.request(() => PodsService.podList(organizationId, options.limit ?? 100, options.pageToken ?? options.cursor));

package/dist/namespaces/records.d.ts

@@ -18,14 +18,14 @@ export declare class RecordsNamespace {
     constructor(client: GeneratedClientAdapter, http: HttpClient, podId: () => string);
     list(table: string, options?: ListRecordsOptions): Promise<RecordListResponse>;
     listWithParams(table: string, params: Record<string, string | number | boolean | undefined | null>): Promise<RecordListResponse>;
-    create(table: string, data: Record<string, unknown>): Promise<import("../types.js").RecordResponse>;
-    get(table: string, recordId: string): Promise<import("../types.js").RecordResponse>;
-    update(table: string, recordId: string, data: Record<string, unknown>): Promise<import("../types.js").RecordResponse>;
-    delete(table: string, recordId: string): Promise<import("../types.js").DatastoreMessageResponse>;
+    create(table: string, data: Record<string, unknown>): Promise<Record<string, any>>;
+    get(table: string, recordId: string): Promise<Record<string, any>>;
+    update(table: string, recordId: string, data: Record<string, unknown>): Promise<Record<string, any>>;
+    delete(table: string, recordId: string): Promise<void>;
     query(table: string, payload: RecordQueryRequest): Promise<RecordListResponse>;
     readonly bulk: {
-        create: (table: string, records: Record<string, unknown>[]) => Promise<import("../types.js").DatastoreMessageResponse>;
-        update: (table: string, records: Record<string, unknown>[]) => Promise<import("../types.js").DatastoreMessageResponse>;
-        delete: (table: string, recordIds: Array<string | number>) => Promise<import("../types.js").DatastoreMessageResponse>;
+        create: (table: string, records: Record<string, unknown>[]) => Promise<import("../types.js").DatastoreCountResponse>;
+        update: (table: string, records: Record<string, unknown>[]) => Promise<import("../types.js").DatastoreCountResponse>;
+        delete: (table: string, recordIds: Array<string | number>) => Promise<import("../types.js").DatastoreCountResponse>;
     };
 }

package/dist/namespaces/resource-access.d.ts

@@ -0,0 +1,11 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { ResourceAccessGrantRequest } from "../openapi_client/models/ResourceAccessGrantRequest.js";
+import type { ResourceType } from "../openapi_client/models/ResourceType.js";
+export declare class ResourceAccessNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    get(resourceType: ResourceType | string, resourceName: string, podId?: string): Promise<import("../types.js").ResourceAccessResponse>;
+    replaceGrant(resourceType: ResourceType | string, resourceName: string, granteeType: string, granteeId: string, payload: ResourceAccessGrantRequest, podId?: string): Promise<import("../types.js").ResourceAccessResponse>;
+    deleteGrant(resourceType: ResourceType | string, resourceName: string, granteeType: string, granteeId: string, podId?: string): Promise<import("../types.js").ResourceAccessResponse>;
+}

package/dist/namespaces/resource-access.js

@@ -0,0 +1,18 @@
+import { PodResourceAccessService } from "../openapi_client/services/PodResourceAccessService.js";
+export class ResourceAccessNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    get(resourceType, resourceName, podId) {
+        return this.client.request(() => PodResourceAccessService.podResourceAccessGet(podId ?? this.podId(), resourceType, resourceName));
+    }
+    replaceGrant(resourceType, resourceName, granteeType, granteeId, payload, podId) {
+        return this.client.request(() => PodResourceAccessService.podResourceAccessGrantReplace(podId ?? this.podId(), resourceType, resourceName, granteeType, granteeId, payload));
+    }
+    deleteGrant(resourceType, resourceName, granteeType, granteeId, podId) {
+        return this.client.request(() => PodResourceAccessService.podResourceAccessGrantDelete(podId ?? this.podId(), resourceType, resourceName, granteeType, granteeId));
+    }
+}

package/dist/namespaces/schedules.d.ts

@@ -7,6 +7,7 @@ export interface ScheduleListOptions {
     isActive?: boolean | null;
     agentName?: string | null;
     workflowName?: string | null;
+    name?: string | null;
     limit?: number;
     pageToken?: string | null;
 }
@@ -15,8 +16,8 @@ export declare class SchedulesNamespace {
     private readonly podId;
     constructor(client: GeneratedClientAdapter, podId: () => string);
     list(options?: ScheduleListOptions): Promise<import("../types.js").ScheduleListResponse>;
-    create(payload: CreateScheduleRequest): Promise<import("../types.js").ScheduleResponse>;
-    get(scheduleId: string): Promise<import("../types.js").ScheduleResponse>;
-    update(scheduleId: string, payload: UpdateScheduleRequest): Promise<import("../types.js").ScheduleResponse>;
+    create(payload: CreateScheduleRequest): Promise<import("../types.js").ScheduleDetailResponse>;
+    get(scheduleId: string): Promise<import("../types.js").ScheduleDetailResponse>;
+    update(scheduleId: string, payload: UpdateScheduleRequest): Promise<import("../types.js").ScheduleDetailResponse>;
     delete(scheduleId: string): Promise<void>;
 }

package/dist/namespaces/schedules.js

@@ -7,7 +7,7 @@ export class SchedulesNamespace {
         this.podId = podId;
     }
     list(options = {}) {
-        return this.client.request(() => SchedulesService.scheduleList(this.podId(), options.scheduleType, options.isActive, options.agentName, options.workflowName, options.limit ?? 100, options.pageToken));
+        return this.client.request(() => SchedulesService.scheduleList(this.podId(), options.scheduleType, options.isActive, options.agentName, options.workflowName, options.name, options.limit ?? 100, options.pageToken));
     }
     create(payload) {
         return this.client.request(() => SchedulesService.scheduleCreate(this.podId(), payload));

package/dist/namespaces/tables.d.ts

@@ -15,13 +15,13 @@ export declare class TablesNamespace {
         limit?: number;
         pageToken?: string;
     }): Promise<import("../types.js").TableListResponse>;
-    create(payload: CreateTableInput): Promise<import("../types.js").TableResponse>;
-    get(tableName: string): Promise<import("../types.js").TableResponse>;
-    update(tableName: string, payload: UpdateTableRequest): Promise<import("../types.js").TableResponse>;
-    delete(tableName: string): Promise<import("../types.js").DatastoreMessageResponse>;
+    create(payload: CreateTableInput): Promise<import("../types.js").TableDetailResponse>;
+    get(tableName: string): Promise<import("../types.js").TableDetailResponse>;
+    update(tableName: string, payload: UpdateTableRequest): Promise<import("../types.js").TableDetailResponse>;
+    delete(tableName: string): Promise<void>;
     readonly columns: {
-        add: (tableName: string, request: AddColumnRequest | AddColumnRequest["column"]) => Promise<import("../types.js").TableResponse>;
-        remove: (tableName: string, columnName: string) => Promise<import("../types.js").DatastoreMessageResponse>;
+        add: (tableName: string, request: AddColumnRequest | AddColumnRequest["column"]) => Promise<import("../types.js").TableDetailResponse>;
+        remove: (tableName: string, columnName: string) => Promise<void>;
     };
 }
 export {};

package/dist/namespaces/workflows.d.ts

@@ -1,9 +1,9 @@
 import type { GeneratedClientAdapter } from "../generated.js";
-import { type HttpClient } from "../http.js";
+import type { HttpClient } from "../http.js";
 import type { WorkflowCreateRequest } from "../openapi_client/models/WorkflowCreateRequest.js";
 import type { WorkflowGraphUpdateRequest } from "../openapi_client/models/WorkflowGraphUpdateRequest.js";
+import type { WorkflowRunFormSubmitRequest } from "../openapi_client/models/WorkflowRunFormSubmitRequest.js";
 import type { WorkflowUpdateRequest } from "../openapi_client/models/WorkflowUpdateRequest.js";
-import type { WorkflowRunInputs } from "../types.js";
 export declare class WorkflowsNamespace {
     private readonly client;
     private readonly http;
@@ -13,17 +13,21 @@ export declare class WorkflowsNamespace {
         limit?: number;
         pageToken?: string;
     }): Promise<import("../types.js").WorkflowListResponse>;
-    create(payload: WorkflowCreateRequest): Promise<import("../types.js").FlowResponse>;
-    get(workflowName: string): Promise<import("../types.js").FlowResponse>;
-    update(workflowName: string, payload: WorkflowUpdateRequest): Promise<import("../types.js").FlowResponse>;
+    create(payload: WorkflowCreateRequest): Promise<import("../types.js").FlowDetailResponse>;
+    get(workflowName: string): Promise<import("../types.js").FlowDetailResponse>;
+    update(workflowName: string, payload: WorkflowUpdateRequest): Promise<import("../types.js").FlowDetailResponse>;
     delete(workflowName: string): Promise<void>;
     visualize(workflowName: string): Promise<string>;
     readonly graph: {
-        update: (workflowName: string, graph: WorkflowGraphUpdateRequest) => Promise<import("../types.js").FlowResponse>;
+        update: (workflowName: string, graph: WorkflowGraphUpdateRequest) => Promise<import("../types.js").FlowDetailResponse>;
     };
-    private postRunAction;
     readonly runs: {
-        start: (workflowName: string, inputs?: WorkflowRunInputs) => Promise<import("../types.js").FlowRunEntity>;
+        /**
+         * Create a run. Runs take no inputs: when the workflow starts with a
+         * form, the returned run is WAITING with `active_wait` describing the
+         * form to render and submit via `runs.submitForm`.
+         */
+        create: (workflowName: string) => Promise<import("../types.js").WorkflowRunResponse>;
         list: (workflowName: string, options?: {
             limit?: number;
             pageToken?: string;
@@ -32,10 +36,10 @@ export declare class WorkflowsNamespace {
             limit?: number;
             pageToken?: string;
         }) => Promise<import("../types.js").WorkflowRunWaitAssignmentListResponse>;
-        get: (runId: string, podId?: string) => Promise<import("../types.js").FlowRunEntity>;
-        resume: (runId: string, inputs?: WorkflowRunInputs, podId?: string) => Promise<import("../types.js").FlowRunEntity>;
+        get: (runId: string, podId?: string) => Promise<import("../types.js").WorkflowRunResponse>;
+        /** Submit the form a run is waiting on. node_id must match active_wait.node_id. */
+        submitForm: (runId: string, payload: WorkflowRunFormSubmitRequest, podId?: string) => Promise<import("../types.js").WorkflowRunResponse>;
         visualize: (runId: string, podId?: string) => Promise<string>;
-        cancel: (runId: string, podId?: string) => Promise<Record<string, unknown>>;
-        retry: (runId: string, podId?: string) => Promise<Record<string, unknown>>;
+        cancel: (runId: string, podId?: string) => Promise<import("../types.js").WorkflowRunResponse>;
     };
 }

package/dist/namespaces/workflows.js

@@ -1,4 +1,3 @@
-import { ApiError } from "../http.js";
 import { WorkflowsService } from "../openapi_client/services/WorkflowsService.js";
 export class WorkflowsNamespace {
     client;
@@ -30,27 +29,19 @@ export class WorkflowsNamespace {
     graph = {
         update: (workflowName, graph) => this.client.request(() => WorkflowsService.workflowGraphUpdate(this.podId(), workflowName, graph)),
     };
-    async postRunAction(runId, action, podId) {
-        const encodedPodId = encodeURIComponent(podId);
-        const encodedRunId = encodeURIComponent(runId);
-        try {
-            return await this.http.request("POST", `/pods/${encodedPodId}/workflow-runs/${encodedRunId}/${action}`, { body: {} });
-        }
-        catch (error) {
-            if (error instanceof ApiError && (error.statusCode === 404 || error.statusCode === 405)) {
-                return this.http.request("POST", `/pods/${encodedPodId}/flow-runs/${encodedRunId}/${action}`, { body: {} });
-            }
-            throw error;
-        }
-    }
     runs = {
-        start: (workflowName, inputs = {}) => this.client.request(() => WorkflowsService.workflowStart(this.podId(), workflowName, inputs)),
+        /**
+         * Create a run. Runs take no inputs: when the workflow starts with a
+         * form, the returned run is WAITING with `active_wait` describing the
+         * form to render and submit via `runs.submitForm`.
+         */
+        create: (workflowName) => this.client.request(() => WorkflowsService.workflowRunCreate(this.podId(), workflowName)),
         list: (workflowName, options = {}) => this.client.request(() => WorkflowsService.workflowRunList(this.podId(), workflowName, options.limit ?? 100, options.pageToken)),
         waitingAssignedToMe: (options = {}) => this.client.request(() => WorkflowsService.workflowRunWaitingAssignedToMe(this.podId(), options.limit ?? 100, options.pageToken)),
         get: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunGet(podId, runId)),
-        resume: (runId, inputs = {}, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunResume(podId, runId, inputs)),
+        /** Submit the form a run is waiting on. node_id must match active_wait.node_id. */
+        submitForm: (runId, payload, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunFormSubmit(podId, runId, payload)),
         visualize: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunVisualize(podId, runId)),
-        cancel: (runId, podId = this.podId()) => this.postRunAction(runId, "cancel", podId),
-        retry: (runId, podId = this.podId()) => this.postRunAction(runId, "retry", podId),
+        cancel: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunCancel(podId, runId)),
     };
 }