casedev 0.3.0 → 0.4.1

package/src/resources/privilege/v1.ts

@@ -0,0 +1,122 @@
+// 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 { RequestOptions } from '../../internal/request-options';
+
+export class V1 extends APIResource {
+  /**
+   * Analyzes text or vault documents for legal privilege. Detects attorney-client
+   * privilege, work product doctrine, common interest privilege, and litigation hold
+   * materials.
+   *
+   * Returns structured privilege flags with confidence scores and policy-friendly
+   * rationale suitable for discovery workflows and privilege logs.
+   *
+   * **Size Limit:** Maximum 200,000 characters (larger documents rejected).
+   *
+   * **Permissions:** Requires `chat` permission. When using `document_id`, also
+   * requires `vault` permission.
+   *
+   * **Note:** When analyzing vault documents, results are automatically stored in
+   * the document's `privilege_analysis` metadata field.
+   */
+  detect(body: V1DetectParams, options?: RequestOptions): APIPromise<V1DetectResponse> {
+    return this._client.post('/privilege/v1/detect', { body, ...options });
+  }
+}
+
+export interface V1DetectResponse {
+  categories: Array<V1DetectResponse.Category>;
+
+  /**
+   * Overall confidence score (0-1)
+   */
+  confidence: number;
+
+  /**
+   * Policy-friendly explanation for privilege log
+   */
+  policy_rationale: string;
+
+  /**
+   * Whether any privilege was detected
+   */
+  privileged: boolean;
+
+  /**
+   * Recommended action for discovery
+   */
+  recommendation: 'withhold' | 'redact' | 'produce' | 'review';
+}
+
+export namespace V1DetectResponse {
+  export interface Category {
+    /**
+     * Confidence for this category (0-1)
+     */
+    confidence?: number;
+
+    /**
+     * Whether this privilege type was detected
+     */
+    detected?: boolean;
+
+    /**
+     * Specific phrases or patterns found
+     */
+    indicators?: Array<string>;
+
+    /**
+     * Explanation of detection result
+     */
+    rationale?: string;
+
+    /**
+     * Privilege category
+     */
+    type?: string;
+  }
+}
+
+export interface V1DetectParams {
+  /**
+   * Privilege categories to check. Defaults to all: attorney_client, work_product,
+   * common_interest, litigation_hold
+   */
+  categories?: Array<'attorney_client' | 'work_product' | 'common_interest' | 'litigation_hold'>;
+
+  /**
+   * Text content to analyze (required if document_id not provided)
+   */
+  content?: string;
+
+  /**
+   * Vault object ID to analyze (required if content not provided)
+   */
+  document_id?: string;
+
+  /**
+   * Include detailed rationale for each category
+   */
+  include_rationale?: boolean;
+
+  /**
+   * Jurisdiction for privilege rules
+   */
+  jurisdiction?: 'US-Federal';
+
+  /**
+   * LLM model to use for analysis
+   */
+  model?: string;
+
+  /**
+   * Vault ID (required when using document_id)
+   */
+  vault_id?: string;
+}
+
+export declare namespace V1 {
+  export { type V1DetectResponse as V1DetectResponse, type V1DetectParams as V1DetectParams };
+}

package/src/resources/privilege.ts

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

package/src/resources/superdoc/index.ts

@@ -0,0 +1,4 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Superdoc } from './superdoc';
+export { V1, type V1AnnotateParams, type V1ConvertParams } from './v1';

package/src/resources/superdoc/superdoc.ts

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

package/src/resources/superdoc/v1.ts

@@ -0,0 +1,146 @@
+// 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 { maybeMultipartFormRequestOptions } from '../../internal/uploads';
+
+export class V1 extends APIResource {
+  /**
+   * Populate fields inside a DOCX template using SuperDoc annotations. Supports
+   * text, images, dates, and numbers. Can target individual fields by ID or multiple
+   * fields by group.
+   */
+  annotate(body: V1AnnotateParams, options?: RequestOptions): APIPromise<Response> {
+    return this._client.post('/superdoc/v1/annotate', {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: 'application/pdf' }, options?.headers]),
+      __binaryResponse: true,
+    });
+  }
+
+  /**
+   * Convert documents between formats using SuperDoc. Supports DOCX to PDF, Markdown
+   * to DOCX, and HTML to DOCX conversions.
+   */
+  convert(body: V1ConvertParams, options?: RequestOptions): APIPromise<Response> {
+    return this._client.post(
+      '/superdoc/v1/convert',
+      maybeMultipartFormRequestOptions(
+        {
+          body,
+          ...options,
+          headers: buildHeaders([{ Accept: 'application/pdf' }, options?.headers]),
+          __binaryResponse: true,
+        },
+        this._client,
+      ),
+    );
+  }
+}
+
+export interface V1AnnotateParams {
+  /**
+   * Document source - provide either URL or base64
+   */
+  document: V1AnnotateParams.Document;
+
+  /**
+   * Fields to populate in the template
+   */
+  fields: Array<V1AnnotateParams.Field>;
+
+  /**
+   * Output format for the annotated document
+   */
+  output_format?: 'docx' | 'pdf';
+}
+
+export namespace V1AnnotateParams {
+  /**
+   * Document source - provide either URL or base64
+   */
+  export interface Document {
+    /**
+     * Base64-encoded DOCX template
+     */
+    base64?: string;
+
+    /**
+     * URL to the DOCX template
+     */
+    url?: string;
+  }
+
+  export interface Field {
+    /**
+     * Field data type
+     */
+    type: 'text' | 'image' | 'date' | 'number';
+
+    /**
+     * Value to populate
+     */
+    value: string | number;
+
+    /**
+     * Target field ID (for single field)
+     */
+    id?: string;
+
+    /**
+     * Target field group (for multiple fields with same tag)
+     */
+    group?: string;
+
+    /**
+     * Optional configuration (e.g., image dimensions)
+     */
+    options?: Field.Options;
+  }
+
+  export namespace Field {
+    /**
+     * Optional configuration (e.g., image dimensions)
+     */
+    export interface Options {
+      /**
+       * Image height in pixels
+       */
+      height?: number;
+
+      /**
+       * Image width in pixels
+       */
+      width?: number;
+    }
+  }
+}
+
+export interface V1ConvertParams {
+  /**
+   * Source format of the document
+   */
+  from: 'docx' | 'md' | 'html';
+
+  /**
+   * Base64-encoded document content
+   */
+  document_base64?: string;
+
+  /**
+   * URL to the document to convert
+   */
+  document_url?: string;
+
+  /**
+   * Target format for conversion
+   */
+  to?: 'pdf' | 'docx';
+}
+
+export declare namespace V1 {
+  export { type V1AnnotateParams as V1AnnotateParams, type V1ConvertParams as V1ConvertParams };
+}

package/src/resources/superdoc.ts

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

package/src/resources/translate/index.ts

@@ -0,0 +1,12 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Translate } from './translate';
+export {
+  V1,
+  type V1DetectResponse,
+  type V1ListLanguagesResponse,
+  type V1TranslateResponse,
+  type V1DetectParams,
+  type V1ListLanguagesParams,
+  type V1TranslateParams,
+} from './v1';

package/src/resources/translate/translate.ts

@@ -0,0 +1,31 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as V1API from './v1';
+import {
+  V1,
+  V1DetectParams,
+  V1DetectResponse,
+  V1ListLanguagesParams,
+  V1ListLanguagesResponse,
+  V1TranslateParams,
+  V1TranslateResponse,
+} from './v1';
+
+export class Translate extends APIResource {
+  v1: V1API.V1 = new V1API.V1(this._client);
+}
+
+Translate.V1 = V1;
+
+export declare namespace Translate {
+  export {
+    V1 as V1,
+    type V1DetectResponse as V1DetectResponse,
+    type V1ListLanguagesResponse as V1ListLanguagesResponse,
+    type V1TranslateResponse as V1TranslateResponse,
+    type V1DetectParams as V1DetectParams,
+    type V1ListLanguagesParams as V1ListLanguagesParams,
+    type V1TranslateParams as V1TranslateParams,
+  };
+}

package/src/resources/translate/v1.ts

@@ -0,0 +1,197 @@
+// 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 { RequestOptions } from '../../internal/request-options';
+
+export class V1 extends APIResource {
+  /**
+   * Detect the language of text. Returns the most likely language code and
+   * confidence score. Supports batch detection for multiple texts.
+   *
+   * @example
+   * ```ts
+   * const response = await client.translate.v1.detect({
+   *   q: 'string',
+   * });
+   * ```
+   */
+  detect(body: V1DetectParams, options?: RequestOptions): APIPromise<V1DetectResponse> {
+    return this._client.post('/translate/v1/detect', { body, ...options });
+  }
+
+  /**
+   * Get the list of languages supported for translation. Optionally specify a target
+   * language to get translated language names.
+   *
+   * @example
+   * ```ts
+   * const response = await client.translate.v1.listLanguages();
+   * ```
+   */
+  listLanguages(
+    query: V1ListLanguagesParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<V1ListLanguagesResponse> {
+    return this._client.get('/translate/v1/languages', { query, ...options });
+  }
+
+  /**
+   * Translate text between languages using Google Cloud Translation API. Supports
+   * 100+ languages, automatic language detection, HTML preservation, and batch
+   * translation.
+   *
+   * @example
+   * ```ts
+   * const response = await client.translate.v1.translate({
+   *   q: 'string',
+   *   target: 'es',
+   * });
+   * ```
+   */
+  translate(body: V1TranslateParams, options?: RequestOptions): APIPromise<V1TranslateResponse> {
+    return this._client.post('/translate/v1/translate', { body, ...options });
+  }
+}
+
+export interface V1DetectResponse {
+  data?: V1DetectResponse.Data;
+}
+
+export namespace V1DetectResponse {
+  export interface Data {
+    detections?: Array<Array<Data.Detection>>;
+  }
+
+  export namespace Data {
+    export interface Detection {
+      /**
+       * Confidence score (0-1)
+       */
+      confidence?: number;
+
+      /**
+       * Whether the detection is reliable
+       */
+      isReliable?: boolean;
+
+      /**
+       * Detected language code (ISO 639-1)
+       */
+      language?: string;
+    }
+  }
+}
+
+export interface V1ListLanguagesResponse {
+  data?: V1ListLanguagesResponse.Data;
+}
+
+export namespace V1ListLanguagesResponse {
+  export interface Data {
+    languages?: Array<Data.Language>;
+  }
+
+  export namespace Data {
+    export interface Language {
+      /**
+       * Language code (ISO 639-1)
+       */
+      language?: string;
+
+      /**
+       * Language name (if target specified)
+       */
+      name?: string;
+    }
+  }
+}
+
+export interface V1TranslateResponse {
+  data?: V1TranslateResponse.Data;
+}
+
+export namespace V1TranslateResponse {
+  export interface Data {
+    translations?: Array<Data.Translation>;
+  }
+
+  export namespace Data {
+    export interface Translation {
+      /**
+       * Detected source language (if source not specified)
+       */
+      detectedSourceLanguage?: string;
+
+      /**
+       * Model used for translation
+       */
+      model?: string;
+
+      /**
+       * Translated text
+       */
+      translatedText?: string;
+    }
+  }
+}
+
+export interface V1DetectParams {
+  /**
+   * Text to detect language for. Can be a single string or an array for batch
+   * detection.
+   */
+  q: string | Array<string>;
+}
+
+export interface V1ListLanguagesParams {
+  /**
+   * Translation model to check language support for
+   */
+  model?: 'nmt' | 'base';
+
+  /**
+   * Target language code for translating language names (e.g., 'es' for Spanish
+   * names)
+   */
+  target?: string;
+}
+
+export interface V1TranslateParams {
+  /**
+   * Text to translate. Can be a single string or an array for batch translation.
+   */
+  q: string | Array<string>;
+
+  /**
+   * Target language code (ISO 639-1)
+   */
+  target: string;
+
+  /**
+   * Format of the source text. Use 'html' to preserve HTML tags.
+   */
+  format?: 'text' | 'html';
+
+  /**
+   * Translation model. 'nmt' (Neural Machine Translation) is recommended for
+   * quality.
+   */
+  model?: 'nmt' | 'base';
+
+  /**
+   * Source language code (ISO 639-1). If not specified, language is auto-detected.
+   */
+  source?: string;
+}
+
+export declare namespace V1 {
+  export {
+    type V1DetectResponse as V1DetectResponse,
+    type V1ListLanguagesResponse as V1ListLanguagesResponse,
+    type V1TranslateResponse as V1TranslateResponse,
+    type V1DetectParams as V1DetectParams,
+    type V1ListLanguagesParams as V1ListLanguagesParams,
+    type V1TranslateParams as V1TranslateParams,
+  };
+}

package/src/resources/translate.ts

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

package/src/resources/vault/graphrag.ts

@@ -35,6 +35,28 @@ export class Graphrag extends APIResource {
   init(id: string, options?: RequestOptions): APIPromise<GraphragInitResponse> {
     return this._client.post(path`/vault/${id}/graphrag/init`, options);
   }
+
+  /**
+   * Manually trigger GraphRAG indexing for a vault object. The object must already
+   * be ingested (completed status). This extracts entities, relationships, and
+   * communities from the document for advanced knowledge graph queries.
+   *
+   * @example
+   * ```ts
+   * const response = await client.vault.graphrag.processObject(
+   *   'objectId',
+   *   { id: 'id' },
+   * );
+   * ```
+   */
+  processObject(
+    objectID: string,
+    params: GraphragProcessObjectParams,
+    options?: RequestOptions,
+  ): APIPromise<GraphragProcessObjectResponse> {
+    const { id } = params;
+    return this._client.post(path`/vault/${id}/graphrag/${objectID}`, options);
+  }
 }
 
 export interface GraphragGetStatsResponse {
@@ -79,9 +101,73 @@ export interface GraphragInitResponse {
   vault_id?: string;
 }
 
+export interface GraphragProcessObjectResponse {
+  /**
+   * Number of communities detected
+   */
+  communities: number;
+
+  /**
+   * Number of entities extracted
+   */
+  entities: number;
+
+  /**
+   * ID of the indexed object
+   */
+  objectId: string;
+
+  /**
+   * Number of relationships extracted
+   */
+  relationships: number;
+
+  /**
+   * Extraction statistics
+   */
+  stats: GraphragProcessObjectResponse.Stats;
+
+  /**
+   * Status from GraphRAG service
+   */
+  status: string;
+
+  /**
+   * Whether indexing completed successfully
+   */
+  success: boolean;
+
+  /**
+   * ID of the vault
+   */
+  vaultId: string;
+}
+
+export namespace GraphragProcessObjectResponse {
+  /**
+   * Extraction statistics
+   */
+  export interface Stats {
+    community_count?: number;
+
+    entity_count?: number;
+
+    relationship_count?: number;
+  }
+}
+
+export interface GraphragProcessObjectParams {
+  /**
+   * Vault ID
+   */
+  id: string;
+}
+
 export declare namespace Graphrag {
   export {
     type GraphragGetStatsResponse as GraphragGetStatsResponse,
     type GraphragInitResponse as GraphragInitResponse,
+    type GraphragProcessObjectResponse as GraphragProcessObjectResponse,
+    type GraphragProcessObjectParams as GraphragProcessObjectParams,
   };
 }

package/src/resources/vault/index.ts

@@ -1,27 +1,54 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { Graphrag, type GraphragGetStatsResponse, type GraphragInitResponse } from './graphrag';
+export {
+  Graphrag,
+  type GraphragGetStatsResponse,
+  type GraphragInitResponse,
+  type GraphragProcessObjectResponse,
+  type GraphragProcessObjectParams,
+} from './graphrag';
+export {
+  Multipart,
+  type MultipartGetPartURLsResponse,
+  type MultipartInitResponse,
+  type MultipartAbortParams,
+  type MultipartCompleteParams,
+  type MultipartGetPartURLsParams,
+  type MultipartInitParams,
+} from './multipart';
 export {
   Objects,
   type ObjectRetrieveResponse,
+  type ObjectUpdateResponse,
   type ObjectListResponse,
+  type ObjectDeleteResponse,
   type ObjectCreatePresignedURLResponse,
   type ObjectDownloadResponse,
+  type ObjectGetOcrWordsResponse,
+  type ObjectGetSummarizeJobResponse,
   type ObjectGetTextResponse,
   type ObjectRetrieveParams,
+  type ObjectUpdateParams,
+  type ObjectDeleteParams,
   type ObjectCreatePresignedURLParams,
   type ObjectDownloadParams,
+  type ObjectGetOcrWordsParams,
+  type ObjectGetSummarizeJobParams,
   type ObjectGetTextParams,
 } from './objects';
 export {
   Vault,
   type VaultCreateResponse,
   type VaultRetrieveResponse,
+  type VaultUpdateResponse,
   type VaultListResponse,
+  type VaultDeleteResponse,
   type VaultIngestResponse,
   type VaultSearchResponse,
   type VaultUploadResponse,
   type VaultCreateParams,
+  type VaultUpdateParams,
+  type VaultDeleteParams,
   type VaultIngestParams,
   type VaultSearchParams,
   type VaultUploadParams,