@epilot/sdk 2.3.10 → 2.4.1

package/dist/{entity.d-ByufVI16.d.cts → entity.d-BHR9dEon.d.cts}

@@ -17,7 +17,9 @@ declare namespace Components {
          * 01F130Q52Q6MWSNS8N2AVXV4JN
          */
         Schemas.ActivityId /* ulid ^01[0-9a-zA-Z]{24}$ */ | ("" | null);
+        export type ApplyChangesetsQueryParam = boolean;
         export type AsyncOperationQueryParam = boolean;
+        export type DirectQueryParam = boolean;
         export type DryRunQueryParam = boolean;
         export type EntityIdPathParam = Schemas.EntityId /* uuid */;
         export type EntityRelationsModeQueryParam = "direct" | "reverse" | "both";
@@ -86,6 +88,8 @@ declare namespace Components {
         DryRunQueryParam?: Parameters.DryRunQueryParam;
         FillActivityQueryParam?: Parameters.FillActivityQueryParam;
         ValidateEntityQueryParam?: Parameters.ValidateEntityQueryParam;
+        DirectQueryParam?: Parameters.DirectQueryParam;
+        ApplyChangesetsQueryParam?: Parameters.ApplyChangesetsQueryParam;
     }
     namespace Responses {
         /**
@@ -171,6 +175,10 @@ declare namespace Components {
              * - RelationsSoftDeleted
              * - RelationsRestored
              * - RelationsDeleted
+             * - ChangesetCreated
+             * - ChangesetAutoCleared
+             * - ChangesetApplied
+             * - ChangesetDismissed
              *
              */
             ActivityType;
@@ -284,6 +292,10 @@ declare namespace Components {
              * - RelationsSoftDeleted
              * - RelationsRestored
              * - RelationsDeleted
+             * - ChangesetCreated
+             * - ChangesetAutoCleared
+             * - ChangesetApplied
+             * - ChangesetDismissed
              *
              */
             ActivityType;
@@ -340,6 +352,10 @@ declare namespace Components {
          * - RelationsSoftDeleted
          * - RelationsRestored
          * - RelationsDeleted
+         * - ChangesetCreated
+         * - ChangesetAutoCleared
+         * - ChangesetApplied
+         * - ChangesetDismissed
          *
          */
         export type ActivityType = string;
@@ -496,6 +512,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "address";
             default_address_fields?: /**
              * Default fields visible on addresses
@@ -677,6 +732,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "relation_address";
             default_address_fields?: /**
              * Default fields visible on addresses
@@ -875,6 +969,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "automation";
         }
         export interface BaseActivityItem {
@@ -899,6 +1032,10 @@ declare namespace Components {
              * - RelationsSoftDeleted
              * - RelationsRestored
              * - RelationsDeleted
+             * - ChangesetCreated
+             * - ChangesetAutoCleared
+             * - ChangesetApplied
+             * - ChangesetDismissed
              *
              */
             ActivityType;
@@ -1084,6 +1221,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
         }
         /**
          * example:
@@ -1166,6 +1342,15 @@ declare namespace Components {
              * Manifest ID used to create/update the entity
              */
             _manifest?: string /* uuid */[] | null;
+            /**
+             * Pending attribute changesets for attributes configured with external or approval edit mode.
+             * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+             * Use the changeset management endpoints to apply or dismiss changesets.
+             *
+             */
+            _changesets?: {
+                [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+            } | null;
         }
         /**
          * Reference to blueprint
@@ -1324,9 +1509,118 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "boolean";
             display_type?: "switch" | "checkbox";
         }
+        /**
+         * A pending proposed change for a single entity attribute, awaiting external confirmation or human approval.
+         */
+        export interface Changeset {
+            /**
+             * The proposed new value for the attribute. Type matches the attribute type.
+             */
+            proposed_value: any;
+            /**
+             * The attribute value at the time the changeset was created. Stored for reference.
+             */
+            previous_value?: any;
+            /**
+             * Timestamp when the changeset was created
+             */
+            created_at: string; // date-time
+            created_by?: /* Identifies the actor that created the changeset. */ ChangesetCreator;
+            /**
+             * The edit mode that triggered this changeset.
+             * - `external`: auto-cleared by a matching `?direct=true` write (see `match_strategy`).
+             * - `approval`: resolved only via explicit `:apply` / `:dismiss` endpoints; never auto-clears.
+             *
+             */
+            edit_mode: "external" | "approval";
+            /**
+             * Match strategy copied from the attribute's `edit_mode_config` at changeset
+             * creation time. Only consulted when `edit_mode` is `external`; ignored for
+             * `approval` (which never auto-clears).
+             *
+             */
+            match_strategy?: "exact" | "fuzzy" | "any";
+            /**
+             * Optional label indicating where the change originated (e.g. end_customer_portal, installer_portal, journey, automation)
+             */
+            source?: string;
+            /**
+             * Proposed and previous values for related fields in a multi-field attribute group (e.g. currency _decimal/_currency suffixes). Keyed by full field name.
+             */
+            related_values?: {
+                [name: string]: {
+                    /**
+                     * The proposed new value for the related field.
+                     */
+                    proposed_value?: any;
+                    /**
+                     * The value of the related field when the changeset was created.
+                     */
+                    previous_value?: any;
+                };
+            };
+        }
+        /**
+         * Identifies the actor that created the changeset.
+         */
+        export interface ChangesetCreator {
+            /**
+             * Type of actor that created the changeset
+             */
+            type?: "user" | "portal_user" | "api_client" | "automation";
+            /**
+             * ID of the actor (user ID, portal user ID, API client ID, etc.)
+             */
+            id?: string;
+        }
+        /**
+         * Map of attribute name to pending changeset. At most one changeset per attribute.
+         */
+        export interface ChangesetMap {
+            [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+        }
         /**
          * example:
          * taxonomy-slug:classification-slug
@@ -1522,6 +1816,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "computed";
             computed?: boolean;
             /**
@@ -1686,6 +2019,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "consent";
             topic: string;
             identifiers?: string[];
@@ -1843,6 +2215,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "country";
         }
         /**
@@ -1998,6 +2409,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "currency";
             currency_selector_only?: boolean;
             /**
@@ -2163,6 +2613,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "date" | "datetime";
         }
         /**
@@ -2201,6 +2690,38 @@ declare namespace Components {
              */
             cluster?: string;
         }
+        /**
+         * Configuration for `edit_mode: external` auto-clear matching.
+         * Fields here (`match_strategy`, `fuzzy_config`) only take effect when
+         * `edit_mode` is `external`. They are ignored for `edit_mode: approval`,
+         * which never auto-clears and is resolved exclusively via the
+         * `:apply` / `:dismiss` changeset endpoints.
+         *
+         */
+        export interface EditModeConfig {
+            match_strategy?: /**
+             * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+             * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+             * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+             * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+             * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+             * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+             * - `any`: Any update to the attribute clears the changeset, regardless of value.
+             *
+             */
+            MatchStrategy;
+            fuzzy_config?: /**
+             * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+             * Not used for `edit_mode: approval`.
+             *
+             * Type compatibility with attribute shape is enforced at schema save time:
+             * - scalar string attributes: `suffix`, `digits_only`, `regex`
+             * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+             * - relation attributes: `relation_set`
+             *
+             */
+            FuzzyConfig;
+        }
         /**
          * Email address
          */
@@ -2354,6 +2875,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "email";
         }
         /**
@@ -2437,6 +2997,15 @@ declare namespace Components {
              * Manifest ID used to create/update the entity
              */
             _manifest?: string /* uuid */[] | null;
+            /**
+             * Pending attribute changesets for attributes configured with external or approval edit mode.
+             * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+             * Use the changeset management endpoints to apply or dismiss changesets.
+             *
+             */
+            _changesets?: {
+                [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+            } | null;
         }
         /**
          * Access control list (ACL) for an entity. Defines sharing access to external orgs or users.
@@ -2932,6 +3501,15 @@ declare namespace Components {
              * Manifest ID used to create/update the entity
              */
             _manifest?: string /* uuid */[] | null;
+            /**
+             * Pending attribute changesets for attributes configured with external or approval edit mode.
+             * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+             * Use the changeset management endpoints to apply or dismiss changesets.
+             *
+             */
+            _changesets?: {
+                [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+            } | null;
         }
         export interface EntityListParams {
             /**
@@ -3108,6 +3686,10 @@ declare namespace Components {
              * - RelationsSoftDeleted
              * - RelationsRestored
              * - RelationsDeleted
+             * - ChangesetCreated
+             * - ChangesetAutoCleared
+             * - ChangesetApplied
+             * - ChangesetDismissed
              *
              */
             ActivityType;
@@ -3210,6 +3792,15 @@ declare namespace Components {
                  * Manifest ID used to create/update the entity
                  */
                 _manifest?: string /* uuid */[] | null;
+                /**
+                 * Pending attribute changesets for attributes configured with external or approval edit mode.
+                 * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+                 * Use the changeset management endpoints to apply or dismiss changesets.
+                 *
+                 */
+                _changesets?: {
+                    [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+                } | null;
             };
             diff?: {
                 /**
@@ -3294,6 +3885,15 @@ declare namespace Components {
                      * Manifest ID used to create/update the entity
                      */
                     _manifest?: string /* uuid */[] | null;
+                    /**
+                     * Pending attribute changesets for attributes configured with external or approval edit mode.
+                     * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+                     * Use the changeset management endpoints to apply or dismiss changesets.
+                     *
+                     */
+                    _changesets?: {
+                        [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+                    } | null;
                 };
                 /**
                  * Attributes updated in the entity. Note: These values contain the previous values before the update!
@@ -3377,6 +3977,15 @@ declare namespace Components {
                      * Manifest ID used to create/update the entity
                      */
                     _manifest?: string /* uuid */[] | null;
+                    /**
+                     * Pending attribute changesets for attributes configured with external or approval edit mode.
+                     * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+                     * Use the changeset management endpoints to apply or dismiss changesets.
+                     *
+                     */
+                    _changesets?: {
+                        [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+                    } | null;
                 };
                 /**
                  * Attributes removed from the entity as part of the operation
@@ -3460,6 +4069,15 @@ declare namespace Components {
                      * Manifest ID used to create/update the entity
                      */
                     _manifest?: string /* uuid */[] | null;
+                    /**
+                     * Pending attribute changesets for attributes configured with external or approval edit mode.
+                     * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+                     * Use the changeset management endpoints to apply or dismiss changesets.
+                     *
+                     */
+                    _changesets?: {
+                        [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+                    } | null;
                 };
             };
             /**
@@ -4793,6 +5411,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "image" | "file";
             multiple?: boolean;
             /**
@@ -4817,6 +5474,65 @@ declare namespace Components {
              */
             file_size_bytes?: number;
         }
+        /**
+         * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+         * Not used for `edit_mode: approval`.
+         *
+         * Type compatibility with attribute shape is enforced at schema save time:
+         * - scalar string attributes: `suffix`, `digits_only`, `regex`
+         * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+         * - relation attributes: `relation_set`
+         *
+         */
+        export interface FuzzyConfig {
+            /**
+             * Which fuzzy algorithm to apply.
+             */
+            type: "suffix" | "digits_only" | "normalize_phone" | "ignore_fields" | "set_equivalent" | "entry_match" | "relation_set" | "regex";
+            /**
+             * For type=suffix: number of characters to compare from end of string.
+             */
+            suffix_length?: number;
+            /**
+             * For type=ignore_fields and type=set_equivalent: field names to exclude when comparing array entries. `_id` is always stripped by the platform regardless of this config.
+             */
+            fields_to_ignore?: string[];
+            /**
+             * For type=regex: flags to apply to the regex (e.g. 'i' for case-insensitive).
+             */
+            regex_flags?: string;
+            /**
+             * For type=normalize_phone: country dialing code digits to strip (e.g. '49' for Germany). No '+' prefix.
+             */
+            country_code?: string;
+            /**
+             * For type=normalize_phone: attribute key within array entries to compare on (e.g. 'phone_number').
+             */
+            match_on?: string;
+            /**
+             * For type=entry_match: business key(s) within each entry used to match proposed entries against incoming entries.
+             */
+            key?: /* For type=entry_match: business key(s) within each entry used to match proposed entries against incoming entries. */ string | string[];
+            /**
+             * For type=entry_match and type=set_equivalent: how strict the comparison is.
+             * - `subset` (default for entry_match): every proposed entry must exist in incoming; extra incoming entries are allowed.
+             * - `exact_set` (default for set_equivalent): the two sides must contain the same entries (order-insensitive, multiset semantics).
+             *
+             */
+            mode?: "subset" | "exact_set";
+            /**
+             * For type=relation_set: when true, relation order is significant. Defaults to false (order-insensitive).
+             */
+            ordered?: boolean;
+            /**
+             * For type=relation_set: when true, each relation item's `_tags` must match on both sides (order-insensitive). Defaults to false — `_tags` are stripped before compare.
+             */
+            require_tags_match?: boolean;
+            /**
+             * For type=regex: regular expression pattern to test the incoming value against.
+             */
+            pattern?: string;
+        }
         export interface GenerateEntityTableAIFiltersRequest {
             /**
              * The prompt to generate the filters
@@ -4984,6 +5700,10 @@ declare namespace Components {
              * If true, return full entity objects in entityNodes instead of just entity IDs in nodes
              */
             hydrate?: boolean;
+            /**
+             * When true and hydrate is also true, entity objects in entityNodes have pending changeset proposed values applied in-place. The _changesets field is still included in the response.
+             */
+            apply_changesets?: boolean;
         }
         export interface GraphQueryResponse {
             /**
@@ -5400,6 +6120,15 @@ declare namespace Components {
              * Manifest ID used to create/update the entity
              */
             _manifest?: string /* uuid */[] | null;
+            /**
+             * Pending attribute changesets for attributes configured with external or approval edit mode.
+             * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+             * Use the changeset management endpoints to apply or dismiss changesets.
+             *
+             */
+            _changesets?: {
+                [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+            } | null;
             _relations: {
                 entity_id: EntityId /* uuid */;
             }[];
@@ -5557,18 +6286,57 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
-            type: "internal";
-        }
-        /**
-         * Epilot internal user info
-         */
-        export interface InternalUserAttribute {
             /**
-             * ID for the entity attribute
-             * example:
-             * d5839b94-ba20-4225-a78e-76951d352bd6
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
              */
-            id?: string;
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
+            type: "internal";
+        }
+        /**
+         * Epilot internal user info
+         */
+        export interface InternalUserAttribute {
+            /**
+             * ID for the entity attribute
+             * example:
+             * d5839b94-ba20-4225-a78e-76951d352bd6
+             */
+            id?: string;
             name: string;
             label: string;
             placeholder?: string;
@@ -5712,6 +6480,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "internal_user";
         }
         /**
@@ -5867,6 +6674,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "invitation_email";
         }
         /**
@@ -6030,6 +6876,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "link";
         }
         export interface ListSavedViewsResults {
@@ -6040,6 +6925,17 @@ declare namespace Components {
             hits?: number;
             results?: /* A saved entity view */ SavedViewItem[];
         }
+        /**
+         * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+         * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+         * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+         * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+         * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+         * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+         * - `any`: Any update to the attribute clears the changeset, regardless of value.
+         *
+         */
+        export type MatchStrategy = "exact" | "fuzzy" | "any";
         /**
          * Message emil address
          */
@@ -6193,6 +7089,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "message_email_address";
             address?: string;
             send_status?: string;
@@ -6351,6 +7286,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "multiselect" | "checkbox";
             /**
              * controls if the matching of values against the options is case sensitive or not
@@ -6450,6 +7424,15 @@ declare namespace Components {
              * Manifest ID used to create/update the entity
              */
             _manifest?: string /* uuid */[] | null;
+            /**
+             * Pending attribute changesets for attributes configured with external or approval edit mode.
+             * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+             * Use the changeset management endpoints to apply or dismiss changesets.
+             *
+             */
+            _changesets?: {
+                [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+            } | null;
         } | null;
         /**
          * Numeric input
@@ -6604,6 +7587,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "number";
             /**
              * Optional data type override. When set to 'number', the value is stored as a number instead of a string. Defaults to 'string'.
@@ -6768,6 +7790,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "ordered_list";
         }
         /**
@@ -6923,6 +7984,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "partner_organisation";
         }
         /**
@@ -7078,6 +8178,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "partner_status";
         }
         /**
@@ -7233,6 +8372,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "payment";
         }
         /**
@@ -7388,6 +8566,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "relation_payment_method";
         }
         /**
@@ -7543,6 +8760,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "phone";
         }
         /**
@@ -7698,6 +8954,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "portal_access";
         }
         /**
@@ -7853,6 +9148,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "price_component";
         }
         /**
@@ -8008,6 +9342,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "purpose";
         }
         /**
@@ -8178,6 +9551,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval" | "list-view";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "relation";
             relation_type?: "has_many" | "has_one";
             /**
@@ -8199,7 +9611,6 @@ declare namespace Components {
              * When enable_relation_picker is set to true the user will be able to pick existing relations as values. Otherwise, the user will need to create new relation to link.
              */
             enable_relation_picker?: boolean;
-            edit_mode?: "list-view";
             /**
              * Enables the preview, edition, and creation of relation items on a Master-Details view mode.
              */
@@ -8373,6 +9784,15 @@ declare namespace Components {
              * Manifest ID used to create/update the entity
              */
             _manifest?: string /* uuid */[] | null;
+            /**
+             * Pending attribute changesets for attributes configured with external or approval edit mode.
+             * Read-only via normal entity PATCH/PUT operations — cannot be set directly.
+             * Use the changeset management endpoints to apply or dismiss changesets.
+             *
+             */
+            _changesets?: {
+                [name: string]: /* A pending proposed change for a single entity attribute, awaiting external confirmation or human approval. */ Changeset;
+            } | null;
             $relation?: RelationItem;
         }
         export interface RelationItem {
@@ -8547,6 +9967,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
         }
         /**
          * A saved entity view
@@ -8943,10 +10402,14 @@ declare namespace Components {
         export interface SearchMappings {
             [name: string]: {
                 index?: boolean;
-                type?: "keyword" | "text" | "boolean" | "integer" | "long" | "float" | "date" | "flattened" | "nested";
+                type?: "keyword" | "text" | "boolean" | "integer" | "long" | "float" | "date" | "flattened" | "nested" | "object";
                 fields?: {
                     [name: string]: any;
                 };
+                /**
+                 * When false, prevents ES from inferring types for nested fields. Used for _changesets where values can be any type.
+                 */
+                dynamic?: boolean;
             };
         }
         /**
@@ -9102,6 +10565,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "select" | "radio";
             options?: ({
                 value: string;
@@ -9265,6 +10767,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "sequence";
             /**
              * Prefix added before the sequence number
@@ -9437,6 +10978,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "status";
             options?: ((string | null) | {
                 /**
@@ -9688,6 +11268,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "table";
             /**
              * Column definitions for the table
@@ -9899,6 +11518,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "tags";
             options?: string[];
             suggestions?: string[];
@@ -10256,6 +11914,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "string";
             multiline?: boolean;
             rich_text?: boolean;
@@ -10424,6 +12121,45 @@ declare namespace Components {
              */
             repeatable?: boolean;
             has_primary?: boolean;
+            /**
+             * Controls how updates to this attribute are handled.
+             * - `direct` (default): update is applied immediately. No changeset created.
+             * - `external`: update creates a changeset, auto-cleared on matching external update (e.g. ERP inbound sync via ?direct=true).
+             * - `approval`: update creates a changeset, requires explicit human approval.
+             *
+             */
+            edit_mode?: "direct" | "external" | "approval";
+            /**
+             * Configuration for auto-clear matching on `edit_mode: external` attributes.
+             * `match_strategy` and `fuzzy_config` are only consulted for `external` mode —
+             * they are ignored for `approval` mode, which resolves via explicit
+             * `:apply` / `:dismiss` endpoints and never auto-clears.
+             *
+             */
+            edit_mode_config?: {
+                match_strategy?: /**
+                 * Strategy for auto-clearing a changeset on an `edit_mode: external` attribute
+                 * when a direct write (`?direct=true`) arrives — typically an ERP inbound sync.
+                 * Ignored for `edit_mode: approval`, which does not auto-clear and is resolved
+                 * exclusively via the `:apply` / `:dismiss` changeset endpoints.
+                 * - `exact`: The inbound value must exactly match the proposed value (deep equality).
+                 * - `fuzzy`: The inbound value is compared using the configured `fuzzy_config` algorithm.
+                 * - `any`: Any update to the attribute clears the changeset, regardless of value.
+                 *
+                 */
+                MatchStrategy;
+                fuzzy_config?: /**
+                 * Configuration for fuzzy auto-clear matching on `edit_mode: external` attributes.
+                 * Not used for `edit_mode: approval`.
+                 *
+                 * Type compatibility with attribute shape is enforced at schema save time:
+                 * - scalar string attributes: `suffix`, `digits_only`, `regex`
+                 * - repeatable attributes: `set_equivalent`, `entry_match`, `ignore_fields`, `normalize_phone`
+                 * - relation attributes: `relation_set`
+                 *
+                 */
+                FuzzyConfig;
+            };
             type: "relation_user";
             multiple?: boolean;
         }
@@ -10469,6 +12205,81 @@ declare namespace Paths {
             Components.Responses.NotFoundError;
         }
     }
+    namespace ApplyChangeset {
+        namespace Parameters {
+            export type Attribute = string;
+            export type Id = Components.Schemas.EntityId /* uuid */;
+            export type Slug = /**
+             * URL-friendly identifier for the entity schema
+             * example:
+             * contact
+             */
+            Components.Schemas.EntitySlug /* ^[a-zA-Z0-9_-]+$ */;
+        }
+        export interface PathParameters {
+            slug: Parameters.Slug;
+            id: Parameters.Id;
+            attribute: Parameters.Attribute;
+        }
+        namespace Responses {
+            export type $200 = /**
+             * example:
+             * {
+             *   "_id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+             *   "_org": "123",
+             *   "_owners": [
+             *     {
+             *       "org_id": "123",
+             *       "user_id": "123"
+             *     },
+             *     {
+             *       "org_id": "123",
+             *       "user_id": "123"
+             *     }
+             *   ],
+             *   "_schema": "contact",
+             *   "_tags": [
+             *     "example",
+             *     "mock",
+             *     "example",
+             *     "mock"
+             *   ],
+             *   "_created_at": "2021-02-09T12:41:43.662Z",
+             *   "_updated_at": "2021-02-09T12:41:43.662Z",
+             *   "_acl": {
+             *     "view": [
+             *       "org:456",
+             *       "org:789",
+             *       "org:456",
+             *       "org:789"
+             *     ],
+             *     "edit": [
+             *       "org:456",
+             *       "org:456"
+             *     ],
+             *     "delete": [
+             *       "org:456",
+             *       "org:456"
+             *     ]
+             *   },
+             *   "_manifest": [
+             *     "123e4567-e89b-12d3-a456-426614174000",
+             *     "123e4567-e89b-12d3-a456-426614174000"
+             *   ]
+             * }
+             */
+            Components.Schemas.EntityItem;
+            export type $404 = /**
+             * A generic error returned by the API
+             * example:
+             * {
+             *   "status": 404,
+             *   "error": "Not Found"
+             * }
+             */
+            Components.Responses.NotFoundError;
+        }
+    }
     namespace AttachActivity {
         namespace Parameters {
             export type Entities = Components.Schemas.EntityId /* uuid */[];
@@ -11235,6 +13046,87 @@ declare namespace Paths {
             Components.Responses.TooManyRequestsError;
         }
     }
+    namespace DismissChangeset {
+        namespace Parameters {
+            export type Attribute = string;
+            export type Id = Components.Schemas.EntityId /* uuid */;
+            export type Slug = /**
+             * URL-friendly identifier for the entity schema
+             * example:
+             * contact
+             */
+            Components.Schemas.EntitySlug /* ^[a-zA-Z0-9_-]+$ */;
+        }
+        export interface PathParameters {
+            slug: Parameters.Slug;
+            id: Parameters.Id;
+            attribute: Parameters.Attribute;
+        }
+        export interface RequestBody {
+            /**
+             * Optional reason for dismissing the changeset
+             */
+            reason?: string;
+        }
+        namespace Responses {
+            export type $200 = /**
+             * example:
+             * {
+             *   "_id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+             *   "_org": "123",
+             *   "_owners": [
+             *     {
+             *       "org_id": "123",
+             *       "user_id": "123"
+             *     },
+             *     {
+             *       "org_id": "123",
+             *       "user_id": "123"
+             *     }
+             *   ],
+             *   "_schema": "contact",
+             *   "_tags": [
+             *     "example",
+             *     "mock",
+             *     "example",
+             *     "mock"
+             *   ],
+             *   "_created_at": "2021-02-09T12:41:43.662Z",
+             *   "_updated_at": "2021-02-09T12:41:43.662Z",
+             *   "_acl": {
+             *     "view": [
+             *       "org:456",
+             *       "org:789",
+             *       "org:456",
+             *       "org:789"
+             *     ],
+             *     "edit": [
+             *       "org:456",
+             *       "org:456"
+             *     ],
+             *     "delete": [
+             *       "org:456",
+             *       "org:456"
+             *     ]
+             *   },
+             *   "_manifest": [
+             *     "123e4567-e89b-12d3-a456-426614174000",
+             *     "123e4567-e89b-12d3-a456-426614174000"
+             *   ]
+             * }
+             */
+            Components.Schemas.EntityItem;
+            export type $404 = /**
+             * A generic error returned by the API
+             * example:
+             * {
+             *   "status": 404,
+             *   "error": "Not Found"
+             * }
+             */
+            Components.Responses.NotFoundError;
+        }
+    }
     namespace ExportEntities {
         namespace Parameters {
             export type IsTemplate = /* Pass 'true' to generate import template */ Components.Schemas.IsTemplate;
@@ -11542,6 +13434,7 @@ declare namespace Paths {
     }
     namespace GetEntityV2 {
         namespace Parameters {
+            export type ApplyChangesets = boolean;
             export type Fields = /**
              * List of entity fields to include or exclude in the response
              *
@@ -11576,6 +13469,7 @@ declare namespace Paths {
         export interface QueryParameters {
             hydrate?: Parameters.Hydrate;
             fields?: Parameters.Fields;
+            apply_changesets?: Parameters.ApplyChangesets;
         }
         namespace Responses {
             export type $200 = /**
@@ -12480,7 +14374,7 @@ declare namespace Paths {
             /**
              * ISO 8601 timestamp to filter jobs created after this time (e.g., 2023-01-01T00:00:00Z).
              * example:
-             * 2023-01-01T00:00:00.000Z
+             * 2023-01-01T00:00:00Z
              */
             export type CreatedAfter = string; // date-time
             /**
@@ -12506,7 +14400,7 @@ declare namespace Paths {
             created_after?: /**
              * ISO 8601 timestamp to filter jobs created after this time (e.g., 2023-01-01T00:00:00Z).
              * example:
-             * 2023-01-01T00:00:00.000Z
+             * 2023-01-01T00:00:00Z
              */
             Parameters.CreatedAfter /* date-time */;
             sort_pending_first?: /* When true, sorts PENDING status jobs to the top of the results. */ Parameters.SortPendingFirst;
@@ -12593,6 +14487,33 @@ declare namespace Paths {
             }
         }
     }
+    namespace ListChangesets {
+        namespace Parameters {
+            export type Id = Components.Schemas.EntityId /* uuid */;
+            export type Slug = /**
+             * URL-friendly identifier for the entity schema
+             * example:
+             * contact
+             */
+            Components.Schemas.EntitySlug /* ^[a-zA-Z0-9_-]+$ */;
+        }
+        export interface PathParameters {
+            slug: Parameters.Slug;
+            id: Parameters.Id;
+        }
+        namespace Responses {
+            export type $200 = /* Map of attribute name to pending changeset. At most one changeset per attribute. */ Components.Schemas.ChangesetMap;
+            export type $404 = /**
+             * A generic error returned by the API
+             * example:
+             * {
+             *   "status": 404,
+             *   "error": "Not Found"
+             * }
+             */
+            Components.Responses.NotFoundError;
+        }
+    }
     namespace ListEntities {
         export type RequestBody = Components.Schemas.EntityListParams;
         namespace Responses {
@@ -12753,6 +14674,7 @@ declare namespace Paths {
              */
             Components.Schemas.ActivityId /* ulid ^01[0-9a-zA-Z]{24}$ */ | ("" | null);
             export type Async = boolean;
+            export type Direct = boolean;
             export type DryRun = boolean;
             export type FillActivity = boolean;
             export type Id = Components.Schemas.EntityId /* uuid */;
@@ -12774,6 +14696,7 @@ declare namespace Paths {
             dry_run?: Parameters.DryRun;
             async?: Parameters.Async;
             validate?: Parameters.Validate;
+            direct?: Parameters.Direct;
         }
         export type RequestBody = /**
          * example:
@@ -13401,6 +15324,7 @@ declare namespace Paths {
              */
             Components.Schemas.ActivityId /* ulid ^01[0-9a-zA-Z]{24}$ */ | ("" | null);
             export type Async = boolean;
+            export type Direct = boolean;
             export type FillActivity = boolean;
             export type Id = Components.Schemas.EntityId /* uuid */;
             export type Slug = /**
@@ -13420,6 +15344,7 @@ declare namespace Paths {
             fill_activity?: Parameters.FillActivity;
             async?: Parameters.Async;
             validate?: Parameters.Validate;
+            direct?: Parameters.Direct;
         }
         export type RequestBody = /**
          * example:
@@ -13928,6 +15853,7 @@ declare namespace Paths {
     }
 }
 
+
 interface OperationMethods {
   /**
    * listSchemas - listSchemas
@@ -14498,6 +16424,39 @@ interface OperationMethods {
     data?: any,
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.AttachActivity.Responses.$200>
+  /**
+   * applyChangeset - applyChangeset
+   * 
+   * Applies the proposed value from a pending changeset to the entity attribute
+   * and removes the changeset. Used for human approval of pending changes.
+   * 
+   */
+  'applyChangeset'(
+    parameters?: Parameters<Paths.ApplyChangeset.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig  
+  ): OperationResponse<Paths.ApplyChangeset.Responses.$200>
+  /**
+   * dismissChangeset - dismissChangeset
+   * 
+   * Removes a pending changeset without applying it. The attribute value remains unchanged.
+   * 
+   */
+  'dismissChangeset'(
+    parameters?: Parameters<Paths.DismissChangeset.PathParameters> | null,
+    data?: Paths.DismissChangeset.RequestBody,
+    config?: AxiosRequestConfig  
+  ): OperationResponse<Paths.DismissChangeset.Responses.$200>
+  /**
+   * listChangesets - listChangesets
+   * 
+   * Returns all pending changesets for an entity.
+   */
+  'listChangesets'(
+    parameters?: Parameters<Paths.ListChangesets.PathParameters> | null,
+    data?: any,
+    config?: AxiosRequestConfig  
+  ): OperationResponse<Paths.ListChangesets.Responses.$200>
   /**
    * getEntityActivityFeed - getEntityActivityFeed
    * 
@@ -15694,6 +17653,45 @@ interface PathsDictionary {
       config?: AxiosRequestConfig  
     ): OperationResponse<Paths.AttachActivity.Responses.$200>
   }
+  ['/v1/entity/{slug}/{id}/changesets/{attribute}:apply']: {
+    /**
+     * applyChangeset - applyChangeset
+     * 
+     * Applies the proposed value from a pending changeset to the entity attribute
+     * and removes the changeset. Used for human approval of pending changes.
+     * 
+     */
+    'post'(
+      parameters?: Parameters<Paths.ApplyChangeset.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig  
+    ): OperationResponse<Paths.ApplyChangeset.Responses.$200>
+  }
+  ['/v1/entity/{slug}/{id}/changesets/{attribute}:dismiss']: {
+    /**
+     * dismissChangeset - dismissChangeset
+     * 
+     * Removes a pending changeset without applying it. The attribute value remains unchanged.
+     * 
+     */
+    'post'(
+      parameters?: Parameters<Paths.DismissChangeset.PathParameters> | null,
+      data?: Paths.DismissChangeset.RequestBody,
+      config?: AxiosRequestConfig  
+    ): OperationResponse<Paths.DismissChangeset.Responses.$200>
+  }
+  ['/v1/entity/{slug}/{id}/changesets']: {
+    /**
+     * listChangesets - listChangesets
+     * 
+     * Returns all pending changesets for an entity.
+     */
+    'get'(
+      parameters?: Parameters<Paths.ListChangesets.PathParameters> | null,
+      data?: any,
+      config?: AxiosRequestConfig  
+    ): OperationResponse<Paths.ListChangesets.Responses.$200>
+  }
   ['/v1/entity/{slug}/{id}/activity']: {
     /**
      * getEntityActivityFeed - getEntityActivityFeed
@@ -16338,6 +18336,7 @@ interface PathsDictionary {
 
 type Client = OpenAPIClient<OperationMethods, PathsDictionary>
 
+
 type Activity = Components.Schemas.Activity;
 type ActivityCallerContext = Components.Schemas.ActivityCallerContext;
 type ActivityId = Components.Schemas.ActivityId;
@@ -16353,6 +18352,9 @@ type BaseAttribute = Components.Schemas.BaseAttribute;
 type BaseEntity = Components.Schemas.BaseEntity;
 type BlueprintEntityId = Components.Schemas.BlueprintEntityId;
 type BooleanAttribute = Components.Schemas.BooleanAttribute;
+type Changeset = Components.Schemas.Changeset;
+type ChangesetCreator = Components.Schemas.ChangesetCreator;
+type ChangesetMap = Components.Schemas.ChangesetMap;
 type ClassificationId = Components.Schemas.ClassificationId;
 type ClassificationIdOrPattern = Components.Schemas.ClassificationIdOrPattern;
 type ClassificationSlug = Components.Schemas.ClassificationSlug;
@@ -16364,6 +18366,7 @@ type CurrencyAttribute = Components.Schemas.CurrencyAttribute;
 type DateAttribute = Components.Schemas.DateAttribute;
 type DefaultAddressFields = Components.Schemas.DefaultAddressFields;
 type ESClusterAssignment = Components.Schemas.ESClusterAssignment;
+type EditModeConfig = Components.Schemas.EditModeConfig;
 type EmailAttribute = Components.Schemas.EmailAttribute;
 type Entity = Components.Schemas.Entity;
 type EntityAcl = Components.Schemas.EntityAcl;
@@ -16403,6 +18406,7 @@ type ErrorObject = Components.Schemas.ErrorObject;
 type ExportJobId = Components.Schemas.ExportJobId;
 type FieldsParam = Components.Schemas.FieldsParam;
 type FileAttribute = Components.Schemas.FileAttribute;
+type FuzzyConfig = Components.Schemas.FuzzyConfig;
 type GenerateEntityTableAIFiltersRequest = Components.Schemas.GenerateEntityTableAIFiltersRequest;
 type GenerateEntityTableAIFiltersResponse = Components.Schemas.GenerateEntityTableAIFiltersResponse;
 type GetRelatedEntitiesCount = Components.Schemas.GetRelatedEntitiesCount;
@@ -16425,6 +18429,7 @@ type IsTemplate = Components.Schemas.IsTemplate;
 type Language = Components.Schemas.Language;
 type LinkAttribute = Components.Schemas.LinkAttribute;
 type ListSavedViewsResults = Components.Schemas.ListSavedViewsResults;
+type MatchStrategy = Components.Schemas.MatchStrategy;
 type MessageEmailAddressAttribute = Components.Schemas.MessageEmailAddressAttribute;
 type MultiSelectAttribute = Components.Schemas.MultiSelectAttribute;
 type NullableEntity = Components.Schemas.NullableEntity;
@@ -16471,4 +18476,4 @@ type TaxonomySlug = Components.Schemas.TaxonomySlug;
 type TextAttribute = Components.Schemas.TextAttribute;
 type UserRelationAttribute = Components.Schemas.UserRelationAttribute;
 
-export { type EntitySearchResults as $, type Activity as A, type BaseActivityItem as B, type Client as C, type DateAttribute as D, type ESClusterAssignment as E, type EntityAcl as F, type EntityAction as G, type EntityCapability as H, type EntityCapabilityWithCompositeID as I, type EntityDefaultCreate as J, type EntityDefaultEdit as K, type EntityDefaultTable as L, type EntityId as M, type EntityImportParams as N, type OperationMethods as O, Paths as P, type EntityItem as Q, type EntityListParams as R, type EntityOperation as S, type EntityOwner as T, type EntitySchema as U, type EntitySchemaGroup as V, type EntitySchemaGroupWithCompositeID as W, type EntitySchemaItem as X, type EntitySearchIncludeDeletedParam as Y, type EntitySearchOptions as Z, type EntitySearchParams as _, Components as a, type SearchMappings as a$, type EntitySlug as a0, type EntityTableFilterOption as a1, type EntityTableFilterSearch as a2, type EntityValidationError as a3, type EntityValidationResult as a4, type EntityValidationResultError as a5, type EntityValidationResultSuccess as a6, type EntityValidationV2Error as a7, type EntityValidationV2Result as a8, type EntityValidationV2ResultError as a9, type LinkAttribute as aA, type ListSavedViewsResults as aB, type MessageEmailAddressAttribute as aC, type MultiSelectAttribute as aD, type NullableEntity as aE, type NumberAttribute as aF, type OrderedListAttribute as aG, type PartnerOrganisationAttribute as aH, type PartnerStatusAttribute as aI, type PaymentAttribute as aJ, type PaymentMethodRelationAttribute as aK, type PhoneAttribute as aL, type PortalAccessAttribute as aM, type PriceComponentAttribute as aN, type PurposeAttribute as aO, type RedirectEntityView as aP, type RelationAttribute as aQ, type RelationEntity as aR, type RelationItem as aS, type RepeatableAttribute as aT, type SavedView as aU, type SavedViewId as aV, type SavedViewItem as aW, type SavedViewPartial as aX, type SchemaId as aY, type SearchFilter as aZ, type SearchFilterValue as a_, type EntityValidationV2ResultSuccess as aa, type EntityViewDisabled as ab, type ErrorObject as ac, type ExportJobId as ad, type FieldsParam as ae, type FileAttribute as af, type GenerateEntityTableAIFiltersRequest as ag, type GenerateEntityTableAIFiltersResponse as ah, GetRelatedEntitiesCount as ai, type GetRelationsResp as aj, type GetRelationsRespWithPagination as ak, type GraphDefinition as al, type GraphEdge as am, type GraphNode as an, type GraphQueryRequest as ao, type GraphQueryResponse as ap, type GraphSeed as aq, type GroupHeadline as ar, type GroupHeadlineWithCompositeID as as, type HydratedEntity as at, type HydratedEntityItem as au, type InternalAttribute as av, type InternalUserAttribute as aw, type InvitationEmailAttribute as ax, type IsTemplate as ay, type Language as az, type PathsDictionary as b, type SelectAttribute as b0, type SequenceAttribute as b1, type SettingFlag as b2, type StatusAttribute as b3, type SummaryAttribute as b4, type SummaryField as b5, type TableAttribute as b6, type TagsAttribute as b7, type Taxonomy as b8, type TaxonomyBulkJob as b9, type TaxonomyBulkJobActionType as ba, type TaxonomyBulkJobStatus as bb, type TaxonomyBulkJobTriggerResponse as bc, type TaxonomyClassification as bd, type TaxonomyLocationId as be, type TaxonomySearchIncludeArchivedParam as bf, type TaxonomySlug as bg, type TextAttribute as bh, type UserRelationAttribute as bi, type ActivityCallerContext as c, type ActivityId as d, type ActivityItem as e, type ActivityType as f, type AddressAttribute as g, type AddressRelationAttribute as h, type Attribute as i, type AttributeWithCompositeID as j, type AutomationAttribute as k, type BaseAttribute as l, type BaseEntity as m, type BlueprintEntityId as n, type BooleanAttribute as o, type ClassificationId as p, type ClassificationIdOrPattern as q, type ClassificationSlug as r, type ClassificationsUpdate as s, type ComputedAttribute as t, type ConsentAttribute as u, type CountryAttribute as v, type CurrencyAttribute as w, type DefaultAddressFields as x, type EmailAttribute as y, type Entity as z };
+export { type EntitySchemaItem as $, type Activity as A, type BaseActivityItem as B, type Client as C, type DateAttribute as D, type DefaultAddressFields as E, type ESClusterAssignment as F, type EditModeConfig as G, type EmailAttribute as H, type Entity as I, type EntityAcl as J, type EntityAction as K, type EntityCapability as L, type EntityCapabilityWithCompositeID as M, type EntityDefaultCreate as N, type OperationMethods as O, Paths as P, type EntityDefaultEdit as Q, type EntityDefaultTable as R, type EntityId as S, type EntityImportParams as T, type EntityItem as U, type EntityListParams as V, type EntityOperation as W, type EntityOwner as X, type EntitySchema as Y, type EntitySchemaGroup as Z, type EntitySchemaGroupWithCompositeID as _, Components as a, type SavedViewId as a$, type EntitySearchIncludeDeletedParam as a0, type EntitySearchOptions as a1, type EntitySearchParams as a2, type EntitySearchResults as a3, type EntitySlug as a4, type EntityTableFilterOption as a5, type EntityTableFilterSearch as a6, type EntityValidationError as a7, type EntityValidationResult as a8, type EntityValidationResultError as a9, type InternalAttribute as aA, type InternalUserAttribute as aB, type InvitationEmailAttribute as aC, type IsTemplate as aD, type Language as aE, type LinkAttribute as aF, type ListSavedViewsResults as aG, type MatchStrategy as aH, type MessageEmailAddressAttribute as aI, type MultiSelectAttribute as aJ, type NullableEntity as aK, type NumberAttribute as aL, type OrderedListAttribute as aM, type PartnerOrganisationAttribute as aN, type PartnerStatusAttribute as aO, type PaymentAttribute as aP, type PaymentMethodRelationAttribute as aQ, type PhoneAttribute as aR, type PortalAccessAttribute as aS, type PriceComponentAttribute as aT, type PurposeAttribute as aU, type RedirectEntityView as aV, type RelationAttribute as aW, type RelationEntity as aX, type RelationItem as aY, type RepeatableAttribute as aZ, type SavedView as a_, type EntityValidationResultSuccess as aa, type EntityValidationV2Error as ab, type EntityValidationV2Result as ac, type EntityValidationV2ResultError as ad, type EntityValidationV2ResultSuccess as ae, type EntityViewDisabled as af, type ErrorObject as ag, type ExportJobId as ah, type FieldsParam as ai, type FileAttribute as aj, type FuzzyConfig as ak, type GenerateEntityTableAIFiltersRequest as al, type GenerateEntityTableAIFiltersResponse as am, GetRelatedEntitiesCount as an, type GetRelationsResp as ao, type GetRelationsRespWithPagination as ap, type GraphDefinition as aq, type GraphEdge as ar, type GraphNode as as, type GraphQueryRequest as at, type GraphQueryResponse as au, type GraphSeed as av, type GroupHeadline as aw, type GroupHeadlineWithCompositeID as ax, type HydratedEntity as ay, type HydratedEntityItem as az, type PathsDictionary as b, type SavedViewItem as b0, type SavedViewPartial as b1, type SchemaId as b2, type SearchFilter as b3, type SearchFilterValue as b4, type SearchMappings as b5, type SelectAttribute as b6, type SequenceAttribute as b7, type SettingFlag as b8, type StatusAttribute as b9, type SummaryAttribute as ba, type SummaryField as bb, type TableAttribute as bc, type TagsAttribute as bd, type Taxonomy as be, type TaxonomyBulkJob as bf, type TaxonomyBulkJobActionType as bg, type TaxonomyBulkJobStatus as bh, type TaxonomyBulkJobTriggerResponse as bi, type TaxonomyClassification as bj, type TaxonomyLocationId as bk, type TaxonomySearchIncludeArchivedParam as bl, type TaxonomySlug as bm, type TextAttribute as bn, type UserRelationAttribute as bo, type ActivityCallerContext as c, type ActivityId as d, type ActivityItem as e, type ActivityType as f, type AddressAttribute as g, type AddressRelationAttribute as h, type Attribute as i, type AttributeWithCompositeID as j, type AutomationAttribute as k, type BaseAttribute as l, type BaseEntity as m, type BlueprintEntityId as n, type BooleanAttribute as o, type Changeset as p, type ChangesetCreator as q, type ChangesetMap as r, type ClassificationId as s, type ClassificationIdOrPattern as t, type ClassificationSlug as u, type ClassificationsUpdate as v, type ComputedAttribute as w, type ConsentAttribute as x, type CountryAttribute as y, type CurrencyAttribute as z };