lemma-sdk 0.2.43 → 0.2.44

package/dist/namespaces/functions.js

@@ -21,6 +21,10 @@ export class FunctionsNamespace {
     delete(name) {
         return this.client.request(() => FunctionsService.functionDelete(this.podId(), name));
     }
+    permissions = {
+        get: (name) => this.client.request(() => FunctionsService.functionPermissionsGet(this.podId(), name)),
+        replace: (name, payload) => this.client.request(() => FunctionsService.functionPermissionsReplace(this.podId(), name, payload)),
+    };
     runs = {
         create: (name, options = {}) => this.client.request(() => {
             const payload = { input_data: options.input };

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.listAuthConfigsOrganizationsOrganizationIdIntegrationsAuthConfigsGet(organizationId, options.limit ?? 100, options.pageToken)),
+        create: (organizationId, payload) => this.client.request(() => IntegrationsService.createAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsPost(organizationId, payload)),
+        get: (organizationId, authConfigName) => this.client.request(() => IntegrationsService.getAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsAuthConfigNameGet(organizationId, authConfigName)),
+        delete: (organizationId, authConfigName) => this.client.request(() => IntegrationsService.deleteAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsAuthConfigNameDelete(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/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, resourceId: string, podId?: string): Promise<import("../types.js").ResourceAccessResponse>;
+    replaceGrant(resourceType: ResourceType | string, resourceId: string, granteeType: string, granteeId: string, payload: ResourceAccessGrantRequest, podId?: string): Promise<import("../types.js").ResourceAccessResponse>;
+    deleteGrant(resourceType: ResourceType | string, resourceId: 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, resourceId, podId) {
+        return this.client.request(() => PodResourceAccessService.podResourceAccessGet(podId ?? this.podId(), resourceType, resourceId));
+    }
+    replaceGrant(resourceType, resourceId, granteeType, granteeId, payload, podId) {
+        return this.client.request(() => PodResourceAccessService.podResourceAccessGrantReplace(podId ?? this.podId(), resourceType, resourceId, granteeType, granteeId, payload));
+    }
+    deleteGrant(resourceType, resourceId, granteeType, granteeId, podId) {
+        return this.client.request(() => PodResourceAccessService.podResourceAccessGrantDelete(podId ?? this.podId(), resourceType, resourceId, granteeType, granteeId));
+    }
+}

package/dist/namespaces/schedules.d.ts

@@ -15,8 +15,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/tables.d.ts

@@ -15,12 +15,12 @@ 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>;
+    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<import("../types.js").DatastoreMessageResponse>;
     readonly columns: {
-        add: (tableName: string, request: AddColumnRequest | AddColumnRequest["column"]) => Promise<import("../types.js").TableResponse>;
+        add: (tableName: string, request: AddColumnRequest | AddColumnRequest["column"]) => Promise<import("../types.js").TableDetailResponse>;
         remove: (tableName: string, columnName: string) => Promise<import("../types.js").DatastoreMessageResponse>;
     };
 }

package/dist/namespaces/workflows.d.ts

@@ -13,13 +13,13 @@ 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: {