@mobilerun/sdk 4.0.0 → 5.2.0

package/src/resources/workflows/actions/actions.ts

@@ -0,0 +1,167 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as Shared from '../../shared';
+import * as ServicesAPI from './services';
+import { ServiceListMethodsResponse, ServiceListResponse, Services } from './services';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class Actions extends APIResource {
+  services: ServicesAPI.Services = new ServicesAPI.Services(this._client);
+
+  /**
+   * Create a reusable action from a catalog entry (`catalogEntryId`), with an
+   * optional `params` object supplying the values for that entry's service method.
+   * Returns 400 if the params are invalid for the chosen catalog entry.
+   */
+  create(body: ActionCreateParams, options?: RequestOptions): APIPromise<ActionCreateResponse> {
+    return this._client.post('/actions', { body, ...options });
+  }
+
+  /**
+   * Fetch a single action by its ID, including its configured service, method, and
+   * params. Returns 404 if no action matches.
+   */
+  retrieve(actionID: string, options?: RequestOptions): APIPromise<ActionRetrieveResponse> {
+    return this._client.get(path`/actions/${actionID}`, options);
+  }
+
+  /**
+   * Partially update an action's name, description, or params; all fields are
+   * optional. Returns 404 if the action does not exist.
+   */
+  update(
+    actionID: string,
+    body: ActionUpdateParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ActionUpdateResponse> {
+    return this._client.patch(path`/actions/${actionID}`, { body, ...options });
+  }
+
+  /**
+   * Return a paginated list of actions. Supports filtering by `service`, free-text
+   * `search`, and ordering by name, createdAt, or updatedAt.
+   */
+  list(
+    query: ActionListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ActionListResponse> {
+    return this._client.get('/actions', { query, ...options });
+  }
+
+  /**
+   * Delete an action by its ID. Returns 404 if no action matches.
+   */
+  delete(actionID: string, options?: RequestOptions): APIPromise<ActionDeleteResponse> {
+    return this._client.delete(path`/actions/${actionID}`, options);
+  }
+}
+
+export interface Action {
+  id: string;
+
+  catalogEntryId: string;
+
+  createdAt: string | null;
+
+  createdBy: string | null;
+
+  description: string | null;
+
+  method: string;
+
+  name: string;
+
+  ownerId: string;
+
+  service: 'tasks_api' | 'devices_api' | 'agents_api' | 'webhooks';
+
+  updatedAt: string | null;
+
+  /**
+   * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+   */
+  userId: string;
+
+  params?: unknown;
+
+  paramsSchema?: unknown;
+}
+
+export interface ActionCreateResponse {
+  data: Action;
+}
+
+export interface ActionRetrieveResponse {
+  data: Action;
+}
+
+export interface ActionUpdateResponse {
+  data: Action;
+}
+
+export interface ActionListResponse {
+  items: Array<Action>;
+
+  pagination: Shared.Pagination;
+}
+
+export interface ActionDeleteResponse {
+  message: string;
+}
+
+export interface ActionCreateParams {
+  catalogEntryId: string;
+
+  name: string;
+
+  description?: string;
+
+  params?: { [key: string]: unknown };
+}
+
+export interface ActionUpdateParams {
+  description?: string;
+
+  name?: string;
+
+  params?: { [key: string]: unknown };
+}
+
+export interface ActionListParams {
+  orderBy?: 'name' | 'createdAt' | 'updatedAt';
+
+  orderByDirection?: 'asc' | 'desc';
+
+  page?: number;
+
+  pageSize?: number;
+
+  search?: string;
+
+  service?: 'tasks_api' | 'devices_api' | 'agents_api' | 'webhooks';
+}
+
+Actions.Services = Services;
+
+export declare namespace Actions {
+  export {
+    type Action as Action,
+    type ActionCreateResponse as ActionCreateResponse,
+    type ActionRetrieveResponse as ActionRetrieveResponse,
+    type ActionUpdateResponse as ActionUpdateResponse,
+    type ActionListResponse as ActionListResponse,
+    type ActionDeleteResponse as ActionDeleteResponse,
+    type ActionCreateParams as ActionCreateParams,
+    type ActionUpdateParams as ActionUpdateParams,
+    type ActionListParams as ActionListParams,
+  };
+
+  export {
+    Services as Services,
+    type ServiceListResponse as ServiceListResponse,
+    type ServiceListMethodsResponse as ServiceListMethodsResponse,
+  };
+}

package/src/resources/workflows/actions/index.ts

@@ -0,0 +1,15 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Actions,
+  type Action,
+  type ActionCreateResponse,
+  type ActionRetrieveResponse,
+  type ActionUpdateResponse,
+  type ActionListResponse,
+  type ActionDeleteResponse,
+  type ActionCreateParams,
+  type ActionUpdateParams,
+  type ActionListParams,
+} from './actions';
+export { Services, type ServiceListResponse, type ServiceListMethodsResponse } from './services';

package/src/resources/workflows/actions/services.ts

@@ -0,0 +1,64 @@
+// 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 Services extends APIResource {
+  /**
+   * Return the names of the services that actions can be built against. Use these
+   * values to look up each service's allowed methods.
+   */
+  list(options?: RequestOptions): APIPromise<ServiceListResponse> {
+    return this._client.get('/actions/services', options);
+  }
+
+  /**
+   * Return the methods allowed for the given service, each with its parameter
+   * definitions (name, type, whether required, description, and optional
+   * default/example). Returns 404 if the service is unknown.
+   */
+  listMethods(service: string, options?: RequestOptions): APIPromise<ServiceListMethodsResponse> {
+    return this._client.get(path`/actions/services/${service}/methods`, options);
+  }
+}
+
+export interface ServiceListResponse {
+  data: Array<string>;
+}
+
+export interface ServiceListMethodsResponse {
+  data: Array<ServiceListMethodsResponse.Data>;
+}
+
+export namespace ServiceListMethodsResponse {
+  export interface Data {
+    method: string;
+
+    params: Array<Data.Param>;
+  }
+
+  export namespace Data {
+    export interface Param {
+      description: string;
+
+      name: string;
+
+      required: boolean;
+
+      type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+
+      default?: unknown;
+
+      example?: unknown;
+    }
+  }
+}
+
+export declare namespace Services {
+  export {
+    type ServiceListResponse as ServiceListResponse,
+    type ServiceListMethodsResponse as ServiceListMethodsResponse,
+  };
+}

package/src/resources/workflows/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/workflows/events/catalog.ts

@@ -0,0 +1,5 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+
+export class Catalog extends APIResource {}

package/src/resources/workflows/events/events.ts

@@ -0,0 +1,167 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as WorkflowsAPI from '../workflows';
+import * as CatalogAPI from './catalog';
+import { Catalog } from './catalog';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+
+export class Events extends APIResource {
+  catalog: CatalogAPI.Catalog = new CatalogAPI.Catalog(this._client);
+
+  /**
+   * Simulate an event against all configured flows. Returns which flows would match
+   * and what actions would run, without storing the event or enqueuing jobs.
+   */
+  dryRun(body: EventDryRunParams, options?: RequestOptions): APIPromise<EventDryRunResponse> {
+    return this._client.post('/events/dry-run', { body, ...options });
+  }
+
+  /**
+   * Ingest an event for trigger evaluation. Returns immediately with 202 Accepted.
+   */
+  ingest(body: EventIngestParams, options?: RequestOptions): APIPromise<EventIngestResponse> {
+    return this._client.post('/events/ingest', { body, ...options });
+  }
+}
+
+export interface EventDryRunResponse {
+  data: EventDryRunResponse.Data;
+}
+
+export namespace EventDryRunResponse {
+  export interface Data {
+    matchedFlows: Array<Data.MatchedFlow>;
+
+    validation: Data.Validation;
+  }
+
+  export namespace Data {
+    export interface MatchedFlow {
+      actions: Array<MatchedFlow.Action>;
+
+      flow: WorkflowsAPI.Flow;
+
+      gates: MatchedFlow.Gates;
+
+      trigger: MatchedFlow.Trigger;
+
+      wouldFire: boolean;
+    }
+
+    export namespace MatchedFlow {
+      export interface Action {
+        continueOnError: boolean;
+
+        method: string;
+
+        name: string;
+
+        service: 'tasks_api' | 'devices_api' | 'agents_api' | 'webhooks';
+
+        /**
+         * Nested child actions (loop/branch bodies), each the same shape as a
+         * ResolvedAction.
+         */
+        children?: Array<unknown>;
+
+        params?: { [key: string]: unknown };
+      }
+
+      export interface Gates {
+        blocked: boolean;
+
+        cooldownActive: boolean | null;
+
+        deviceAttached: boolean;
+
+        deviceIds: Array<string>;
+
+        enabled: boolean;
+      }
+
+      export interface Trigger {
+        id: string;
+
+        activation: 'event' | 'schedule' | 'custom';
+
+        createdAt: string | null;
+
+        createdBy: string | null;
+
+        customPayloadSchema: { [key: string]: unknown } | null;
+
+        description: string | null;
+
+        eventType: string | null;
+
+        name: string;
+
+        ownerId: string;
+
+        scheduleRule: unknown;
+
+        timezone: string | null;
+
+        updatedAt: string | null;
+
+        /**
+         * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+         */
+        userId: string;
+
+        conditions?: unknown;
+
+        nextFireTime?: string | null;
+      }
+    }
+
+    export interface Validation {
+      valid: boolean;
+
+      errors?: Array<Validation.Error>;
+    }
+
+    export namespace Validation {
+      export interface Error {
+        field: string;
+
+        message: string;
+      }
+    }
+  }
+}
+
+export interface EventIngestResponse {
+  eventId: string;
+}
+
+export interface EventDryRunParams {
+  eventType: string;
+
+  deviceId?: string;
+
+  payload?: { [key: string]: unknown };
+}
+
+export interface EventIngestParams {
+  eventType: string;
+
+  deviceId?: string;
+
+  payload?: { [key: string]: unknown };
+}
+
+Events.Catalog = Catalog;
+
+export declare namespace Events {
+  export {
+    type EventDryRunResponse as EventDryRunResponse,
+    type EventIngestResponse as EventIngestResponse,
+    type EventDryRunParams as EventDryRunParams,
+    type EventIngestParams as EventIngestParams,
+  };
+
+  export { Catalog as Catalog };
+}

package/src/resources/workflows/events/index.ts

@@ -0,0 +1,10 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Catalog } from './catalog';
+export {
+  Events,
+  type EventDryRunResponse,
+  type EventIngestResponse,
+  type EventDryRunParams,
+  type EventIngestParams,
+} from './events';

package/src/resources/workflows/events.ts

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

package/src/resources/workflows/executions.ts

@@ -0,0 +1,194 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as ExecutionsAPI from './executions';
+import * as Shared from '../shared';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Executions extends APIResource {
+  /**
+   * Fetch a single flow execution by its ID, including its status, kind, result or
+   * error, and start/finish timestamps. Returns 404 if no execution matches.
+   */
+  retrieve(executionID: string, options?: RequestOptions): APIPromise<ExecutionRetrieveResponse> {
+    return this._client.get(path`/executions/${executionID}`, options);
+  }
+
+  /**
+   * Return a paginated history of flow executions. Supports filtering by `flowId`,
+   * `triggerId`, `status`, and a `from`/`to` time range, plus free-text `search` and
+   * ordering by startedAt, finishedAt, or status.
+   */
+  list(
+    query: ExecutionListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ExecutionListResponse> {
+    return this._client.get('/executions', { query, ...options });
+  }
+
+  /**
+   * Return aggregate execution metrics — total count, counts by status, average
+   * duration, and the last execution time. Can be scoped by `flowId`, `triggerId`,
+   * and a `from`/`to` time range.
+   */
+  getMetrics(
+    query: ExecutionGetMetricsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ExecutionGetMetricsResponse> {
+    return this._client.get('/executions/metrics', { query, ...options });
+  }
+}
+
+export interface FlowExecution {
+  id: string;
+
+  error: string | null;
+
+  eventId: string | null;
+
+  finishedAt: string | null;
+
+  flowId: string;
+
+  flowName: string | null;
+
+  kind: 'live' | 'dry_run';
+
+  startedAt: string | null;
+
+  status: 'pending' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'invalid' | null;
+
+  triggerId: string;
+
+  triggerName: string | null;
+
+  /**
+   * Opaque per-step result blob ({ steps: [...] }). Each step additionally carries a
+   * `verdict` field ({ outcome, summary, reason? } | null) when it is an agent.run
+   * step that opted into a verdict — null otherwise. Table-backed steps (current
+   * executions) also carry a `status` string (e.g. success/failed/stopped, see
+   * deriveStepStatus); it is optional and absent on legacy blob-only executions, so
+   * clients must not assume its presence.
+   */
+  result?: unknown;
+}
+
+export interface ExecutionRetrieveResponse {
+  data: ExecutionRetrieveResponse.Data;
+}
+
+export namespace ExecutionRetrieveResponse {
+  export interface Data extends ExecutionsAPI.FlowExecution {
+    createdBy: string | null;
+
+    /**
+     * Files produced by files.upload steps, plus files an agent.run step reported on
+     * its terminal response (agent-created output or a workflow upload minted during
+     * the turn); derived server-side at read time.
+     */
+    files: Array<Data.File>;
+  }
+
+  export namespace Data {
+    export interface File {
+      fileId: string;
+
+      filename: string;
+
+      mimeType: string;
+
+      sizeBytes: number;
+    }
+  }
+}
+
+export interface ExecutionListResponse {
+  items: Array<ExecutionListResponse.Item>;
+
+  pagination: Shared.Pagination;
+}
+
+export namespace ExecutionListResponse {
+  export interface Item extends ExecutionsAPI.FlowExecution {
+    createdBy: string | null;
+  }
+}
+
+export interface ExecutionGetMetricsResponse {
+  data: ExecutionGetMetricsResponse.Data;
+}
+
+export namespace ExecutionGetMetricsResponse {
+  export interface Data {
+    avgDurationMs: number | null;
+
+    byStatus: Data.ByStatus;
+
+    lastExecutionAt: string | null;
+
+    total: number;
+  }
+
+  export namespace Data {
+    export interface ByStatus {
+      cancelled: number;
+
+      failed: number;
+
+      invalid: number;
+
+      pending: number;
+
+      running: number;
+
+      skipped: number;
+
+      success: number;
+    }
+  }
+}
+
+export interface ExecutionListParams {
+  flowId?: string;
+
+  from?: string | null;
+
+  orderBy?: 'startedAt' | 'finishedAt' | 'status';
+
+  orderByDirection?: 'asc' | 'desc';
+
+  page?: number;
+
+  pageSize?: number;
+
+  search?: string;
+
+  status?: 'pending' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'invalid';
+
+  to?: string | null;
+
+  triggerId?: string;
+}
+
+export interface ExecutionGetMetricsParams {
+  flowId?: string;
+
+  from?: string | null;
+
+  to?: string | null;
+
+  triggerId?: string;
+}
+
+export declare namespace Executions {
+  export {
+    type FlowExecution as FlowExecution,
+    type ExecutionRetrieveResponse as ExecutionRetrieveResponse,
+    type ExecutionListResponse as ExecutionListResponse,
+    type ExecutionGetMetricsResponse as ExecutionGetMetricsResponse,
+    type ExecutionListParams as ExecutionListParams,
+    type ExecutionGetMetricsParams as ExecutionGetMetricsParams,
+  };
+}