picked 0.0.101-next.2 → 0.0.101

package/docs/reference/management-api/schema/experience.md

@@ -0,0 +1,1098 @@
+---
+type: reference
+layout: docs
+generated: true
+---
+
+# Experience schema
+
+The operations and types that `experience.graphql` adds to the Management API. See [Management API schema](/reference/management-api/schema) for every domain, the endpoint and authentication.
+
+## Queries
+
+### `experience`
+
+Get an experience by ID within a workspace.
+
+```graphql
+experience(id: ID!, workspaceId: ID!): Experience @auth
+```
+
+### `experiences`
+
+List experiences within a workspace. Filter by name with `search` (case-insensitive
+substring) and order with `sortKey` (default `NAME`) plus `reverse`.
+
+```graphql
+experiences(workspaceId: ID!, type: ExperienceType, first: Int, after: String, last: Int, before: String, search: String, sortKey: ExperienceSortKeys = NAME, reverse: Boolean = false): ExperienceConnection! @auth
+```
+
+## Mutations
+
+### `experienceCreate`
+
+Create a new experience. Requires scope: `ORGANIZATION_PROJECTS_UPDATE`.
+
+```graphql
+experienceCreate(input: ExperienceCreateInput!): ExperienceCreatePayload! @auth
+```
+
+### `experienceUpdate`
+
+Update an experience. Requires scope: `ORGANIZATION_PROJECTS_UPDATE`.
+
+```graphql
+experienceUpdate(input: ExperienceUpdateInput!): ExperienceUpdatePayload! @auth
+```
+
+### `experienceDelete`
+
+Delete an experience. Requires scope: `ORGANIZATION_PROJECTS_UPDATE`.
+
+```graphql
+experienceDelete(input: ExperienceDeleteInput!): ExperienceDeletePayload! @auth
+```
+
+### `experienceFlowUpdate`
+
+Atomically save all changes to an experience flow. Requires scope: `ORGANIZATION_PROJECTS_UPDATE`.
+
+```graphql
+experienceFlowUpdate(input: ExperienceFlowUpdateInput!): ExperienceFlowUpdatePayload! @auth
+```
+
+## Types
+
+### `ExperienceNodeType`
+
+```graphql
+"""Discriminator for `ExperienceNode` implementations."""
+enum ExperienceNodeType {
+  """The starting point of every flow graph. Exactly one per experience."""
+  ORIGIN
+  """A node that renders a step (UI)."""
+  STEP
+  """A node that evaluates a condition for branching."""
+  CONDITION
+  """A node that triggers an action (side effect)."""
+  ACTION
+  """A node that launches another experience."""
+  EXPERIENCE
+}
+```
+
+### `ExperienceEdgeHandle`
+
+```graphql
+"""
+Edge handle for `ConditionNode` outgoing edges. Picks which branch of a
+condition the flow follows when the condition resolves true / false.
+"""
+enum ExperienceEdgeHandle {
+  """The TRUE branch of a `ConditionNode`."""
+  TRUE
+  """The FALSE branch of a `ConditionNode`."""
+  FALSE
+}
+```
+
+### `Position`
+
+```graphql
+"""
+Position of a node on the flow graph canvas. Used purely for layout in the dashboard editor.
+"""
+type Position {
+  """X coordinate (canvas units, can be negative)."""
+  x: Float!
+  """Y coordinate (canvas units, can be negative)."""
+  y: Float!
+}
+```
+
+### `PositionInput`
+
+```graphql
+"""Input form of `Position`."""
+input PositionInput {
+  """X coordinate."""
+  x: Float!
+  """Y coordinate."""
+  y: Float!
+}
+```
+
+### `ExperienceTargetPlacement`
+
+```graphql
+"""
+Where the experience content is placed relative to the target DOM element.
+
+`REPLACE` swaps the target node out. `APPEND` / `PREPEND` add children
+inside the target. `BEFORE` / `AFTER` insert siblings around the target.
+"""
+enum ExperienceTargetPlacement {
+  REPLACE
+  APPEND
+  PREPEND
+  BEFORE
+  AFTER
+}
+```
+
+### `ExperienceTarget`
+
+```graphql
+"""
+A DOM target element and how the experience content is placed relative to it.
+"""
+type ExperienceTarget {
+  """CSS selector identifying the target DOM element."""
+  selector: String!
+  """How the experience content is placed relative to the target element."""
+  placement: ExperienceTargetPlacement!
+}
+```
+
+### `ExperienceTargetInput`
+
+```graphql
+"""Input form of `ExperienceTarget`."""
+input ExperienceTargetInput {
+  """CSS selector for the target DOM element."""
+  selector: String!
+  """How the experience content is placed relative to the target element."""
+  placement: ExperienceTargetPlacement!
+}
+```
+
+### `ExperienceType`
+
+```graphql
+"""
+Experience kind discriminator.
+
+`FLOW` is a multi-step user journey driven by a flow graph. `PAGE` is a
+CMS-backed dynamic landing page with a single auto-created step.
+Mutations branch on this discriminator at create time.
+"""
+enum ExperienceType {
+  """Multi-step user journey driven by a flow graph."""
+  FLOW
+  """CMS-backed dynamic landing page with a single auto-created step."""
+  PAGE
+}
+```
+
+### `ExperienceStatus`
+
+```graphql
+"""
+Delivery status for an experience.
+
+`ACTIVE` is delivered to every request. `DRAFT` is omitted from the published
+payload, along with the steps, fields and actions only it references, and
+delivered only to a request carrying a valid preview token for the owning
+workspace.
+
+Status is captured in the published snapshot, so a change takes effect once the
+workspace is published again.
+"""
+enum ExperienceStatus {
+  """Delivered to every request."""
+  ACTIVE
+  """Delivered only behind a valid preview token."""
+  DRAFT
+}
+```
+
+### `Experience`
+
+```graphql
+"""
+An experience defines a user journey within a workspace. The flow graph
+is stored opaquely in `flowJson` and exposed structurally via `nodes` and
+`edges`.
+
+`targets` selects which DOM elements the experience attaches to. `key`
+is a stable identifier SDK consumers use to opt in to specific
+experiences. `condition` is a JSON Logic expression gating whether the
+experience renders at all.
+"""
+type Experience {
+  """Unique experience identifier."""
+  id: ID!
+  """Display name of the experience."""
+  name: String!
+  """DOM elements this experience attaches to, with placement strategy."""
+  targets: [ExperienceTarget!]!
+  """Stable, human-readable key for SDK consumers."""
+  key: String!
+  """
+  Discriminator: `FLOW` (multi-step journey) or `PAGE` (CMS-backed landing).
+  """
+  type: ExperienceType!
+  """
+  Delivery status: `ACTIVE` to everyone, `DRAFT` only behind a valid preview token.
+  """
+  status: ExperienceStatus!
+  """Opaque flow graph blob. Use `nodes` + `edges` for structured access."""
+  flowJson: JSON
+  """Optional JSON Logic condition gating whether the experience renders."""
+  condition: JSON
+  """
+  JSON value controlling whether the experience initialises in an open state.
+  """
+  initializeOpen: JSON
+  """
+  Name of the React/Svelte component the SDK should render for this experience.
+  """
+  componentName: String!
+  """The workspace this experience belongs to."""
+  workspace: Workspace!
+  """Nodes in the flow graph, typed by their `__typename`."""
+  nodes: [ExperienceNode!]!
+  """Edges in the flow graph connecting nodes."""
+  edges: [ExperienceEdge!]!
+  """All steps referenced by `STEP` nodes in this experience's flow."""
+  steps: [Step!]!
+  """
+  All conditions referenced by `CONDITION` nodes in this experience's flow.
+  """
+  conditions: [Condition!]!
+  """All actions referenced by `ACTION` nodes in this experience's flow."""
+  actions: [Action!]!
+  """When this experience was created."""
+  createdAt: DateTime!
+  """When this experience was last updated."""
+  updatedAt: DateTime!
+}
+```
+
+### `ExperienceConnection`
+
+```graphql
+"""
+Relay-style connection of experiences, with both an `edges` list and a flat `nodes` accessor.
+"""
+type ExperienceConnection {
+  """List of experience edges."""
+  edges: [ExperienceConnectionEdge!]!
+  """
+  Flat list of experiences, equivalent to `edges[].node`. Convenience accessor.
+  """
+  nodes: [Experience!]!
+  """Pagination metadata."""
+  pageInfo: PageInfo!
+  """Total number of experiences."""
+  totalCount: Int!
+}
+```
+
+### `ExperienceConnectionEdge`
+
+```graphql
+"""Edge type for `ExperienceConnection`."""
+type ExperienceConnectionEdge {
+  """Pagination cursor for this edge."""
+  cursor: String!
+  """The experience."""
+  node: Experience!
+}
+```
+
+### `ExperienceNode`
+
+```graphql
+"""
+A node in the experience flow graph. Use `__typename` to discriminate the implementation.
+"""
+interface ExperienceNode {
+  """Stable node identifier within the graph."""
+  id: ID!
+  """Node kind discriminator (also encoded in `__typename`)."""
+  type: ExperienceNodeType!
+  """Canvas position for the dashboard editor."""
+  position: Position!
+}
+```
+
+### `OriginNode`
+
+```graphql
+"""Starting point of an experience flow. Exactly one per experience."""
+type OriginNode implements ExperienceNode {
+  id: ID!
+  type: ExperienceNodeType!
+  position: Position!
+}
+```
+
+### `StepNode`
+
+```graphql
+"""A node that renders a step's UI."""
+type StepNode implements ExperienceNode {
+  id: ID!
+  type: ExperienceNodeType!
+  position: Position!
+  """The step rendered when the flow reaches this node."""
+  step: Step!
+}
+```
+
+### `ConditionNode`
+
+```graphql
+"""
+A node that evaluates a condition for branching. Outgoing edges carry `sourceHandle: TRUE | FALSE`.
+"""
+type ConditionNode implements ExperienceNode {
+  id: ID!
+  type: ExperienceNodeType!
+  position: Position!
+  """The condition evaluated when the flow reaches this node."""
+  condition: Condition!
+}
+```
+
+### `ActionNode`
+
+```graphql
+"""A node that triggers an action (side effect)."""
+type ActionNode implements ExperienceNode {
+  id: ID!
+  type: ExperienceNodeType!
+  position: Position!
+  """The action triggered when the flow reaches this node."""
+  action: Action!
+}
+```
+
+### `LaunchExperienceNode`
+
+```graphql
+"""A node that launches another experience. Used to compose experiences."""
+type LaunchExperienceNode implements ExperienceNode {
+  id: ID!
+  type: ExperienceNodeType!
+  position: Position!
+  """The experience launched when the flow reaches this node."""
+  targetExperience: Experience!
+}
+```
+
+### `ExperienceEdge`
+
+```graphql
+"""An edge connecting two nodes in the experience flow graph."""
+type ExperienceEdge {
+  """Stable edge identifier within the graph."""
+  id: ID!
+  """Source node (resolved)."""
+  sourceNode: ExperienceNode!
+  """Destination node (resolved)."""
+  destinationNode: ExperienceNode!
+  """Source node id (denormalised)."""
+  sourceNodeId: ID!
+  """Destination node id (denormalised)."""
+  destinationNodeId: ID!
+  """
+  Only meaningful when the source is a `ConditionNode` — picks the TRUE / FALSE branch.
+  """
+  sourceHandle: ExperienceEdgeHandle
+}
+```
+
+### `ExperienceNodeInput`
+
+```graphql
+"""
+Input form of a node in the flow graph. Only the field matching the node's `type` should be populated.
+"""
+input ExperienceNodeInput {
+  """Stable node identifier."""
+  id: ID!
+  """Node kind discriminator."""
+  type: ExperienceNodeType!
+  """Canvas position."""
+  position: PositionInput!
+  """For STEP nodes: referenced step id."""
+  stepId: ID
+  """For CONDITION nodes: referenced condition id."""
+  conditionId: ID
+  """For ACTION nodes: referenced action id."""
+  actionId: ID
+  """For EXPERIENCE nodes: referenced experience id to launch."""
+  targetExperienceId: ID
+}
+```
+
+### `ExperienceEdgeInput`
+
+```graphql
+"""Input form of an edge in the flow graph."""
+input ExperienceEdgeInput {
+  """Stable edge identifier."""
+  id: ID!
+  """Source node id."""
+  sourceNodeId: ID!
+  """Destination node id."""
+  destinationNodeId: ID!
+  """For edges from a `ConditionNode`: which branch (TRUE / FALSE)."""
+  sourceHandle: ExperienceEdgeHandle
+}
+```
+
+### `ExperienceCreateInput`
+
+```graphql
+"""Input for `experienceCreate`."""
+input ExperienceCreateInput {
+  """Workspace ID to create the experience in."""
+  workspaceId: ID!
+  """Display name for the experience."""
+  name: String!
+  """Stable, human-readable key for SDK consumers."""
+  key: String!
+  """
+  Discriminator. `PAGE` auto-creates the singleton Step; `FLOW` uses the caller-supplied nodes / edges.
+  """
+  type: ExperienceType
+  """Delivery status. Defaults to `ACTIVE`."""
+  status: ExperienceStatus
+  """Optional JSON Logic condition gating whether the experience renders."""
+  condition: JSON
+  """Whether the experience should initialise in an open state."""
+  initializeOpen: JSON
+  """Name of the React/Svelte component the SDK should render."""
+  componentName: String
+  """
+  Targeting configuration — which DOM elements the experience attaches to.
+  """
+  targets: [ExperienceTargetInput!]
+  """Initial flow graph nodes."""
+  nodes: [ExperienceNodeInput!]
+  """Initial flow graph edges."""
+  edges: [ExperienceEdgeInput!]
+}
+```
+
+### `ExperienceCreatePayload`
+
+```graphql
+"""Payload returned by `experienceCreate`."""
+type ExperienceCreatePayload {
+  """The created experience."""
+  experience: Experience
+}
+```
+
+### `ExperienceUpdateInput`
+
+```graphql
+"""Input for `experienceUpdate`. Omit a field to leave it unchanged."""
+input ExperienceUpdateInput {
+  """Experience ID."""
+  id: ID!
+  """New display name."""
+  name: String
+  """New delivery status."""
+  status: ExperienceStatus
+  """New JSON Logic condition gating whether the experience renders."""
+  condition: JSON
+  """Whether the experience should initialise in an open state."""
+  initializeOpen: JSON
+  """New component name."""
+  componentName: String
+  """New targeting configuration."""
+  targets: [ExperienceTargetInput!]
+}
+```
+
+### `ExperienceUpdatePayload`
+
+```graphql
+"""Payload returned by `experienceUpdate`."""
+type ExperienceUpdatePayload {
+  """The updated experience."""
+  experience: Experience
+}
+```
+
+### `ExperienceDeleteInput`
+
+```graphql
+"""Input for `experienceDelete`."""
+input ExperienceDeleteInput {
+  """Experience ID."""
+  id: ID!
+}
+```
+
+### `ExperienceDeletePayload`
+
+```graphql
+"""Payload returned by `experienceDelete`."""
+type ExperienceDeletePayload {
+  """ID of the deleted experience."""
+  deletedExperienceId: ID
+}
+```
+
+### `ExperienceFlowUpdateInput`
+
+```graphql
+"""
+Atomically save all changes to an experience flow in a single
+operation. Handles creation, updates, and deletion of nodes, edges,
+steps, conditions, actions, and fields.
+
+Set `allowPartialSuccess: true` to persist valid changes even when some
+fail validation; the failures appear in `errors` while successful
+changes are committed. Default (`false`) treats the operation as
+all-or-nothing.
+"""
+input ExperienceFlowUpdateInput {
+  """New display name."""
+  name: String
+  """New delivery status."""
+  status: ExperienceStatus
+  """New JSON Logic condition gating whether the experience renders."""
+  condition: JSON
+  """Whether the experience should initialise in an open state."""
+  initializeOpen: JSON
+  """New component name."""
+  componentName: String
+  """New targeting configuration."""
+  targets: [ExperienceTargetInput!]
+  """The experience to update."""
+  experienceId: ID!
+  """All changes to apply to the experience flow."""
+  changes: ExperienceFlowChangesInput!
+  """
+  When true, valid changes are persisted even if some fail validation. When false (default), the entire operation fails if any change fails.
+  """
+  allowPartialSuccess: Boolean = false
+}
+```
+
+### `ExperienceFlowChangesInput`
+
+```graphql
+"""Container for all change operations grouped by entity type."""
+input ExperienceFlowChangesInput {
+  """Step changes (workspace-level resources)."""
+  steps: StepChangesInput
+  """Condition changes (workspace-level resources)."""
+  conditions: ConditionChangesInput
+  """Action changes (workspace-level resources)."""
+  actions: ActionChangesInput
+  """Field changes (workspace-level resources)."""
+  fields: FieldChangesInput
+  """Node changes in the flow graph."""
+  nodes: ExperienceNodeChangesInput
+  """Edge changes connecting nodes."""
+  edges: ExperienceEdgeChangesInput
+}
+```
+
+### `StepChangesInput`
+
+```graphql
+"""Step-level changes within an `experienceFlowUpdate` batch."""
+input StepChangesInput {
+  """
+  Steps to create. Each entry carries a `clientId` for cross-referencing from `nodes`.
+  """
+  create: [StepCreateData!]
+  """Steps to update."""
+  update: [StepUpdateData!]
+  """Step ids to delete."""
+  delete: [ID!]
+}
+```
+
+### `StepCreateData`
+
+```graphql
+"""Data for creating a new step in the parent workspace."""
+input StepCreateData {
+  """Client-generated ID for mapping and cross-referencing."""
+  clientId: ID!
+  """Display name for the step."""
+  name: String!
+  """Unique key identifier for the step."""
+  key: String!
+  """Optional description."""
+  description: String
+  """Layout name."""
+  layoutName: String
+  """IDs of existing workspace-level fields to reference."""
+  fieldIds: [ID!]
+  """Step content configuration (free-form JSON)."""
+  content: JSON
+  """
+  ID of an existing step. When set, the create acts as an idempotent upsert against the existing step.
+  """
+  stepId: ID
+}
+```
+
+### `StepUpdateData`
+
+```graphql
+"""Data for updating an existing step."""
+input StepUpdateData {
+  """Step ID."""
+  id: ID!
+  """New display name."""
+  name: String
+  """New description."""
+  description: String
+  """New layout name."""
+  layoutName: String
+  """New field-id list (replaces the existing list when set)."""
+  fieldIds: [ID!]
+  """New step content configuration."""
+  content: JSON
+}
+```
+
+### `ConditionChangesInput`
+
+```graphql
+"""Condition-level changes within an `experienceFlowUpdate` batch."""
+input ConditionChangesInput {
+  """
+  Conditions to create. Each entry carries a `clientId` for cross-referencing from `nodes`.
+  """
+  create: [ConditionCreateData!]
+  """Conditions to update."""
+  update: [ConditionUpdateData!]
+  """Condition ids to delete."""
+  delete: [ID!]
+}
+```
+
+### `ConditionCreateData`
+
+```graphql
+"""Data for creating a new condition."""
+input ConditionCreateData {
+  """Client-generated ID for mapping and cross-referencing."""
+  clientId: ID!
+  """Display name for the condition."""
+  name: String!
+  """Unique key identifier for the condition."""
+  key: String!
+  """JSON Logic expression for condition evaluation."""
+  logic: JSON!
+  """
+  ID of an existing condition. When set, the create acts as an idempotent upsert against the existing condition.
+  """
+  conditionId: ID
+}
+```
+
+### `ConditionUpdateData`
+
+```graphql
+"""Data for updating an existing condition."""
+input ConditionUpdateData {
+  """Condition ID."""
+  id: ID!
+  """New display name."""
+  name: String
+  """New JSON Logic expression."""
+  logic: JSON
+}
+```
+
+### `ActionChangesInput`
+
+```graphql
+"""Action-level changes within an `experienceFlowUpdate` batch."""
+input ActionChangesInput {
+  """
+  Actions to create. Each entry carries a `clientId` for cross-referencing from `nodes`.
+  """
+  create: [ActionCreateData!]
+  """Actions to update."""
+  update: [ActionUpdateData!]
+  """Action ids to delete."""
+  delete: [ID!]
+}
+```
+
+### `ActionCreateData`
+
+```graphql
+"""Data for creating a new action in the parent workspace."""
+input ActionCreateData {
+  """Client-generated ID for mapping and cross-referencing."""
+  clientId: ID!
+  """Display name for the action."""
+  name: String!
+  """Unique key identifier for the action."""
+  key: String!
+  """Description of what this action does."""
+  description: String
+  """
+  ID of an existing action. When set, the create acts as an idempotent upsert against the existing action.
+  """
+  actionId: ID
+}
+```
+
+### `ActionUpdateData`
+
+```graphql
+"""Data for updating an existing action."""
+input ActionUpdateData {
+  """Action ID."""
+  id: ID!
+  """New display name."""
+  name: String
+  """New description."""
+  description: String
+  """
+  Replacement set of ids for the fields whose responses this action receives.
+  Omit to leave the set unchanged; pass an empty list to request nothing.
+  """
+  fieldIds: [ID!]
+}
+```
+
+### `FieldChangesInput`
+
+```graphql
+"""Field-level changes within an `experienceFlowUpdate` batch."""
+input FieldChangesInput {
+  """
+  Fields to create. Each entry carries a `clientId` and a step reference.
+  """
+  create: [FieldCreateData!]
+  """Fields to update."""
+  update: [FieldUpdateData!]
+  """Field ids to delete."""
+  delete: [ID!]
+}
+```
+
+### `FieldCreateData`
+
+```graphql
+"""Data for creating a new field in the parent workspace."""
+input FieldCreateData {
+  """Client-generated ID for mapping and cross-referencing."""
+  clientId: ID!
+  """
+  Reference an existing step by server ID. Mutually exclusive with `stepClientId`.
+  """
+  stepId: ID
+  """
+  Reference a step being created in this same mutation. Mutually exclusive with `stepId`.
+  """
+  stepClientId: ID
+  """Stable machine-readable name."""
+  name: String!
+  """Unique key identifier for the field."""
+  key: String!
+  """Human-readable label."""
+  label: String!
+  """The field type."""
+  type: FieldType!
+  """Whether multiple values are allowed."""
+  multiple: Boolean
+  """Whether the field is required."""
+  required: Boolean
+  """Validation rules as a JSON-encoded string. Parsed server-side."""
+  validationString: String
+  """JSON default value."""
+  defaultValue: JSON
+  """JSON Logic condition controlling whether the field is rendered."""
+  condition: JSON
+  """Placeholder text."""
+  placeholder: String
+  """Description."""
+  description: String
+  """Help text."""
+  helpText: String
+  """
+  When true, the captured value is excluded from analytics tracking. Omitted defaults to `true`: tracking is opt-in.
+  """
+  doNotTrack: Boolean
+  """
+  When true, the captured value is excluded from persistence. Omitted defaults to `true`: persistence is opt-in.
+  """
+  doNotStore: Boolean
+  """
+  ID of an existing field. When set, the create acts as an idempotent upsert against the existing field.
+  """
+  fieldId: ID
+}
+```
+
+### `FieldUpdateData`
+
+```graphql
+"""Data for updating an existing field."""
+input FieldUpdateData {
+  """Field ID."""
+  id: ID!
+  """New machine-readable name."""
+  name: String
+  """New label."""
+  label: String
+  """
+  Field type. Required even when unchanged — used to coerce other fields server-side.
+  """
+  type: FieldType!
+  """Whether multiple values are allowed."""
+  multiple: Boolean
+  """Whether the field is required."""
+  required: Boolean
+  """Validation rules as a JSON-encoded string."""
+  validationString: String
+  """JSON default value."""
+  defaultValue: JSON
+  """JSON Logic condition controlling whether the field is rendered."""
+  condition: JSON
+  """Placeholder text."""
+  placeholder: String
+  """Description."""
+  description: String
+  """Help text."""
+  helpText: String
+  """When true, the captured value is excluded from analytics tracking."""
+  doNotTrack: Boolean
+  """When true, the captured value is excluded from persistence."""
+  doNotStore: Boolean
+  """Field options as a JSON array."""
+  options: JSON
+}
+```
+
+### `ExperienceNodeChangesInput`
+
+```graphql
+"""Node-level changes within an `experienceFlowUpdate` batch."""
+input ExperienceNodeChangesInput {
+  """Nodes to create."""
+  create: [ExperienceNodeCreateData!]
+  """Nodes to update."""
+  update: [ExperienceNodeUpdateData!]
+  """Node ids to delete."""
+  delete: [ID!]
+}
+```
+
+### `ExperienceNodeCreateData`
+
+```graphql
+"""
+Data for creating a new node in the flow graph. The fields populated
+depend on `type`:
+
+- `STEP`: `stepId` or `stepClientId` (mutually exclusive).
+- `CONDITION`: `conditionId` or `conditionClientId`.
+- `ACTION`: `actionId` or `actionClientId`.
+- `EXPERIENCE`: `targetExperienceId`.
+- `ORIGIN`: no extras.
+"""
+input ExperienceNodeCreateData {
+  """Client-generated ID for mapping and cross-referencing from edges."""
+  clientId: ID!
+  """Node kind discriminator."""
+  type: ExperienceNodeType!
+  """Canvas position."""
+  position: PositionInput!
+  """
+  For STEP nodes: reference an existing step by server ID. Mutually exclusive with `stepClientId`.
+  """
+  stepId: ID
+  """
+  For STEP nodes: reference a step being created in this same mutation. Mutually exclusive with `stepId`.
+  """
+  stepClientId: ID
+  """
+  For CONDITION nodes: reference an existing condition by server ID. Mutually exclusive with `conditionClientId`.
+  """
+  conditionId: ID
+  """
+  For CONDITION nodes: reference a condition being created in this same mutation. Mutually exclusive with `conditionId`.
+  """
+  conditionClientId: ID
+  """
+  For ACTION nodes: reference an existing workspace-level action. Mutually exclusive with `actionClientId`.
+  """
+  actionId: ID
+  """
+  For ACTION nodes: reference an action being created in this same mutation. Mutually exclusive with `actionId`.
+  """
+  actionClientId: ID
+  """For EXPERIENCE nodes: reference target experience to launch."""
+  targetExperienceId: ID
+}
+```
+
+### `ExperienceNodeUpdateData`
+
+```graphql
+"""Data for updating an existing node."""
+input ExperienceNodeUpdateData {
+  """Node ID."""
+  id: ID!
+  """New canvas position."""
+  position: PositionInput!
+  """For STEP nodes: new step reference."""
+  stepId: ID
+  """For CONDITION nodes: new condition reference."""
+  conditionId: ID
+  """For ACTION nodes: new action reference."""
+  actionId: ID
+  """For EXPERIENCE nodes: new target experience."""
+  targetExperienceId: ID
+}
+```
+
+### `ExperienceEdgeChangesInput`
+
+```graphql
+"""Edge-level changes within an `experienceFlowUpdate` batch."""
+input ExperienceEdgeChangesInput {
+  """Edges to create."""
+  create: [ExperienceEdgeCreateInput!]
+  """Edges to update."""
+  update: [ExperienceEdgeUpdateInput!]
+  """Edge ids to delete."""
+  delete: [ID!]
+}
+```
+
+### `ExperienceEdgeCreateInput`
+
+```graphql
+"""Data for creating a new edge."""
+input ExperienceEdgeCreateInput {
+  """Client-generated ID for this edge."""
+  clientId: ID!
+  """
+  Source node by server ID. Mutually exclusive with `sourceNodeClientId`.
+  """
+  sourceNodeId: ID
+  """
+  Source node being created in this same mutation. Mutually exclusive with `sourceNodeId`.
+  """
+  sourceNodeClientId: ID
+  """
+  Destination node by server ID. Mutually exclusive with `destinationNodeClientId`.
+  """
+  destinationNodeId: ID
+  """
+  Destination node being created in this same mutation. Mutually exclusive with `destinationNodeId`.
+  """
+  destinationNodeClientId: ID
+  """For edges from conditional nodes: which branch (TRUE / FALSE)."""
+  sourceHandle: ExperienceEdgeHandle
+}
+```
+
+### `ExperienceEdgeUpdateInput`
+
+```graphql
+"""Data for updating an existing edge."""
+input ExperienceEdgeUpdateInput {
+  """Edge ID."""
+  id: ID!
+  """New source node id."""
+  sourceNodeId: ID
+  """New destination node id."""
+  destinationNodeId: ID
+  """New conditional branch handle."""
+  sourceHandle: ExperienceEdgeHandle
+}
+```
+
+### `ExperienceFlowUpdatePayload`
+
+```graphql
+"""Payload returned by `experienceFlowUpdate`."""
+type ExperienceFlowUpdatePayload {
+  """The updated experience with all changes applied."""
+  experience: Experience
+  """
+  Mappings from client-generated IDs to server-generated IDs, grouped by entity kind.
+  """
+  idMappings: ExperienceFlowIdMappings!
+  """Validation errors. Empty array indicates success."""
+  errors: [UserError!]!
+}
+```
+
+### `ExperienceFlowIdMappings`
+
+```graphql
+"""
+Categorised client-to-server ID mappings emitted by `experienceFlowUpdate`.
+"""
+type ExperienceFlowIdMappings {
+  """Step id mappings."""
+  steps: [IdMapping!]!
+  """Condition id mappings."""
+  conditions: [IdMapping!]!
+  """Action id mappings."""
+  actions: [IdMapping!]!
+  """Field id mappings."""
+  fields: [IdMapping!]!
+  """Node id mappings."""
+  nodes: [IdMapping!]!
+  """Edge id mappings."""
+  edges: [IdMapping!]!
+}
+```
+
+### `IdMapping`
+
+```graphql
+"""Maps a client-generated ID to a server-generated ID."""
+type IdMapping {
+  """The ID provided by the client in the create operation."""
+  clientId: ID!
+  """The ID generated by the server for the created entity."""
+  id: ID!
+}
+```
+
+### `ReferencingExperience`
+
+```graphql
+"""
+An experience that references a workspace resource, preventing its
+deletion. Returned in `ActionDeleteUserError`, `ConditionDeleteUserError`,
+and `StepDeleteUserError` when the delete is blocked by usage.
+"""
+type ReferencingExperience {
+  """The experience id."""
+  id: ID!
+  """The experience name."""
+  name: String!
+}
+```
+
+### `ExperienceSortKeys`
+
+```graphql
+"""
+Sort keys for `experiences(...)`. Pair with `reverse: true` to flip the order (`NAME` + `reverse: false` sorts A→Z; `CREATED_AT` + `reverse: true` is newest-first).
+"""
+enum ExperienceSortKeys {
+  """Sort by `name` (alphabetical)."""
+  NAME
+  """Sort by `createdAt`."""
+  CREATED_AT
+  """Sort by `updatedAt`."""
+  UPDATED_AT
+}
+```