lemma-sdk 0.2.43 → 0.2.44

package/dist/openapi_client/services/IntegrationsService.d.ts

@@ -1,60 +1,111 @@
+import type { AccountCreateSchema } from '../models/AccountCreateSchema.js';
 import type { AccountCredentialsResponseSchema } from '../models/AccountCredentialsResponseSchema.js';
 import type { AccountListResponseSchema } from '../models/AccountListResponseSchema.js';
 import type { AccountResponseSchema } from '../models/AccountResponseSchema.js';
+import type { AuthConfigCreateSchema } from '../models/AuthConfigCreateSchema.js';
+import type { AuthConfigListResponseSchema } from '../models/AuthConfigListResponseSchema.js';
+import type { AuthConfigResponseSchema } from '../models/AuthConfigResponseSchema.js';
 import type { ConnectRequestInitiateSchema } from '../models/ConnectRequestInitiateSchema.js';
 import type { ConnectRequestResponseSchema } from '../models/ConnectRequestResponseSchema.js';
 import type { MessageResponseSchema } from '../models/MessageResponseSchema.js';
 import type { CancelablePromise } from '../core/CancelablePromise.js';
 export declare class IntegrationsService {
+    /**
+     * OAuth Callback
+     * Handle OAuth callback and complete account connection. This endpoint is public and uses state parameter for security.
+     * @param error
+     * @param format
+     * @returns string Successful Response
+     * @throws ApiError
+     */
+    static integrationOauthCallback(error?: (string | null), format?: (string | null)): CancelablePromise<string>;
     /**
      * List Accounts
      * Get all connected accounts for the current user. Optionally filter by application_id or application_name
+     * @param organizationId
      * @param applicationId
      * @param limit
      * @param pageToken
      * @returns AccountListResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationAccountList(applicationId?: (string | null), limit?: number, pageToken?: (string | null)): CancelablePromise<AccountListResponseSchema>;
+    static integrationAccountList(organizationId: string, applicationId?: (string | null), limit?: number, pageToken?: (string | null)): CancelablePromise<AccountListResponseSchema>;
+    /**
+     * Create Account
+     * Directly connect a credential-managed native account for an org auth config.
+     * @param organizationId
+     * @param requestBody
+     * @returns AccountResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static integrationAccountCreate(organizationId: string, requestBody: AccountCreateSchema): CancelablePromise<AccountResponseSchema>;
     /**
      * Delete Account
      * Delete a connected account and revoke the connection
+     * @param organizationId
      * @param accountId
      * @returns MessageResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationAccountDelete(accountId: string): CancelablePromise<MessageResponseSchema>;
+    static integrationAccountDelete(organizationId: string, accountId: string): CancelablePromise<MessageResponseSchema>;
     /**
      * Get Account
      * Get a specific account by ID
+     * @param organizationId
      * @param accountId
      * @returns AccountResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationAccountGet(accountId: string): CancelablePromise<AccountResponseSchema>;
+    static integrationAccountGet(organizationId: string, accountId: string): CancelablePromise<AccountResponseSchema>;
     /**
      * Get Credentials
      * Get the credentials for a specific account
+     * @param organizationId
      * @param accountId
      * @returns AccountCredentialsResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationAccountCredentialsGet(accountId: string): CancelablePromise<AccountCredentialsResponseSchema>;
+    static integrationAccountCredentialsGet(organizationId: string, accountId: string): CancelablePromise<AccountCredentialsResponseSchema>;
     /**
-     * Initiate Connect Request
-     * Initiate an OAuth connection request for an application
+     * List Auth Configs
+     * @param organizationId
+     * @param limit
+     * @param pageToken
+     * @returns AuthConfigListResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static listAuthConfigsOrganizationsOrganizationIdIntegrationsAuthConfigsGet(organizationId: string, limit?: number, pageToken?: (string | null)): CancelablePromise<AuthConfigListResponseSchema>;
+    /**
+     * Create Auth Config
+     * @param organizationId
      * @param requestBody
-     * @returns ConnectRequestResponseSchema Successful Response
+     * @returns AuthConfigResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationConnectRequestCreate(requestBody: ConnectRequestInitiateSchema): CancelablePromise<ConnectRequestResponseSchema>;
+    static createAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsPost(organizationId: string, requestBody: AuthConfigCreateSchema): CancelablePromise<AuthConfigResponseSchema>;
     /**
-     * OAuth Callback
-     * Handle OAuth callback and complete account connection. This endpoint is public and uses state parameter for security.
-     * @param error
-     * @param format
-     * @returns string Successful Response
+     * Delete Auth Config
+     * @param organizationId
+     * @param authConfigName
+     * @returns boolean Successful Response
      * @throws ApiError
      */
-    static integrationOauthCallback(error?: (string | null), format?: (string | null)): CancelablePromise<string>;
+    static deleteAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsAuthConfigNameDelete(organizationId: string, authConfigName: string): CancelablePromise<Record<string, boolean>>;
+    /**
+     * Get Auth Config
+     * @param organizationId
+     * @param authConfigName
+     * @returns AuthConfigResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static getAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsAuthConfigNameGet(organizationId: string, authConfigName: string): CancelablePromise<AuthConfigResponseSchema>;
+    /**
+     * Initiate Connect Request
+     * Initiate an OAuth connection request for an application
+     * @param organizationId
+     * @param requestBody
+     * @returns ConnectRequestResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static integrationConnectRequestCreate(organizationId: string, requestBody: ConnectRequestInitiateSchema): CancelablePromise<ConnectRequestResponseSchema>;
 }

package/dist/openapi_client/services/IntegrationsService.js

@@ -1,19 +1,44 @@
 import { OpenAPI } from '../core/OpenAPI.js';
 import { request as __request } from '../core/request.js';
 export class IntegrationsService {
+    /**
+     * OAuth Callback
+     * Handle OAuth callback and complete account connection. This endpoint is public and uses state parameter for security.
+     * @param error
+     * @param format
+     * @returns string Successful Response
+     * @throws ApiError
+     */
+    static integrationOauthCallback(error, format) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/integrations/connect-requests/oauth/callback',
+            query: {
+                'error': error,
+                'format': format,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * List Accounts
      * Get all connected accounts for the current user. Optionally filter by application_id or application_name
+     * @param organizationId
      * @param applicationId
      * @param limit
      * @param pageToken
      * @returns AccountListResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationAccountList(applicationId, limit = 100, pageToken) {
+    static integrationAccountList(organizationId, applicationId, limit = 100, pageToken) {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/integrations/accounts',
+            url: '/organizations/{organization_id}/integrations/accounts',
+            path: {
+                'organization_id': organizationId,
+            },
             query: {
                 'application_id': applicationId,
                 'limit': limit,
@@ -24,18 +49,42 @@ export class IntegrationsService {
             },
         });
     }
+    /**
+     * Create Account
+     * Directly connect a credential-managed native account for an org auth config.
+     * @param organizationId
+     * @param requestBody
+     * @returns AccountResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static integrationAccountCreate(organizationId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/organizations/{organization_id}/integrations/accounts',
+            path: {
+                'organization_id': organizationId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * Delete Account
      * Delete a connected account and revoke the connection
+     * @param organizationId
      * @param accountId
      * @returns MessageResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationAccountDelete(accountId) {
+    static integrationAccountDelete(organizationId, accountId) {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/integrations/accounts/{account_id}',
+            url: '/organizations/{organization_id}/integrations/accounts/{account_id}',
             path: {
+                'organization_id': organizationId,
                 'account_id': accountId,
             },
             errors: {
@@ -46,15 +95,17 @@ export class IntegrationsService {
     /**
      * Get Account
      * Get a specific account by ID
+     * @param organizationId
      * @param accountId
      * @returns AccountResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationAccountGet(accountId) {
+    static integrationAccountGet(organizationId, accountId) {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/integrations/accounts/{account_id}',
+            url: '/organizations/{organization_id}/integrations/accounts/{account_id}',
             path: {
+                'organization_id': organizationId,
                 'account_id': accountId,
             },
             errors: {
@@ -65,15 +116,17 @@ export class IntegrationsService {
     /**
      * Get Credentials
      * Get the credentials for a specific account
+     * @param organizationId
      * @param accountId
      * @returns AccountCredentialsResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationAccountCredentialsGet(accountId) {
+    static integrationAccountCredentialsGet(organizationId, accountId) {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/integrations/accounts/{account_id}/credentials',
+            url: '/organizations/{organization_id}/integrations/accounts/{account_id}/credentials',
             path: {
+                'organization_id': organizationId,
                 'account_id': accountId,
             },
             errors: {
@@ -82,16 +135,43 @@ export class IntegrationsService {
         });
     }
     /**
-     * Initiate Connect Request
-     * Initiate an OAuth connection request for an application
+     * List Auth Configs
+     * @param organizationId
+     * @param limit
+     * @param pageToken
+     * @returns AuthConfigListResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static listAuthConfigsOrganizationsOrganizationIdIntegrationsAuthConfigsGet(organizationId, limit = 100, pageToken) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/organizations/{organization_id}/integrations/auth-configs',
+            path: {
+                'organization_id': organizationId,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Create Auth Config
+     * @param organizationId
      * @param requestBody
-     * @returns ConnectRequestResponseSchema Successful Response
+     * @returns AuthConfigResponseSchema Successful Response
      * @throws ApiError
      */
-    static integrationConnectRequestCreate(requestBody) {
+    static createAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsPost(organizationId, requestBody) {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/integrations/connect-requests',
+            url: '/organizations/{organization_id}/integrations/auth-configs',
+            path: {
+                'organization_id': organizationId,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -100,24 +180,65 @@ export class IntegrationsService {
         });
     }
     /**
-     * OAuth Callback
-     * Handle OAuth callback and complete account connection. This endpoint is public and uses state parameter for security.
-     * @param error
-     * @param format
-     * @returns string Successful Response
+     * Delete Auth Config
+     * @param organizationId
+     * @param authConfigName
+     * @returns boolean Successful Response
      * @throws ApiError
      */
-    static integrationOauthCallback(error, format) {
+    static deleteAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsAuthConfigNameDelete(organizationId, authConfigName) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/organizations/{organization_id}/integrations/auth-configs/{auth_config_name}',
+            path: {
+                'organization_id': organizationId,
+                'auth_config_name': authConfigName,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Get Auth Config
+     * @param organizationId
+     * @param authConfigName
+     * @returns AuthConfigResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static getAuthConfigOrganizationsOrganizationIdIntegrationsAuthConfigsAuthConfigNameGet(organizationId, authConfigName) {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/integrations/connect-requests/oauth/callback',
-            query: {
-                'error': error,
-                'format': format,
+            url: '/organizations/{organization_id}/integrations/auth-configs/{auth_config_name}',
+            path: {
+                'organization_id': organizationId,
+                'auth_config_name': authConfigName,
             },
             errors: {
                 422: `Validation Error`,
             },
         });
     }
+    /**
+     * Initiate Connect Request
+     * Initiate an OAuth connection request for an application
+     * @param organizationId
+     * @param requestBody
+     * @returns ConnectRequestResponseSchema Successful Response
+     * @throws ApiError
+     */
+    static integrationConnectRequestCreate(organizationId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/organizations/{organization_id}/integrations/connect-requests',
+            path: {
+                'organization_id': organizationId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
 }

package/dist/openapi_client/services/OrganizationsService.d.ts

@@ -108,6 +108,14 @@ export declare class OrganizationsService {
      * @throws ApiError
      */
     static orgInvitationInvite(orgId: string, requestBody: OrganizationInvitationRequest): CancelablePromise<OrganizationInvitationResponse>;
+    /**
+     * Join Auto-Join Organization
+     * Join an organization when the current user's email domain is allowed to auto-join
+     * @param orgId
+     * @returns OrganizationResponse Successful Response
+     * @throws ApiError
+     */
+    static orgJoinAutoJoin(orgId: string): CancelablePromise<OrganizationResponse>;
     /**
      * List Organization Members
      * Get all members of an organization

package/dist/openapi_client/services/OrganizationsService.js

@@ -229,6 +229,25 @@ export class OrganizationsService {
             },
         });
     }
+    /**
+     * Join Auto-Join Organization
+     * Join an organization when the current user's email domain is allowed to auto-join
+     * @param orgId
+     * @returns OrganizationResponse Successful Response
+     * @throws ApiError
+     */
+    static orgJoinAutoJoin(orgId) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/organizations/{org_id}/join',
+            path: {
+                'org_id': orgId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * List Organization Members
      * Get all members of an organization

package/dist/openapi_client/services/PodMembersService.d.ts

@@ -60,16 +60,6 @@ export declare class PodMembersService {
      * @throws ApiError
      */
     static podMemberGet(podId: string, podMemberId: string): CancelablePromise<PodMemberDetailResponse>;
-    /**
-     * Update Member Role
-     * Update a pod member's role
-     * @param podId
-     * @param podMemberId
-     * @param requestBody
-     * @returns PodMemberResponse Successful Response
-     * @throws ApiError
-     */
-    static podMemberUpdateRole(podId: string, podMemberId: string, requestBody: PodMemberUpdateRoleRequest): CancelablePromise<PodMemberResponse>;
     /**
      * Update Member Roles
      * Update a pod member's roles

package/dist/openapi_client/services/PodMembersService.js

@@ -134,30 +134,6 @@ export class PodMembersService {
             },
         });
     }
-    /**
-     * Update Member Role
-     * Update a pod member's role
-     * @param podId
-     * @param podMemberId
-     * @param requestBody
-     * @returns PodMemberResponse Successful Response
-     * @throws ApiError
-     */
-    static podMemberUpdateRole(podId, podMemberId, requestBody) {
-        return __request(OpenAPI, {
-            method: 'PATCH',
-            url: '/pods/{pod_id}/members/{pod_member_id}/role',
-            path: {
-                'pod_id': podId,
-                'pod_member_id': podMemberId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
     /**
      * Update Member Roles
      * Update a pod member's roles

package/dist/openapi_client/services/PodPermissionsService.d.ts

@@ -0,0 +1,19 @@
+import type { PodEffectivePermissionsResponse } from '../models/PodEffectivePermissionsResponse.js';
+import type { PodPermissionCatalogResponse } from '../models/PodPermissionCatalogResponse.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class PodPermissionsService {
+    /**
+     * Get Pod Permission Catalog
+     * @param podId
+     * @returns PodPermissionCatalogResponse Successful Response
+     * @throws ApiError
+     */
+    static podPermissionsCatalog(podId: string): CancelablePromise<PodPermissionCatalogResponse>;
+    /**
+     * Get My Pod Permissions
+     * @param podId
+     * @returns PodEffectivePermissionsResponse Successful Response
+     * @throws ApiError
+     */
+    static podPermissionsMe(podId: string): CancelablePromise<PodEffectivePermissionsResponse>;
+}

package/dist/openapi_client/services/PodPermissionsService.js

@@ -0,0 +1,40 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class PodPermissionsService {
+    /**
+     * Get Pod Permission Catalog
+     * @param podId
+     * @returns PodPermissionCatalogResponse Successful Response
+     * @throws ApiError
+     */
+    static podPermissionsCatalog(podId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/permissions/catalog',
+            path: {
+                'pod_id': podId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Get My Pod Permissions
+     * @param podId
+     * @returns PodEffectivePermissionsResponse Successful Response
+     * @throws ApiError
+     */
+    static podPermissionsMe(podId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/permissions/me',
+            path: {
+                'pod_id': podId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+}

package/dist/openapi_client/services/PodResourceAccessService.d.ts

@@ -0,0 +1,38 @@
+import type { ResourceAccessGrantRequest } from '../models/ResourceAccessGrantRequest.js';
+import type { ResourceAccessResponse } from '../models/ResourceAccessResponse.js';
+import type { ResourceType } from '../models/ResourceType.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class PodResourceAccessService {
+    /**
+     * Get Resource Access
+     * @param podId
+     * @param resourceType
+     * @param resourceId
+     * @returns ResourceAccessResponse Successful Response
+     * @throws ApiError
+     */
+    static podResourceAccessGet(podId: string, resourceType: ResourceType, resourceId: string): CancelablePromise<ResourceAccessResponse>;
+    /**
+     * Delete Resource Access Grant
+     * @param podId
+     * @param resourceType
+     * @param resourceId
+     * @param granteeType
+     * @param granteeId
+     * @returns ResourceAccessResponse Successful Response
+     * @throws ApiError
+     */
+    static podResourceAccessGrantDelete(podId: string, resourceType: ResourceType, resourceId: string, granteeType: string, granteeId: string): CancelablePromise<ResourceAccessResponse>;
+    /**
+     * Replace Resource Access Grant
+     * @param podId
+     * @param resourceType
+     * @param resourceId
+     * @param granteeType
+     * @param granteeId
+     * @param requestBody
+     * @returns ResourceAccessResponse Successful Response
+     * @throws ApiError
+     */
+    static podResourceAccessGrantReplace(podId: string, resourceType: ResourceType, resourceId: string, granteeType: string, granteeId: string, requestBody: ResourceAccessGrantRequest): CancelablePromise<ResourceAccessResponse>;
+}

package/dist/openapi_client/services/PodResourceAccessService.js

@@ -0,0 +1,81 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class PodResourceAccessService {
+    /**
+     * Get Resource Access
+     * @param podId
+     * @param resourceType
+     * @param resourceId
+     * @returns ResourceAccessResponse Successful Response
+     * @throws ApiError
+     */
+    static podResourceAccessGet(podId, resourceType, resourceId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/resources/{resource_type}/{resource_id}/access',
+            path: {
+                'pod_id': podId,
+                'resource_type': resourceType,
+                'resource_id': resourceId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Delete Resource Access Grant
+     * @param podId
+     * @param resourceType
+     * @param resourceId
+     * @param granteeType
+     * @param granteeId
+     * @returns ResourceAccessResponse Successful Response
+     * @throws ApiError
+     */
+    static podResourceAccessGrantDelete(podId, resourceType, resourceId, granteeType, granteeId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/pods/{pod_id}/resources/{resource_type}/{resource_id}/access/grantees/{grantee_type}/{grantee_id}',
+            path: {
+                'pod_id': podId,
+                'resource_type': resourceType,
+                'resource_id': resourceId,
+                'grantee_type': granteeType,
+                'grantee_id': granteeId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Replace Resource Access Grant
+     * @param podId
+     * @param resourceType
+     * @param resourceId
+     * @param granteeType
+     * @param granteeId
+     * @param requestBody
+     * @returns ResourceAccessResponse Successful Response
+     * @throws ApiError
+     */
+    static podResourceAccessGrantReplace(podId, resourceType, resourceId, granteeType, granteeId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/pods/{pod_id}/resources/{resource_type}/{resource_id}/access/grantees/{grantee_type}/{grantee_id}',
+            path: {
+                'pod_id': podId,
+                'resource_type': resourceType,
+                'resource_id': resourceId,
+                'grantee_type': granteeType,
+                'grantee_id': granteeId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+}