casedev 0.0.1

package/src/resources/actions/v1.ts

@@ -0,0 +1,179 @@
+// 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';
+
+export class V1 extends APIResource {
+  /**
+   * Create a new action definition for multi-step workflow automation. Actions can
+   * be defined using YAML or JSON format and support complex workflows including
+   * document processing, data extraction, and analysis pipelines.
+   */
+  create(body: V1CreateParams, options?: RequestOptions): APIPromise<V1CreateResponse> {
+    return this._client.post('/actions/v1', { body, ...options });
+  }
+
+  /**
+   * Retrieve a specific action definition by ID. Actions are reusable workflow
+   * components that can perform tasks like document analysis, data extraction, or
+   * API integrations. Only actions belonging to your organization can be accessed.
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/actions/v1/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Retrieve all action definitions for your organization. Actions are reusable
+   * automation components that can perform tasks like document processing, data
+   * extraction, and workflow execution.
+   */
+  list(options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/actions/v1', {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Permanently deletes an action definition from your organization. This will
+   * remove all workflow steps and configurations associated with the action.
+   * **Warning:** This operation cannot be undone.
+   */
+  delete(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/actions/v1/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Execute a multi-step action workflow with the provided input data. Actions can
+   * run synchronously (returning results immediately) or asynchronously (with
+   * webhook notifications when complete).
+   */
+  execute(id: string, body: V1ExecuteParams, options?: RequestOptions): APIPromise<V1ExecuteResponse> {
+    return this._client.post(path`/actions/v1/${id}/execute`, { body, ...options });
+  }
+
+  /**
+   * Retrieve the status and results of a specific action execution. Returns
+   * execution details including current status, results, error messages, and
+   * execution metadata.
+   */
+  retrieveExecution(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/actions/v1/executions/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface V1CreateResponse {
+  id?: string;
+
+  createdAt?: string;
+
+  createdBy?: string;
+
+  definition?: unknown;
+
+  description?: string;
+
+  isActive?: boolean;
+
+  name?: string;
+
+  organizationId?: string;
+
+  updatedAt?: string;
+
+  version?: number;
+
+  webhookEndpointId?: string;
+}
+
+export interface V1ExecuteResponse {
+  /**
+   * Execution duration in milliseconds (only for completed executions)
+   */
+  duration_ms?: number;
+
+  /**
+   * Unique identifier for this execution
+   */
+  execution_id?: string;
+
+  /**
+   * Human-readable status message
+   */
+  message?: string;
+
+  /**
+   * Final output (only for synchronous/completed executions)
+   */
+  output?: { [key: string]: unknown };
+
+  /**
+   * Current status of the execution
+   */
+  status?: 'completed' | 'running';
+
+  /**
+   * Results from each step (only for synchronous/completed executions)
+   */
+  step_results?: Array<{ [key: string]: unknown }>;
+
+  /**
+   * Whether webhook notifications are configured
+   */
+  webhook_configured?: boolean;
+}
+
+export interface V1CreateParams {
+  /**
+   * Action definition in YAML string, JSON string, or JSON object format
+   */
+  definition: string | unknown;
+
+  /**
+   * Unique name for the action
+   */
+  name: string;
+
+  /**
+   * Optional description of the action's purpose
+   */
+  description?: string;
+
+  /**
+   * Optional webhook endpoint ID for action completion notifications
+   */
+  webhook_id?: string;
+}
+
+export interface V1ExecuteParams {
+  /**
+   * Input data for the action execution
+   */
+  input: { [key: string]: unknown };
+
+  /**
+   * Optional webhook endpoint ID to override the action's default webhook
+   */
+  webhook_id?: string;
+}
+
+export declare namespace V1 {
+  export {
+    type V1CreateResponse as V1CreateResponse,
+    type V1ExecuteResponse as V1ExecuteResponse,
+    type V1CreateParams as V1CreateParams,
+    type V1ExecuteParams as V1ExecuteParams,
+  };
+}

package/src/resources/actions.ts

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

package/src/resources/compute/compute.ts

@@ -0,0 +1,20 @@
+// 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, V1DeployParams, V1DeployResponse, V1GetUsageParams } from './v1/v1';
+
+export class Compute extends APIResource {
+  v1: V1API.V1 = new V1API.V1(this._client);
+}
+
+Compute.V1 = V1;
+
+export declare namespace Compute {
+  export {
+    V1 as V1,
+    type V1DeployResponse as V1DeployResponse,
+    type V1DeployParams as V1DeployParams,
+    type V1GetUsageParams as V1GetUsageParams,
+  };
+}

package/src/resources/compute/index.ts

@@ -0,0 +1,4 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Compute } from './compute';
+export { V1, type V1DeployResponse, type V1DeployParams, type V1GetUsageParams } from './v1/index';

package/src/resources/compute/v1/environments.ts

@@ -0,0 +1,154 @@
+// 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';
+
+export class Environments extends APIResource {
+  /**
+   * Creates a new compute environment for running serverless workloads. Each
+   * environment gets its own isolated namespace with a unique domain for hosting
+   * applications and APIs. The first environment created becomes the default
+   * environment for the organization.
+   *
+   * @example
+   * ```ts
+   * const environment =
+   *   await client.compute.v1.environments.create({
+   *     name: 'document-review-prod',
+   *   });
+   * ```
+   */
+  create(body: EnvironmentCreateParams, options?: RequestOptions): APIPromise<EnvironmentCreateResponse> {
+    return this._client.post('/compute/v1/environments', { body, ...options });
+  }
+
+  /**
+   * Retrieve a specific compute environment by name. Returns environment
+   * configuration including status, domain, and metadata for your serverless compute
+   * infrastructure.
+   *
+   * @example
+   * ```ts
+   * await client.compute.v1.environments.retrieve('name');
+   * ```
+   */
+  retrieve(name: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/compute/v1/environments/${name}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Retrieve all compute environments for your organization. Environments provide
+   * isolated execution contexts for running code and workflows.
+   *
+   * @example
+   * ```ts
+   * await client.compute.v1.environments.list();
+   * ```
+   */
+  list(options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/compute/v1/environments', {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Permanently delete a compute environment and all its associated resources. This
+   * will stop all running deployments and clean up related configurations. The
+   * default environment cannot be deleted if other environments exist.
+   *
+   * @example
+   * ```ts
+   * const environment =
+   *   await client.compute.v1.environments.delete(
+   *     'litigation-processing',
+   *   );
+   * ```
+   */
+  delete(name: string, options?: RequestOptions): APIPromise<EnvironmentDeleteResponse> {
+    return this._client.delete(path`/compute/v1/environments/${name}`, options);
+  }
+
+  /**
+   * Sets a compute environment as the default for the organization. Only one
+   * environment can be default at a time - setting a new default will automatically
+   * unset the previous one.
+   *
+   * @example
+   * ```ts
+   * await client.compute.v1.environments.setDefault(
+   *   'prod-legal-docs',
+   * );
+   * ```
+   */
+  setDefault(name: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.post(path`/compute/v1/environments/${name}/default`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface EnvironmentCreateResponse {
+  /**
+   * Unique environment identifier
+   */
+  id?: string;
+
+  /**
+   * Environment creation timestamp
+   */
+  createdAt?: string;
+
+  /**
+   * Unique domain for this environment
+   */
+  domain?: string;
+
+  /**
+   * Whether this is the default environment
+   */
+  isDefault?: boolean;
+
+  /**
+   * Environment name
+   */
+  name?: string;
+
+  /**
+   * URL-friendly slug derived from name
+   */
+  slug?: string;
+
+  /**
+   * Environment status
+   */
+  status?: 'active' | 'inactive';
+}
+
+export interface EnvironmentDeleteResponse {
+  message: string;
+
+  success: boolean;
+}
+
+export interface EnvironmentCreateParams {
+  /**
+   * Environment name (alphanumeric, hyphens, and underscores only)
+   */
+  name: string;
+}
+
+export declare namespace Environments {
+  export {
+    type EnvironmentCreateResponse as EnvironmentCreateResponse,
+    type EnvironmentDeleteResponse as EnvironmentDeleteResponse,
+    type EnvironmentCreateParams as EnvironmentCreateParams,
+  };
+}

package/src/resources/compute/v1/functions.ts

@@ -0,0 +1,70 @@
+// 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';
+
+export class Functions extends APIResource {
+  /**
+   * Retrieves all serverless functions deployed in a specified compute environment.
+   * Functions can be used for custom document processing, AI model inference, or
+   * other computational tasks in legal workflows.
+   *
+   * @example
+   * ```ts
+   * await client.compute.v1.functions.list();
+   * ```
+   */
+  list(query: FunctionListParams | null | undefined = {}, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/compute/v1/functions', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Retrieve execution logs from a deployed serverless function. Logs include
+   * function output, errors, and runtime information. Useful for debugging and
+   * monitoring function performance in production.
+   *
+   * @example
+   * ```ts
+   * await client.compute.v1.functions.getLogs('id');
+   * ```
+   */
+  getLogs(
+    id: string,
+    query: FunctionGetLogsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.get(path`/compute/v1/functions/${id}/logs`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface FunctionListParams {
+  /**
+   * Environment name. If not specified, uses the default environment.
+   */
+  env?: string;
+}
+
+export interface FunctionGetLogsParams {
+  /**
+   * Number of log lines to retrieve (default 200, max 1000)
+   */
+  tail?: number;
+}
+
+export declare namespace Functions {
+  export {
+    type FunctionListParams as FunctionListParams,
+    type FunctionGetLogsParams as FunctionGetLogsParams,
+  };
+}

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

@@ -0,0 +1,21 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Environments,
+  type EnvironmentCreateResponse,
+  type EnvironmentDeleteResponse,
+  type EnvironmentCreateParams,
+} from './environments';
+export { Functions, type FunctionListParams, type FunctionGetLogsParams } from './functions';
+export { Invoke, type InvokeRunResponse, type InvokeRunParams } from './invoke';
+export { Runs, type RunListParams } from './runs';
+export {
+  Secrets,
+  type SecretCreateResponse,
+  type SecretCreateParams,
+  type SecretListParams,
+  type SecretDeleteGroupParams,
+  type SecretRetrieveGroupParams,
+  type SecretUpdateGroupParams,
+} from './secrets';
+export { V1, type V1DeployResponse, type V1DeployParams, type V1GetUsageParams } from './v1';

package/src/resources/compute/v1/invoke.ts

@@ -0,0 +1,91 @@
+// 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';
+import { path } from '../../../internal/utils/path';
+
+export class Invoke extends APIResource {
+  /**
+   * Execute a deployed compute function with custom input data. Supports both
+   * synchronous and asynchronous execution modes. Functions can be invoked by ID or
+   * name and can process various types of input data for legal document analysis,
+   * data processing, or other computational tasks.
+   *
+   * @example
+   * ```ts
+   * const response = await client.compute.v1.invoke.run(
+   *   'func_abc123 or document-analyzer',
+   *   { input: { foo: 'bar' } },
+   * );
+   * ```
+   */
+  run(functionID: string, body: InvokeRunParams, options?: RequestOptions): APIPromise<InvokeRunResponse> {
+    return this._client.post(path`/compute/v1/invoke/${functionID}`, { body, ...options });
+  }
+}
+
+export type InvokeRunResponse =
+  | InvokeRunResponse.SynchronousResponse
+  | InvokeRunResponse.AsynchronousResponse;
+
+export namespace InvokeRunResponse {
+  export interface SynchronousResponse {
+    /**
+     * Execution duration in milliseconds
+     */
+    duration?: number;
+
+    /**
+     * Error message if status is failed
+     */
+    error?: string;
+
+    /**
+     * Function return value
+     */
+    output?: unknown;
+
+    /**
+     * Unique run identifier
+     */
+    runId?: string;
+
+    status?: 'completed' | 'failed';
+  }
+
+  export interface AsynchronousResponse {
+    /**
+     * URL to check run status and logs
+     */
+    logsUrl?: string;
+
+    /**
+     * Unique run identifier
+     */
+    runId?: string;
+
+    status?: 'running';
+  }
+}
+
+export interface InvokeRunParams {
+  /**
+   * Input data to pass to the function
+   */
+  input: { [key: string]: unknown };
+
+  /**
+   * If true, returns immediately with run ID for background execution
+   */
+  async?: boolean;
+
+  /**
+   * Override the auto-detected function suffix
+   */
+  functionSuffix?: '_modal' | '_task' | '_web' | '_server';
+}
+
+export declare namespace Invoke {
+  export { type InvokeRunResponse as InvokeRunResponse, type InvokeRunParams as InvokeRunParams };
+}

package/src/resources/compute/v1/runs.ts

@@ -0,0 +1,65 @@
+// 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';
+
+export class Runs extends APIResource {
+  /**
+   * Retrieve detailed information about a specific compute function run, including
+   * execution status, input/output data, resource usage metrics, and cost
+   * information.
+   *
+   * @example
+   * ```ts
+   * await client.compute.v1.runs.retrieve('id');
+   * ```
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/compute/v1/runs/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Retrieve a list of recent compute runs for your organization. Filter by
+   * environment or function, and limit the number of results returned. Useful for
+   * monitoring serverless function executions and tracking performance metrics.
+   *
+   * @example
+   * ```ts
+   * await client.compute.v1.runs.list();
+   * ```
+   */
+  list(query: RunListParams | null | undefined = {}, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/compute/v1/runs', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface RunListParams {
+  /**
+   * Environment name to filter runs by
+   */
+  env?: string;
+
+  /**
+   * Function name to filter runs by
+   */
+  function?: string;
+
+  /**
+   * Maximum number of runs to return (1-100, default: 50)
+   */
+  limit?: number;
+}
+
+export declare namespace Runs {
+  export { type RunListParams as RunListParams };
+}