@mobilerun/sdk 4.0.0 → 5.1.0

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

@@ -0,0 +1,61 @@
+// 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 {
+  /**
+   * List available services
+   */
+  list(options?: RequestOptions): APIPromise<ServiceListResponse> {
+    return this._client.get('/actions/services', options);
+  }
+
+  /**
+   * List allowed methods for a service
+   */
+  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,88 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as Shared from '../../shared';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+
+export class Catalog extends APIResource {
+  /**
+   * List event catalog
+   */
+  list(
+    query: CatalogListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<CatalogListResponse> {
+    return this._client.get('/events/catalog', { query, ...options });
+  }
+
+  /**
+   * Register event types in the catalog
+   */
+  register(body: CatalogRegisterParams, options?: RequestOptions): APIPromise<CatalogRegisterResponse> {
+    return this._client.post('/events/catalog/register', { body, ...options });
+  }
+}
+
+export interface CatalogListResponse {
+  items: Array<CatalogListResponse.Item>;
+
+  pagination: Shared.Pagination;
+}
+
+export namespace CatalogListResponse {
+  export interface Item {
+    createdAt: string | null;
+
+    description: string | null;
+
+    eventType: string;
+
+    label: string;
+
+    source: string | null;
+
+    updatedAt: string | null;
+
+    payloadSchema?: unknown;
+  }
+}
+
+export interface CatalogRegisterResponse {
+  message: string;
+}
+
+export interface CatalogListParams {
+  page?: number;
+
+  pageSize?: number;
+
+  source?: 'device' | 'system' | 'webhook';
+}
+
+export interface CatalogRegisterParams {
+  events: Array<CatalogRegisterParams.Event>;
+}
+
+export namespace CatalogRegisterParams {
+  export interface Event {
+    eventType: string;
+
+    label: string;
+
+    description?: string;
+
+    payloadSchema?: { [key: string]: unknown };
+
+    source?: 'device' | 'system' | 'webhook';
+  }
+}
+
+export declare namespace Catalog {
+  export {
+    type CatalogListResponse as CatalogListResponse,
+    type CatalogRegisterResponse as CatalogRegisterResponse,
+    type CatalogListParams as CatalogListParams,
+    type CatalogRegisterParams as CatalogRegisterParams,
+  };
+}

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

@@ -0,0 +1,189 @@
+// 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,
+  CatalogListParams,
+  CatalogListResponse,
+  CatalogRegisterParams,
+  CatalogRegisterResponse,
+} 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;
+
+        customPayloadSchema: { [key: string]: unknown } | null;
+
+        description: string | null;
+
+        eventType: string | null;
+
+        name: string;
+
+        scheduleRule: Trigger.ScheduleRule | null;
+
+        timezone: string | null;
+
+        updatedAt: string | null;
+
+        userId: string;
+
+        conditions?: unknown;
+
+        nextFireTime?: string | null;
+      }
+
+      export namespace Trigger {
+        export interface ScheduleRule {
+          type: 'once' | 'cron' | 'recurring';
+
+          /**
+           * ISO 8601 datetime (for type=once)
+           */
+          dateTime?: string;
+
+          /**
+           * Cron expression (for type=cron)
+           */
+          expression?: string;
+
+          /**
+           * RRULE string (for type=recurring)
+           */
+          rrule?: string;
+        }
+      }
+    }
+
+    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;
+
+  payload?: { [key: string]: unknown };
+}
+
+export interface EventIngestParams {
+  eventType: 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,
+    type CatalogListResponse as CatalogListResponse,
+    type CatalogRegisterResponse as CatalogRegisterResponse,
+    type CatalogListParams as CatalogListParams,
+    type CatalogRegisterParams as CatalogRegisterParams,
+  };
+}

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

@@ -0,0 +1,16 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Catalog,
+  type CatalogListResponse,
+  type CatalogRegisterResponse,
+  type CatalogListParams,
+  type CatalogRegisterParams,
+} 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,149 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+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 {
+  /**
+   * Get execution details
+   */
+  retrieve(executionID: string, options?: RequestOptions): APIPromise<ExecutionRetrieveResponse> {
+    return this._client.get(path`/executions/${executionID}`, options);
+  }
+
+  /**
+   * List flow executions
+   */
+  list(
+    query: ExecutionListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ExecutionListResponse> {
+    return this._client.get('/executions', { query, ...options });
+  }
+
+  /**
+   * Get execution metrics
+   */
+  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;
+
+  result?: unknown;
+}
+
+export interface ExecutionRetrieveResponse {
+  data: FlowExecution;
+}
+
+export interface ExecutionListResponse {
+  items: Array<FlowExecution>;
+
+  pagination: Shared.Pagination;
+}
+
+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,
+  };
+}

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

@@ -0,0 +1,141 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as FlowsAPI from './flows';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class Actions extends APIResource {
+  /**
+   * List actions for a flow
+   */
+  list(flowID: string, options?: RequestOptions): APIPromise<ActionListResponse> {
+    return this._client.get(path`/flows/${flowID}/actions`, options);
+  }
+
+  /**
+   * Add an action to a flow
+   */
+  add(flowID: string, body: ActionAddParams, options?: RequestOptions): APIPromise<ActionAddResponse> {
+    return this._client.post(path`/flows/${flowID}/actions`, { body, ...options });
+  }
+
+  /**
+   * Remove an action from a flow
+   */
+  remove(
+    flowActionID: string,
+    params: ActionRemoveParams,
+    options?: RequestOptions,
+  ): APIPromise<ActionRemoveResponse> {
+    const { flowId } = params;
+    return this._client.delete(path`/flows/${flowId}/actions/${flowActionID}`, options);
+  }
+
+  /**
+   * Replace all actions for a flow
+   */
+  replace(
+    flowID: string,
+    body: ActionReplaceParams,
+    options?: RequestOptions,
+  ): APIPromise<ActionReplaceResponse> {
+    return this._client.put(path`/flows/${flowID}/actions`, { body, ...options });
+  }
+}
+
+export interface FlowAction {
+  id: string;
+
+  actionId: string;
+
+  continueOnError: boolean;
+
+  createdAt: string | null;
+
+  flowId: string;
+
+  nameOverride: string | null;
+
+  overrides: FlowAction.Overrides | null;
+
+  parentFlowActionId: string | null;
+
+  position: number;
+}
+
+export namespace FlowAction {
+  export interface Overrides {
+    params?: { [key: string]: unknown };
+  }
+}
+
+export interface ActionListResponse {
+  data: Array<FlowAction>;
+}
+
+export interface ActionAddResponse {
+  data: FlowAction;
+}
+
+export interface ActionRemoveResponse {
+  message: string;
+}
+
+export interface ActionReplaceResponse {
+  data: Array<FlowAction>;
+}
+
+export interface ActionAddParams {
+  actionId: string;
+
+  position: number;
+
+  children?: Array<FlowsAPI.FlowChildActionInput>;
+
+  continueOnError?: boolean;
+
+  nameOverride?: string;
+
+  overrides?: FlowsAPI.FlowActionOverrides | null;
+
+  parentFlowActionId?: string | null;
+}
+
+export interface ActionRemoveParams {
+  flowId: string;
+}
+
+export interface ActionReplaceParams {
+  actions: Array<ActionReplaceParams.Action>;
+}
+
+export namespace ActionReplaceParams {
+  export interface Action {
+    actionId: string;
+
+    position: number;
+
+    children?: Array<FlowsAPI.FlowChildActionInput>;
+
+    continueOnError?: boolean;
+
+    nameOverride?: string;
+
+    overrides?: FlowsAPI.FlowActionOverrides | null;
+  }
+}
+
+export declare namespace Actions {
+  export {
+    type FlowAction as FlowAction,
+    type ActionListResponse as ActionListResponse,
+    type ActionAddResponse as ActionAddResponse,
+    type ActionRemoveResponse as ActionRemoveResponse,
+    type ActionReplaceResponse as ActionReplaceResponse,
+    type ActionAddParams as ActionAddParams,
+    type ActionRemoveParams as ActionRemoveParams,
+    type ActionReplaceParams as ActionReplaceParams,
+  };
+}