@trycourier/courier 7.10.2 → 7.19.1

package/src/resources/journeys/journeys.ts

@@ -0,0 +1,1289 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as JourneysAPI from './journeys';
+import * as Shared from '../shared';
+import * as TemplatesAPI from './templates';
+import {
+  TemplateArchiveParams,
+  TemplateCreateParams,
+  TemplateListParams,
+  TemplateListVersionsParams,
+  TemplatePublishParams,
+  TemplatePutContentParams,
+  TemplatePutLocaleParams,
+  TemplateReplaceParams,
+  TemplateRetrieveContentParams,
+  TemplateRetrieveParams,
+  Templates,
+} from './templates';
+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 Journeys extends APIResource {
+  templates: TemplatesAPI.Templates = new TemplatesAPI.Templates(this._client);
+
+  /**
+   * Create a journey. Defaults to `DRAFT` state; pass `state: "PUBLISHED"` to
+   * publish on create. Send nodes are not allowed on `POST`. The standard flow is:
+   * create the journey shell here, add notification templates with
+   * `POST /journeys/{templateId}/templates`, then wire them into the journey with
+   * `PUT /journeys/{templateId}`. Call `POST /journeys/{templateId}/publish` to
+   * publish a draft after the fact.
+   *
+   * @example
+   * ```ts
+   * const journeyResponse = await client.journeys.create({
+   *   name: 'Welcome Journey',
+   *   nodes: [
+   *     {
+   *       id: 'trigger-1',
+   *       type: 'trigger',
+   *       trigger_type: 'api',
+   *     },
+   *     { id: 'send-1', type: 'send' },
+   *   ],
+   *   enabled: true,
+   *   state: 'DRAFT',
+   * });
+   * ```
+   */
+  create(body: JourneyCreateParams, options?: RequestOptions): APIPromise<JourneyResponse> {
+    return this._client.post('/journeys', { body, ...options });
+  }
+
+  /**
+   * Fetch a journey by id. Pass `?version=draft` (default `published`) to retrieve
+   * the working draft, or `?version=vN` to retrieve a historical version.
+   *
+   * @example
+   * ```ts
+   * const journeyResponse = await client.journeys.retrieve('x');
+   * ```
+   */
+  retrieve(
+    templateID: string,
+    query: JourneyRetrieveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<JourneyResponse> {
+    return this._client.get(path`/journeys/${templateID}`, { query, ...options });
+  }
+
+  /**
+   * Get the list of journeys.
+   *
+   * @example
+   * ```ts
+   * const journeysListResponse = await client.journeys.list();
+   * ```
+   */
+  list(
+    query: JourneyListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<JourneysListResponse> {
+    return this._client.get('/journeys', { query, ...options });
+  }
+
+  /**
+   * Archive a journey. Archived journeys cannot be invoked. Existing journey runs
+   * continue to completion.
+   *
+   * @example
+   * ```ts
+   * await client.journeys.archive('x');
+   * ```
+   */
+  archive(templateID: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/journeys/${templateID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Cancel journey runs. The request body must include EXACTLY ONE of
+   * `cancelation_token` (cancels every run associated with the token) or `run_id`
+   * (cancels a single tenant-scoped run). Supplying both or neither returns a `400`.
+   * A `run_id` that does not match a run for the tenant returns `404`. Cancelation
+   * is idempotent: a run that has already finished (`PROCESSED`/`ERROR`) or was
+   * already `CANCELED` is left unchanged and its current status is returned.
+   *
+   * @example
+   * ```ts
+   * const cancelJourneyResponse = await client.journeys.cancel({
+   *   cancelation_token: 'order-1234',
+   * });
+   * ```
+   */
+  cancel(body: JourneyCancelParams, options?: RequestOptions): APIPromise<CancelJourneyResponse> {
+    return this._client.post('/journeys/cancel', { body, ...options });
+  }
+
+  /**
+   * Invoke a journey by id or alias to start a new run. The response includes a
+   * `runId` identifying the run.
+   *
+   * @example
+   * ```ts
+   * const journeysInvokeResponse = await client.journeys.invoke(
+   *   'templateId',
+   *   {
+   *     data: { order_id: 'order-456', amount: 99.99 },
+   *     user_id: 'user-123',
+   *   },
+   * );
+   * ```
+   */
+  invoke(
+    templateID: string,
+    body: JourneyInvokeParams,
+    options?: RequestOptions,
+  ): APIPromise<JourneysInvokeResponse> {
+    return this._client.post(path`/journeys/${templateID}/invoke`, { body, ...options });
+  }
+
+  /**
+   * List published versions of a journey, ordered most recent first.
+   *
+   * @example
+   * ```ts
+   * const journeyVersionsListResponse =
+   *   await client.journeys.listVersions('x');
+   * ```
+   */
+  listVersions(templateID: string, options?: RequestOptions): APIPromise<JourneyVersionsListResponse> {
+    return this._client.get(path`/journeys/${templateID}/versions`, options);
+  }
+
+  /**
+   * Publish the current draft as a new version. Body is optional; pass
+   * `{ "version": "vN" }` to roll back to a prior version instead. Returns 404 if
+   * the journey has no draft to publish.
+   *
+   * @example
+   * ```ts
+   * const journeyResponse = await client.journeys.publish('x');
+   * ```
+   */
+  publish(
+    templateID: string,
+    body: JourneyPublishParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<JourneyResponse> {
+    return this._client.post(path`/journeys/${templateID}/publish`, { body, ...options });
+  }
+
+  /**
+   * Replace the journey draft. Updates the working draft only; call
+   * `POST /journeys/{templateId}/publish` to make it live, or pass
+   * `state: "PUBLISHED"` in this request to publish immediately. Send-node
+   * `template` ids must already exist and be scoped to this journey, and node ids
+   * must not be claimed by another journey.
+   *
+   * @example
+   * ```ts
+   * const journeyResponse = await client.journeys.replace('x', {
+   *   name: 'Welcome Journey v2',
+   *   nodes: [],
+   *   enabled: true,
+   *   state: 'DRAFT',
+   * });
+   * ```
+   */
+  replace(
+    templateID: string,
+    body: JourneyReplaceParams,
+    options?: RequestOptions,
+  ): APIPromise<JourneyResponse> {
+    return this._client.put(path`/journeys/${templateID}`, { body, ...options });
+  }
+}
+
+/**
+ * Request body for `POST /journeys/cancel`. Provide EXACTLY ONE of
+ * `cancelation_token` (cancels every run associated with the token) or `run_id`
+ * (cancels a single tenant-scoped run).
+ */
+export type CancelJourneyRequest = CancelJourneyRequest.ByCancelationToken | CancelJourneyRequest.ByRunID;
+
+export namespace CancelJourneyRequest {
+  export interface ByCancelationToken {
+    cancelation_token: string;
+  }
+
+  export interface ByRunID {
+    run_id: string;
+  }
+}
+
+/**
+ * `202 Accepted` body for `POST /journeys/cancel`, returning the submitted
+ * identifier. When called with `cancelation_token`, returns
+ * `{ cancelation_token }`; when called with `run_id`, returns
+ * `{ run_id, status }`.
+ */
+export type CancelJourneyResponse = CancelJourneyResponse.TokenBranch | CancelJourneyResponse.RunIDBranch;
+
+export namespace CancelJourneyResponse {
+  export interface TokenBranch {
+    cancelation_token: string;
+  }
+
+  export interface RunIDBranch {
+    run_id: string;
+
+    /**
+     * The run's resulting status. `CANCELED` when the run was active and has been
+     * canceled; `PROCESSED` or `ERROR` when the run had already finished and was left
+     * unchanged; `CANCELED` for an already-canceled run.
+     */
+    status: string;
+  }
+}
+
+/**
+ * Request body for creating a journey.
+ */
+export interface CreateJourneyRequest {
+  name: string;
+
+  nodes: Array<JourneyNode>;
+
+  enabled?: boolean;
+
+  /**
+   * Lifecycle state of a journey.
+   */
+  state?: JourneyState;
+}
+
+/**
+ * A journey template representing an automation workflow.
+ */
+export interface Journey {
+  /**
+   * The unique identifier of the journey.
+   */
+  id: string;
+
+  /**
+   * The name of the journey.
+   */
+  name: string;
+
+  /**
+   * The version of the journey (published or draft).
+   */
+  version: 'published' | 'draft';
+
+  /**
+   * ISO 8601 timestamp when the journey was created.
+   */
+  createdAt?: string;
+
+  /**
+   * ISO 8601 timestamp when the journey was last updated.
+   */
+  updatedAt?: string;
+}
+
+/**
+ * Invoke an AI step with `user_prompt` and optional `web_search`. Returns a
+ * structured response conforming to `output_schema`.
+ */
+export interface JourneyAINode {
+  /**
+   * A JSONSchema object (Draft-07-compatible). Validated at runtime by Ajv.
+   */
+  output_schema: { [key: string]: unknown };
+
+  type: 'ai';
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+
+  model?: string;
+
+  user_prompt?: string;
+
+  web_search?: boolean;
+}
+
+/**
+ * Trigger fired when the journey is invoked via the API. The optional `schema`
+ * field is a JSON Schema that validates the invocation payload.
+ */
+export interface JourneyAPIInvokeTriggerNode {
+  trigger_type: 'api-invoke';
+
+  type: 'trigger';
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+
+  /**
+   * A JSONSchema object (Draft-07-compatible). Validated at runtime by Ajv.
+   */
+  schema?: { [key: string]: unknown };
+}
+
+/**
+ * A single condition expressed as a positional tuple of strings.
+ *
+ * - Binary form (3 elements): `[path, operator, value]` where `operator` is one of
+ *   `is equal`, `is not equal`, `contains`, `does not contain`, `starts with`,
+ *   `ends with`, `greater than`, `greater than or equal`, `less than`,
+ *   `less than or equal`.
+ *
+ *   Example: `["user.tier", "is equal", "gold"]`.
+ *
+ * - Unary form (2 elements): `[path, operator]` where `operator` is one of
+ *   `exists`, `does not exist`.
+ *
+ *   Example: `["user.email", "exists"]`.
+ *
+ * The first element is a non-empty dot-path. The second element is the operator
+ * (must come from one of the two operator sets above). For the binary form, the
+ * third element is the comparison value (string). Runtime validation of the
+ * operator value and arity is performed by the backend; SDKs surface this as a
+ * string list.
+ */
+export type JourneyConditionAtom = Array<string>;
+
+/**
+ * A leaf condition group. Exactly one of `AND` or `OR` must be present at runtime;
+ * each is a list of `JourneyConditionAtom` tuples.
+ */
+export interface JourneyConditionGroup {
+  AND?: Array<JourneyConditionAtom>;
+
+  OR?: Array<JourneyConditionAtom>;
+}
+
+/**
+ * A nested condition group. Exactly one of `AND` or `OR` must be present at
+ * runtime; each is a list of `JourneyConditionGroup` items.
+ */
+export interface JourneyConditionNestedGroup {
+  AND?: Array<JourneyConditionGroup>;
+
+  OR?: Array<JourneyConditionGroup>;
+}
+
+/**
+ * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+ * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+ * express "no conditions".
+ */
+export type JourneyConditionsField =
+  | JourneyConditionAtom
+  | JourneyConditionGroup
+  | JourneyConditionNestedGroup;
+
+/**
+ * Pause the journey run for a fixed `duration`.
+ */
+export interface JourneyDelayDurationNode {
+  duration: string;
+
+  mode: 'duration';
+
+  type: 'delay';
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+}
+
+/**
+ * Pause the journey run `until` a specific time.
+ */
+export interface JourneyDelayUntilNode {
+  mode: 'until';
+
+  type: 'delay';
+
+  until: string;
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+}
+
+/**
+ * Terminate the journey run.
+ */
+export interface JourneyExitNode {
+  type: 'exit';
+
+  id?: string;
+}
+
+/**
+ * A/B experiment config for a send node. The recipient is deterministically
+ * bucketed by `bucketingKey` and routed to one of the `variants` in proportion to
+ * its `weight`. Present on a send node INSTEAD OF `message.template`.
+ */
+export interface JourneyExperiment {
+  /**
+   * The value used to deterministically assign a recipient to a variant. Must be
+   * non-empty with no leading or trailing whitespace.
+   */
+  bucketingKey: string;
+
+  /**
+   * Between 2 and 10 weighted template variants.
+   */
+  variants: Array<JourneyExperimentVariant>;
+
+  /**
+   * Unique experiment id (prefixed `exp_`). Omit to have one generated
+   * automatically; when supplied it must be a valid `exp_` id.
+   */
+  id?: string;
+
+  /**
+   * Optional display name for the experiment.
+   */
+  name?: string;
+}
+
+/**
+ * A single weighted variant of an experiment. Variant ids must be unique within
+ * the experiment and the sum of all variant weights must be greater than 0.
+ * Weights are relative (no sum-to-100 requirement) — routing normalizes them
+ * proportionally.
+ */
+export interface JourneyExperimentVariant {
+  id: string;
+
+  /**
+   * The notification template sent for this variant.
+   */
+  templateId: string;
+
+  /**
+   * Relative routing weight. Must be non-negative.
+   */
+  weight: number;
+
+  /**
+   * Optional display name for the variant.
+   */
+  name?: string;
+}
+
+/**
+ * Issue an HTTP GET or DELETE request and merge the response into the journey
+ * state per `merge_strategy`.
+ */
+export interface JourneyFetchGetDeleteNode {
+  /**
+   * Strategy for merging a fetch response into the journey run state.
+   */
+  merge_strategy: JourneyMergeStrategy;
+
+  method: 'get' | 'delete';
+
+  type: 'fetch';
+
+  url: string;
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+
+  headers?: { [key: string]: string };
+
+  query_params?: { [key: string]: string };
+
+  /**
+   * A JSONSchema object (Draft-07-compatible). Validated at runtime by Ajv.
+   */
+  response_schema?: { [key: string]: unknown };
+}
+
+/**
+ * Issue an HTTP POST or PUT request with a `body` and merge the response into the
+ * journey state per `merge_strategy`.
+ */
+export interface JourneyFetchPostPutNode {
+  /**
+   * Strategy for merging a fetch response into the journey run state.
+   */
+  merge_strategy: JourneyMergeStrategy;
+
+  method: 'post' | 'put';
+
+  type: 'fetch';
+
+  url: string;
+
+  id?: string;
+
+  body?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+
+  headers?: { [key: string]: string };
+
+  query_params?: { [key: string]: string };
+
+  /**
+   * A JSONSchema object (Draft-07-compatible). Validated at runtime by Ajv.
+   */
+  response_schema?: { [key: string]: unknown };
+}
+
+/**
+ * Strategy for merging a fetch response into the journey run state.
+ */
+export type JourneyMergeStrategy = 'overwrite' | 'soft-merge' | 'replace' | 'none';
+
+/**
+ * A single node in a journey DAG. Discriminated by `type`, with a secondary
+ * discriminator on some variants (`trigger_type` for trigger, `mode` for delay,
+ * `method` for fetch, `scope` for throttle).
+ */
+export type JourneyNode =
+  | JourneyAPIInvokeTriggerNode
+  | JourneySegmentTriggerNode
+  | JourneySendNode
+  | JourneyDelayDurationNode
+  | JourneyDelayUntilNode
+  | JourneyFetchGetDeleteNode
+  | JourneyFetchPostPutNode
+  | JourneyAINode
+  | JourneyThrottleStaticNode
+  | JourneyThrottleDynamicNode
+  | JourneyNode.JourneyBatchNode
+  | JourneyNode.JourneyAddToDigestNode
+  | JourneyExitNode
+  | JourneyNode.JourneyBranchNode;
+
+export namespace JourneyNode {
+  /**
+   * Collect events arriving at the node into a single batch and fire one downstream
+   * step with the aggregated payload. The first event into a batch owns the run;
+   * later contributing events terminate at the batch step. The batch releases when
+   * any of `max_items` is reached, a quiet window of `wait_period` elapses, or the
+   * `max_wait_period` ceiling hits.
+   */
+  export interface JourneyBatchNode {
+    /**
+     * ISO 8601 duration. Hard ceiling from the first event into the batch; releases
+     * the batch unconditionally when it elapses.
+     */
+    max_wait_period: string;
+
+    /**
+     * How to select which collected events to retain in the aggregated payload when
+     * the batch releases.
+     */
+    retain: JourneyBatchNode.Retain;
+
+    scope: 'user';
+
+    type: 'batch';
+
+    /**
+     * ISO 8601 duration. Quiet window that releases the batch when it elapses with no
+     * new contributing events. Must be less than `max_wait_period`.
+     */
+    wait_period: string;
+
+    id?: string;
+
+    /**
+     * Optional partition key. Events with the same `category_key` are batched
+     * together; events with different values are batched separately.
+     */
+    category_key?: string;
+
+    /**
+     * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+     * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+     * express "no conditions".
+     */
+    conditions?: JourneysAPI.JourneyConditionsField;
+
+    /**
+     * Releases the batch once this many events have been collected.
+     */
+    max_items?: number;
+  }
+
+  export namespace JourneyBatchNode {
+    /**
+     * How to select which collected events to retain in the aggregated payload when
+     * the batch releases.
+     */
+    export interface Retain {
+      count: number;
+
+      type: 'first' | 'last' | 'highest' | 'lowest';
+
+      /**
+       * Dot-path into the event payload (e.g. `data.priority`). Required when `type` is
+       * `highest` or `lowest`.
+       */
+      sort_key?: string;
+    }
+  }
+
+  /**
+   * Add the current event to a digest keyed by the given subscription topic. The
+   * digest accumulates events and releases them on the schedule configured for the
+   * topic.
+   */
+  export interface JourneyAddToDigestNode {
+    /**
+     * The subscription topic that owns the digest the event is added to.
+     */
+    subscription_topic_id: string;
+
+    type: 'add-to-digest';
+
+    id?: string;
+
+    /**
+     * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+     * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+     * express "no conditions".
+     */
+    conditions?: JourneysAPI.JourneyConditionsField;
+  }
+
+  /**
+   * Branch node. Routes to the first entry in `paths[]` whose `conditions` match,
+   * else falls through to `default.nodes`.
+   */
+  export interface JourneyBranchNode {
+    default: JourneyBranchNode.Default;
+
+    paths: Array<JourneyBranchNode.Path>;
+
+    type: 'branch';
+
+    id?: string;
+  }
+
+  export namespace JourneyBranchNode {
+    export interface Default {
+      nodes: Array<JourneysAPI.JourneyNode>;
+
+      label?: string;
+    }
+
+    export interface Path {
+      /**
+       * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+       * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+       * express "no conditions".
+       */
+      conditions: JourneysAPI.JourneyConditionsField;
+
+      nodes: Array<JourneysAPI.JourneyNode>;
+
+      label?: string;
+    }
+  }
+}
+
+/**
+ * Request body for publishing a journey. Pass `version` to roll back to a prior
+ * version; omit to publish the current draft.
+ */
+export interface JourneyPublishRequest {
+  version?: string;
+}
+
+/**
+ * A journey, with its current draft or published nodes and metadata.
+ */
+export interface JourneyResponse {
+  id: string;
+
+  created: number | null;
+
+  creator: string | null;
+
+  enabled: boolean;
+
+  name: string;
+
+  nodes: Array<JourneyNode>;
+
+  published: number | null;
+
+  /**
+   * Lifecycle state of a journey.
+   */
+  state: JourneyState;
+
+  updated: number | null;
+
+  updater: string | null;
+}
+
+/**
+ * Trigger fired by a segment event (`identify`, `group`, or `track`).
+ */
+export interface JourneySegmentTriggerNode {
+  request_type: 'identify' | 'group' | 'track';
+
+  trigger_type: 'segment';
+
+  type: 'trigger';
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+
+  event_id?: string;
+}
+
+/**
+ * Send to the recipient. A send node sources its content from EXACTLY ONE of
+ * `message.template` (a single notification template) or `experiment` (an A/B
+ * split across weighted template variants) — supplying both, or neither, is
+ * rejected. Optionally override the recipient address, delay the send, or attach
+ * `data`.
+ */
+export interface JourneySendNode {
+  message: JourneySendNode.Message;
+
+  type: 'send';
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+
+  /**
+   * A/B experiment config for a send node. The recipient is deterministically
+   * bucketed by `bucketingKey` and routed to one of the `variants` in proportion to
+   * its `weight`. Present on a send node INSTEAD OF `message.template`.
+   */
+  experiment?: JourneyExperiment;
+}
+
+export namespace JourneySendNode {
+  export interface Message {
+    data?: { [key: string]: unknown };
+
+    delay?: Message.Delay;
+
+    template?: string;
+
+    to?: Message.To;
+  }
+
+  export namespace Message {
+    export interface Delay {
+      until: string;
+
+      timezone?: string;
+    }
+
+    export interface To {
+      email_override?: string;
+
+      phone_number_override?: string;
+
+      user_id_override?: string;
+    }
+  }
+}
+
+/**
+ * Lifecycle state of a journey.
+ */
+export type JourneyState = 'DRAFT' | 'PUBLISHED';
+
+/**
+ * Request body for creating a notification template scoped to a journey.
+ */
+export interface JourneyTemplateCreateRequest {
+  channel: string;
+
+  notification: JourneyTemplateCreateRequest.Notification;
+
+  providerKey?: string;
+
+  state?: string;
+}
+
+export namespace JourneyTemplateCreateRequest {
+  export interface Notification {
+    brand: Notification.Brand | null;
+
+    content: Notification.Content;
+
+    name: string;
+
+    subscription: Notification.Subscription | null;
+
+    tags: Array<string>;
+  }
+
+  export namespace Notification {
+    export interface Brand {
+      id: string;
+    }
+
+    export interface Content {
+      elements: Array<Shared.ElementalNode>;
+
+      version: '2022-01-01';
+
+      scope?: 'default' | 'strict';
+    }
+
+    export interface Subscription {
+      topic_id: string;
+    }
+  }
+}
+
+/**
+ * A journey-scoped notification template.
+ */
+export interface JourneyTemplateGetResponse {
+  id: string;
+
+  brand: JourneyTemplateGetResponse.Brand | null;
+
+  content: JourneyTemplateGetResponse.Content;
+
+  created: number;
+
+  creator: string;
+
+  name: string;
+
+  state: 'DRAFT' | 'PUBLISHED';
+
+  subscription: JourneyTemplateGetResponse.Subscription | null;
+
+  tags: Array<string>;
+
+  updated?: number;
+
+  updater?: string;
+}
+
+export namespace JourneyTemplateGetResponse {
+  export interface Brand {
+    id: string;
+  }
+
+  export interface Content {
+    elements: Array<Shared.ElementalNode>;
+
+    version: '2022-01-01';
+
+    scope?: 'default' | 'strict';
+  }
+
+  export interface Subscription {
+    topic_id: string;
+  }
+}
+
+/**
+ * Paged list of journey-scoped notification templates.
+ */
+export interface JourneyTemplateListResponse {
+  paging: Shared.Paging;
+
+  results: Array<JourneyTemplateSummary>;
+}
+
+/**
+ * Request body for publishing a journey-scoped notification template. Pass
+ * `version` to roll back to a prior version; omit to publish the current draft.
+ */
+export interface JourneyTemplatePublishRequest {
+  version?: string;
+}
+
+/**
+ * Request body for replacing a journey-scoped notification template draft.
+ */
+export interface JourneyTemplateReplaceRequest {
+  notification: JourneyTemplateReplaceRequest.Notification;
+
+  state?: string;
+}
+
+export namespace JourneyTemplateReplaceRequest {
+  export interface Notification {
+    brand: Notification.Brand | null;
+
+    content: Notification.Content;
+
+    name: string;
+
+    subscription: Notification.Subscription | null;
+
+    tags: Array<string>;
+  }
+
+  export namespace Notification {
+    export interface Brand {
+      id: string;
+    }
+
+    export interface Content {
+      elements: Array<Shared.ElementalNode>;
+
+      version: '2022-01-01';
+
+      scope?: 'default' | 'strict';
+    }
+
+    export interface Subscription {
+      topic_id: string;
+    }
+  }
+}
+
+/**
+ * Summary fields of a journey-scoped notification template returned in list
+ * responses.
+ */
+export interface JourneyTemplateSummary {
+  id: string;
+
+  created: number;
+
+  creator: string;
+
+  name: string;
+
+  state: string;
+
+  tags: Array<string>;
+
+  updated?: number;
+
+  updater?: string;
+}
+
+/**
+ * Throttle the journey by a dynamic `throttle_key`, allowing at most `max_allowed`
+ * invocations per `period`.
+ */
+export interface JourneyThrottleDynamicNode {
+  max_allowed: number;
+
+  period: string;
+
+  scope: 'dynamic';
+
+  throttle_key: string;
+
+  type: 'throttle';
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+}
+
+/**
+ * Throttle the journey by a static `scope` (`user` or `global`), allowing at most
+ * `max_allowed` invocations per `period`.
+ */
+export interface JourneyThrottleStaticNode {
+  max_allowed: number;
+
+  period: string;
+
+  scope: 'user' | 'global';
+
+  type: 'throttle';
+
+  id?: string;
+
+  /**
+   * Condition spec for a journey node. Accepts a single condition atom, an AND/OR
+   * group, or an AND/OR nested group. Omit the `conditions` property entirely to
+   * express "no conditions".
+   */
+  conditions?: JourneyConditionsField;
+}
+
+/**
+ * A published version of a journey.
+ */
+export interface JourneyVersionItem {
+  created: number | null;
+
+  creator: string | null;
+
+  name: string;
+
+  published: number | null;
+
+  version: string;
+}
+
+/**
+ * Paged list of published journey versions, most recent first.
+ */
+export interface JourneyVersionsListResponse {
+  paging: Shared.Paging;
+
+  results: Array<JourneyVersionItem>;
+}
+
+/**
+ * Request body for invoking a journey. Requires either a user identifier or a
+ * profile with contact information. User identifiers can be provided via user_id
+ * field, or resolved from profile/data objects (user_id, userId, or anonymousId
+ * fields).
+ */
+export interface JourneysInvokeRequest {
+  /**
+   * Data payload passed to the journey. The expected shape can be predefined using
+   * the schema builder in the journey editor. This data is available in journey
+   * steps for condition evaluation and template variable interpolation. Can also
+   * contain user identifiers (user_id, userId, anonymousId) if not provided
+   * elsewhere.
+   */
+  data?: { [key: string]: unknown };
+
+  /**
+   * Profile data for the user. Can contain contact information (email,
+   * phone_number), user identifiers (user_id, userId, anonymousId), or any custom
+   * profile fields. Profile fields are merged with any existing stored profile for
+   * the user. Include context.tenant_id to load a tenant-scoped profile for
+   * multi-tenant scenarios.
+   */
+  profile?: { [key: string]: unknown };
+
+  /**
+   * A unique identifier for the user. If not provided, the system will attempt to
+   * resolve the user identifier from profile or data objects.
+   */
+  user_id?: string;
+}
+
+export interface JourneysInvokeResponse {
+  /**
+   * A unique identifier for the journey run that was created.
+   */
+  runId: string;
+}
+
+export interface JourneysListResponse {
+  /**
+   * A cursor token for pagination. Present when there are more results available.
+   */
+  cursor?: string;
+
+  templates?: Array<Journey>;
+}
+
+export interface JourneyCreateParams {
+  name: string;
+
+  nodes: Array<JourneyNode>;
+
+  enabled?: boolean;
+
+  /**
+   * Lifecycle state of a journey.
+   */
+  state?: JourneyState;
+}
+
+export interface JourneyRetrieveParams {
+  /**
+   * Version selector: `draft`, `published` (default), or `vN`.
+   */
+  version?: string;
+}
+
+export interface JourneyListParams {
+  /**
+   * A cursor token for pagination. Use the cursor from the previous response to
+   * fetch the next page of results.
+   */
+  cursor?: string;
+
+  /**
+   * The version of journeys to retrieve. Accepted values are published (for
+   * published journeys) or draft (for draft journeys). Defaults to published.
+   */
+  version?: 'published' | 'draft';
+}
+
+export type JourneyCancelParams = JourneyCancelParams.ByCancelationToken | JourneyCancelParams.ByRunID;
+
+export declare namespace JourneyCancelParams {
+  export interface ByCancelationToken {
+    cancelation_token: string;
+  }
+
+  export interface ByRunID {
+    run_id: string;
+  }
+}
+
+export interface JourneyInvokeParams {
+  /**
+   * Data payload passed to the journey. The expected shape can be predefined using
+   * the schema builder in the journey editor. This data is available in journey
+   * steps for condition evaluation and template variable interpolation. Can also
+   * contain user identifiers (user_id, userId, anonymousId) if not provided
+   * elsewhere.
+   */
+  data?: { [key: string]: unknown };
+
+  /**
+   * Profile data for the user. Can contain contact information (email,
+   * phone_number), user identifiers (user_id, userId, anonymousId), or any custom
+   * profile fields. Profile fields are merged with any existing stored profile for
+   * the user. Include context.tenant_id to load a tenant-scoped profile for
+   * multi-tenant scenarios.
+   */
+  profile?: { [key: string]: unknown };
+
+  /**
+   * A unique identifier for the user. If not provided, the system will attempt to
+   * resolve the user identifier from profile or data objects.
+   */
+  user_id?: string;
+}
+
+export interface JourneyPublishParams {
+  version?: string;
+}
+
+export interface JourneyReplaceParams {
+  name: string;
+
+  nodes: Array<JourneyNode>;
+
+  enabled?: boolean;
+
+  /**
+   * Lifecycle state of a journey.
+   */
+  state?: JourneyState;
+}
+
+Journeys.Templates = Templates;
+
+export declare namespace Journeys {
+  export {
+    type CancelJourneyRequest as CancelJourneyRequest,
+    type CancelJourneyResponse as CancelJourneyResponse,
+    type CreateJourneyRequest as CreateJourneyRequest,
+    type Journey as Journey,
+    type JourneyAINode as JourneyAINode,
+    type JourneyAPIInvokeTriggerNode as JourneyAPIInvokeTriggerNode,
+    type JourneyConditionAtom as JourneyConditionAtom,
+    type JourneyConditionGroup as JourneyConditionGroup,
+    type JourneyConditionNestedGroup as JourneyConditionNestedGroup,
+    type JourneyConditionsField as JourneyConditionsField,
+    type JourneyDelayDurationNode as JourneyDelayDurationNode,
+    type JourneyDelayUntilNode as JourneyDelayUntilNode,
+    type JourneyExitNode as JourneyExitNode,
+    type JourneyExperiment as JourneyExperiment,
+    type JourneyExperimentVariant as JourneyExperimentVariant,
+    type JourneyFetchGetDeleteNode as JourneyFetchGetDeleteNode,
+    type JourneyFetchPostPutNode as JourneyFetchPostPutNode,
+    type JourneyMergeStrategy as JourneyMergeStrategy,
+    type JourneyNode as JourneyNode,
+    type JourneyPublishRequest as JourneyPublishRequest,
+    type JourneyResponse as JourneyResponse,
+    type JourneySegmentTriggerNode as JourneySegmentTriggerNode,
+    type JourneySendNode as JourneySendNode,
+    type JourneyState as JourneyState,
+    type JourneyTemplateCreateRequest as JourneyTemplateCreateRequest,
+    type JourneyTemplateGetResponse as JourneyTemplateGetResponse,
+    type JourneyTemplateListResponse as JourneyTemplateListResponse,
+    type JourneyTemplatePublishRequest as JourneyTemplatePublishRequest,
+    type JourneyTemplateReplaceRequest as JourneyTemplateReplaceRequest,
+    type JourneyTemplateSummary as JourneyTemplateSummary,
+    type JourneyThrottleDynamicNode as JourneyThrottleDynamicNode,
+    type JourneyThrottleStaticNode as JourneyThrottleStaticNode,
+    type JourneyVersionItem as JourneyVersionItem,
+    type JourneyVersionsListResponse as JourneyVersionsListResponse,
+    type JourneysInvokeRequest as JourneysInvokeRequest,
+    type JourneysInvokeResponse as JourneysInvokeResponse,
+    type JourneysListResponse as JourneysListResponse,
+    type JourneyCreateParams as JourneyCreateParams,
+    type JourneyRetrieveParams as JourneyRetrieveParams,
+    type JourneyListParams as JourneyListParams,
+    type JourneyCancelParams as JourneyCancelParams,
+    type JourneyInvokeParams as JourneyInvokeParams,
+    type JourneyPublishParams as JourneyPublishParams,
+    type JourneyReplaceParams as JourneyReplaceParams,
+  };
+
+  export {
+    Templates as Templates,
+    type TemplateCreateParams as TemplateCreateParams,
+    type TemplateRetrieveParams as TemplateRetrieveParams,
+    type TemplateListParams as TemplateListParams,
+    type TemplateArchiveParams as TemplateArchiveParams,
+    type TemplateListVersionsParams as TemplateListVersionsParams,
+    type TemplatePublishParams as TemplatePublishParams,
+    type TemplatePutContentParams as TemplatePutContentParams,
+    type TemplatePutLocaleParams as TemplatePutLocaleParams,
+    type TemplateReplaceParams as TemplateReplaceParams,
+    type TemplateRetrieveContentParams as TemplateRetrieveContentParams,
+  };
+}