casedev 0.68.0 → 0.69.0

package/src/internal/parse.ts

@@ -1,7 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import type { FinalRequestOptions } from './request-options';
-import { Stream } from '../core/streaming';
 import { type Casedev } from '../client';
 import { formatRequestDetails, loggerFor } from './utils/log';
 
@@ -17,19 +16,6 @@ export type APIResponseProps = {
 export async function defaultParseResponse<T>(client: Casedev, props: APIResponseProps): Promise<T> {
   const { response, requestLogID, retryOfRequestLogID, startTime } = props;
   const body = await (async () => {
-    if (props.options.stream) {
-      loggerFor(client).debug('response', response.status, response.url, response.headers, response.body);
-
-      // Note: there is an invariant here that isn't represented in the type system
-      // that if you set `stream: true` the response type must also be `Stream<T>`
-
-      if (props.options.__streamClass) {
-        return props.options.__streamClass.fromSSEResponse(response, props.controller, client) as any;
-      }
-
-      return Stream.fromSSEResponse(response, props.controller, client) as any;
-    }
-
     // fetch refuses to read the body when the status code is 204.
     if (response.status === 204) {
       return null as T;

package/src/internal/request-options.ts

@@ -3,7 +3,6 @@
 import { NullableHeaders } from './headers';
 
 import type { BodyInit } from './builtin-types';
-import { Stream } from '../core/streaming';
 import type { HTTPMethod, MergedRequestInit } from './types';
 import { type HeadersLike } from './headers';
 
@@ -77,7 +76,6 @@ export type RequestOptions = {
   defaultBaseURL?: string | undefined;
 
   __binaryResponse?: boolean | undefined;
-  __streamClass?: typeof Stream;
 };
 
 export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };

package/src/resources/connectors/connectors.ts

@@ -0,0 +1,21 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as V1API from './v1/v1';
+import { V1, V1SyncLinkParams, V1SyncLinkResponse, V1TransferParams, V1TransferResponse } from './v1/v1';
+
+export class Connectors extends APIResource {
+  v1: V1API.V1 = new V1API.V1(this._client);
+}
+
+Connectors.V1 = V1;
+
+export declare namespace Connectors {
+  export {
+    V1 as V1,
+    type V1SyncLinkResponse as V1SyncLinkResponse,
+    type V1TransferResponse as V1TransferResponse,
+    type V1SyncLinkParams as V1SyncLinkParams,
+    type V1TransferParams as V1TransferParams,
+  };
+}

package/src/resources/connectors/index.ts

@@ -0,0 +1,10 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Connectors } from './connectors';
+export {
+  V1,
+  type V1SyncLinkResponse,
+  type V1TransferResponse,
+  type V1SyncLinkParams,
+  type V1TransferParams,
+} from './v1/index';

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

@@ -0,0 +1,186 @@
+// 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 (Google Drive) and vaults
+ */
+export class Connections extends APIResource {
+  /**
+   * Create a pending provider connection and return a one-time connect_url for the
+   * 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 });
+  }
+
+  /**
+   * Retrieve one provider connection, including account identity and health.
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/connectors/v1/connections/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * List provider connections for the organization, with health status.
+   */
+  list(
+    query: ConnectionListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ConnectionListResponse> {
+    return this._client.get('/connectors/v1/connections', { query, ...options });
+  }
+
+  /**
+   * Unlink a provider account: revoke tokens at the provider and delete them.
+   * purge=true additionally deletes the vault documents its import links brought in.
+   */
+  delete(
+    id: string,
+    params: ConnectionDeleteParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    const { purge } = params ?? {};
+    return this._client.delete(path`/connectors/v1/connections/${id}`, {
+      query: { purge },
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Browse the provider one level at a time. Without a site, container, or parent,
+   * 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.
+   */
+  browse(
+    id: string,
+    query: ConnectionBrowseParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ConnectionBrowseResponse> {
+    return this._client.get(path`/connectors/v1/connections/${id}/browse`, { query, ...options });
+  }
+}
+
+export interface ConnectionCreateResponse {
+  connect_url?: string;
+
+  connection_id?: string;
+
+  expires_at?: string;
+}
+
+export interface ConnectionListResponse {
+  capabilities?: ConnectionListResponse.Capabilities;
+
+  connections?: Array<unknown>;
+
+  cursor?: string | null;
+}
+
+export namespace ConnectionListResponse {
+  export interface Capabilities {
+    google_drive_folder_mirroring?: boolean;
+  }
+}
+
+export interface ConnectionBrowseResponse {
+  cursor?: string | null;
+
+  items?: Array<ConnectionBrowseResponse.Item>;
+}
+
+export namespace ConnectionBrowseResponse {
+  export interface Item {
+    id?: string;
+
+    browse_ref?: unknown | null;
+
+    container_id?: string | null;
+
+    kind?: 'my_drive' | 'shared_drive' | 'matter' | 'site' | 'document_library' | 'folder' | 'file';
+
+    mime_type?: string | null;
+
+    modified_at?: string | null;
+
+    name?: string;
+
+    parent_ids?: Array<string>;
+
+    path?: string | null;
+
+    size_bytes?: number | null;
+  }
+}
+
+export interface ConnectionCreateParams {
+  provider: 'clio' | 'gdrive' | 'microsoft';
+
+  /**
+   * 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.
+   */
+  scope_tier?: 'clio.us' | 'drive' | 'microsoft.read';
+}
+
+export interface ConnectionListParams {
+  provider?: string;
+
+  status?: 'pending' | 'healthy' | 'reauth_required' | 'revoked' | 'throttled';
+}
+
+export interface ConnectionDeleteParams {
+  purge?: boolean;
+}
+
+export interface ConnectionBrowseParams {
+  /**
+   * Container id to list, or the container containing parent
+   */
+  container?: string;
+
+  cursor?: string;
+
+  page_size?: number;
+
+  /**
+   * Folder id to list
+   */
+  parent?: string;
+
+  /**
+   * Optional provider-supported search text
+   */
+  query?: string;
+
+  /**
+   * Site id to list
+   */
+  site?: string;
+}
+
+export declare namespace Connections {
+  export {
+    type ConnectionCreateResponse as ConnectionCreateResponse,
+    type ConnectionListResponse as ConnectionListResponse,
+    type ConnectionBrowseResponse as ConnectionBrowseResponse,
+    type ConnectionCreateParams as ConnectionCreateParams,
+    type ConnectionListParams as ConnectionListParams,
+    type ConnectionDeleteParams as ConnectionDeleteParams,
+    type ConnectionBrowseParams as ConnectionBrowseParams,
+  };
+}

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

@@ -0,0 +1,31 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Connections,
+  type ConnectionCreateResponse,
+  type ConnectionListResponse,
+  type ConnectionBrowseResponse,
+  type ConnectionCreateParams,
+  type ConnectionListParams,
+  type ConnectionDeleteParams,
+  type ConnectionBrowseParams,
+} from './connections';
+export {
+  Installations,
+  type InstallationListParams,
+  type InstallationEnsureParams,
+} from './installations/index';
+export {
+  Links,
+  type LinkUpdateParams,
+  type LinkListParams,
+  type LinkDeleteParams,
+  type LinkListObjectsParams,
+} from './links';
+export {
+  V1,
+  type V1SyncLinkResponse,
+  type V1TransferResponse,
+  type V1SyncLinkParams,
+  type V1TransferParams,
+} from './v1';

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

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

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

@@ -0,0 +1,72 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../../core/resource';
+import * as VaultsAPI from './vaults';
+import { VaultGrantParams, VaultRevokeParams, Vaults } from './vaults';
+import { APIPromise } from '../../../../core/api-promise';
+import { buildHeaders } from '../../../../internal/headers';
+import { RequestOptions } from '../../../../internal/request-options';
+
+/**
+ * Import and export between provider folders (Google Drive) and vaults
+ */
+export class Installations extends APIResource {
+  vaults: VaultsAPI.Vaults = new VaultsAPI.Vaults(this._client);
+
+  /**
+   * List application installations (tenants) in this organization.
+   */
+  list(query: InstallationListParams | null | undefined = {}, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/connectors/v1/installations', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Idempotently create (or return) the installation for (application,
+   * external_tenant_id) in this organization. Send the returned installation id as
+   * X-Case-Installation-Id on connector requests to scope them to this tenant.
+   */
+  ensure(body: InstallationEnsureParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post('/connectors/v1/installations', {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface InstallationListParams {
+  application?: string;
+
+  external_tenant_id?: string;
+}
+
+export interface InstallationEnsureParams {
+  /**
+   * Consuming application key (e.g. "p3").
+   */
+  application: string;
+
+  /**
+   * The application's own tenant identifier (e.g. a P3 organization id).
+   */
+  external_tenant_id: string;
+}
+
+Installations.Vaults = Vaults;
+
+export declare namespace Installations {
+  export {
+    type InstallationListParams as InstallationListParams,
+    type InstallationEnsureParams as InstallationEnsureParams,
+  };
+
+  export {
+    Vaults as Vaults,
+    type VaultGrantParams as VaultGrantParams,
+    type VaultRevokeParams as VaultRevokeParams,
+  };
+}

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

@@ -0,0 +1,88 @@
+// 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 (Google Drive) and vaults
+ */
+export class Vaults extends APIResource {
+  /**
+   * List the vaults an installation may use, with capabilities and revocation state.
+   */
+  list(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/connectors/v1/installations/${id}/vaults`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Grant (or update) an installation's access to a vault. Re-granting a revoked
+   * vault reactivates it. Import links need can_write; export links need can_read;
+   * mirror deletion and purge need can_manage.
+   */
+  grant(vaultID: string, params: VaultGrantParams, options?: RequestOptions): APIPromise<void> {
+    const { id, ...body } = params;
+    return this._client.put(path`/connectors/v1/installations/${id}/vaults/${vaultID}`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Revoke an installation's access to a vault. Links using the vault pause at their
+   * next run; nothing is deleted.
+   */
+  revoke(vaultID: string, params: VaultRevokeParams, options?: RequestOptions): APIPromise<void> {
+    const { id } = params;
+    return this._client.delete(path`/connectors/v1/installations/${id}/vaults/${vaultID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface VaultGrantParams {
+  /**
+   * Path param
+   */
+  id: string;
+
+  /**
+   * Body param
+   */
+  can_manage?: boolean;
+
+  /**
+   * Body param
+   */
+  can_read?: boolean;
+
+  /**
+   * Body param
+   */
+  can_write?: boolean;
+
+  /**
+   * Body param
+   */
+  relationship?: 'owned' | 'shared';
+
+  /**
+   * Body param
+   */
+  source?: 'provisioning' | 'lazy_reconcile' | 'explicit_share';
+}
+
+export interface VaultRevokeParams {
+  id: string;
+}
+
+export declare namespace Vaults {
+  export { type VaultGrantParams as VaultGrantParams, type VaultRevokeParams as VaultRevokeParams };
+}

package/src/resources/{database.ts → connectors/v1/installations.ts}

@@ -1,3 +1,3 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export * from './database/index';
+export * from './installations/index';

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

@@ -0,0 +1,121 @@
+// 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 (Google Drive) and vaults
+ */
+export class Links extends APIResource {
+  /**
+   * Retrieve one link: state, counts, and embedded active_run/last_run. Poll this
+   * after POST /transfer.
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/connectors/v1/links/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Pause/resume a link (state "paused" | "ready"), change its mode (synced -> once
+   * is the sync downgrade), or edit its policy in place.
+   */
+  update(id: string, body: LinkUpdateParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.patch(path`/connectors/v1/links/${id}`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * List transfer links, filterable by vault, connection, direction, mode, and
+   * state.
+   */
+  list(query: LinkListParams | null | undefined = {}, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/connectors/v1/links', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Delete a link and its ledger. vault_docs=delete additionally removes the vault
+   * documents an import link brought in (default: keep).
+   */
+  delete(
+    id: string,
+    params: LinkDeleteParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    const { vault_docs } = params ?? {};
+    return this._client.delete(path`/connectors/v1/links/${id}`, {
+      query: { vault_docs },
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Per-file transfer ledger for a link: provider item, vault object, path, content
+   * version, state, and error.
+   */
+  listObjects(
+    id: string,
+    query: LinkListObjectsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.get(path`/connectors/v1/links/${id}/objects`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface LinkUpdateParams {
+  mode?: 'once' | 'synced';
+
+  policy?: unknown;
+
+  state?: 'paused' | 'ready';
+}
+
+export interface LinkListParams {
+  connection_id?: string;
+
+  direction?: 'import' | 'export';
+
+  mode?: 'once' | 'synced';
+
+  pair_id?: string;
+
+  state?: 'ready' | 'running' | 'active' | 'paused' | 'orphaned' | 'error';
+
+  vault_id?: string;
+}
+
+export interface LinkDeleteParams {
+  vault_docs?: 'keep' | 'delete';
+}
+
+export interface LinkListObjectsParams {
+  cursor?: string;
+
+  state?: 'pending' | 'transferring' | 'ingesting' | 'synced' | 'skipped' | 'failed' | 'tombstoned';
+}
+
+export declare namespace Links {
+  export {
+    type LinkUpdateParams as LinkUpdateParams,
+    type LinkListParams as LinkListParams,
+    type LinkDeleteParams as LinkDeleteParams,
+    type LinkListObjectsParams as LinkListObjectsParams,
+  };
+}