casedev 0.69.0 → 0.70.0

package/src/resources/connectors/v1/connections.ts

@@ -7,7 +7,7 @@ import { RequestOptions } from '../../../internal/request-options';
 import { path } from '../../../internal/utils/path';
 
 /**
- * Import and export between provider folders (Google Drive) and vaults
+ * Import and export between provider folders and vaults
  */
 export class Connections extends APIResource {
   /**
@@ -15,28 +15,69 @@ export class Connections extends APIResource {
    * hosted OAuth flow. The user completes provider consent at connect_url and is
    * redirected to return_url with ?connection_id=.
    */
-  create(body: ConnectionCreateParams, options?: RequestOptions): APIPromise<ConnectionCreateResponse> {
-    return this._client.post('/connectors/v1/connections', { body, ...options });
+  create(params: ConnectionCreateParams, options?: RequestOptions): APIPromise<ConnectionCreateResponse> {
+    const { 'x-case-connector-subject': xCaseConnectorSubject, ...body } = params;
+    return this._client.post('/connectors/v1/connections', {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xCaseConnectorSubject != null ?
+            { 'x-case-connector-subject': xCaseConnectorSubject }
+          : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
    * Retrieve one provider connection, including account identity and health.
    */
-  retrieve(id: string, options?: RequestOptions): APIPromise<void> {
+  retrieve(
+    id: string,
+    params: ConnectionRetrieveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    const { 'x-case-connector-subject': xCaseConnectorSubject } = params ?? {};
     return this._client.get(path`/connectors/v1/connections/${id}`, {
       ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+      headers: buildHeaders([
+        {
+          Accept: '*/*',
+          ...(xCaseConnectorSubject != null ?
+            { 'x-case-connector-subject': xCaseConnectorSubject }
+          : undefined),
+        },
+        options?.headers,
+      ]),
     });
   }
 
   /**
-   * List provider connections for the organization, with health status.
+   * List provider connections for the organization, with health status. Returns at
+   * most `limit` connections (default 200, maximum 200). When `pagination.has_more`
+   * is true, replay `pagination.next_cursor` as `?cursor=` to fetch the following
+   * page. Cursors are opaque and are only valid for the exact filter set and
+   * installation/subject scope they were issued under.
    */
   list(
-    query: ConnectionListParams | null | undefined = {},
+    params: ConnectionListParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<ConnectionListResponse> {
-    return this._client.get('/connectors/v1/connections', { query, ...options });
+    const { 'x-case-connector-subject': xCaseConnectorSubject, ...query } = params ?? {};
+    return this._client.get('/connectors/v1/connections', {
+      query,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xCaseConnectorSubject != null ?
+            { 'x-case-connector-subject': xCaseConnectorSubject }
+          : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
@@ -48,11 +89,19 @@ export class Connections extends APIResource {
     params: ConnectionDeleteParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<void> {
-    const { purge } = params ?? {};
+    const { purge, 'x-case-connector-subject': xCaseConnectorSubject } = params ?? {};
     return this._client.delete(path`/connectors/v1/connections/${id}`, {
       query: { purge },
       ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+      headers: buildHeaders([
+        {
+          Accept: '*/*',
+          ...(xCaseConnectorSubject != null ?
+            { 'x-case-connector-subject': xCaseConnectorSubject }
+          : undefined),
+        },
+        options?.headers,
+      ]),
     });
   }
 
@@ -61,13 +110,41 @@ export class Connections extends APIResource {
    * returns top-level resources. Pass the stable browse_ref fields returned by one
    * response to navigate into the next level. Returns 403
    * provider_scope_insufficient when the connection scope cannot browse server-side.
+   * Clio browsing shares request capacity with background runs; throttled responses
+   * include Retry-After when a retry deadline is known.
    */
   browse(
     id: string,
-    query: ConnectionBrowseParams | null | undefined = {},
+    params: ConnectionBrowseParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<ConnectionBrowseResponse> {
-    return this._client.get(path`/connectors/v1/connections/${id}/browse`, { query, ...options });
+    const { 'x-case-connector-subject': xCaseConnectorSubject, ...query } = params ?? {};
+    return this._client.get(path`/connectors/v1/connections/${id}/browse`, {
+      query,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xCaseConnectorSubject != null ?
+            { 'x-case-connector-subject': xCaseConnectorSubject }
+          : undefined),
+        },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * Enable or disable new runs and scheduled syncs for one provider across the
+   * authenticated organization or installation. This organization-wide operation
+   * requires explicit confirmation. Existing credentials, links, and imported files
+   * are preserved; active runs are not interrupted.
+   */
+  updateAll(body: ConnectionUpdateAllParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.patch('/connectors/v1/connections', {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
   }
 }
 
@@ -84,13 +161,41 @@ export interface ConnectionListResponse {
 
   connections?: Array<unknown>;
 
+  /**
+   * @deprecated Mirror of `pagination.next_cursor`. Prefer `pagination`.
+   */
   cursor?: string | null;
+
+  pagination?: ConnectionListResponse.Pagination;
+
+  /**
+   * Available import providers and their adapter-declared capabilities.
+   */
+  providers?: Array<ConnectionListResponse.Provider>;
 }
 
 export namespace ConnectionListResponse {
   export interface Capabilities {
     google_drive_folder_mirroring?: boolean;
   }
+
+  export interface Pagination {
+    has_more?: boolean;
+
+    limit?: number;
+
+    next_cursor?: string | null;
+  }
+
+  export interface Provider {
+    id?: string;
+
+    resource_types?: Array<string>;
+
+    scope_tier?: string;
+
+    supports_export?: boolean;
+  }
 }
 
 export interface ConnectionBrowseResponse {
@@ -107,6 +212,13 @@ export namespace ConnectionBrowseResponse {
 
     container_id?: string | null;
 
+    description?: string | null;
+
+    /**
+     * Importable container root, when different from its browse reference.
+     */
+    import_ref?: unknown | null;
+
     kind?: 'my_drive' | 'shared_drive' | 'matter' | 'site' | 'document_library' | 'folder' | 'file';
 
     mime_type?: string | null;
@@ -124,53 +236,146 @@ export namespace ConnectionBrowseResponse {
 }
 
 export interface ConnectionCreateParams {
-  provider: 'clio' | 'gdrive' | 'microsoft';
+  /**
+   * Body param
+   */
+  provider: 'box' | 'clio' | 'dropbox' | 'gdrive' | 'microsoft' | 'smokeball';
 
   /**
-   * HTTPS URL the user is sent back to after consent.
+   * Body param: HTTPS URL the user is sent back to after consent.
    */
   return_url: string;
 
   /**
-   * Provider-specific OAuth permission tier. Omit to use the provider's default.
+   * Body param: Provider-specific OAuth permission tier. Omit to use the provider's
+   * default. Microsoft defaults to organizational OneDrive/SharePoint; use
+   * microsoft.personal.read for a personal Microsoft account's own OneDrive.
+   * Microsoft write tiers are a separately gated private pilot; exports and paired
+   * sync are not yet available.
    */
-  scope_tier?: 'clio.us' | 'drive' | 'microsoft.read';
+  scope_tier?:
+    | 'box.readwrite'
+    | 'box.readwrite.webhooks'
+    | 'clio.us'
+    | 'dropbox.readwrite'
+    | 'drive'
+    | 'microsoft.read'
+    | 'microsoft.personal.read'
+    | 'microsoft.write'
+    | 'microsoft.personal.write'
+    | 'smokeball.us'
+    | 'smokeball.us.staging';
+
+  /**
+   * Header param: Trusted server-to-server application-user assertion. Derive it
+   * from the authenticated application session, never browser input. Omit only for
+   * the legacy organization-scoped namespace.
+   */
+  'x-case-connector-subject'?: string;
+}
+
+export interface ConnectionRetrieveParams {
+  /**
+   * Trusted server-to-server application-user assertion. Derive it from the
+   * authenticated application session, never browser input. Omit only for the legacy
+   * organization-scoped namespace.
+   */
+  'x-case-connector-subject'?: string;
 }
 
 export interface ConnectionListParams {
+  /**
+   * Query param: Opaque continuation cursor from `pagination.next_cursor` of the
+   * previous page. Must be replayed with the same filters and scope that produced
+   * it.
+   */
+  cursor?: string;
+
+  /**
+   * Query param: Connections per page (1-200). Defaults to 200.
+   */
+  limit?: number;
+
+  /**
+   * Query param
+   */
   provider?: string;
 
+  /**
+   * Query param
+   */
   status?: 'pending' | 'healthy' | 'reauth_required' | 'revoked' | 'throttled';
+
+  /**
+   * Header param: Trusted server-to-server application-user assertion. Derive it
+   * from the authenticated application session, never browser input. Omit only for
+   * the legacy organization-scoped namespace.
+   */
+  'x-case-connector-subject'?: string;
 }
 
 export interface ConnectionDeleteParams {
+  /**
+   * Query param
+   */
   purge?: boolean;
+
+  /**
+   * Header param: Trusted server-to-server application-user assertion. Derive it
+   * from the authenticated application session, never browser input. Omit only for
+   * the legacy organization-scoped namespace.
+   */
+  'x-case-connector-subject'?: string;
 }
 
 export interface ConnectionBrowseParams {
   /**
-   * Container id to list, or the container containing parent
+   * Query param: Container id to list, or the container containing parent
    */
   container?: string;
 
+  /**
+   * Query param
+   */
   cursor?: string;
 
+  /**
+   * Query param
+   */
   page_size?: number;
 
   /**
-   * Folder id to list
+   * Query param: Folder id to list
    */
   parent?: string;
 
   /**
-   * Optional provider-supported search text
+   * Query param: Optional provider-supported search text
    */
   query?: string;
 
   /**
-   * Site id to list
+   * Query param: Site id to list
    */
   site?: string;
+
+  /**
+   * Header param: Trusted server-to-server application-user assertion. Derive it
+   * from the authenticated application session, never browser input. Omit only for
+   * the legacy organization-scoped namespace.
+   */
+  'x-case-connector-subject'?: string;
+}
+
+export interface ConnectionUpdateAllParams {
+  /**
+   * Confirms that this change applies to every user connection in scope.
+   */
+  confirm_organization_wide: true;
+
+  enabled: boolean;
+
+  provider: string;
 }
 
 export declare namespace Connections {
@@ -179,8 +384,10 @@ export declare namespace Connections {
     type ConnectionListResponse as ConnectionListResponse,
     type ConnectionBrowseResponse as ConnectionBrowseResponse,
     type ConnectionCreateParams as ConnectionCreateParams,
+    type ConnectionRetrieveParams as ConnectionRetrieveParams,
     type ConnectionListParams as ConnectionListParams,
     type ConnectionDeleteParams as ConnectionDeleteParams,
     type ConnectionBrowseParams as ConnectionBrowseParams,
+    type ConnectionUpdateAllParams as ConnectionUpdateAllParams,
   };
 }

package/src/resources/connectors/v1/index.ts

@@ -1,22 +1,27 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+export { Applications } from './applications/index';
 export {
   Connections,
   type ConnectionCreateResponse,
   type ConnectionListResponse,
   type ConnectionBrowseResponse,
   type ConnectionCreateParams,
+  type ConnectionRetrieveParams,
   type ConnectionListParams,
   type ConnectionDeleteParams,
   type ConnectionBrowseParams,
+  type ConnectionUpdateAllParams,
 } from './connections';
 export {
   Installations,
+  type InstallationListResponse,
   type InstallationListParams,
   type InstallationEnsureParams,
 } from './installations/index';
 export {
   Links,
+  type LinkRetrieveParams,
   type LinkUpdateParams,
   type LinkListParams,
   type LinkDeleteParams,
@@ -24,6 +29,10 @@ export {
 } from './links';
 export {
   V1,
+  type SyncLinkLinkRun,
+  type SyncLinkRun,
+  type TransferLinkRun,
+  type TransferRun,
   type V1SyncLinkResponse,
   type V1TransferResponse,
   type V1SyncLinkParams,

package/src/resources/connectors/v1/installations/index.ts

@@ -1,4 +1,10 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { Installations, type InstallationListParams, type InstallationEnsureParams } from './installations';
+export {
+  Installations,
+  type InstallationListResponse,
+  type InstallationListParams,
+  type InstallationEnsureParams,
+} from './installations';
+export { Tokens, type TokenCreateResponse, type TokenCreateParams, type TokenRevokeParams } from './tokens';
 export { Vaults, type VaultGrantParams, type VaultRevokeParams } from './vaults';

package/src/resources/connectors/v1/installations/installations.ts

@@ -1,6 +1,8 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../../../core/resource';
+import * as TokensAPI from './tokens';
+import { TokenCreateParams, TokenCreateResponse, TokenRevokeParams, Tokens } from './tokens';
 import * as VaultsAPI from './vaults';
 import { VaultGrantParams, VaultRevokeParams, Vaults } from './vaults';
 import { APIPromise } from '../../../../core/api-promise';
@@ -8,20 +10,24 @@ import { buildHeaders } from '../../../../internal/headers';
 import { RequestOptions } from '../../../../internal/request-options';
 
 /**
- * Import and export between provider folders (Google Drive) and vaults
+ * Import and export between provider folders and vaults
  */
 export class Installations extends APIResource {
+  tokens: TokensAPI.Tokens = new TokensAPI.Tokens(this._client);
   vaults: VaultsAPI.Vaults = new VaultsAPI.Vaults(this._client);
 
   /**
-   * List application installations (tenants) in this organization.
+   * List application installations (tenants) in this organization. Returns at most
+   * `limit` installations (default 200, maximum 200). When `pagination.has_more` is
+   * true, replay `pagination.next_cursor` as `?cursor=` to fetch the following page.
+   * Cursors are opaque and are only valid for the exact filter set and caller scope
+   * they were issued under.
    */
-  list(query: InstallationListParams | null | undefined = {}, options?: RequestOptions): APIPromise<void> {
-    return this._client.get('/connectors/v1/installations', {
-      query,
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  list(
+    query: InstallationListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<InstallationListResponse> {
+    return this._client.get('/connectors/v1/installations', { query, ...options });
   }
 
   /**
@@ -38,10 +44,37 @@ export class Installations extends APIResource {
   }
 }
 
+export interface InstallationListResponse {
+  installations?: Array<unknown>;
+
+  pagination?: InstallationListResponse.Pagination;
+}
+
+export namespace InstallationListResponse {
+  export interface Pagination {
+    has_more?: boolean;
+
+    limit?: number;
+
+    next_cursor?: string | null;
+  }
+}
+
 export interface InstallationListParams {
   application?: string;
 
+  /**
+   * Opaque continuation cursor from `pagination.next_cursor` of the previous page.
+   * Must be replayed with the same filters and scope that produced it.
+   */
+  cursor?: string;
+
   external_tenant_id?: string;
+
+  /**
+   * Installations per page (1-200). Defaults to 200.
+   */
+  limit?: number;
 }
 
 export interface InstallationEnsureParams {
@@ -56,14 +89,23 @@ export interface InstallationEnsureParams {
   external_tenant_id: string;
 }
 
+Installations.Tokens = Tokens;
 Installations.Vaults = Vaults;
 
 export declare namespace Installations {
   export {
+    type InstallationListResponse as InstallationListResponse,
     type InstallationListParams as InstallationListParams,
     type InstallationEnsureParams as InstallationEnsureParams,
   };
 
+  export {
+    Tokens as Tokens,
+    type TokenCreateResponse as TokenCreateResponse,
+    type TokenCreateParams as TokenCreateParams,
+    type TokenRevokeParams as TokenRevokeParams,
+  };
+
   export {
     Vaults as Vaults,
     type VaultGrantParams as VaultGrantParams,

package/src/resources/connectors/v1/installations/tokens.ts

@@ -0,0 +1,61 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../../core/resource';
+import { APIPromise } from '../../../../core/api-promise';
+import { buildHeaders } from '../../../../internal/headers';
+import { RequestOptions } from '../../../../internal/request-options';
+import { path } from '../../../../internal/utils/path';
+
+/**
+ * Import and export between provider folders and vaults
+ */
+export class Tokens extends APIResource {
+  /**
+   * Bound application management API key only. Returns a 256-bit opaque bearer
+   * secret once; valid for 15 minutes, connector data-plane only. No refresh token.
+   * At most 4 overlapping credentials and 20 mints/minute per installation. The
+   * application server must derive tenant identity; this is not browser
+   * authentication.
+   */
+  create(id: string, body: TokenCreateParams, options?: RequestOptions): APIPromise<TokenCreateResponse> {
+    return this._client.post(path`/connectors/v1/installations/${id}/tokens`, { body, ...options });
+  }
+
+  /**
+   * Issuing API key only; installation credentials cannot revoke or mint
+   * credentials. Immediate revocation on the next request.
+   */
+  revoke(tokenID: string, params: TokenRevokeParams, options?: RequestOptions): APIPromise<void> {
+    const { id } = params;
+    return this._client.delete(path`/connectors/v1/installations/${id}/tokens/${tokenID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface TokenCreateResponse {
+  id: string;
+
+  token: string;
+
+  expires_at: string;
+
+  installation_id: string;
+}
+
+export interface TokenCreateParams {
+  scopes: Array<'read' | 'write'>;
+}
+
+export interface TokenRevokeParams {
+  id: string;
+}
+
+export declare namespace Tokens {
+  export {
+    type TokenCreateResponse as TokenCreateResponse,
+    type TokenCreateParams as TokenCreateParams,
+    type TokenRevokeParams as TokenRevokeParams,
+  };
+}

package/src/resources/connectors/v1/installations/vaults.ts

@@ -7,7 +7,7 @@ import { RequestOptions } from '../../../../internal/request-options';
 import { path } from '../../../../internal/utils/path';
 
 /**
- * Import and export between provider folders (Google Drive) and vaults
+ * Import and export between provider folders and vaults
  */
 export class Vaults extends APIResource {
   /**