@boostxyz/sdk 0.0.0-alpha.8 → 1.1.0-alpha.22

package/dist/Actions/EventAction.d.ts

@@ -1,10 +1,262 @@
 import { eventActionAbi } from '@boostxyz/evm';
-import { type Abi, type AbiEvent, type Address, type ContractEventName, type Hex, type Log } from 'viem';
+import { type AbiEvent, type AbiFunction, type Address, type ContractFunctionName, type GetLogsReturnType, type Hex, type Transaction } from 'viem';
 import type { DeployableOptions, GenericDeployableParams } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import { type ActionClaimant, type ActionStep, type Criteria, type EventActionPayload, FilterType, type GetLogsParams, PrimitiveType, type ReadParams, RegistryType, type WriteParams } from '../utils';
-import type { SignatureType } from './../utils';
-export type { EventActionPayload, ActionStep, ActionClaimant, SignatureType, FilterType, PrimitiveType, };
+import { type ReadParams, RegistryType, type WriteParams } from '../utils';
+/**
+ * Filter types used to determine how criteria are evaluated.
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum FilterType {
+    EQUAL = 0,
+    NOT_EQUAL = 1,
+    GREATER_THAN = 2,
+    LESS_THAN = 3,
+    CONTAINS = 4,
+    REGEX = 5
+}
+/**
+ * The primitive types supported for filtering.
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum PrimitiveType {
+    UINT = 0,
+    ADDRESS = 1,
+    BYTES = 2,
+    STRING = 3
+}
+/**
+ * Object representation of a `Criteria` struct used in event actions.
+ *
+ * @export
+ * @interface Criteria
+ * @typedef {Criteria}
+ */
+export interface Criteria {
+    /**
+     * The filter type used in this criteria.
+     *
+     * @type {FilterType}
+     */
+    filterType: FilterType;
+    /**
+     * The primitive type of the field being filtered.
+     *
+     * @type {PrimitiveType}
+     */
+    fieldType: PrimitiveType;
+    /**
+     * The index in the logs argument array where the field is located.
+     *
+     * @type {number}
+     */
+    fieldIndex: number;
+    /**
+     * The filter data used for complex filtering.
+     *
+     * @type {Hex}
+     */
+    filterData: Hex;
+}
+/**
+ * Whether a given signature is an event or function
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum SignatureType {
+    EVENT = 0,
+    FUNC = 1
+}
+/**
+ *  The payload describing how claimants are identified
+ *
+ * @export
+ * @interface ActionClaimant
+ * @typedef {ActionClaimant}
+ */
+export interface ActionClaimant {
+    /**
+     * Whether claimaint is inferred from event or function
+     *
+     * @type {SignatureType}
+     */
+    signatureType: SignatureType;
+    /**
+     * The 4 byte signature of the event or function
+     *
+     * @type {Hex}
+     */
+    signature: Hex;
+    /**
+     * The index corresponding to claimant.
+     *
+     * @type {number}
+     */
+    fieldIndex: number;
+    /**
+     * The address of the target contract
+     *
+     * @type {Address}
+     */
+    targetContract: Address;
+    /**
+     * The chain id of the target contract.
+     * @type {number}
+     */
+    chainid: number;
+}
+/**
+ * Object representation of an `ActionStep` struct used in event actions.
+ *
+ * @export
+ * @interface ActionStep
+ * @typedef {ActionStep}
+ */
+export interface ActionStep {
+    /**
+     * The signature of the event.
+     *
+     * @type {Hex}
+     */
+    signature: Hex;
+    /**
+     * Whether claimaint is inferred from event or function
+     *
+     * @type {SignatureType}
+     */
+    signatureType: SignatureType;
+    /**
+     * The type of action being performed.
+     *
+     * @type {number}
+     */
+    actionType?: number;
+    /**
+     * The address of the target contract.
+     *
+     * @type {Address}
+     */
+    targetContract: Address;
+    /**
+     * The chain id of the target contract.
+     * @type {number}
+     */
+    chainid: number;
+    /**
+     * The criteria used for this action step.
+     *
+     * @type {Criteria}
+     */
+    actionParameter: Criteria;
+}
+/**
+ * Parameters for validating an action step.
+ *
+ * @typedef {Object} ValidateActionStepParams
+ * @property {Record<Hex, AbiEvent | AbiFunction>} [knownSignatures] - Optional record of known events, keyed by 32 byte selectors.
+ * @property {AbiEvent | AbiFunction} [abiItem] - Optional ABI item definition.
+ * @property {EventLogs} [logs] - Event logs to validate against. Required if 'hash' is not provided.
+ * @property {Hex} [hash] - Transaction hash to validate against. Required if 'logs' is not provided.
+ * @property {number} [chainId] - Chain ID for the transaction. Required if 'hash' is provided.
+ */
+export type ValidateActionStepParams = {
+    knownSignatures?: Record<Hex, AbiEvent | AbiFunction>;
+    abiItem?: AbiEvent | AbiFunction;
+} & ({
+    logs: EventLogs;
+} | {
+    hash: Hex;
+    chainId: number;
+});
+/**
+ * You can either supply a simplified version of the payload, or one that explicitly declares action steps.
+ *
+ * @export
+ * @typedef {EventActionPayload}
+ */
+export type EventActionPayload = EventActionPayloadSimple | EventActionPayloadRaw;
+export interface EventActionPayloadSimple {
+    /**
+     *  The payload describing how claimants are identified
+     *
+     * @type {ActionClaimant}
+     */
+    actionClaimant: ActionClaimant;
+    /**
+     * Up to 4 action steps.
+     * If you supply less than 4, then the last step will be reused to satisfy the EventAction.InitPayload
+     * Any more than 4 will throw an error.
+     *
+     * @type {ActionStep[]}
+     */
+    actionSteps: ActionStep[];
+}
+export type ActionStepTuple = [ActionStep, ActionStep, ActionStep, ActionStep];
+/**
+ * Typeguard to determine if a user is supplying a simple or raw EventActionPayload
+ *
+ * @param {*} opts
+ * @returns {opts is EventActionPayloadSimple}
+ */
+export declare function isEventActionPayloadSimple(opts: EventActionPayload): opts is EventActionPayloadSimple;
+/**
+ * Object representation of an `InitPayload` struct used to initialize event actions.
+ *
+ * @export
+ * @interface EventActionPayloadRaw
+ * @typedef {EventActionPayloadRaw}
+ */
+export interface EventActionPayloadRaw {
+    /**
+     *  The payload describing how claimants are identified
+     *
+     * @type {ActionClaimant}
+     */
+    actionClaimant: ActionClaimant;
+    /**
+     * The first action step.
+     *
+     * @type {ActionStep}
+     */
+    actionStepOne: ActionStep;
+    /**
+     * The second action step.
+     *
+     * @type {ActionStep}
+     */
+    actionStepTwo: ActionStep;
+    /**
+     * The third action step.
+     *
+     * @type {ActionStep}
+     */
+    actionStepThree: ActionStep;
+    /**
+     * The fourth action step.
+     *
+     * @type {ActionStep}
+     */
+    actionStepFour: ActionStep;
+}
+/**
+ * Array of event logs to pass into TxParams
+ * @export
+ * @typedef {EventLogs}
+ */
+export type EventLogs = GetLogsReturnType<AbiEvent, AbiEvent[], true>;
+/**
+ * Getter params from the event action contract
+ *
+ * @export
+ * @typedef {ReadEventActionParams}
+ * @param {fnName} fnName - The getter function name
+ */
+export type ReadEventActionParams<fnName extends ContractFunctionName<typeof eventActionAbi, 'pure' | 'view'>> = ReadParams<typeof eventActionAbi, fnName>;
 /**
  * A generic event action
  *
@@ -146,8 +398,8 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
                 readonly type: "uint8";
             }, {
                 readonly name: "signature";
-                readonly internalType: "bytes4";
-                readonly type: "bytes4";
+                readonly internalType: "bytes32";
+                readonly type: "bytes32";
             }, {
                 readonly name: "fieldIndex";
                 readonly internalType: "uint8";
@@ -156,6 +408,10 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
                 readonly name: "targetContract";
                 readonly internalType: "address";
                 readonly type: "address";
+            }, {
+                readonly name: "chainid";
+                readonly internalType: "uint256";
+                readonly type: "uint256";
             }];
         }];
         readonly stateMutability: "view";
@@ -173,8 +429,8 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
             readonly type: "tuple";
             readonly components: readonly [{
                 readonly name: "signature";
-                readonly internalType: "bytes4";
-                readonly type: "bytes4";
+                readonly internalType: "bytes32";
+                readonly type: "bytes32";
             }, {
                 readonly name: "signatureType";
                 readonly internalType: "enum AEventAction.SignatureType";
@@ -187,6 +443,10 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
                 readonly name: "targetContract";
                 readonly internalType: "address";
                 readonly type: "address";
+            }, {
+                readonly name: "chainid";
+                readonly internalType: "uint256";
+                readonly type: "uint256";
             }, {
                 readonly name: "actionParameter";
                 readonly internalType: "struct AEventAction.Criteria";
@@ -221,8 +481,8 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
             readonly type: "tuple[]";
             readonly components: readonly [{
                 readonly name: "signature";
-                readonly internalType: "bytes4";
-                readonly type: "bytes4";
+                readonly internalType: "bytes32";
+                readonly type: "bytes32";
             }, {
                 readonly name: "signatureType";
                 readonly internalType: "enum AEventAction.SignatureType";
@@ -235,6 +495,10 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
                 readonly name: "targetContract";
                 readonly internalType: "address";
                 readonly type: "address";
+            }, {
+                readonly name: "chainid";
+                readonly internalType: "uint256";
+                readonly type: "uint256";
             }, {
                 readonly name: "actionParameter";
                 readonly internalType: "struct AEventAction.Criteria";
@@ -323,9 +587,9 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
      *
      * @public
      * @static
-     * @type {Address}
+     * @type {Record<number, Address>}
      */
-    static base: Address;
+    static bases: Record<number, Address>;
     /**
      * @inheritdoc
      *
@@ -340,44 +604,44 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
      * @public
      * @async
      * @param {number} index The index of the action event to retrieve
-     * @param {?ReadParams<typeof eventActionAbi, 'getActionStep'>} [params]
+     * @param {?ReadEventActionParams<'getActionStep'>} [params]
      * @returns {Promise<ActionStep>}
      */
-    getActionStep(index: number, params?: ReadParams<typeof eventActionAbi, 'getActionStep'>): Promise<ActionStep | undefined>;
+    getActionStep(index: number, params?: ReadEventActionParams<'getActionStep'>): Promise<ActionStep | undefined>;
     /**
      * Gets all action events
      *
      * @public
      * @async
-     * @param {?ReadParams<typeof eventActionAbi, 'getActionSteps'>} [params]
+     * @param {?ReadEventActionParams<'getActionSteps'>} [params]
      * @returns {Promise<ActionStep[]>}
      */
-    getActionSteps(params?: ReadParams<typeof eventActionAbi, 'getActionSteps'>): Promise<ActionStep[]>;
+    getActionSteps(params?: ReadEventActionParams<'getActionSteps'>): Promise<ActionStep[]>;
     /**
      * Gets the count of action events
      *
      * @public
      * @async
-     * @param {?ReadParams<typeof eventActionAbi, 'getActionStepsCount'>} [params]
+     * @param {?ReadEventActionParams<'getActionStepsCount'>} [params]
      * @returns {Promise<bigint>}
      */
-    getActionStepsCount(params?: ReadParams<typeof eventActionAbi, 'getActionStepsCount'>): Promise<number>;
+    getActionStepsCount(params?: ReadEventActionParams<'getActionStepsCount'>): Promise<number>;
     /**
      * Retrieves the payload describing how claimants can be identified from logs or function calls.
      *
      * @public
      * @async
-     * @param {?ReadParams<typeof eventActionAbi, 'getActionClaimant'>} [params]
+     * @param {?ReadEventActionParams<'getActionClaimant'>} [params]
      * @returns {Promise<ActionClaimant>}
      */
-    getActionClaimant(params?: ReadParams<typeof eventActionAbi, 'getActionClaimant'>): Promise<ActionClaimant>;
+    getActionClaimant(params?: ReadEventActionParams<'getActionClaimant'>): Promise<ActionClaimant>;
     /**
      * Executes a prepared event action
      *
      * @public
      * @async
      * @param {Hex} data
-     * @param {?WriteParams<typeof eventActionAbi, 'execute'>} [params]
+     * @param {?WriteParams} [params]
      * @returns {Promise<readonly [boolean, `0x${string}`]>}
      */
     execute(data: Hex, params?: WriteParams<typeof eventActionAbi, 'execute'>): Promise<readonly [boolean, `0x${string}`]>;
@@ -387,55 +651,134 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
      * @public
      * @async
      * @param {Hex} data
-     * @param {?WriteParams<typeof eventActionAbi, 'execute'>} [params]
-     * @returns {unknown}
+     * @param {?WriteParams} [params]
+     * @returns {Promise<{ hash: `0x${string}`; result: readonly [boolean, `0x${string}`]; }>}
      */
     executeRaw(data: Hex, params?: WriteParams<typeof eventActionAbi, 'execute'>): Promise<{
         hash: `0x${string}`;
         result: readonly [boolean, `0x${string}`];
     }>;
+    /**
+     * Derives the action claimant address from a transaction based on the provided ActionClaimant configuration.
+     * This method supports both event-based and function-based claimant derivation.
+     *
+     ** @example
+     * // Example usage
+     * const eventAction = boost.action as EventAction
+     * const claimant = await eventAction.getActionClaimant() // {
+     *   signatureType: SignatureType.EVENT,
+     *   signature: '0x1234...',
+     *   fieldIndex: 2,
+     *   targetContract: '0xabcd...',
+     *   chainid: 1
+     * };
+     * const params: ValidateActionStepParams = {
+     *   hash: '0x5678...',
+     *   chainId: 1,
+     *   knownSignatures?: {
+     *     '0x1234...': {}
+     *   }
+     * };
+     * const claimantAddress = await eventAction.deriveActionClaimantFromTransaction(claimant, params);
+     *
+     * @param {ActionClaimant} claimant - The configuration specifying how to derive the claimant.
+     * @param {ValidateActionStepParams} params - Parameters for validation, including transaction hash, known signatures, logs, and chain ID.
+     * @returns {Promise<Address | undefined>} The derived claimant address if found, undefined otherwise.
+     * @throws {ValidationAbiMissingError} If the ABI for the specified signature is not found.
+     * @throws {FunctionDataDecodeError} If there's an error decoding function data (for function-based derivation).
+     */
+    deriveActionClaimantFromTransaction(claimant: ActionClaimant, params: ValidateActionStepParams): Promise<Address | undefined>;
+    /**
+     * Validates the action claimant against the arguments of a log or function data.
+     *
+     * @param {ActionClaimant} claimant - The action claimant to validate.
+     * @param {Object} [logOrFnData] - Optional object containing the arguments to validate against.
+     * @param {Array<any> | readonly unknown[] | Record<string, unknown>} [logOrFnData.args] - The arguments from the log or function data.
+     * @returns {Address | undefined} The validated address if found and valid, otherwise undefined.
+     */
+    validateClaimantAgainstArgs(claimant: ActionClaimant, logOrFnData?: {
+        args: Array<unknown> | readonly unknown[] | Record<string, unknown>;
+    }): Address | undefined;
     /**
      * Retrieves action steps, and uses them to validate against, and optionally fetch logs that match the step's signature.
      * If logs are provided in the optional `params` argument, then those logs will be used instead of fetched with the configured client.
      *
      * @public
      * @async
-     * @param {?ReadParams<typeof eventActionAbi, 'getActionSteps'> &
-     *       GetLogsParams<Abi, ContractEventName<Abi>> & {
-     *         knownEvents?: Record<Hex, AbiEvent>;
-     *         logs?: Log[];
-     *       }} [params]
+     * @param ValidateActionStepParams params
      * @returns {Promise<boolean>}
      */
-    validateActionSteps(params?: ReadParams<typeof eventActionAbi, 'getActionSteps'> & GetLogsParams<Abi, ContractEventName<Abi>> & {
-        knownEvents?: Record<Hex, AbiEvent>;
-        logs?: Log[];
-    }): Promise<boolean>;
+    validateActionSteps(params: ValidateActionStepParams): Promise<boolean>;
     /**
-     * Validates a single action step with a given criteria against logs.
-     * If logs are provided in the optional `params` argument, then those logs will be used instead of fetched with the configured client.
+     * Validates a single action step with a given criteria against logs or function calls.
+     * If logs are provided in the optional `params` argument, then those logs will be used instead of being fetched with the configured client.
+     * For functions a hash is required.
      *
      * @public
      * @async
-     * @param {ActionStep} actionStep
-     * @param {?GetLogsParams<Abi, ContractEventName<Abi>> & {
-     *       knownEvents?: Record<Hex, AbiEvent>;
-     *       logs?: Log[];
-     *     }} [params]
+     * @param {ActionStep} actionStep - The action step to validate. Can be a function of event step.
+     * @param {ValidateActionStepParams} params - Additional parameters for validation, including hash, known events, logs, and chain ID.
      * @returns {Promise<boolean>}
      */
-    isActionStepValid(actionStep: ActionStep, params?: GetLogsParams<Abi, ContractEventName<Abi>> & {
-        knownEvents?: Record<Hex, AbiEvent>;
-        logs?: Log[];
-    }): Promise<boolean>;
+    isActionStepValid(actionStep: ActionStep, params: ValidateActionStepParams): Promise<boolean>;
+    /**
+     * Validates a single action event with a given criteria against logs.
+     * If logs are provided in the optional `params` argument, then those logs will be used instead of being fetched with the configured client.
+     *
+     * @public
+     * @async
+     * @param {ActionStep} actionStep - The action step containing the event to validate.
+     * @param {EventLogs} logs - Event logs to validate the given step against
+     * @returns {Promise<boolean>} Resolves to true if the action event is valid, throws if input is invalid, otherwise false.
+     */
+    isActionEventValid(actionStep: ActionStep, logs: EventLogs): boolean;
+    /**
+     * Validates a single action function with a given criteria against the transaction input.
+     *
+     * @public
+     * @param {ActionStep} actionStep - The action step containing the function to validate.
+     * @param {Transaction} transaction - The transaction that will be validated against.
+     * @param {Object} [params] - Optional parameters for validation.
+     * @param {AbiItem} [params.abiItem] - The ABI item for the function, if known.
+     * @param {Record<Hex, AbiEvent | AbiFunction>} [params.knownSignatures] - A record of known signatures.
+     * @returns {boolean} Returns true if the action function is valid, false otherwise.
+     * @throws {ValidationAbiMissingError} Throws if the ABI for the function signature is not found.
+     * @throws {FunctionDataDecodeError} Throws if there's an error decoding the function data.
+     */
+    isActionFunctionValid(actionStep: ActionStep, transaction: Transaction, params?: Pick<ValidateActionStepParams, 'abiItem' | 'knownSignatures'>): boolean;
+    /**
+     * Validates a field against a given criteria.
+     *
+     * @param {Criteria} criteria - The criteria to validate against.
+     * @param {string | bigint | Hex} fieldValue - The field value to validate.
+     * @param {Object} input - Additional context for validation.
+     * @param {EventLogs[0]} [input.log] - The event log, if validating an event.
+     * @param {readonly (string | bigint)[]} [input.decodedArgs] - The decoded function arguments, if validating a function call.
+     * @returns {Promise<boolean>} - Returns true if the field passes the criteria, false otherwise.
+     */
+    validateFieldAgainstCriteria(criteria: Criteria, fieldValue: string | bigint | Hex, input: {
+        log: EventLogs[0];
+    } | {
+        decodedArgs: readonly (string | bigint)[];
+    }): boolean;
     /**
      * Validates a {@link Log} against a given criteria.
+     * If the criteria's fieldIndex is 255, it is reserved for anyValidation
      *
      * @param {Criteria} criteria - The criteria to validate against.
      * @param {Log} log - The Viem event log.
-     * @returns {Promise<boolean>} - Returns true if the log passes the criteria, false otherwise.
+     * @returns {boolean} - Returns true if the log passes the criteria, false otherwise.
      */
-    validateLogAgainstCriteria(criteria: Criteria, log: Log): Promise<boolean>;
+    validateLogAgainstCriteria(criteria: Criteria, log: EventLogs[0]): boolean;
+    /**
+     * Validates a function's decoded arguments against a given criteria.
+     * If the criteria's fieldIndex is 255, it is reserved for anyValidation
+     *
+     * @param {Criteria} criteria - The criteria to validate against.
+     * @param {unknown[]} decodedArgs - The decoded arguments of the function call.
+     * @returns {Promise<boolean>} - Returns true if the decoded argument passes the criteria, false otherwise.
+     */
+    validateFunctionAgainstCriteria(criteria: Criteria, decodedArgs: readonly (string | bigint)[]): boolean;
     /**
      * @inheritdoc
      *
@@ -445,5 +788,37 @@ export declare class EventAction extends DeployableTarget<EventActionPayload, ty
      * @returns {GenericDeployableParams}
      */
     buildParameters(_payload?: EventActionPayload, _options?: DeployableOptions): GenericDeployableParams;
+    isArraylikeIndexed(step: ActionStep, event: AbiEvent): boolean;
 }
+/**
+ * Function to properly encode an event action payload.
+ *
+ * @param {InitPayload} param0
+ * @param {ActionStep} param0.actionStepOne - The first action step to initialize.
+ * @param {ActionStep} param0.actionStepTwo - The second action step to initialize.
+ * @param {ActionStep} param0.actionStepThree - The third action step to initialize.
+ * @param {ActionStep} param0.actionStepFour - The fourth action step to initialize.
+ * @returns {Hex}
+ */
+export declare function prepareEventActionPayload({ actionClaimant, actionStepOne, actionStepTwo, actionStepThree, actionStepFour, }: EventActionPayloadRaw): `0x${string}`;
+/**
+ * Creates a default Criteria object that allows validation to pass. This is used if you don't care about targeting specific parameters in the action step.
+ *
+ * This function returns a Criteria object with the following properties:
+ * - filterType: Set to EQUAL for exact matching
+ * - fieldType: Set to BYTES to handle any data type
+ * - fieldIndex: Set to 255, which is typically used to indicate "any" or "all" in this context
+ * - filterData: Set to zeroHash (0x0000...0000)
+ *
+ * @returns {Criteria} A Criteria object that can be used to match any action parameter
+ *
+ * @example
+ * const anyCriteria = anyActionParameter();
+ * // Use this criteria in an ActionStep to match any parameter
+ * const actionStep = {
+ *   // ... other properties ...
+ *   actionParameter: anyCriteria
+ * };
+ */
+export declare function anyActionParameter(): Criteria;
 //# sourceMappingURL=EventAction.d.ts.map

package/dist/Actions/EventAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventAction.d.ts","sourceRoot":"","sources":["../../src/Actions/EventAction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAKf,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,KAAK,GAAG,EACR,KAAK,QAAQ,EACb,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,GAAG,EACR,KAAK,GAAG,EAET,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EACV,iBAAiB,EACjB,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AASlE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAEvB,UAAU,EACV,KAAK,aAAa,EAClB,aAAa,EACb,KAAK,UAAU,EACf,YAAY,EACZ,KAAK,WAAW,EAIjB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,YAAY,EACV,kBAAkB,EAClB,UAAU,EACV,cAAc,EACd,aAAa,EACb,UAAU,EACV,aAAa,GACd,CAAC;AAEF;;;;;;;GAOG;AACH,qBAAa,WAAY,SAAQ,gBAAgB,CAC/C,kBAAkB,EAClB,OAAO,cAAc,CACtB;IACC;;;;;;OAMG;IACH,SAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAkB;IAC9C;;;;;;OAMG;IACH,OAAuB,IAAI,EAAE,OAAO,CAA0C;IAC9E;;;;;;OAMG;IACH,OAAuB,YAAY,EAAE,YAAY,CAAuB;IAExE;;;;;;;;OAQG;IACU,aAAa,CACxB,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,EAAE,eAAe,CAAC;IAM7D;;;;;;;OAOG;IACU,cAAc,CACzB,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC;IAW9D;;;;;;;OAOG;IACU,mBAAmB,CAC9B,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,EAAE,qBAAqB,CAAC;IAMnE;;;;;;;OAOG;IACU,iBAAiB,CAC5B,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,EAAE,mBAAmB,CAAC;IAUjE;;;;;;;;OAQG;IACU,OAAO,CAClB,IAAI,EAAE,GAAG,EACT,MAAM,CAAC,EAAE,WAAW,CAAC,OAAO,cAAc,EAAE,SAAS,CAAC;IAKxD;;;;;;;;OAQG;IACU,UAAU,CACrB,IAAI,EAAE,GAAG,EACT,MAAM,CAAC,EAAE,WAAW,CAAC,OAAO,cAAc,EAAE,SAAS,CAAC;;;;IAaxD;;;;;;;;;;;;OAYG;IACU,mBAAmB,CAC9B,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC,GAC1D,aAAa,CAAC,GAAG,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC,GAAG;QAC3C,WAAW,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACpC,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;KACd;IAWL;;;;;;;;;;;;OAYG;IACU,iBAAiB,CAC5B,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,aAAa,CAAC,GAAG,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC,GAAG;QACpD,WAAW,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACpC,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;KACd;IAiCH;;;;;;OAMG;IACU,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG;IA6CpE;;;;;;;OAOG;IACa,eAAe,CAC7B,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,uBAAuB;CAqC3B"}
+{"version":3,"file":"EventAction.d.ts","sourceRoot":"","sources":["../../src/Actions/EventAction.ts"],"names":[],"mappings":"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"}