igniteui-webcomponents-layouts 7.1.1-beta.2 → 7.1.1-beta.3

package/esm2022/lib/igc-tool-action-event-detail-collection.d.ts

@@ -0,0 +1,8 @@
+import { IgCollection } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { ToolActionEventDetail as ToolActionEventDetail_internal } from './ToolActionEventDetail';
+import { IgcToolActionEventDetail as IgcToolActionEventDetail } from './igc-tool-action-event-detail';
+export declare class IgcToolActionEventDetailCollection extends IgCollection<IgcToolActionEventDetail, ToolActionEventDetail_internal> {
+    constructor(list?: IgcToolActionEventDetail[]);
+    protected _createInnerColl(): SyncableObservableCollection$2<IgcToolActionEventDetail, ToolActionEventDetail_internal>;
+}

package/esm2022/lib/igc-tool-action-event-detail-collection.js

@@ -0,0 +1,53 @@
+import { IgCollection } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { ToolActionEventDetail as ToolActionEventDetail_internal } from './ToolActionEventDetail';
+import { IgcToolActionEventDetail as IgcToolActionEventDetail } from './igc-tool-action-event-detail';
+export class IgcToolActionEventDetailCollection extends IgCollection {
+    constructor(list) {
+        super();
+        if (!IgcToolActionEventDetail.$type) {
+            IgcToolActionEventDetail.$type = markType(IgcToolActionEventDetail, "IgcToolActionEventDetail");
+        }
+        if (list) {
+            for (let i = 0; i < list.length; i++) {
+                this.add(list[i]);
+            }
+        }
+    }
+    _createInnerColl() {
+        if (!IgcToolActionEventDetail.$type) {
+            IgcToolActionEventDetail.$type = markType(IgcToolActionEventDetail, "IgcToolActionEventDetail");
+        }
+        let coll = new SyncableObservableCollection$2(IgcToolActionEventDetail.$type, ToolActionEventDetail_internal.$type, 0);
+        coll.compare = (ext, int) => {
+            let comp = ext;
+            if (comp._implementation) {
+                comp = comp._implementation;
+            }
+            if (comp.equals) {
+                return comp.equals(int);
+            }
+            return comp === int;
+        };
+        coll.createTo = (ext) => {
+            return ext._implementation;
+        };
+        coll.createFrom = (int) => {
+            let ext = int.externalObject;
+            if (!ext) {
+                ext = new IgcToolActionEventDetail();
+                if (ext) {
+                    if (!int.$type && ext._implementation.setNativeElement) {
+                        ext._implementation.setNativeElement(int);
+                    }
+                    else {
+                        ext._implementation = int;
+                    }
+                }
+            }
+            return ext;
+        };
+        return coll;
+    }
+}

package/esm2022/lib/igc-tool-action-event-detail.d.ts

@@ -0,0 +1,30 @@
+import { ToolActionType } from "igniteui-webcomponents-core";
+import { ToolActionEventDetail as ToolActionEventDetail_internal } from "./ToolActionEventDetail";
+export declare class IgcToolActionEventDetail {
+    protected createImplementation(): ToolActionEventDetail_internal;
+    protected _implementation: any;
+    /**
+     * @hidden
+     */
+    get i(): ToolActionEventDetail_internal;
+    private onImplementationCreated;
+    constructor();
+    protected _provideImplementation(i: any): void;
+    get actionId(): string;
+    set actionId(v: string);
+    get actionType(): ToolActionType;
+    set actionType(v: ToolActionType);
+    get isModified(): boolean;
+    set isModified(v: boolean);
+    get boolValue(): boolean;
+    set boolValue(v: boolean);
+    get numberValue(): number;
+    set numberValue(v: number);
+    get dateTimeValue(): Date;
+    set dateTimeValue(v: Date);
+    get untypedValue(): any;
+    set untypedValue(v: any);
+    get stringValue(): string;
+    set stringValue(v: string);
+    findByName(name: string): any;
+}

package/esm2022/lib/igc-tool-action-event-detail.js

@@ -0,0 +1,88 @@
+import { ToolActionType_$type } from "igniteui-webcomponents-core";
+import { ToolActionEventDetail as ToolActionEventDetail_internal } from "./ToolActionEventDetail";
+import { ensureEnum, ensureBool } from "igniteui-webcomponents-core";
+export class IgcToolActionEventDetail {
+    createImplementation() {
+        return new ToolActionEventDetail_internal();
+    }
+    /**
+     * @hidden
+     */
+    get i() {
+        return this._implementation;
+    }
+    onImplementationCreated() {
+    }
+    constructor() {
+        this._implementation = this.createImplementation();
+        Object.defineProperty(this._implementation, 'externalObject', { value: this, enumerable: false, configurable: true, writable: true });
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    _provideImplementation(i) {
+        this._implementation = i;
+        Object.defineProperty(this._implementation, 'externalObject', { value: this, enumerable: false, configurable: true, writable: true });
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    get actionId() {
+        return this.i.g;
+    }
+    set actionId(v) {
+        this.i.g = v;
+    }
+    get actionType() {
+        return this.i.a;
+    }
+    set actionType(v) {
+        this.i.a = ensureEnum(ToolActionType_$type, v);
+    }
+    get isModified() {
+        return this.i.c;
+    }
+    set isModified(v) {
+        this.i.c = ensureBool(v);
+    }
+    get boolValue() {
+        return this.i.b;
+    }
+    set boolValue(v) {
+        this.i.b = ensureBool(v);
+    }
+    get numberValue() {
+        return this.i.e;
+    }
+    set numberValue(v) {
+        this.i.e = +v;
+    }
+    get dateTimeValue() {
+        return this.i.d;
+    }
+    set dateTimeValue(v) {
+        this.i.d = v;
+    }
+    get untypedValue() {
+        return this.i.f;
+    }
+    set untypedValue(v) {
+        this.i.f = v;
+    }
+    get stringValue() {
+        return this.i.h;
+    }
+    set stringValue(v) {
+        this.i.h = v;
+    }
+    findByName(name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        return null;
+    }
+}

package/esm2022/lib/igc-tool-action-field-selector-aggregation-module.d.ts

@@ -0,0 +1,3 @@
+export declare class IgcToolActionFieldSelectorAggregationModule {
+    static register(): void;
+}

package/esm2022/lib/igc-tool-action-field-selector-aggregation-module.js

@@ -0,0 +1,15 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE: you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { IgcToolActionFieldSelectorAggregation } from './igc-tool-action-field-selector-aggregation';
+import { ToolActionFieldSelectorAggregation } from './ToolActionFieldSelectorAggregation';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+export class IgcToolActionFieldSelectorAggregationModule {
+    static register() {
+        TypeRegistrar.registerCons("IgcToolActionFieldSelectorAggregation", IgcToolActionFieldSelectorAggregation);
+        TypeRegistrar.register("ToolActionFieldSelectorAggregation", ToolActionFieldSelectorAggregation.$type);
+    }
+}

package/esm2022/lib/igc-tool-action-field-selector-aggregation.d.ts

@@ -0,0 +1,20 @@
+import { DataSourceSummaryOperand } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorAggregation as ToolActionFieldSelectorAggregation_internal } from "./ToolActionFieldSelectorAggregation";
+export declare class IgcToolActionFieldSelectorAggregation {
+    protected createImplementation(): ToolActionFieldSelectorAggregation_internal;
+    protected _implementation: any;
+    /**
+     * @hidden
+     */
+    get i(): ToolActionFieldSelectorAggregation_internal;
+    private onImplementationCreated;
+    constructor();
+    protected _provideImplementation(i: any): void;
+    get label(): string;
+    set label(v: string);
+    get name(): string;
+    set name(v: string);
+    get operand(): DataSourceSummaryOperand;
+    set operand(v: DataSourceSummaryOperand);
+    findByName(name: string): any;
+}

package/esm2022/lib/igc-tool-action-field-selector-aggregation.js

@@ -0,0 +1,58 @@
+import { DataSourceSummaryOperand_$type } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorAggregation as ToolActionFieldSelectorAggregation_internal } from "./ToolActionFieldSelectorAggregation";
+import { ensureEnum } from "igniteui-webcomponents-core";
+export class IgcToolActionFieldSelectorAggregation {
+    createImplementation() {
+        return new ToolActionFieldSelectorAggregation_internal();
+    }
+    /**
+     * @hidden
+     */
+    get i() {
+        return this._implementation;
+    }
+    onImplementationCreated() {
+    }
+    constructor() {
+        this._implementation = this.createImplementation();
+        Object.defineProperty(this._implementation, 'externalObject', { value: this, enumerable: false, configurable: true, writable: true });
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    _provideImplementation(i) {
+        this._implementation = i;
+        Object.defineProperty(this._implementation, 'externalObject', { value: this, enumerable: false, configurable: true, writable: true });
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    get label() {
+        return this.i.label;
+    }
+    set label(v) {
+        this.i.label = v;
+    }
+    get name() {
+        return this.i.name;
+    }
+    set name(v) {
+        this.i.name = v;
+    }
+    get operand() {
+        return this.i.operand;
+    }
+    set operand(v) {
+        this.i.operand = ensureEnum(DataSourceSummaryOperand_$type, v);
+    }
+    findByName(name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        return null;
+    }
+}

package/esm2022/lib/igc-tool-action-field-selector-aggregations-collection.d.ts

@@ -0,0 +1,8 @@
+import { IgCollection } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorAggregation as ToolActionFieldSelectorAggregation_internal } from './ToolActionFieldSelectorAggregation';
+import { IgcToolActionFieldSelectorAggregation as IgcToolActionFieldSelectorAggregation } from './igc-tool-action-field-selector-aggregation';
+export declare class IgcToolActionFieldSelectorAggregationsCollection extends IgCollection<IgcToolActionFieldSelectorAggregation, ToolActionFieldSelectorAggregation_internal> {
+    constructor(list?: IgcToolActionFieldSelectorAggregation[]);
+    protected _createInnerColl(): SyncableObservableCollection$2<IgcToolActionFieldSelectorAggregation, ToolActionFieldSelectorAggregation_internal>;
+}

package/esm2022/lib/igc-tool-action-field-selector-aggregations-collection.js

@@ -0,0 +1,53 @@
+import { IgCollection } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorAggregation as ToolActionFieldSelectorAggregation_internal } from './ToolActionFieldSelectorAggregation';
+import { IgcToolActionFieldSelectorAggregation as IgcToolActionFieldSelectorAggregation } from './igc-tool-action-field-selector-aggregation';
+export class IgcToolActionFieldSelectorAggregationsCollection extends IgCollection {
+    constructor(list) {
+        super();
+        if (!IgcToolActionFieldSelectorAggregation.$type) {
+            IgcToolActionFieldSelectorAggregation.$type = markType(IgcToolActionFieldSelectorAggregation, "IgcToolActionFieldSelectorAggregation");
+        }
+        if (list) {
+            for (let i = 0; i < list.length; i++) {
+                this.add(list[i]);
+            }
+        }
+    }
+    _createInnerColl() {
+        if (!IgcToolActionFieldSelectorAggregation.$type) {
+            IgcToolActionFieldSelectorAggregation.$type = markType(IgcToolActionFieldSelectorAggregation, "IgcToolActionFieldSelectorAggregation");
+        }
+        let coll = new SyncableObservableCollection$2(IgcToolActionFieldSelectorAggregation.$type, ToolActionFieldSelectorAggregation_internal.$type, 0);
+        coll.compare = (ext, int) => {
+            let comp = ext;
+            if (comp._implementation) {
+                comp = comp._implementation;
+            }
+            if (comp.equals) {
+                return comp.equals(int);
+            }
+            return comp === int;
+        };
+        coll.createTo = (ext) => {
+            return ext._implementation;
+        };
+        coll.createFrom = (int) => {
+            let ext = int.externalObject;
+            if (!ext) {
+                ext = new IgcToolActionFieldSelectorAggregation();
+                if (ext) {
+                    if (!int.$type && ext._implementation.setNativeElement) {
+                        ext._implementation.setNativeElement(int);
+                    }
+                    else {
+                        ext._implementation = int;
+                    }
+                }
+            }
+            return ext;
+        };
+        return coll;
+    }
+}

package/esm2022/lib/igc-tool-action-field-selector-component.d.ts

@@ -0,0 +1,73 @@
+import { IDataSource } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorType } from "./ToolActionFieldSelectorType";
+import { IgcToolActionFieldSelectorAggregationsCollection } from "./igc-tool-action-field-selector-aggregations-collection";
+import { IgcToolActionFieldSelectorSelectedAggregationsCollection } from "./igc-tool-action-field-selector-selected-aggregations-collection";
+import { IgcToolActionComponent } from "./igc-tool-action-component";
+import { ToolActionFieldSelector } from "./ToolActionFieldSelector";
+export declare class IgcToolActionFieldSelectorComponent extends IgcToolActionComponent {
+    protected createImplementation(): ToolActionFieldSelector;
+    /**
+                                 * @hidden
+                                 */
+    get i(): ToolActionFieldSelector;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private static _observedAttributesIgcToolActionFieldSelectorComponent;
+    static get observedAttributes(): string[];
+    static htmlTagName: string;
+    protected static _isElementRegistered: boolean;
+    static register(): void;
+    /**
+     * Gets or sets if the tool action is checked.
+    */
+    get dataSource(): IDataSource;
+    set dataSource(v: IDataSource);
+    get legendTarget(): any;
+    set legendTarget(v: any);
+    /**
+     * Gets or sets if the tool action is checked.
+    */
+    get fieldType(): ToolActionFieldSelectorType;
+    set fieldType(v: ToolActionFieldSelectorType);
+    /**
+     * Gets or sets if the list only takes one selection at a time.
+    */
+    get singleSelection(): boolean;
+    set singleSelection(v: boolean);
+    private _aggregations;
+    /**
+     * Gets or sets a list of aggregations to use, if null a default list is used instead.
+     * If list provided has custom aggregations the data source is never updated.
+    */
+    get aggregations(): IgcToolActionFieldSelectorAggregationsCollection;
+    set aggregations(v: IgcToolActionFieldSelectorAggregationsCollection);
+    /**
+     * Gets or sets if the data source has to be updated when changes are made.
+    */
+    get updateDataSource(): boolean;
+    set updateDataSource(v: boolean);
+    private _selectedAggregations;
+    /**
+     * Used to set default values when using custom aggregations, will be overriden otherwise
+    */
+    get selectedAggregations(): IgcToolActionFieldSelectorSelectedAggregationsCollection;
+    set selectedAggregations(v: IgcToolActionFieldSelectorSelectedAggregationsCollection);
+    get paddingLeft(): number;
+    set paddingLeft(v: number);
+    get actualPaddingLeft(): number;
+    set actualPaddingLeft(v: number);
+    get paddingRight(): number;
+    set paddingRight(v: number);
+    get actualPaddingRight(): number;
+    set actualPaddingRight(v: number);
+    get paddingBottom(): number;
+    set paddingBottom(v: number);
+    get actualPaddingBottom(): number;
+    set actualPaddingBottom(v: number);
+    get paddingTop(): number;
+    set paddingTop(v: number);
+    get actualPaddingTop(): number;
+    set actualPaddingTop(v: number);
+    findByName(name: string): any;
+}

package/esm2022/lib/igc-tool-action-field-selector-component.js

@@ -0,0 +1,259 @@
+import { ToolActionFieldSelectorType_$type } from "./ToolActionFieldSelectorType";
+import { IgcToolActionFieldSelectorAggregationsCollection } from "./igc-tool-action-field-selector-aggregations-collection";
+import { IgcToolActionFieldSelectorSelectedAggregationsCollection } from "./igc-tool-action-field-selector-selected-aggregations-collection";
+import { IgcToolActionComponent } from "./igc-tool-action-component";
+import { ToolActionFieldSelector } from "./ToolActionFieldSelector";
+import { getAllPropertyNames, toSpinal, ensureEnum, enumToString, ensureBool } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorAggregationsCollection as ToolActionFieldSelectorAggregationsCollection_internal } from "./ToolActionFieldSelectorAggregationsCollection";
+import { ToolActionFieldSelectorAggregation } from "./ToolActionFieldSelectorAggregation";
+import { SyncableObservableCollection$1 } from "igniteui-webcomponents-core";
+import { ToolActionFieldSelectorSelectedAggregationsCollection as ToolActionFieldSelectorSelectedAggregationsCollection_internal } from "./ToolActionFieldSelectorSelectedAggregationsCollection";
+import { ToolActionFieldSelectorSelectedAggregation } from "./ToolActionFieldSelectorSelectedAggregation";
+class IgcToolActionFieldSelectorComponent extends IgcToolActionComponent {
+    createImplementation() {
+        return new ToolActionFieldSelector();
+    }
+    /**
+                                 * @hidden
+                                 */
+    get i() {
+        return this._implementation;
+    }
+    constructor() {
+        super();
+        this._aggregations = null;
+        this._selectedAggregations = null;
+    }
+    connectedCallback() {
+        if (super["connectedCallback"]) {
+            super["connectedCallback"]();
+        }
+        if (this.i.connectedCallback) {
+            this.i.connectedCallback();
+        }
+        if (this.updateContentChildren) {
+            this.updateContentChildren();
+        }
+        else if (this._updateAdapters) {
+            this._updateAdapters();
+        }
+        if (!this._attached) {
+            this._attached = true;
+            this._flushQueuedAttributes();
+        }
+    }
+    disconnectedCallback() {
+        if (super["disconnectedCallback"]) {
+            super["disconnectedCallback"]();
+        }
+        if (this.i.disconnectedCallback) {
+            this.i.disconnectedCallback();
+        }
+        if (this._attached) {
+            this._attached = false;
+        }
+    }
+    static { this._observedAttributesIgcToolActionFieldSelectorComponent = null; }
+    static get observedAttributes() {
+        if (IgcToolActionFieldSelectorComponent._observedAttributesIgcToolActionFieldSelectorComponent == null) {
+            let names = getAllPropertyNames(IgcToolActionFieldSelectorComponent);
+            for (let i = 0; i < names.length; i++) {
+                names[i] = toSpinal(names[i]);
+            }
+            IgcToolActionFieldSelectorComponent._observedAttributesIgcToolActionFieldSelectorComponent = names;
+        }
+        return IgcToolActionFieldSelectorComponent._observedAttributesIgcToolActionFieldSelectorComponent;
+    }
+    static { this.htmlTagName = "igc-tool-action-field-selector"; }
+    static { this._isElementRegistered = false; }
+    static register() {
+        if (!IgcToolActionFieldSelectorComponent._isElementRegistered) {
+            IgcToolActionFieldSelectorComponent._isElementRegistered = true;
+            RegisterElementHelper.registerElement(IgcToolActionFieldSelectorComponent.htmlTagName, IgcToolActionFieldSelectorComponent);
+        }
+    }
+    /**
+     * Gets or sets if the tool action is checked.
+    */
+    get dataSource() {
+        return this.i.h5;
+    }
+    set dataSource(v) {
+        this.i.h5 = v;
+    }
+    get legendTarget() {
+        return this.i.i1;
+    }
+    set legendTarget(v) {
+        this.i.i1 = v;
+    }
+    /**
+     * Gets or sets if the tool action is checked.
+    */
+    get fieldType() {
+        return this.i.h9;
+    }
+    set fieldType(v) {
+        this.i.h9 = ensureEnum(ToolActionFieldSelectorType_$type, v);
+        this._a("fieldType", enumToString(ToolActionFieldSelectorType_$type, this.i.h9));
+    }
+    /**
+     * Gets or sets if the list only takes one selection at a time.
+    */
+    get singleSelection() {
+        return this.i.ik;
+    }
+    set singleSelection(v) {
+        this.i.ik = ensureBool(v);
+        this._a("singleSelection", this.i.ik);
+    }
+    /**
+     * Gets or sets a list of aggregations to use, if null a default list is used instead.
+     * If list provided has custom aggregations the data source is never updated.
+    */
+    get aggregations() {
+        if (this._aggregations === null) {
+            let coll = new IgcToolActionFieldSelectorAggregationsCollection();
+            let innerColl = this.i.h6;
+            if (!innerColl) {
+                innerColl = new ToolActionFieldSelectorAggregationsCollection_internal();
+            }
+            this._aggregations = coll._fromInner(innerColl);
+            this.i.h6 = innerColl;
+        }
+        return this._aggregations;
+    }
+    set aggregations(v) {
+        if (this._aggregations !== null) {
+            this._aggregations._setSyncTarget(null);
+            this._aggregations = null;
+        }
+        let coll = new IgcToolActionFieldSelectorAggregationsCollection();
+        this._aggregations = coll._fromOuter(v);
+        let syncColl = new SyncableObservableCollection$1(ToolActionFieldSelectorAggregation.$type);
+        let innerColl = this.i.h6;
+        if (!innerColl) {
+            innerColl = new ToolActionFieldSelectorAggregationsCollection_internal();
+        }
+        syncColl._inner = innerColl;
+        syncColl.clear();
+        this._aggregations._setSyncTarget(syncColl);
+        this.i.h6 = innerColl;
+    }
+    /**
+     * Gets or sets if the data source has to be updated when changes are made.
+    */
+    get updateDataSource() {
+        return this.i.il;
+    }
+    set updateDataSource(v) {
+        this.i.il = ensureBool(v);
+        this._a("updateDataSource", this.i.il);
+    }
+    /**
+     * Used to set default values when using custom aggregations, will be overriden otherwise
+    */
+    get selectedAggregations() {
+        if (this._selectedAggregations === null) {
+            let coll = new IgcToolActionFieldSelectorSelectedAggregationsCollection();
+            let innerColl = this.i.h8;
+            if (!innerColl) {
+                innerColl = new ToolActionFieldSelectorSelectedAggregationsCollection_internal();
+            }
+            this._selectedAggregations = coll._fromInner(innerColl);
+            this.i.h8 = innerColl;
+        }
+        return this._selectedAggregations;
+    }
+    set selectedAggregations(v) {
+        if (this._selectedAggregations !== null) {
+            this._selectedAggregations._setSyncTarget(null);
+            this._selectedAggregations = null;
+        }
+        let coll = new IgcToolActionFieldSelectorSelectedAggregationsCollection();
+        this._selectedAggregations = coll._fromOuter(v);
+        let syncColl = new SyncableObservableCollection$1(ToolActionFieldSelectorSelectedAggregation.$type);
+        let innerColl = this.i.h8;
+        if (!innerColl) {
+            innerColl = new ToolActionFieldSelectorSelectedAggregationsCollection_internal();
+        }
+        syncColl._inner = innerColl;
+        syncColl.clear();
+        this._selectedAggregations._setSyncTarget(syncColl);
+        this.i.h8 = innerColl;
+    }
+    get paddingLeft() {
+        return this.i.iv;
+    }
+    set paddingLeft(v) {
+        this.i.iv = +v;
+        this._a("paddingLeft", this.i.iv);
+    }
+    get actualPaddingLeft() {
+        return this.i.ir;
+    }
+    set actualPaddingLeft(v) {
+        this.i.ir = +v;
+        this._a("actualPaddingLeft", this.i.ir);
+    }
+    get paddingRight() {
+        return this.i.iw;
+    }
+    set paddingRight(v) {
+        this.i.iw = +v;
+        this._a("paddingRight", this.i.iw);
+    }
+    get actualPaddingRight() {
+        return this.i.is;
+    }
+    set actualPaddingRight(v) {
+        this.i.is = +v;
+        this._a("actualPaddingRight", this.i.is);
+    }
+    get paddingBottom() {
+        return this.i.iu;
+    }
+    set paddingBottom(v) {
+        this.i.iu = +v;
+        this._a("paddingBottom", this.i.iu);
+    }
+    get actualPaddingBottom() {
+        return this.i.iq;
+    }
+    set actualPaddingBottom(v) {
+        this.i.iq = +v;
+        this._a("actualPaddingBottom", this.i.iq);
+    }
+    get paddingTop() {
+        return this.i.ix;
+    }
+    set paddingTop(v) {
+        this.i.ix = +v;
+        this._a("paddingTop", this.i.ix);
+    }
+    get actualPaddingTop() {
+        return this.i.it;
+    }
+    set actualPaddingTop(v) {
+        this.i.it = +v;
+        this._a("actualPaddingTop", this.i.it);
+    }
+    findByName(name) {
+        var baseResult = super.findByName(name);
+        if (baseResult) {
+            return baseResult;
+        }
+        if (this.dataSource && this.dataSource.name && this.dataSource.name == name) {
+            return this.dataSource;
+        }
+        if (this.aggregations != null && this.aggregations.findByName && this.aggregations.findByName(name)) {
+            return this.aggregations.findByName(name);
+        }
+        if (this.selectedAggregations != null && this.selectedAggregations.findByName && this.selectedAggregations.findByName(name)) {
+            return this.selectedAggregations.findByName(name);
+        }
+        return null;
+    }
+}
+export { IgcToolActionFieldSelectorComponent };

package/esm2022/lib/igc-tool-action-field-selector-module.d.ts

@@ -0,0 +1,3 @@
+export declare class IgcToolActionFieldSelectorModule {
+    static register(): void;
+}