@mobilerun/sdk 4.0.0 → 5.2.0

package/src/resources/workflows/triggers.ts

@@ -0,0 +1,471 @@
+// 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 Triggers extends APIResource {
+  /**
+   * Create a trigger with an activation type of `event`, `schedule`, or `custom`.
+   * Each type requires its own fields (e.g. `eventType` and optional `conditions`
+   * for events, `scheduleRule` and `timezone` for schedules, `customPayloadSchema`
+   * for custom triggers); mismatched fields are rejected.
+   */
+  create(body: TriggerCreateParams, options?: RequestOptions): APIPromise<TriggerCreateResponse> {
+    return this._client.post('/triggers', { body, ...options });
+  }
+
+  /**
+   * Fetch a single trigger by its ID, including its activation type and
+   * type-specific configuration. Returns 404 if no trigger matches.
+   */
+  retrieve(triggerID: string, options?: RequestOptions): APIPromise<TriggerRetrieveResponse> {
+    return this._client.get(path`/triggers/${triggerID}`, options);
+  }
+
+  /**
+   * Partially update a trigger; all fields are optional. When `activation` is
+   * changed, the type-specific field rules are re-validated. Returns 404 if the
+   * trigger does not exist.
+   */
+  update(
+    triggerID: string,
+    body: TriggerUpdateParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<TriggerUpdateResponse> {
+    return this._client.patch(path`/triggers/${triggerID}`, { body, ...options });
+  }
+
+  /**
+   * Return a paginated list of triggers. Supports filtering by `activation` and
+   * `eventType`, free-text `search`, and ordering by name, createdAt, or updatedAt.
+   */
+  list(
+    query: TriggerListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<TriggerListResponse> {
+    return this._client.get('/triggers', { query, ...options });
+  }
+
+  /**
+   * Delete a trigger by its ID. Returns 404 if no trigger matches.
+   */
+  delete(triggerID: string, options?: RequestOptions): APIPromise<TriggerDeleteResponse> {
+    return this._client.delete(path`/triggers/${triggerID}`, options);
+  }
+
+  /**
+   * Invoke a custom trigger directly with an arbitrary JSON payload.
+   *
+   * Fan-out: a trigger may be referenced by multiple flows (workflows). Firing it
+   * enqueues one execution per enabled, non-deleted flow attached to this trigger,
+   * each receiving the same payload. The `enqueuedCount` in the response reports how
+   * many were enqueued (0 if no flows are attached, or if all matching flows are
+   * gated by a cooldown).
+   *
+   * Payload validation:
+   *
+   * - If the trigger has a `customPayloadSchema`, the payload is validated against
+   *   it (JSON Schema via AJV).
+   * - If no schema is configured, the payload only needs to be a JSON object — any
+   *   keys and values are accepted.
+   *
+   * Only triggers with `activation = "custom"` can be fired through this endpoint;
+   * event and schedule triggers return 409.
+   */
+  fire(
+    triggerID: string,
+    body: TriggerFireParams,
+    options?: RequestOptions,
+  ): APIPromise<TriggerFireResponse> {
+    return this._client.post(path`/triggers/${triggerID}/fire`, { body, ...options });
+  }
+}
+
+export interface TriggerCreateResponse {
+  data: TriggerCreateResponse.Data;
+}
+
+export namespace TriggerCreateResponse {
+  export interface Data {
+    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: Data.ScheduleRule;
+
+    timezone: string | null;
+
+    updatedAt: string | null;
+
+    /**
+     * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+     */
+    userId: string;
+
+    conditions?: unknown;
+
+    nextFireTime?: string | null;
+  }
+
+  export namespace Data {
+    export interface ScheduleRule {
+      type: 'once' | 'cron' | 'recurring';
+
+      /**
+       * ISO 8601 datetime (for type=once)
+       */
+      dateTime?: string;
+
+      /**
+       * Cron expression (for type=cron)
+       */
+      expression?: string;
+
+      /**
+       * Optional per-occurrence random window around the nominal schedule time
+       */
+      jitter?: ScheduleRule.Jitter;
+
+      /**
+       * RRULE string (for type=recurring)
+       */
+      rrule?: string;
+    }
+
+    export namespace ScheduleRule {
+      /**
+       * Optional per-occurrence random window around the nominal schedule time
+       */
+      export interface Jitter {
+        afterMinutes?: number;
+
+        beforeMinutes?: number;
+      }
+    }
+  }
+}
+
+export interface TriggerRetrieveResponse {
+  data: TriggerRetrieveResponse.Data;
+}
+
+export namespace TriggerRetrieveResponse {
+  export interface Data {
+    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 TriggerUpdateResponse {
+  data: TriggerUpdateResponse.Data;
+}
+
+export namespace TriggerUpdateResponse {
+  export interface Data {
+    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 TriggerListResponse {
+  items: Array<TriggerListResponse.Item>;
+
+  pagination: Shared.Pagination;
+}
+
+export namespace TriggerListResponse {
+  export interface Item {
+    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 TriggerDeleteResponse {
+  message: string;
+}
+
+export interface TriggerFireResponse {
+  /**
+   * Number of flow executions enqueued. May be 0 if no flows are attached to this
+   * trigger, or if all attached flows are currently in cooldown.
+   */
+  enqueuedCount: number;
+
+  /**
+   * Unique ID for this fire invocation. Job IDs in the execution queue are derived
+   * from it (one per enqueued flow).
+   */
+  invocationId: string;
+}
+
+export interface TriggerCreateParams {
+  activation: 'event' | 'schedule' | 'custom';
+
+  name: string;
+
+  conditions?: TriggerCreateParams.Conditions;
+
+  /**
+   * Optional JSON Schema for validating payloads sent to this custom trigger
+   */
+  customPayloadSchema?: { [key: string]: unknown };
+
+  description?: string;
+
+  eventType?: string;
+
+  scheduleRule?: TriggerCreateParams.ScheduleRule;
+
+  timezone?: string;
+}
+
+export namespace TriggerCreateParams {
+  export interface Conditions {
+    all?: Array<unknown>;
+
+    any?: Array<unknown>;
+  }
+
+  export interface ScheduleRule {
+    type: 'once' | 'cron' | 'recurring';
+
+    /**
+     * ISO 8601 datetime (for type=once)
+     */
+    dateTime?: string;
+
+    /**
+     * Cron expression (for type=cron)
+     */
+    expression?: string;
+
+    /**
+     * Optional per-occurrence random window around the nominal schedule time
+     */
+    jitter?: ScheduleRule.Jitter;
+
+    /**
+     * RRULE string (for type=recurring)
+     */
+    rrule?: string;
+  }
+
+  export namespace ScheduleRule {
+    /**
+     * Optional per-occurrence random window around the nominal schedule time
+     */
+    export interface Jitter {
+      afterMinutes?: number;
+
+      beforeMinutes?: number;
+    }
+  }
+}
+
+export interface TriggerUpdateParams {
+  activation?: 'event' | 'schedule' | 'custom';
+
+  conditions?: TriggerUpdateParams.Conditions;
+
+  customPayloadSchema?: { [key: string]: unknown };
+
+  description?: string;
+
+  eventType?: string;
+
+  name?: string;
+
+  scheduleRule?: TriggerUpdateParams.ScheduleRule;
+
+  timezone?: string | null;
+}
+
+export namespace TriggerUpdateParams {
+  export interface Conditions {
+    all?: Array<unknown>;
+
+    any?: Array<unknown>;
+  }
+
+  export interface ScheduleRule {
+    type: 'once' | 'cron' | 'recurring';
+
+    /**
+     * ISO 8601 datetime (for type=once)
+     */
+    dateTime?: string;
+
+    /**
+     * Cron expression (for type=cron)
+     */
+    expression?: string;
+
+    /**
+     * Optional per-occurrence random window around the nominal schedule time
+     */
+    jitter?: ScheduleRule.Jitter;
+
+    /**
+     * RRULE string (for type=recurring)
+     */
+    rrule?: string;
+  }
+
+  export namespace ScheduleRule {
+    /**
+     * Optional per-occurrence random window around the nominal schedule time
+     */
+    export interface Jitter {
+      afterMinutes?: number;
+
+      beforeMinutes?: number;
+    }
+  }
+}
+
+export interface TriggerListParams {
+  activation?: 'event' | 'schedule' | 'custom';
+
+  eventType?: string;
+
+  orderBy?: 'name' | 'createdAt' | 'updatedAt';
+
+  orderByDirection?: 'asc' | 'desc';
+
+  page?: number;
+
+  pageSize?: number;
+
+  search?: string;
+}
+
+export interface TriggerFireParams {
+  /**
+   * Arbitrary JSON object forwarded to every flow attached to this trigger.
+   * Validated against the trigger's customPayloadSchema when one is configured;
+   * otherwise only "must be a JSON object" is enforced.
+   */
+  payload: { [key: string]: unknown };
+}
+
+export declare namespace Triggers {
+  export {
+    type TriggerCreateResponse as TriggerCreateResponse,
+    type TriggerRetrieveResponse as TriggerRetrieveResponse,
+    type TriggerUpdateResponse as TriggerUpdateResponse,
+    type TriggerListResponse as TriggerListResponse,
+    type TriggerDeleteResponse as TriggerDeleteResponse,
+    type TriggerFireResponse as TriggerFireResponse,
+    type TriggerCreateParams as TriggerCreateParams,
+    type TriggerUpdateParams as TriggerUpdateParams,
+    type TriggerListParams as TriggerListParams,
+    type TriggerFireParams as TriggerFireParams,
+  };
+}

package/src/resources/workflows/workflows.ts

@@ -0,0 +1,239 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as ActionCatalogAPI from './action-catalog';
+import {
+  ActionCatalog,
+  ActionCatalogEntry,
+  ActionCatalogListParams,
+  ActionCatalogListResponse,
+  ActionCatalogRetrieveResponse,
+} from './action-catalog';
+import * as ExecutionsAPI from './executions';
+import {
+  ExecutionGetMetricsParams,
+  ExecutionGetMetricsResponse,
+  ExecutionListParams,
+  ExecutionListResponse,
+  ExecutionRetrieveResponse,
+  Executions,
+  FlowExecution,
+} from './executions';
+import * as TimezonesAPI from './timezones';
+import { TimezoneListResponse, Timezones } from './timezones';
+import * as TriggersAPI from './triggers';
+import {
+  TriggerCreateParams,
+  TriggerCreateResponse,
+  TriggerDeleteResponse,
+  TriggerFireParams,
+  TriggerFireResponse,
+  TriggerListParams,
+  TriggerListResponse,
+  TriggerRetrieveResponse,
+  TriggerUpdateParams,
+  TriggerUpdateResponse,
+  Triggers,
+} from './triggers';
+import * as ActionsAPI from './actions/actions';
+import {
+  Action,
+  ActionCreateParams,
+  ActionCreateResponse,
+  ActionDeleteResponse,
+  ActionListParams,
+  ActionListResponse,
+  ActionRetrieveResponse,
+  ActionUpdateParams,
+  ActionUpdateResponse,
+  Actions,
+} from './actions/actions';
+import * as EventsAPI from './events/events';
+import {
+  EventDryRunParams,
+  EventDryRunResponse,
+  EventIngestParams,
+  EventIngestResponse,
+  Events,
+} from './events/events';
+import * as FlowsAPI from './flows/flows';
+import {
+  FlowActionOverrides,
+  FlowChildActionInput,
+  FlowCloneParams,
+  FlowCloneResponse,
+  FlowCreateParams,
+  FlowCreateResponse,
+  FlowDeleteResponse,
+  FlowListParams,
+  FlowListResponse,
+  FlowRetrieveResponse,
+  FlowUnblockResponse,
+  FlowUpdateParams,
+  FlowUpdateResponse,
+  Flows,
+} from './flows/flows';
+
+export class Workflows extends APIResource {
+  triggers: TriggersAPI.Triggers = new TriggersAPI.Triggers(this._client);
+  actionCatalog: ActionCatalogAPI.ActionCatalog = new ActionCatalogAPI.ActionCatalog(this._client);
+  actions: ActionsAPI.Actions = new ActionsAPI.Actions(this._client);
+  flows: FlowsAPI.Flows = new FlowsAPI.Flows(this._client);
+  events: EventsAPI.Events = new EventsAPI.Events(this._client);
+  executions: ExecutionsAPI.Executions = new ExecutionsAPI.Executions(this._client);
+  timezones: TimezonesAPI.Timezones = new TimezonesAPI.Timezones(this._client);
+}
+
+export interface Flow {
+  id: string;
+
+  blockedAt: string | null;
+
+  consecutiveFailures: number;
+
+  cooldownScope: 'flow' | 'device';
+
+  cooldownSeconds: number | null;
+
+  createdAt: string | null;
+
+  createdBy: string | null;
+
+  description: string | null;
+
+  deviceIds: Array<string>;
+
+  enabled: boolean;
+
+  healthMonitoringEnabled: boolean;
+
+  lastFailureAt: string | null;
+
+  lastFailureCode:
+    | 'device_not_found'
+    | 'permission_denied'
+    | 'client_error'
+    | 'transient'
+    | 'logic'
+    | 'invalid_config'
+    | null;
+
+  lastTriggeredAt: string | null;
+
+  name: string;
+
+  notifyOnFailure: boolean;
+
+  notifyOnSuccess: boolean;
+
+  notifyWebhookId: string | null;
+
+  ownerId: string;
+
+  selfHealingEnabled: boolean;
+
+  selfHealingMaxAttempts: number;
+
+  status: 'healthy' | 'failing' | 'blocked';
+
+  /**
+   * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
+   * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
+   * a whole-token null stays JSON null). Existing flows stay 1; new flows default
+   * to 2.
+   */
+  templateResolutionVersion: number;
+
+  triggerId: string;
+
+  updatedAt: string | null;
+
+  /**
+   * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+   */
+  userId: string;
+}
+
+Workflows.Triggers = Triggers;
+Workflows.ActionCatalog = ActionCatalog;
+Workflows.Actions = Actions;
+Workflows.Flows = Flows;
+Workflows.Events = Events;
+Workflows.Executions = Executions;
+Workflows.Timezones = Timezones;
+
+export declare namespace Workflows {
+  export { type Flow as Flow };
+
+  export {
+    Triggers as Triggers,
+    type TriggerCreateResponse as TriggerCreateResponse,
+    type TriggerRetrieveResponse as TriggerRetrieveResponse,
+    type TriggerUpdateResponse as TriggerUpdateResponse,
+    type TriggerListResponse as TriggerListResponse,
+    type TriggerDeleteResponse as TriggerDeleteResponse,
+    type TriggerFireResponse as TriggerFireResponse,
+    type TriggerCreateParams as TriggerCreateParams,
+    type TriggerUpdateParams as TriggerUpdateParams,
+    type TriggerListParams as TriggerListParams,
+    type TriggerFireParams as TriggerFireParams,
+  };
+
+  export {
+    ActionCatalog as ActionCatalog,
+    type ActionCatalogEntry as ActionCatalogEntry,
+    type ActionCatalogRetrieveResponse as ActionCatalogRetrieveResponse,
+    type ActionCatalogListResponse as ActionCatalogListResponse,
+    type ActionCatalogListParams as ActionCatalogListParams,
+  };
+
+  export {
+    Actions as Actions,
+    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 {
+    Flows as Flows,
+    type FlowActionOverrides as FlowActionOverrides,
+    type FlowChildActionInput as FlowChildActionInput,
+    type FlowCreateResponse as FlowCreateResponse,
+    type FlowRetrieveResponse as FlowRetrieveResponse,
+    type FlowUpdateResponse as FlowUpdateResponse,
+    type FlowListResponse as FlowListResponse,
+    type FlowDeleteResponse as FlowDeleteResponse,
+    type FlowCloneResponse as FlowCloneResponse,
+    type FlowUnblockResponse as FlowUnblockResponse,
+    type FlowCreateParams as FlowCreateParams,
+    type FlowUpdateParams as FlowUpdateParams,
+    type FlowListParams as FlowListParams,
+    type FlowCloneParams as FlowCloneParams,
+  };
+
+  export {
+    Events as Events,
+    type EventDryRunResponse as EventDryRunResponse,
+    type EventIngestResponse as EventIngestResponse,
+    type EventDryRunParams as EventDryRunParams,
+    type EventIngestParams as EventIngestParams,
+  };
+
+  export {
+    Executions as Executions,
+    type FlowExecution as FlowExecution,
+    type ExecutionRetrieveResponse as ExecutionRetrieveResponse,
+    type ExecutionListResponse as ExecutionListResponse,
+    type ExecutionGetMetricsResponse as ExecutionGetMetricsResponse,
+    type ExecutionListParams as ExecutionListParams,
+    type ExecutionGetMetricsParams as ExecutionGetMetricsParams,
+  };
+
+  export { Timezones as Timezones, type TimezoneListResponse as TimezoneListResponse };
+}

package/src/resources/workflows.ts

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

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '4.0.0'; // x-release-please-version
+export const VERSION = '5.2.0'; // x-release-please-version

package/uploads.d.mts

@@ -1,2 +1,3 @@
+/** @deprecated Import from ./core/uploads instead */
 export * from "./core/uploads.mjs";
 //# sourceMappingURL=uploads.d.mts.map