@wix/automations 1.0.0

package/type-bundles/context.bundle.d.ts

@@ -0,0 +1,775 @@
+interface Activation {
+    /** Activation ID */
+    _id?: string;
+    /** Activation automation */
+    automation?: Automation;
+}
+/** Automation */
+interface Automation extends AutomationOriginInfoOneOf {
+    /** Application info */
+    applicationInfo?: ApplicationOrigin;
+    /** Preinstalled info */
+    preinstalledInfo?: PreinstalledOrigin;
+    /**
+     * Automation ID.
+     * @readonly
+     */
+    _id?: string | null;
+    /**
+     * Revision number, which increments by 1 each time the Automation is updated.
+     * To prevent conflicting changes,
+     * the current revision must be passed when updating the Automation.
+     *
+     * Ignored when creating an Automation.
+     * @readonly
+     */
+    revision?: string | null;
+    /**
+     * information about the creator of the automation
+     * @readonly
+     */
+    createdBy?: AuditInfo;
+    /**
+     * Date and time the Automation was created.
+     * @readonly
+     */
+    _createdDate?: Date;
+    /**
+     * information about who updated of the automation
+     * @readonly
+     */
+    updatedBy?: AuditInfo;
+    /**
+     * Date and time the Automation was last updated.
+     * @readonly
+     */
+    _updatedDate?: Date;
+    /** Automation name */
+    name?: string;
+    /** Automation description */
+    description?: string | null;
+    /** Automation runtime configuration */
+    configuration?: AutomationConfiguration;
+    /** Origin type */
+    origin?: Origin;
+    /** Automation settings */
+    settings?: AutomationSettings;
+}
+/** @oneof */
+interface AutomationOriginInfoOneOf {
+    /** Application info */
+    applicationInfo?: ApplicationOrigin;
+    /** Preinstalled info */
+    preinstalledInfo?: PreinstalledOrigin;
+}
+interface ActionSettings {
+    /** list of permanent action ids of actions that cannot be deleted (default - empty, all actions are deletable by default) */
+    permanentActionIds?: string[];
+    /** list of readonly action ids, (default - empty, all actions are editable by default) */
+    readonlyActionIds?: string[];
+    /** sets if adding a delay action is disabled for this automation */
+    disableDelayAddition?: boolean;
+    /** sets if adding a condition action is disabled for this automation */
+    disableConditionAddition?: boolean;
+}
+interface AuditInfo extends AuditInfoIdOneOf {
+    /** user identifier */
+    userId?: string;
+    /** application identifier */
+    appId?: string;
+}
+/** @oneof */
+interface AuditInfoIdOneOf {
+    /** user identifier */
+    userId?: string;
+    /** application identifier */
+    appId?: string;
+}
+/** Automation runtime configuration */
+interface AutomationConfiguration {
+    /** Automation's Status */
+    status?: AutomationConfigurationStatus;
+    /** Trigger configuration */
+    trigger?: Trigger;
+    /** actions that run in parallel after the trigger */
+    rootActionIds?: string[];
+    /**
+     * map of all actions by actionId
+     * The key is the actionId of the action, and the value is the action configuration
+     */
+    actions?: Record<string, AutomationConfigurationAction>;
+}
+declare enum TimeUnit {
+    UNDEFINED = "UNDEFINED",
+    MINUTES = "MINUTES",
+    HOURS = "HOURS",
+    DAYS = "DAYS",
+    WEEKS = "WEEKS",
+    MONTHS = "MONTHS"
+}
+interface Filter {
+    /** the filter identifier */
+    _id?: string;
+    /** the field key from the schema, for example "formId" */
+    fieldKey?: string;
+    /** filter expression that evaluates to a boolean, for example - {{ contains(["guid1","guid2"];formId) }} */
+    filterExpression?: string;
+}
+interface FutureDateActivationOffset {
+    /**
+     * expression of offset before the trigger's time (in selected time unit), when the Automation should run
+     * only allows negative offset from the trigger's date (before the trigger), positive offset should be achieved via offset delay action
+     * preScheduledEventOffsetExpression: "{{5}}" + timeUnit: Days -  to run the Automation 5 days before the trigger's date
+     * or, preScheduledEventOffsetExpression: "{{ someNumberField }}" + timeUnit: Minutes, to run the Automation someNumberField's value in minutes before the trigger's date
+     */
+    preScheduledEventOffsetExpression?: string;
+    /** Time unit for the scheduled event offset */
+    scheduledEventOffsetTimeUnit?: TimeUnit;
+}
+interface ConditionExpressionGroup {
+    /** expression group operator */
+    operator?: Operator;
+    /**
+     * list of boolean expressions to be evaluated with the given operator
+     * examples - {{ true }}, {{ someBooleanField }}, {{ contains(["guid1...","guid2..."];formId) }}
+     */
+    booleanExpressions?: string[];
+}
+declare enum Operator {
+    UNKNOWN_OPERATOR = "UNKNOWN_OPERATOR",
+    OR = "OR",
+    AND = "AND"
+}
+declare enum Type {
+    /** Automation will be triggered according to the trigger configuration */
+    UNKNOWN_ACTION_TYPE = "UNKNOWN_ACTION_TYPE",
+    /** App defined Action */
+    APP_DEFINED = "APP_DEFINED",
+    /** Condition Action */
+    CONDITION = "CONDITION",
+    /** Delay Action */
+    DELAY = "DELAY",
+    /** RateLimit Action */
+    RATE_LIMIT = "RATE_LIMIT",
+    /** Output Action */
+    OUTPUT = "OUTPUT"
+}
+interface AppDefinedAction {
+    /** Action app id */
+    appId?: string;
+    /** Action key */
+    actionKey?: string;
+    /**
+     * Action input mapping, example:
+     * {
+     * "to": "{{ var(contact.email) }}",
+     * "subject": "Your registration to {{ var(eventName) }} is Confirmed",
+     * "body": "Hi {{ var(contact.name) }}, you are confirmed for the event"
+     * }
+     */
+    inputMapping?: Record<string, any> | null;
+    /**
+     * optional skip condition configuration - if this action should be skipped when the automation runs (following actions of a skipped action will still run)
+     * the action will be skipped if either of the expression groups evaluate to `true`
+     * the relation between the expression groups is an OR relation.
+     */
+    skipConditionOrExpressionGroups?: ConditionExpressionGroup[];
+    /** actions to run in parallel after this action finishes */
+    postActionIds?: string[];
+}
+interface ConditionAction {
+    /**
+     * the condition evaluates to `true` if either of the expression groups evaluate to `true`
+     * the relation between the expression groups is an OR relation.
+     */
+    orExpressionGroups?: ConditionExpressionGroup[];
+    /** actions to run when the entire condition is evaluated to `true` */
+    truePostActionIds?: string[];
+    /** actions to run when the entire condition is evaluated to `false` */
+    falsePostActionIds?: string[];
+}
+interface DelayAction {
+    /**
+     * optional - expression for amount of time to wait (in selected time unit) - from a specific date or from the time the action is executed
+     * offsetExpression: "{{5}}" + timeUnit: Days -  to wait for 5 days from the time the delay was invoked
+     * or, offsetExpression: "{{5}}" + timeUnit: Days + dueDateEpochExpression: "{{someDateField}}" -  to wait for 5 days from the time date in "someDateField" field in the payload
+     * or, offsetExpression: "{{ someNumberField }}" + timeUnit: Minutes,  to wait for someNumberField's value in minutes
+     */
+    offsetExpression?: string | null;
+    /** Time unit for delay offset */
+    offsetTimeUnit?: TimeUnit;
+    /**
+     * optional - expression of the due date to wait until, if an offset was defined, it will be calculated from this date
+     * number of milliseconds since the Unix Epoch (1 January, 1970 UTC)
+     * for example - "{{ 18238348023423 }}", or "{{ someEpochFromPayloadField }}" / "{{ contact.birthdate }}"
+     */
+    dueDateEpochExpression?: string | null;
+    /** actions to run in parallel after this action finishes */
+    postActionIds?: string[];
+}
+interface RateLimitAction {
+    /**
+     * Maximum number of activations expression. the expression will need to be parsed to Int on runtime
+     * for example - "{{ 1 }}" to set max activations to 1, or "{{ var(someNumberField) }}" to set max activations as the value of "someNumberField" from the payload
+     */
+    maxActivationsExpression?: string;
+    /**
+     * Duration of the rate limiting window (in selected time unit) expression for rate limiter, if empty then no time limit. the expression will need to be parsed to Int on runtime
+     * for example - "{{ 10 }}" to set timeframe to be 10 minutes, or {{ var(someNumberField) }} to set timeframe in minutes as the value of "someNumberField" from the payload
+     */
+    rateLimitDurationExpression?: string | null;
+    /** Time unit for the rate limit duration */
+    rateLimitDurationTimeUnit?: TimeUnit;
+    /**
+     * Unique identifier of each activation by which rate limiter will count activations, expected return type is string
+     * for example - {{ var(contact.id) }} to set the unique identifier as the value of "contact.id" from the payload
+     */
+    uniqueIdentifierExpression?: string | null;
+    /** actions to run in parallel after this action finishes */
+    postActionIds?: string[];
+}
+declare enum AutomationConfigurationStatus {
+    /** unused */
+    UNKNOWN_STATUS = "UNKNOWN_STATUS",
+    /** Automation will be triggered according to the trigger configuration */
+    ACTIVE = "ACTIVE",
+    /** Automation will not be triggered */
+    INACTIVE = "INACTIVE"
+}
+interface Trigger {
+    /** Trigger Application id */
+    appId?: string;
+    /** Trigger key */
+    triggerKey?: string;
+    /**
+     * optional - list of filters on schema fields
+     * the relation between the filter expressions is an AND relation.
+     * all filter expressions must be evaluated to `true` for a given payload in order for the automation to be executed
+     */
+    filters?: Filter[];
+    /** optional - future date trigger activation offset */
+    scheduledEventOffset?: FutureDateActivationOffset;
+}
+interface AutomationConfigurationAction extends AutomationConfigurationActionInfoOneOf {
+    /** App defined Action (via RPC, HTTP or Velo) */
+    appDefinedInfo?: AppDefinedAction;
+    /** Condition action */
+    conditionInfo?: ConditionAction;
+    /** Delay action */
+    delayInfo?: DelayAction;
+    /** Rate limiting action */
+    rateLimitInfo?: RateLimitAction;
+    /** Action id, if not specified, will be generated */
+    _id?: string | null;
+    /** Type of the action */
+    type?: Type;
+    /**
+     * Human readable name for the action (may only contain alphanumeric characters and underscores) to differentiate from other actions of the same kind.
+     * if the action has output, the output will be available in the payload under this name, otherwise it will be concatenated to the payload as is
+     * without namespaces (or in case of exact same namespaces), if the user has multiple actions of the same kind (appId+actionKey), the output will be overwritten.
+     *
+     * for example, given:
+     * - if the action output looks like this - { "message": "hello" }
+     * - the namespace is "action_1"
+     * - the trigger payload looks like this - { "someField": "50", "someBoolean": true }
+     *
+     * the payload will look like this:
+     * {
+     * "someField": "50",
+     * "someBoolean": true,
+     * "action_1": {
+     * "message": "hello"
+     * }
+     * }
+     *
+     * given the following Automation configuration:
+     *
+     * (Trigger A)
+     * |
+     * (Action B) // namespace = "action_b_1"
+     * |
+     * (Action B) // namespace = "action_b_2"
+     * |
+     * (Action C)
+     *
+     *
+     * the available fields that Action C will be able to use to map to it's input fields will be:
+     * {
+     * "someField": "50",
+     * "someBoolean": true,
+     * "action_b_1": {
+     * "message": "hello"
+     * },
+     * "action_b_2": {
+     * "message": "hello"
+     * }
+     * }
+     * so the user can select which specific action output to use (action_b_1.message or action_b_2.message, in the case above)
+     */
+    namespace?: string | null;
+}
+/** @oneof */
+interface AutomationConfigurationActionInfoOneOf {
+    /** App defined Action (via RPC, HTTP or Velo) */
+    appDefinedInfo?: AppDefinedAction;
+    /** Condition action */
+    conditionInfo?: ConditionAction;
+    /** Delay action */
+    delayInfo?: DelayAction;
+    /** Rate limiting action */
+    rateLimitInfo?: RateLimitAction;
+}
+declare enum Origin {
+    /** default value. this is unused */
+    UNKNOWN_ORIGIN = "UNKNOWN_ORIGIN",
+    /** user created automation */
+    USER = "USER",
+    /** automation created by application (site specific) */
+    APPLICATION = "APPLICATION",
+    /** preinstalled application automation */
+    PREINSTALLED = "PREINSTALLED"
+}
+interface ApplicationOrigin {
+    /** identifier for the application */
+    appId?: string;
+}
+interface PreinstalledOrigin {
+    /** identifier for the application */
+    appId?: string;
+    /** application component ID */
+    componentId?: string;
+    /** application component Version */
+    componentVersion?: number;
+    /**
+     * is this a user modified preinstalled automation (on a specific site) or the original one
+     * @readonly
+     */
+    override?: boolean | null;
+}
+interface AutomationSettings {
+    /** sets if the automation is hidden from users */
+    hidden?: boolean;
+    /** sets if the automation is readonly */
+    readonly?: boolean;
+    /** sets if deleting the automation is disabled */
+    disableDelete?: boolean;
+    /** sets if changing the automation status is disabled (from active to inactive and vice versa) */
+    disableStatusChange?: boolean;
+    /** Automation's action settings */
+    actionSettings?: ActionSettings;
+}
+interface ActivationStatusChanged extends ActivationStatusChangedStatusInfoOneOf {
+    /** Initiated status information */
+    initiatedInfo?: InitiatedStatusInfo;
+    /** Scheduled status information */
+    scheduledInfo?: ScheduledStatusInfo;
+    /** Cancelled status information */
+    cancelledInfo?: CancelledStatusInfo;
+    /** Failed status information */
+    failedInfo?: ActivationStatusChangedFailedStatusInfo;
+    /** Activation */
+    activation?: Activation;
+    /** Activation status */
+    status?: ActivationStatusChangedStatus;
+    /** Change event created date */
+    statusChangedDate?: Date;
+}
+/** @oneof */
+interface ActivationStatusChangedStatusInfoOneOf {
+    /** Initiated status information */
+    initiatedInfo?: InitiatedStatusInfo;
+    /** Scheduled status information */
+    scheduledInfo?: ScheduledStatusInfo;
+    /** Cancelled status information */
+    cancelledInfo?: CancelledStatusInfo;
+    /** Failed status information */
+    failedInfo?: ActivationStatusChangedFailedStatusInfo;
+}
+declare enum Target {
+    UNKNOWN_TARGET = "UNKNOWN_TARGET",
+    SCHEDULE = "SCHEDULE",
+    IMMEDIATE = "IMMEDIATE"
+}
+declare enum CancellationReason {
+    UNKNOWN_CANCELLATION_REASON = "UNKNOWN_CANCELLATION_REASON",
+    /** Indicating that the activation was cancelled directly */
+    EVENT_CANCELLED = "EVENT_CANCELLED",
+    /** Indicating that the activation is cancelled because the automation was deactivated */
+    AUTOMATION_DEACTIVATED = "AUTOMATION_DEACTIVATED",
+    /** Indicating that the activation is cancelled because the automation was deleted */
+    AUTOMATION_DELETED = "AUTOMATION_DELETED"
+}
+interface Identity {
+    /** User ID */
+    userId?: string | null;
+    /** App ID */
+    appId?: string | null;
+}
+declare enum ActivationStatusChangedStatus {
+    UNKNOWN_STATUS = "UNKNOWN_STATUS",
+    /** This indicates activation is not started yet (no action has run yet) */
+    INITIATED = "INITIATED",
+    /** The activation is in scheduled status when the automation has future date or debounce defined and we're in the waiting stage (no action has run yet) */
+    SCHEDULED = "SCHEDULED",
+    /** This indicates the automation activation has started and currently in progress */
+    STARTED = "STARTED",
+    /** This indicates all the automation actions were handled either by invoking them, skipping them etc. */
+    ENDED = "ENDED",
+    /** This indicates the activation was cancelled */
+    CANCELLED = "CANCELLED",
+    /**
+     * This indicates the activation failed to start
+     * Note that failure in the activation of a single action will not result a failure in activation of the entire automation
+     */
+    FAILED = "FAILED"
+}
+interface InitiatedStatusInfo {
+    /** Activation target */
+    target?: Target;
+    /** Event payload */
+    payload?: Record<string, any> | null;
+    /** External entity ID */
+    externalEntityId?: string | null;
+    /** Unique identifier for the request that initiated the automation */
+    requestId?: string;
+}
+interface ScheduledStatusInfo {
+    /** Schedule identifier */
+    scheduleId?: string;
+    /** Indicating when the activation should start */
+    date?: Date;
+}
+interface CancelledStatusInfo {
+    /** Cancellation reason */
+    reason?: CancellationReason;
+    /** The identity (such as user, app etc.) that caused the cancellation */
+    initiator?: Identity;
+}
+interface ActivationStatusChangedFailedStatusInfo {
+    /**
+     * Error description
+     * @readonly
+     */
+    errorDescription?: string;
+    /**
+     * Error code
+     * @readonly
+     */
+    errorCode?: string | null;
+}
+interface IdentificationData extends IdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+    /** ID of an app. */
+    appId?: string;
+    /** @readonly */
+    identityType?: WebhookIdentityType;
+}
+/** @oneof */
+interface IdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+    /** ID of an app. */
+    appId?: string;
+}
+declare enum WebhookIdentityType {
+    UNKNOWN = "UNKNOWN",
+    ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR",
+    MEMBER = "MEMBER",
+    WIX_USER = "WIX_USER",
+    APP = "APP"
+}
+interface Idempotency {
+    /**
+     * A unique identifier for the event.
+     * If you send the same idempotency key in multiple report event requests, for the same trigger key and app id,
+     * consecutive requests will be ignored after the first one. Note that the idempotency key is kept for a week before it expires.
+     */
+    key?: string;
+    /** Optional. The time to live (TTL) in milliseconds before the key will expire. Default is a week. */
+    ttlInMilliseconds?: string | null;
+}
+interface ReportEventResponse {
+    /** The activation IDs of triggered ReportEvents. */
+    activationIds?: string[];
+}
+interface EventInfo {
+    /**
+     * Event payload, formatted as key:value pairs.
+     * Must comply with the payload schema
+     * if you provided one when configuring your trigger.
+     */
+    payload?: Record<string, any> | null;
+    /** ID of the related resource in GUID format. */
+    externalEntityId?: string | null;
+    /** Idempotency information for the event */
+    idempotency?: Idempotency;
+}
+interface BulkReportEventResponse {
+    /** Trigger key associated with the event */
+    triggerKey?: string;
+    /** List of results for each item in the bulk report event request */
+    results?: BulkReportEventResult[];
+    /** Metadata for the overall bulk action, including success and failure counts */
+    bulkActionMetadata?: BulkActionMetadata;
+}
+interface BulkReportEventResult {
+    /** Metadata for the individual item in the request */
+    itemMetadata?: ItemMetadata;
+    /** Event details for the item in the request */
+    eventInfo?: EventInfo;
+    /** The activation IDs of triggered ReportEvents. */
+    activationIds?: string[];
+}
+interface ItemMetadata {
+    /** Item ID. Should always be available, unless it's impossible (for example, when failing to create an item). */
+    _id?: string | null;
+    /** Index of the item within the request array. Allows for correlation between request and response items. */
+    originalIndex?: number;
+    /** Whether the requested action was successful for this item. When `false`, the `error` field is populated. */
+    success?: boolean;
+    /** Details about the error in case of failure. */
+    error?: ApplicationError;
+}
+interface ApplicationError {
+    /** Error code. */
+    code?: string;
+    /** Description of the error. */
+    description?: string;
+    /** Data related to the error. */
+    data?: Record<string, any> | null;
+}
+interface BulkActionMetadata {
+    /** Number of items that were successfully processed. */
+    totalSuccesses?: number;
+    /** Number of items that couldn't be processed. */
+    totalFailures?: number;
+    /** Number of failures without details because detailed failure threshold was exceeded. */
+    undetailedFailures?: number;
+}
+interface BulkCancelEventResponse {
+    /** Trigger key related to the cancelled event */
+    triggerKey?: string;
+    /** List of results for each item in the bulk cancel event request */
+    results?: BulkCancelEventResult[];
+    /** Metadata for the overall bulk action, including success and failure counts */
+    bulkActionMetadata?: BulkActionMetadata;
+}
+interface BulkCancelEventResult {
+    /** Metadata of the item, including its ID and success or failure status */
+    itemMetadata?: ItemMetadata;
+    /** ID of the related resource in GUID format */
+    externalEntityId?: string;
+}
+interface ReportEventResponseNonNullableFields {
+    activationIds: string[];
+}
+interface BulkReportEventResponseNonNullableFields {
+    triggerKey: string;
+    results: {
+        itemMetadata?: {
+            originalIndex: number;
+            success: boolean;
+            error?: {
+                code: string;
+                description: string;
+            };
+        };
+        eventInfo?: {
+            idempotency?: {
+                key: string;
+            };
+        };
+        activationIds: string[];
+    }[];
+    bulkActionMetadata?: {
+        totalSuccesses: number;
+        totalFailures: number;
+        undetailedFailures: number;
+    };
+}
+interface BulkCancelEventResponseNonNullableFields {
+    triggerKey: string;
+    results: {
+        itemMetadata?: {
+            originalIndex: number;
+            success: boolean;
+            error?: {
+                code: string;
+                description: string;
+            };
+        };
+        externalEntityId: string;
+    }[];
+    bulkActionMetadata?: {
+        totalSuccesses: number;
+        totalFailures: number;
+        undetailedFailures: number;
+    };
+}
+interface BaseEventMetadata {
+    /** App instance ID. */
+    instanceId?: string | null;
+    /** Event type. */
+    eventType?: string;
+    /** The identification type and identity data. */
+    identity?: IdentificationData;
+}
+interface EventMetadata extends BaseEventMetadata {
+    /**
+     * Unique event ID.
+     * Allows clients to ignore duplicate webhooks.
+     */
+    _id?: string;
+    /**
+     * Assumes actions are also always typed to an entity_type
+     * Example: wix.stores.catalog.product, wix.bookings.session, wix.payments.transaction
+     */
+    entityFqdn?: string;
+    /**
+     * This is top level to ease client code dispatching of messages (switch on entity_fqdn+slug)
+     * This is although the created/updated/deleted notion is duplication of the oneof types
+     * Example: created/updated/deleted/started/completed/email_opened
+     */
+    slug?: string;
+    /** ID of the entity associated with the event. */
+    entityId?: string;
+    /** Event timestamp. */
+    eventTime?: Date;
+    /**
+     * Whether the event was triggered as a result of a privacy regulation application
+     * (for example, GDPR).
+     */
+    triggeredByAnonymizeRequest?: boolean | null;
+    /** If present, indicates the action that triggered the event. */
+    originatedFrom?: string | null;
+    /**
+     * A sequence number defining the order of updates to the underlying entity.
+     * For example, given that some entity was updated at 16:00 and than again at 16:01,
+     * it is guaranteed that the sequence number of the second update is strictly higher than the first.
+     * As the consumer, you can use this value to ensure that you handle messages in the correct order.
+     * To do so, you will need to persist this number on your end, and compare the sequence number from the
+     * message against the one you have stored. Given that the stored number is higher, you should ignore the message.
+     */
+    entityEventSequence?: string | null;
+}
+interface ActivationStatusChangedEnvelope {
+    data: ActivationStatusChanged;
+    metadata: EventMetadata;
+}
+interface ReportEventOptions {
+    /**
+     * Event payload, formatted as key:value pairs.
+     * Must comply with the payload schema
+     * if you provided one when configuring your trigger.
+     *
+     * Key names can include only alphanumeric characters or underscores
+     * (`A-Z`, `a-z`, `0-9`, `_`).
+     * They cannot start with an underscore.
+     *
+     * Values can be strings, numbers, integers, booleans, or arrays.
+     * If a value is an array, the array items must be objects,
+     * and nested object properties must be
+     * strings, numbers, integers, or booleans only.
+     */
+    payload?: Record<string, any> | null;
+    /**
+     * ID of the related resource in GUID format.
+     * For example, `fc81a355-3429-50fc-a4c7-def486e828f3`.
+     *
+     * Required if your app needs to
+     * [cancel the event](https://dev.wix.com/docs/rest/business-management/automations/triggered-events/cancel-event)
+     * if the automation becomes no longer relevant.
+     *
+     * Typically, this ID is defined in your system,
+     * but you can also use any Wix resource GUID,
+     * such as contact ID, member ID, or invoice ID.
+     * See
+     * [Choose the right `externalEntityId`](https://dev.wix.com/docs/rest/business-management/automations/triggered-events/reporting-and-canceling-events#about-canceling-events)
+     * for more information.
+     */
+    externalEntityId?: string | null;
+    /** Idempotency information for the event */
+    idempotency?: Idempotency;
+}
+interface BulkReportEventOptions {
+    /** Repeated list of event details for bulk reporting */
+    eventsInfo: EventInfo[];
+}
+interface BulkCancelEventOptions {
+    /** Repeated list of external_entity_id, representing the related resources' IDs */
+    externalEntityIds: string[];
+}
+interface CancelEventOptions {
+    /**
+     * Trigger key whose event you want to cancel.
+     * For example, `form_submitted` or `invoice_due`.
+     */
+    triggerKey: string;
+}
+
+type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
+interface HttpClient {
+    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+}
+type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
+type HttpResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata;
+type APIMetadata = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
+type EventDefinition<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: unknown;
+    __payload: Payload;
+};
+declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?: boolean, _transformations?: unknown): <Payload = unknown>() => EventDefinition<Payload, Type>;
+type EventHandler<T extends EventDefinition> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition<T extends EventDefinition<any, string>> = (handler: EventHandler<T>) => void;
+
+declare function reportEvent$1(httpClient: HttpClient): (triggerKey: string, options?: ReportEventOptions) => Promise<ReportEventResponse & ReportEventResponseNonNullableFields>;
+declare function bulkReportEvent$1(httpClient: HttpClient): (triggerKey: string, options: BulkReportEventOptions) => Promise<BulkReportEventResponse & BulkReportEventResponseNonNullableFields>;
+declare function bulkCancelEvent$1(httpClient: HttpClient): (triggerKey: string, options: BulkCancelEventOptions) => Promise<BulkCancelEventResponse & BulkCancelEventResponseNonNullableFields>;
+declare function cancelEvent$1(httpClient: HttpClient): (externalEntityId: string, options: CancelEventOptions) => Promise<void>;
+declare const onActivationStatusChanged$1: EventDefinition<ActivationStatusChangedEnvelope, "wix.automations.v2.activation_activation_status_changed">;
+
+declare const reportEvent: BuildRESTFunction<typeof reportEvent$1>;
+declare const bulkReportEvent: BuildRESTFunction<typeof bulkReportEvent$1>;
+declare const bulkCancelEvent: BuildRESTFunction<typeof bulkCancelEvent$1>;
+declare const cancelEvent: BuildRESTFunction<typeof cancelEvent$1>;
+declare const onActivationStatusChanged: BuildEventDefinition<typeof onActivationStatusChanged$1>;
+
+declare const context_bulkCancelEvent: typeof bulkCancelEvent;
+declare const context_bulkReportEvent: typeof bulkReportEvent;
+declare const context_cancelEvent: typeof cancelEvent;
+declare const context_onActivationStatusChanged: typeof onActivationStatusChanged;
+declare const context_reportEvent: typeof reportEvent;
+declare namespace context {
+  export { context_bulkCancelEvent as bulkCancelEvent, context_bulkReportEvent as bulkReportEvent, context_cancelEvent as cancelEvent, context_onActivationStatusChanged as onActivationStatusChanged, context_reportEvent as reportEvent };
+}
+
+export { context as activations };