@sap-ux/fiori-mcp-server 0.0.1

package/dist/page-editor-api/parser/model/PageEditProperty.d.ts

@@ -0,0 +1,38 @@
+import type { JSONSchema4 } from 'json-schema';
+import type { Location, SettingOption, PropertyMessage } from './types';
+import { ValidationState } from './types';
+import type { ArtifactType } from '@sap/ux-specification/dist/types/src';
+export interface PageProperties {
+    [key: string]: PageEditProperty;
+}
+/**
+ * Represents a configurable aggregation property in the page editing model.
+ * `PageEditProperty` wraps schema-based metadata for a property and stores
+ * runtime values, validation state, messages, and UI-related options.
+ */
+export declare class PageEditProperty implements SettingOption {
+    schema: JSONSchema4;
+    value?: unknown;
+    pattern?: string;
+    freeText?: boolean;
+    disabled?: boolean;
+    state?: ValidationState;
+    description?: string;
+    required?: boolean;
+    isAtomic?: boolean;
+    i18nClassification?: string;
+    name: string;
+    displayName?: string;
+    artifactType?: ArtifactType;
+    minimum?: number;
+    messages?: PropertyMessage[];
+    locations?: Location[];
+    /**
+     * Creates an instance of `PageEditProperty`.
+     *
+     * @param schema JSON Schema fragment associated with this property.
+     * @param displayName Display name of the property.
+     */
+    constructor(schema: JSONSchema4, displayName: string);
+}
+//# sourceMappingURL=PageEditProperty.d.ts.map

package/dist/page-editor-api/parser/model/PageEditProperty.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageEditProperty = void 0;
+const types_1 = require("./types");
+/**
+ * Represents a configurable aggregation property in the page editing model.
+ * `PageEditProperty` wraps schema-based metadata for a property and stores
+ * runtime values, validation state, messages, and UI-related options.
+ */
+class PageEditProperty {
+    schema;
+    value;
+    pattern;
+    // True if user can enter text freely. Is used to display as combobox:
+    // 1. Selection options from enum;
+    // 2. Free text to enter using input field;
+    freeText;
+    disabled;
+    state = types_1.ValidationState.Valid;
+    // Property description
+    description;
+    // Is property required for input
+    required;
+    isAtomic;
+    i18nClassification;
+    name;
+    displayName;
+    // Property's artifact type
+    artifactType;
+    // Property's minimum allowed value
+    minimum;
+    // Property messages
+    messages;
+    // Location in source file
+    locations;
+    /**
+     * Creates an instance of `PageEditProperty`.
+     *
+     * @param schema JSON Schema fragment associated with this property.
+     * @param displayName Display name of the property.
+     */
+    constructor(schema, displayName) {
+        // Use copy - it allows to make changes in schema if we need.
+        this.schema = structuredClone(schema);
+        this.name = displayName;
+    }
+}
+exports.PageEditProperty = PageEditProperty;
+//# sourceMappingURL=PageEditProperty.js.map

package/dist/page-editor-api/parser/model/RootAggregation.d.ts

@@ -0,0 +1,24 @@
+import { ObjectAggregation } from './ObjectAggregation';
+import { AggregationCreationForm } from './types';
+import type { CreationFormOptions, PageAnnotations } from './types';
+/**
+ * Represents an aggregation for root level object in page/application schema.
+ */
+export declare class RootAggregation extends ObjectAggregation {
+    allowedAnnotationCreationForms: AggregationCreationForm[];
+    name: string;
+    /**
+     * Method provides creation options based on its related annotation node.
+     * Overwritten, return array which was calculated on annotation data refresh.
+     *
+     * @returns Array of creation forms.
+     */
+    getDefaultNativeCreationForms(): CreationFormOptions[];
+    /**
+     * Refreshes internal data based on latest annotation node data.
+     *
+     * @param annotations
+     */
+    updateAnnotationData(annotations: PageAnnotations | undefined): void;
+}
+//# sourceMappingURL=RootAggregation.d.ts.map

package/dist/page-editor-api/parser/model/RootAggregation.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootAggregation = void 0;
+const ObjectAggregation_1 = require("./ObjectAggregation");
+const types_1 = require("./types");
+const i18next_1 = __importDefault(require("i18next"));
+/**
+ * Represents an aggregation for root level object in page/application schema.
+ */
+class RootAggregation extends ObjectAggregation_1.ObjectAggregation {
+    allowedAnnotationCreationForms = [types_1.AggregationCreationForm.AnalyticalChart];
+    name = 'root';
+    /**
+     * Method provides creation options based on its related annotation node.
+     * Overwritten, return array which was calculated on annotation data refresh.
+     *
+     * @returns Array of creation forms.
+     */
+    getDefaultNativeCreationForms() {
+        return this.annotationCreationForms;
+    }
+    /**
+     * Refreshes internal data based on latest annotation node data.
+     *
+     * @param annotations
+     */
+    updateAnnotationData(annotations) {
+        this.annotationCreationForms = [];
+        super.updateAnnotationData(annotations);
+        // Check annotation creations forms
+        const isChartAdded = !!this.aggregations['chart']?.isViewNode;
+        const isViewsEnabled = !!(this.aggregations['table']?.aggregations['views']?.isViewNode && !isChartAdded);
+        if (isViewsEnabled && annotations?.dialogsContext?.analyticalChartSupport !== undefined) {
+            const form = {
+                name: types_1.AggregationCreationForm.AnalyticalChart,
+                title: annotations.dialogsContext.analyticalChartSupport.creationTooltip,
+                disabled: !annotations.dialogsContext.analyticalChartSupport.creationEnabled,
+                kind: types_1.ANNOTATION_CREATION_FORM,
+                visualizationIcon: 'Add',
+                buttonText: i18next_1.default.t('ADD_CHART'),
+                buttonId: 'add-chart'
+            };
+            if (form.disabled) {
+                form.disabledTitle = form.title;
+            }
+            this.annotationCreationForms.push(form);
+        }
+    }
+}
+exports.RootAggregation = RootAggregation;
+//# sourceMappingURL=RootAggregation.js.map

package/dist/page-editor-api/parser/model/actions/ActionAggregation.d.ts

@@ -0,0 +1,34 @@
+import { ObjectAggregation } from '../ObjectAggregation';
+import { AggregationActions, SortingOptions } from '../types';
+import type { DefaultExtensionPosition } from '../utils/sort';
+/**
+ * Represents an aggregation for action object.
+ */
+export declare class ActionAggregation extends ObjectAggregation {
+    actions: AggregationActions[];
+    sortableItem: SortingOptions | undefined;
+    isViewNode: boolean;
+    sortableCollection: string | undefined;
+    data?: DefaultExtensionPosition;
+    /**
+     * Method parses object path key and returns action name.
+     *
+     * @returns Action name.
+     */
+    getTechnicalName(): string | undefined;
+    /**
+     * Public method to mark action as custom action.
+     */
+    markAsCustomAction(): void;
+    /**
+     * Public method to mark action as standard action.
+     */
+    markAsStandardAction(): void;
+    /**
+     * Method returns action type from schema data.
+     *
+     * @returns Action type from schema.
+     */
+    getActionType(): string | undefined;
+}
+//# sourceMappingURL=ActionAggregation.d.ts.map

package/dist/page-editor-api/parser/model/actions/ActionAggregation.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionAggregation = void 0;
+const i18next_1 = __importDefault(require("i18next"));
+const ObjectAggregation_1 = require("../ObjectAggregation");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+/**
+ * Represents an aggregation for action object.
+ */
+class ActionAggregation extends ObjectAggregation_1.ObjectAggregation {
+    actions = [types_1.AggregationActions.Delete];
+    sortableItem = types_1.SortingOptions.Enabled;
+    isViewNode = true;
+    sortableCollection = 'actions';
+    data;
+    /**
+     * Method parses object path key and returns action name.
+     *
+     * @returns Action name.
+     */
+    getTechnicalName() {
+        const key = this.path[this.path.length - 1];
+        if (key && typeof key === 'string') {
+            const keyParts = key.split('::');
+            // Primary method - check for specific key format using 'DATA_FIELD_ACTION'
+            let action = '';
+            if (keyParts[keyParts.length - 1].includes('.')) {
+                for (let i = 0; i < keyParts.length; i++) {
+                    if (keyParts[i] === types_1.DATA_FIELD_ACTION && keyParts[i + 1]) {
+                        action = keyParts[i + 1];
+                    }
+                }
+            }
+            else {
+                action = keyParts[keyParts.length - 1];
+            }
+            if (action) {
+                const actionParts = action.split('.');
+                return actionParts[actionParts.length - 1];
+            }
+        }
+        return super.getTechnicalName();
+    }
+    /**
+     * Public method to mark action as custom action.
+     */
+    markAsCustomAction() {
+        this.custom = true;
+        this.actions = [types_1.AggregationActions.OpenSource];
+        this.sortableItem = types_1.SortingOptions.Enabled;
+        this.additionalText = i18next_1.default.t('PAGE_EDITOR_OUTLINE_NODE_DESC_CUSTOM_ACTION');
+        this.i18nKey = this.parent?.i18nKey;
+        if (this.isMacrosNode()) {
+            (0, utils_1.validateMacrosExtension)(this);
+        }
+        else {
+            this.actions.push(types_1.AggregationActions.Delete);
+        }
+        // Validate anchor
+        const anchor = this.aggregations.position?.properties.anchor;
+        if (anchor?.value) {
+            // Validate anchor if value exists
+            const validEntries = anchor.schema.oneOf || [];
+            if (!validEntries.some((entry) => entry.const === anchor.value)) {
+                (0, utils_1.validateExtension)(this, false, i18next_1.default.t('PAGE_EDITOR_CUSTOM_EXTENSION_NO_ANCHOR'));
+            }
+        }
+    }
+    /**
+     * Public method to mark action as standard action.
+     */
+    markAsStandardAction() {
+        this.sortableItem = types_1.SortingOptions.Readonly;
+        this.additionalText = i18next_1.default.t('PAGE_EDITOR_OUTLINE_NODE_DESC_STANDARD_ACTION');
+        this.i18nKey = this.parent?.i18nKey;
+        this.removeAction(types_1.AggregationActions.Delete);
+    }
+    /**
+     * Method returns action type from schema data.
+     *
+     * @returns Action type from schema.
+     */
+    getActionType() {
+        return typeof this.schema?.actionType === 'string' ? this.schema.actionType : undefined;
+    }
+}
+exports.ActionAggregation = ActionAggregation;
+//# sourceMappingURL=ActionAggregation.js.map

package/dist/page-editor-api/parser/model/actions/ActionsAggregation.d.ts

@@ -0,0 +1,96 @@
+import type { JSONSchema4 } from 'json-schema';
+import type { PageConfig, PageType } from '@sap/ux-specification/dist/types/src';
+import { ObjectAggregation } from '../ObjectAggregation';
+import type { PageEditAggregationData } from '../ObjectAggregation';
+import { AggregationCreationForm } from '../types';
+import type { PageData, CreationFormOptions, PropertyPath, PageAnnotations, AllowedMoveRange } from '../types';
+import { ActionAggregation } from './ActionAggregation';
+export declare enum ActionType {
+    Annotation = "Annotation",
+    Copy = "Copy",
+    Criticality = "Criticality",
+    Custom = "Custom",
+    Standard = "Standard",
+    StandardWithoutAnnotation = "StandardWithoutAnnotation"
+}
+export interface ActionsContainers {
+    top: AllowedMoveRange;
+    bottom: AllowedMoveRange;
+}
+/**
+ * Represents an aggregation for actions container object.
+ */
+export declare class ActionsAggregation extends ObjectAggregation {
+    sortableList: boolean;
+    childClass: typeof ActionAggregation;
+    allowedAnnotationCreationForms: AggregationCreationForm[];
+    sortableCollection: string | undefined;
+    i18nKey: string;
+    /**
+     * Creates an instance of `ActionsAggregation`.
+     *
+     * @param data Optional aggregation data object used to initialize properties.
+     * @param schema Optional JSON schema fragment associated with this aggregation.
+     */
+    constructor(data?: PageEditAggregationData, schema?: JSONSchema4);
+    /**
+     * Method adds aggregation object.
+     * Overwritten to mark standard action.
+     *
+     * @param name Name of aggregation.
+     * @param aggregation Aggregation to add.
+     * @param path Array of path to aggregation.
+     * @param order Order index.
+     * @param overwrite Overwrite existing aggregation.
+     * @returns Added aggregation.
+     */
+    addAggregation(name: string, aggregation: ObjectAggregation, path: PropertyPath, order?: number, overwrite?: boolean): ObjectAggregation;
+    /**
+     * Overwritten method for data update of object page actions
+     * Method receives current values for actions and detects custom actions.
+     *
+     * @param data Data which should be used for value population.
+     * @param page Page config data.
+     * @param pageType Page type.
+     * @param path Aggregation path.
+     * @param annotations Annotations data.
+     */
+    updatePropertiesValues(data: PageData, page: PageConfig, pageType: PageType, path: PropertyPath, annotations: PageAnnotations): void;
+    /**
+     * Method provides creation options based on its related annotation node.
+     *
+     * @param annotations Page annotations.
+     * @returns Array of creation forms.
+     */
+    protected getNativeNodeCreationForms(annotations: PageAnnotations | undefined): CreationFormOptions[];
+    /**
+     * Method returns action type of passed action aggregation.
+     *
+     * @param action Action aggregation.
+     * @returns Action type of passed action aggregation.
+     */
+    private getActionType;
+    /**
+     * Method calculates edge position for two containers - above and below standard actions.
+     *
+     * @param aggregationKeys Array of actions aggregation keys.
+     * @param sourceType Movable source type.
+     * @returns Drop range edges.
+     */
+    private calculateDropRangeEdges;
+    /**
+     * Method returns allowed drop ranges within action for passed action type.
+     *
+     * @param sourceType Action type.
+     * @returns Allowed drop ranges of top and bottom containers.
+     */
+    private getActionsContainers;
+    /**
+     * Method returns allowed drop ranges for passed source aggregation.
+     *
+     * @param source Source aggregation.
+     * @returns Allowed drop ranges for passed source aggregation.
+     */
+    getAllowedDropRange(source: ObjectAggregation): AllowedMoveRange[] | undefined;
+}
+//# sourceMappingURL=ActionsAggregation.d.ts.map

package/dist/page-editor-api/parser/model/actions/ActionsAggregation.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionsAggregation = exports.ActionType = void 0;
+const ObjectAggregation_1 = require("../ObjectAggregation");
+const types_1 = require("../types");
+const ActionAggregation_1 = require("./ActionAggregation");
+// Remove when latest '@sap/ux-specification/dist/types/src' is released
+var ActionType;
+(function (ActionType) {
+    ActionType["Annotation"] = "Annotation";
+    ActionType["Copy"] = "Copy";
+    ActionType["Criticality"] = "Criticality";
+    ActionType["Custom"] = "Custom";
+    ActionType["Standard"] = "Standard";
+    ActionType["StandardWithoutAnnotation"] = "StandardWithoutAnnotation";
+})(ActionType || (exports.ActionType = ActionType = {}));
+/**
+ * Represents an aggregation for actions container object.
+ */
+class ActionsAggregation extends ObjectAggregation_1.ObjectAggregation {
+    sortableList = true;
+    childClass = ActionAggregation_1.ActionAggregation;
+    allowedAnnotationCreationForms = [types_1.AggregationCreationForm.NativeAction, types_1.AggregationCreationForm.NativeNavigation];
+    sortableCollection = 'actions';
+    i18nKey = 'ACTIONS';
+    /**
+     * Creates an instance of `ActionsAggregation`.
+     *
+     * @param data Optional aggregation data object used to initialize properties.
+     * @param schema Optional JSON schema fragment associated with this aggregation.
+     */
+    constructor(data, schema) {
+        super(data, schema);
+        // Custom creation form - check schema if supported
+        if (schema?.properties && this.schema?.additionalProperties && this.schema?.metadata?.type !== 'Aggregation') {
+            this.schemaCreationForms = [
+                {
+                    name: types_1.AggregationCreationForm.CustomAction,
+                    kind: types_1.SCHEMA_CREATION_FORM,
+                    title: 'PAGE_EDITOR_OUTLINE_ADD_CUSTOM_ACTIONS_TITLE',
+                    disabled: false
+                }
+            ];
+        }
+    }
+    /**
+     * Method adds aggregation object.
+     * Overwritten to mark standard action.
+     *
+     * @param name Name of aggregation.
+     * @param aggregation Aggregation to add.
+     * @param path Array of path to aggregation.
+     * @param order Order index.
+     * @param overwrite Overwrite existing aggregation.
+     * @returns Added aggregation.
+     */
+    addAggregation(name, aggregation, path, order, overwrite) {
+        aggregation = super.addAggregation(name, aggregation, path, order, overwrite);
+        if (aggregation instanceof ActionAggregation_1.ActionAggregation && aggregation.name) {
+            switch (aggregation.schema?.actionType) {
+                case ActionType.Standard: {
+                    aggregation.markAsStandardAction();
+                    break;
+                }
+                case ActionType.Copy: {
+                    aggregation.sortableItem = types_1.SortingOptions.Readonly;
+                    break;
+                }
+            }
+        }
+        return aggregation;
+    }
+    /**
+     * Overwritten method for data update of object page actions
+     * Method receives current values for actions and detects custom actions.
+     *
+     * @param data Data which should be used for value population.
+     * @param page Page config data.
+     * @param pageType Page type.
+     * @param path Aggregation path.
+     * @param annotations Annotations data.
+     */
+    updatePropertiesValues(data, page, pageType, path, annotations) {
+        super.updatePropertiesValues(data, page, pageType, path, annotations);
+        this.formSchema = this.additionalProperties?.aggregations['actions'];
+        const actions = data || {};
+        for (const id in actions) {
+            const action = this.aggregations[id];
+            if (action?.name && action.schema?.actionType === 'Standard') {
+                action.markAsStandardAction();
+            }
+            else if (action?.schema && (action.schema.actionType === 'Custom' || !action.schema.annotationPath)) {
+                action.markAsCustomAction();
+            }
+        }
+    }
+    /**
+     * Method provides creation options based on its related annotation node.
+     *
+     * @param annotations Page annotations.
+     * @returns Array of creation forms.
+     */
+    getNativeNodeCreationForms(annotations) {
+        if (this.parent) {
+            if (this.parent.name === 'footer') {
+                this.allowedAnnotationCreationForms = [types_1.AggregationCreationForm.NativeAction];
+            }
+        }
+        return super.getNativeNodeCreationForms(annotations);
+    }
+    /**
+     * Method returns action type of passed action aggregation.
+     *
+     * @param action Action aggregation.
+     * @returns Action type of passed action aggregation.
+     */
+    getActionType(action) {
+        const actionType = action.schema?.actionType;
+        if (actionType) {
+            if (actionType === ActionType.Standard && !action.schema?.annotationPath) {
+                return ActionType.StandardWithoutAnnotation;
+            }
+            return actionType;
+        }
+        return action.custom ? ActionType.Custom : ActionType.Annotation;
+    }
+    /**
+     * Method calculates edge position for two containers - above and below standard actions.
+     *
+     * @param aggregationKeys Array of actions aggregation keys.
+     * @param sourceType Movable source type.
+     * @returns Drop range edges.
+     */
+    calculateDropRangeEdges(aggregationKeys, sourceType) {
+        const edges = {
+            top: -1,
+            bottom: -1
+        };
+        const breakConditions = {
+            top: [ActionType.Standard, ActionType.Copy, ActionType.Annotation],
+            bottom: [ActionType.Criticality, ActionType.Standard, ActionType.Copy]
+        };
+        // Get top container range. Resolve end index by finding first index of Standard, Copy, Annotation
+        for (let i = 0; i < aggregationKeys.length; i++) {
+            const key = aggregationKeys[i];
+            const aggregation = this.aggregations[key];
+            const actionType = this.getActionType(aggregation);
+            if (actionType && breakConditions.top.includes(actionType)) {
+                edges.top = i;
+                break;
+            }
+        }
+        // Get bottom container range. Resolve start index by finding last index of Criticality, Standard, Copy
+        if (sourceType !== ActionType.Custom) {
+            for (let i = 0; i < aggregationKeys.length; i++) {
+                const key = aggregationKeys[i];
+                const aggregation = this.aggregations[key];
+                const actionType = this.getActionType(aggregation);
+                if (actionType && breakConditions.bottom.includes(actionType)) {
+                    edges.bottom = i + 1;
+                }
+            }
+        }
+        else {
+            edges.bottom = edges.top;
+        }
+        return edges;
+    }
+    /**
+     * Method returns allowed drop ranges within action for passed action type.
+     *
+     * @param sourceType Action type.
+     * @returns Allowed drop ranges of top and bottom containers.
+     */
+    getActionsContainers(sourceType) {
+        const aggregationKeys = this.getAggregationKeys(true);
+        // Disallowed drops at the end
+        let restrictedCount = 0;
+        for (let i = aggregationKeys.length - 1; i >= 0; i--) {
+            const key = aggregationKeys[i];
+            const aggregation = this.aggregations[key];
+            const actionType = this.getActionType(aggregation);
+            if (actionType !== ActionType.StandardWithoutAnnotation) {
+                break;
+            }
+            restrictedCount++;
+        }
+        if (sourceType === ActionType.Custom && restrictedCount === 0) {
+            // No limitation for custom actions if there is no Related Apps button(it is not supported to drop after Related Apps button)
+            return undefined;
+        }
+        const edges = this.calculateDropRangeEdges(aggregationKeys, sourceType);
+        if (edges.top === -1) {
+            edges.top = edges.bottom;
+        }
+        if (edges.bottom === -1) {
+            edges.bottom = edges.top;
+        }
+        if (edges.top === -1 || edges.bottom === -1) {
+            return undefined;
+        }
+        return {
+            top: {
+                from: 0,
+                to: edges.top
+            },
+            bottom: {
+                from: edges.bottom,
+                to: aggregationKeys.length - restrictedCount
+            }
+        };
+    }
+    /**
+     * Method returns allowed drop ranges for passed source aggregation.
+     *
+     * @param source Source aggregation.
+     * @returns Allowed drop ranges for passed source aggregation.
+     */
+    getAllowedDropRange(source) {
+        const sourceActionType = this.getActionType(source);
+        const dropContainers = this.getActionsContainers(sourceActionType);
+        let range;
+        if (dropContainers) {
+            switch (sourceActionType) {
+                case ActionType.Custom: {
+                    // Custom actions can be moved across both groups
+                    range = [dropContainers.top, dropContainers.bottom];
+                    break;
+                }
+                case ActionType.Copy:
+                case ActionType.Standard:
+                case ActionType.StandardWithoutAnnotation: {
+                    // Copy can not be moved
+                    range = [];
+                    break;
+                }
+                case ActionType.Criticality: {
+                    range = [dropContainers.top];
+                    break;
+                }
+                case ActionType.Annotation: {
+                    // Custom actions can be moved across both groups
+                    range = [dropContainers.bottom];
+                    break;
+                }
+            }
+        }
+        return range;
+    }
+}
+exports.ActionsAggregation = ActionsAggregation;
+//# sourceMappingURL=ActionsAggregation.js.map

package/dist/page-editor-api/parser/model/actions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ActionAggregation';
+export * from './ActionsAggregation';
+//# sourceMappingURL=index.d.ts.map

package/dist/page-editor-api/parser/model/actions/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ActionAggregation"), exports);
+__exportStar(require("./ActionsAggregation"), exports);
+//# sourceMappingURL=index.js.map