@artu-ai/compliance-sdk 0.13.4 → 0.17.0

package/dist/resources/users.js

@@ -12,6 +12,7 @@ import { TRPCClientError } from "@trpc/client";
 import { mapTRPCError } from "../errors";
 export class UsersResource {
     trpc;
+    /** @internal */
     constructor(trpc) {
         this.trpc = trpc;
     }
@@ -21,6 +22,16 @@ export class UsersResource {
     async listMembers() {
         return this.execute(() => this.trpc.users.listMembers.query());
     }
+    /**
+     * Resolve a single user by id, scoped to the caller's org. Returns
+     * `null` when the user isn't a member (cross-org probes look
+     * indistinguishable from "user doesn't exist"). Two WorkOS calls
+     * round-trip; cache client-side via React Query if you're calling
+     * this from a list surface.
+     */
+    async get(userId) {
+        return this.execute(() => this.trpc.users.get.query({ userId }));
+    }
     async removeMember(membershipId) {
         await this.execute(() => this.trpc.users.removeMember.mutate({ membershipId }));
     }
@@ -48,6 +59,18 @@ export class UsersResource {
     async myRoles() {
         return this.execute(() => this.trpc.users.myRoles.query());
     }
+    /**
+     * Persist the current user's preferred locale to their WorkOS profile.
+     * The dashboard cookie remains the immediate render source of truth; this
+     * makes the choice durable across devices and cleared cookies.
+     */
+    async updateLocale(locale) {
+        return this.execute(() => this.trpc.users.updateLocale.mutate({ locale }));
+    }
+    /** Record the current user's acceptance of the Terms & Conditions. */
+    async acceptTerms() {
+        return this.execute(() => this.trpc.users.acceptTerms.mutate());
+    }
     async assignRole(input) {
         return this.execute(() => this.trpc.users.assignRole.mutate(input));
     }

package/dist/resources/workflow-executions.d.ts

@@ -3,27 +3,22 @@
  *
  * Read-only resource manager for workflow execution records.
  */
-import type { ListOptions, NodeDataResponse, PaginatedResponse, WorkflowExecutionFilter } from "@artu-ai/shared";
+import type { CancelWorkflowExecutionResponse, GetExecutionFileDownloadUrlInput, ListOptions, ListResumableExecutionsResponse, NodeDataResponse, PaginatedResponse, PresignedDownloadUrl, RunReconnectInfo, WorkflowExecutionFilter } from "@artu-ai/shared";
 import { WorkflowExecution } from "../models/WorkflowExecution";
 import { ReadOnlyResource } from "./base";
 /**
  * Read-only resource manager for workflow executions.
  *
- * By default, every execution is recorded regardless of outcome.
- * The React SDK's `WorkflowExecutionsTable` defaults to showing only
- * matched executions (`matched: { eq: true }`) to reduce noise.
- * When using the SDK directly, pass the filter explicitly to get
- * the same behaviour:
+ * Event-triggered workflows whose trigger condition doesn't match no
+ * longer produce execution records — every row in the table represents
+ * a run that actually happened (either completed successfully or
+ * errored). Filter by `workflowId` / `triggerType` / `createdAt` as
+ * needed.
  *
  * @example
  * ```typescript
- * // List only matched executions (recommended default)
+ * // List executions for a specific workflow
  * const { data } = await sdk.workflows.executions.list({
- *   filter: { matched: true },
- * });
- *
- * // List all executions (including non-matched) for debugging
- * const { data: all } = await sdk.workflows.executions.list({
  *   filter: { workflowId: { eq: workflowId } },
  * });
  *
@@ -44,6 +39,33 @@ export declare class WorkflowExecutionsResource extends ReadOnlyResource<Workflo
      * Count workflow executions matching the given filter.
      */
     count(filter?: WorkflowExecutionFilter): Promise<number>;
+    /**
+     * Wait for a workflow execution to reach a stopping state — either truly
+     * terminal (`completed` / `errored` / `timed_out` / `abandoned`) or
+     * suspended waiting for human input (`waiting_for_input`, e.g. paused
+     * on a `form.choice` step). Returns the execution as soon as it
+     * transitions to any of these, or the current row (still `running`) on
+     * timeout. Hard cap: 60 seconds.
+     *
+     * `waiting_for_input` is treated as an early-return state because the
+     * run won't progress without a human acting on the execution — there's
+     * no point waiting longer.
+     *
+     * Long-poll variant of `retrieve`; use this when you want sync semantics
+     * and would otherwise be polling client-side.
+     *
+     * @example
+     * ```typescript
+     * const exec = await sdk.workflows.executions.wait(id, { timeoutMs: 10000 });
+     * if (exec.status === "completed") { ... }
+     * if (exec.status === "waiting_for_input") {
+     *   // Surface to user so they can complete the form step
+     * }
+     * ```
+     */
+    wait(id: string, options?: {
+        timeoutMs?: number;
+    }): Promise<WorkflowExecution>;
     /**
      * Get paginated data rows from a node output in a workflow execution.
      *
@@ -72,6 +94,57 @@ export declare class WorkflowExecutionsResource extends ReadOnlyResource<Workflo
         handle: string;
         limit?: number;
         offset?: number;
+        /**
+         * Case-insensitive substring search applied across every column
+         * (values cast to text). When set, both the returned rows and
+         * `totalRows` reflect only matching records.
+         */
+        search?: string;
     }): Promise<NodeDataResponse | null>;
+    /**
+     * Get a short-lived signed URL to view/download a file produced by an
+     * execution. Authorized by the opaque server-minted `fileId`; the storage
+     * key never leaves the server.
+     */
+    getFileDownloadUrl(input: GetExecutionFileDownloadUrlInput): Promise<PresignedDownloadUrl>;
+    /**
+     * List resumable executions for a workflow.
+     *
+     * Returns the most-recent paused-on-form-step executions plus a
+     * `total` count (of the requested view — "me" by default, or "all"
+     * for the org-wide list) and `mineTotal` (count of paused runs the
+     * current user initiated, used to power the `RunWorkflowButton`
+     * badge regardless of which view the dialog is currently showing).
+     * The server caps `items` so the picker UI can show "Showing N of M"
+     * when more exist beyond the window.
+     */
+    listResumable(input: {
+        workflowId: string;
+        /** `"me"` (default) returns only runs initiated by the current user.
+         *  `"all"` returns every paused run for the workflow. */
+        initiatedBy?: "me" | "all";
+    }): Promise<ListResumableExecutionsResponse>;
+    /**
+     * Get reconnect info for resuming a paused execution run.
+     *
+     * Returns a short-lived public token and metadata needed to reconnect
+     * the browser to the Trigger.dev run so the resume UI can call
+     * `runs.resume()`.
+     */
+    getRunReconnectInfo(input: {
+        executionId: string;
+    }): Promise<RunReconnectInfo>;
+    /**
+     * Cancel an in-flight workflow execution.
+     *
+     * Rejects with `BAD_REQUEST` if the execution is already in a
+     * terminal state. Writes `cancelled` to the DB row immediately and
+     * dispatches the underlying Trigger.dev run cancel in the background.
+     *
+     * @example
+     * ```typescript
+     * await sdk.workflows.executions.cancel("exec_abc");
+     * ```
+     */
+    cancel(id: string): Promise<CancelWorkflowExecutionResponse>;
 }
-//# sourceMappingURL=workflow-executions.d.ts.map

package/dist/resources/workflow-executions.js

@@ -8,21 +8,16 @@ import { ReadOnlyResource } from "./base";
 /**
  * Read-only resource manager for workflow executions.
  *
- * By default, every execution is recorded regardless of outcome.
- * The React SDK's `WorkflowExecutionsTable` defaults to showing only
- * matched executions (`matched: { eq: true }`) to reduce noise.
- * When using the SDK directly, pass the filter explicitly to get
- * the same behaviour:
+ * Event-triggered workflows whose trigger condition doesn't match no
+ * longer produce execution records — every row in the table represents
+ * a run that actually happened (either completed successfully or
+ * errored). Filter by `workflowId` / `triggerType` / `createdAt` as
+ * needed.
  *
  * @example
  * ```typescript
- * // List only matched executions (recommended default)
+ * // List executions for a specific workflow
  * const { data } = await sdk.workflows.executions.list({
- *   filter: { matched: true },
- * });
- *
- * // List all executions (including non-matched) for debugging
- * const { data: all } = await sdk.workflows.executions.list({
  *   filter: { workflowId: { eq: workflowId } },
  * });
  *
@@ -60,6 +55,39 @@ export class WorkflowExecutionsResource extends ReadOnlyResource {
     async count(filter) {
         return this.execute(() => this.trpc.workflows.executions.count.query({ filter }));
     }
+    /**
+     * Wait for a workflow execution to reach a stopping state — either truly
+     * terminal (`completed` / `errored` / `timed_out` / `abandoned`) or
+     * suspended waiting for human input (`waiting_for_input`, e.g. paused
+     * on a `form.choice` step). Returns the execution as soon as it
+     * transitions to any of these, or the current row (still `running`) on
+     * timeout. Hard cap: 60 seconds.
+     *
+     * `waiting_for_input` is treated as an early-return state because the
+     * run won't progress without a human acting on the execution — there's
+     * no point waiting longer.
+     *
+     * Long-poll variant of `retrieve`; use this when you want sync semantics
+     * and would otherwise be polling client-side.
+     *
+     * @example
+     * ```typescript
+     * const exec = await sdk.workflows.executions.wait(id, { timeoutMs: 10000 });
+     * if (exec.status === "completed") { ... }
+     * if (exec.status === "waiting_for_input") {
+     *   // Surface to user so they can complete the form step
+     * }
+     * ```
+     */
+    async wait(id, options) {
+        const response = await this.execute(() => this.trpc.workflows.executions.wait.query({
+            id,
+            ...(options?.timeoutMs !== undefined && {
+                timeoutMs: options.timeoutMs,
+            }),
+        }));
+        return new WorkflowExecution(response);
+    }
     /**
      * Get paginated data rows from a node output in a workflow execution.
      *
@@ -85,4 +113,54 @@ export class WorkflowExecutionsResource extends ReadOnlyResource {
     async getNodeData(input) {
         return this.execute(() => this.trpc.workflows.executions.getNodeData.query(input));
     }
+    /**
+     * Get a short-lived signed URL to view/download a file produced by an
+     * execution. Authorized by the opaque server-minted `fileId`; the storage
+     * key never leaves the server.
+     */
+    async getFileDownloadUrl(input) {
+        return this.execute(() => this.trpc.workflows.executions.getFileDownloadUrl.query(input));
+    }
+    /**
+     * List resumable executions for a workflow.
+     *
+     * Returns the most-recent paused-on-form-step executions plus a
+     * `total` count (of the requested view — "me" by default, or "all"
+     * for the org-wide list) and `mineTotal` (count of paused runs the
+     * current user initiated, used to power the `RunWorkflowButton`
+     * badge regardless of which view the dialog is currently showing).
+     * The server caps `items` so the picker UI can show "Showing N of M"
+     * when more exist beyond the window.
+     */
+    async listResumable(input) {
+        return this.execute(() => this.trpc.workflows.executions.listResumable.query({
+            workflowId: input.workflowId,
+            initiatedBy: input.initiatedBy ?? "me",
+        }));
+    }
+    /**
+     * Get reconnect info for resuming a paused execution run.
+     *
+     * Returns a short-lived public token and metadata needed to reconnect
+     * the browser to the Trigger.dev run so the resume UI can call
+     * `runs.resume()`.
+     */
+    async getRunReconnectInfo(input) {
+        return this.execute(() => this.trpc.workflows.executions.getRunReconnectInfo.query(input));
+    }
+    /**
+     * Cancel an in-flight workflow execution.
+     *
+     * Rejects with `BAD_REQUEST` if the execution is already in a
+     * terminal state. Writes `cancelled` to the DB row immediately and
+     * dispatches the underlying Trigger.dev run cancel in the background.
+     *
+     * @example
+     * ```typescript
+     * await sdk.workflows.executions.cancel("exec_abc");
+     * ```
+     */
+    async cancel(id) {
+        return this.execute(() => this.trpc.workflows.executions.cancel.mutate({ id }));
+    }
 }

package/dist/resources/workflow-links.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Workflow Links Resource
+ *
+ * Resource manager for shareable workflow links.
+ * Allows creating, listing, and revoking links that give external
+ * users access to form-based workflows.
+ *
+ * All input/output types are derived from Zod schemas in
+ * `@artu-ai/shared`, which are also used by the API router for
+ * runtime validation — guaranteeing the client and server stay
+ * in sync.
+ */
+import type { CreateWorkflowLinkInput, CreateWorkflowLinkResult, RevokeWorkflowLinkResult, WorkflowLink } from "@artu-ai/shared";
+import type { ResourceConfig } from "./base";
+export type { CreateWorkflowLinkInput, CreateWorkflowLinkResult, RevokeWorkflowLinkResult, WorkflowLink, } from "@artu-ai/shared";
+/**
+ * Resource manager for workflow links.
+ *
+ * Workflow links are shareable URLs that give external users access to
+ * form-based workflows without needing an account or API key.
+ *
+ * @example
+ * ```typescript
+ * // Create a link
+ * const { id, url } = await sdk.workflows.links.create({
+ *   workflowId: "wf_123",
+ *   allowedEmails: ["user@example.com"],
+ *   expiresAt: new Date("2025-12-31"),
+ * });
+ *
+ * // List active links
+ * const links = await sdk.workflows.links.list("wf_123");
+ *
+ * // Revoke a link
+ * await sdk.workflows.links.revoke("link_abc");
+ * ```
+ */
+export declare class WorkflowLinksResource {
+    constructor(config: ResourceConfig);
+    /**
+     * Create a shareable link for a workflow.
+     *
+     * @param input - Link creation parameters
+     * @returns The created link ID and full URL
+     */
+    create(input: CreateWorkflowLinkInput): Promise<CreateWorkflowLinkResult>;
+    /**
+     * List active links for a workflow.
+     *
+     * @param workflowId - The workflow ID to list links for
+     * @returns Array of workflow links
+     */
+    list(workflowId: string): Promise<WorkflowLink[]>;
+    /**
+     * Revoke a workflow link, making it inaccessible.
+     *
+     * @param linkId - The link ID to revoke
+     * @returns Success indicator
+     */
+    revoke(linkId: string): Promise<RevokeWorkflowLinkResult>;
+}

package/dist/resources/workflow-links.js

@@ -0,0 +1,68 @@
+/**
+ * Workflow Links Resource
+ *
+ * Resource manager for shareable workflow links.
+ * Allows creating, listing, and revoking links that give external
+ * users access to form-based workflows.
+ *
+ * All input/output types are derived from Zod schemas in
+ * `@artu-ai/shared`, which are also used by the API router for
+ * runtime validation — guaranteeing the client and server stay
+ * in sync.
+ */
+/**
+ * Resource manager for workflow links.
+ *
+ * Workflow links are shareable URLs that give external users access to
+ * form-based workflows without needing an account or API key.
+ *
+ * @example
+ * ```typescript
+ * // Create a link
+ * const { id, url } = await sdk.workflows.links.create({
+ *   workflowId: "wf_123",
+ *   allowedEmails: ["user@example.com"],
+ *   expiresAt: new Date("2025-12-31"),
+ * });
+ *
+ * // List active links
+ * const links = await sdk.workflows.links.list("wf_123");
+ *
+ * // Revoke a link
+ * await sdk.workflows.links.revoke("link_abc");
+ * ```
+ */
+export class WorkflowLinksResource {
+    /** @internal */
+    trpc;
+    constructor(config) {
+        this.trpc = config.trpc;
+    }
+    /**
+     * Create a shareable link for a workflow.
+     *
+     * @param input - Link creation parameters
+     * @returns The created link ID and full URL
+     */
+    async create(input) {
+        return this.trpc.workflows.links.create.mutate(input);
+    }
+    /**
+     * List active links for a workflow.
+     *
+     * @param workflowId - The workflow ID to list links for
+     * @returns Array of workflow links
+     */
+    async list(workflowId) {
+        return this.trpc.workflows.links.list.query({ workflowId });
+    }
+    /**
+     * Revoke a workflow link, making it inaccessible.
+     *
+     * @param linkId - The link ID to revoke
+     * @returns Success indicator
+     */
+    async revoke(linkId) {
+        return this.trpc.workflows.links.revoke.mutate({ linkId });
+    }
+}

package/dist/resources/workflow-templates.d.ts

@@ -3,7 +3,7 @@
  *
  * Resource manager for workflow templates — reusable workflow blueprints.
  */
-import type { CreateWorkflowTemplateFromWorkflowInput, CreateWorkflowTemplateInput, ImportWorkflowTemplateInput, ListOptions, PaginatedResponse, UpdateWorkflowTemplateInput, WorkflowTemplateFilter } from "@artu-ai/shared";
+import type { CreateWorkflowTemplateFromWorkflowInput, CreateWorkflowTemplateInput, ImportWorkflowTemplateInput, ListOptions, PaginatedResponse, UpdateWorkflowTemplateInput, WorkflowTemplateFilter, WorkflowTemplateSort } from "@artu-ai/shared";
 import { Workflow } from "../models/Workflow";
 import { WorkflowTemplate } from "../models/WorkflowTemplate";
 import { BaseResource } from "./base";
@@ -31,7 +31,7 @@ export declare class WorkflowTemplatesResource extends BaseResource<WorkflowTemp
     /**
      * List workflow templates with optional filtering and pagination.
      */
-    list(options?: ListOptions<WorkflowTemplateFilter, never>): Promise<PaginatedResponse<WorkflowTemplate>>;
+    list(options?: ListOptions<WorkflowTemplateFilter, WorkflowTemplateSort>): Promise<PaginatedResponse<WorkflowTemplate>>;
     /**
      * Count workflow templates matching the given filter.
      */
@@ -50,4 +50,3 @@ export declare class WorkflowTemplatesResource extends BaseResource<WorkflowTemp
      */
     unpublish(id: string): Promise<WorkflowTemplate>;
 }
-//# sourceMappingURL=workflow-templates.d.ts.map

package/dist/resources/workflow-templates.js

@@ -51,6 +51,7 @@ export class WorkflowTemplatesResource extends BaseResource {
     async list(options) {
         const response = await this.execute(() => this.trpc.workflowTemplates.list.query({
             filter: options?.filter,
+            sort: options?.sort,
             limit: options?.limit,
             offset: options?.offset,
             cursor: options?.cursor,

package/dist/resources/workflow-variables.d.ts

@@ -4,7 +4,7 @@
  * Resource manager for workflow variables (thresholds, config values).
  * Variables store configurable values for workflows and use $VARIABLE_NAME syntax.
  */
-import type { CreateWorkflowVariableInput, ListOptions, PaginatedResponse, SystemVariableFilter, UpdateWorkflowVariableInput, WorkflowVariableFilter, WorkflowVariableHistoryFilter } from "@artu-ai/shared";
+import type { CreateWorkflowVariableInput, ListOptions, PaginatedResponse, SystemVariableFilter, SystemVariableSort, UpdateWorkflowVariableInput, WorkflowVariableFilter, WorkflowVariableHistoryFilter, WorkflowVariableSort } from "@artu-ai/shared";
 import { SystemVariable, WorkflowVariable } from "../models/WorkflowVariable";
 import { BaseResource } from "./base";
 /**
@@ -50,7 +50,7 @@ export declare class WorkflowVariablesResource extends BaseResource<WorkflowVari
     /**
      * List workflow variables with optional filtering and pagination.
      */
-    list(options?: ListOptions<WorkflowVariableFilter, never>): Promise<PaginatedResponse<WorkflowVariable>>;
+    list(options?: ListOptions<WorkflowVariableFilter, WorkflowVariableSort>): Promise<PaginatedResponse<WorkflowVariable>>;
     /**
      * Count workflow variables matching the given filter.
      */
@@ -59,7 +59,7 @@ export declare class WorkflowVariablesResource extends BaseResource<WorkflowVari
      * List system-defined workflow variables with optional filtering and pagination.
      * These are application-level variables available to all organizations.
      */
-    listSystem(options?: ListOptions<SystemVariableFilter, never>): Promise<PaginatedResponse<SystemVariable>>;
+    listSystem(options?: ListOptions<SystemVariableFilter, SystemVariableSort>): Promise<PaginatedResponse<SystemVariable>>;
     /**
      * List all entries for a workflow variable name (history).
      * Returns all effectiveDate entries, sorted by effectiveDate DESC.
@@ -74,4 +74,3 @@ export declare class WorkflowVariablesResource extends BaseResource<WorkflowVari
         offset?: number;
     }): Promise<PaginatedResponse<SystemVariable>>;
 }
-//# sourceMappingURL=workflow-variables.d.ts.map

package/dist/resources/workflow-variables.js

@@ -69,6 +69,7 @@ export class WorkflowVariablesResource extends BaseResource {
     async list(options) {
         const response = await this.execute(() => this.trpc.workflows.variables.list.query({
             filter: options?.filter,
+            sort: options?.sort,
             limit: options?.limit,
             offset: options?.offset,
             cursor: options?.cursor,
@@ -92,6 +93,7 @@ export class WorkflowVariablesResource extends BaseResource {
     async listSystem(options) {
         const response = await this.execute(() => this.trpc.workflows.variables.listSystem.query({
             filter: options?.filter,
+            sort: options?.sort,
             limit: options?.limit,
             offset: options?.offset,
             cursor: options?.cursor,