@bitbybit-dev/base 0.19.6 → 0.19.8

package/lib/api/inputs/{lists-inputs.d.ts → lists-inputs.ts}

@@ -1,10 +1,20 @@
-export declare namespace Lists {
-    enum firstLastEnum {
+/* eslint-disable @typescript-eslint/no-namespace */
+
+
+// tslint:disable-next-line: no-namespace
+export namespace Lists {
+
+    export enum firstLastEnum {
         first = "first",
-        last = "last"
+        last = "last",
     }
-    class ListItemDto<T> {
-        constructor(list?: T[], index?: number, clone?: boolean);
+
+    export class ListItemDto<T> {
+        constructor(list?: T[], index?: number, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (index !== undefined) { this.index = index; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
          * The list to interrogate
          * @default undefined
@@ -17,15 +27,20 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        index: number;
+        index = 0;
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class SubListDto<T> {
-        constructor(list?: T[], indexStart?: number, indexEnd?: number, clone?: boolean);
+    export class SubListDto<T> {
+        constructor(list?: T[], indexStart?: number, indexEnd?: number, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (indexStart !== undefined) { this.indexStart = indexStart; }
+            if (indexEnd !== undefined) { this.indexEnd = indexEnd; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
          * The list to split into a sublist
          * @default undefined
@@ -38,7 +53,7 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        indexStart: number;
+        indexStart = 0;
         /**
          * Index to which to end the sublist - 0 means first.
          * @default 1
@@ -46,15 +61,18 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        indexEnd: number;
+        indexEnd = 1;
         /**
          * Tries to clone the data in the component, sometimes it may not be possible if structure is circular
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class ListCloneDto<T> {
-        constructor(list?: T[], clone?: boolean);
+    export class ListCloneDto<T> {
+        constructor(list?: T[], clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
          * The list to interrogate
          * @default undefined
@@ -64,10 +82,12 @@ export declare namespace Lists {
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class RepeatInPatternDto<T> {
-        constructor(list?: T[]);
+    export class RepeatInPatternDto<T> {
+        constructor(list?: T[]) {
+            if (list !== undefined) { this.list = list; }
+        }
         /**
          * The list to interrogate
          * @default undefined
@@ -77,7 +97,7 @@ export declare namespace Lists {
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
         /**
          * The limit of the length of the list
          * @default 100
@@ -85,10 +105,14 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        lengthLimit: number;
+        lengthLimit = 100;
     }
-    class SortDto<T> {
-        constructor(list?: T[], clone?: boolean, orderAsc?: boolean);
+    export class SortDto<T> {
+        constructor(list?: T[], clone?: boolean, orderAsc?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (clone !== undefined) { this.clone = clone; }
+            if (orderAsc !== undefined) { this.orderAsc = orderAsc; }
+        }
         /**
          * The list to interrogate
          * @default undefined
@@ -98,15 +122,19 @@ export declare namespace Lists {
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
         /**
          * If true, the list will be sorted in ascending order, otherwise in descending order
          * @default true
          */
-        orderAsc: boolean;
+        orderAsc = true;
     }
-    class SortJsonDto<T> {
-        constructor(list?: T[], clone?: boolean, orderAsc?: boolean);
+    export class SortJsonDto<T> {
+        constructor(list?: T[], clone?: boolean, orderAsc?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (clone !== undefined) { this.clone = clone; }
+            if (orderAsc !== undefined) { this.orderAsc = orderAsc; }
+        }
         /**
          * The list to interrogate
          * @default undefined
@@ -116,28 +144,34 @@ export declare namespace Lists {
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
         /**
          * If true, the list will be sorted in ascending order, otherwise in descending order
          * @default true
          */
-        orderAsc: boolean;
+        orderAsc = true;
         /**
          * The property to sort by
          * @default propName
          */
-        property: string;
+        property = "propName";
     }
-    class ListDto<T> {
-        constructor(list?: T[]);
+    export class ListDto<T> {
+        constructor(list?: T[]) {
+            if (list !== undefined) { this.list = list; }
+        }
         /**
          * The list
          * @default undefined
          */
         list: T[];
     }
-    class GroupListDto<T> {
-        constructor(list?: T[], nrElements?: number, keepRemainder?: boolean);
+    export class GroupListDto<T> {
+        constructor(list?: T[], nrElements?: number, keepRemainder?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (nrElements !== undefined) { this.nrElements = nrElements; }
+            if (keepRemainder !== undefined) { this.keepRemainder = keepRemainder; }
+        }
         /**
          * The list of elements to group together
          * @default undefined
@@ -150,15 +184,18 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        nrElements: number;
+        nrElements = 2;
         /**
          * If true, the remainder of the list will be added as a separate group
          * @default false
          */
-        keepRemainder: boolean;
+        keepRemainder = false;
     }
-    class MultiplyItemDto<T> {
-        constructor(item?: T, times?: number);
+    export class MultiplyItemDto<T> {
+        constructor(item?: T, times?: number) {
+            if (item !== undefined) { this.item = item; }
+            if (times !== undefined) { this.times = times; }
+        }
         /**
          * The item to multiply
          * @default undefined
@@ -173,8 +210,13 @@ export declare namespace Lists {
          */
         times: number;
     }
-    class AddItemAtIndexDto<T> {
-        constructor(list?: T[], item?: T, index?: number, clone?: boolean);
+    export class AddItemAtIndexDto<T> {
+        constructor(list?: T[], item?: T, index?: number, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (item !== undefined) { this.item = item; }
+            if (index !== undefined) { this.index = index; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
          * The list to which item needs to be added
          * @default undefined
@@ -192,15 +234,20 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        index: number;
+        index = 0;
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class AddItemAtIndexesDto<T> {
-        constructor(list?: T[], item?: T, indexes?: number[], clone?: boolean);
+    export class AddItemAtIndexesDto<T> {
+        constructor(list?: T[], item?: T, indexes?: number[], clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (item !== undefined) { this.item = item; }
+            if (indexes !== undefined) { this.indexes = indexes; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
          * The list to which item needs to be added
          * @default undefined
@@ -215,15 +262,21 @@ export declare namespace Lists {
          * The index to add the item at
          * @default [0]
          */
-        indexes: number[];
+        indexes: number[] = [0];
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class AddItemsAtIndexesDto<T> {
-        constructor(list?: T[], items?: T[], indexes?: number[], clone?: boolean);
+
+    export class AddItemsAtIndexesDto<T> {
+        constructor(list?: T[], items?: T[], indexes?: number[], clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (items !== undefined) { this.items = items; }
+            if (indexes !== undefined) { this.indexes = indexes; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
          * The list to which item needs to be added
          * @default undefined
@@ -238,15 +291,19 @@ export declare namespace Lists {
          * The index to add the item at
          * @default [0]
          */
-        indexes: number[];
+        indexes: number[] = [0];
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class RemoveItemAtIndexDto<T> {
-        constructor(list?: T[], index?: number, clone?: boolean);
+    export class RemoveItemAtIndexDto<T> {
+        constructor(list?: T[], index?: number, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (index !== undefined) { this.index = index; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
         * The list from which item needs to be removed
         * @default undefined
@@ -259,15 +316,19 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        index: number;
+        index = 0;
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class RemoveItemsAtIndexesDto<T> {
-        constructor(list?: T[], indexes?: number[], clone?: boolean);
+    export class RemoveItemsAtIndexesDto<T> {
+        constructor(list?: T[], indexes?: number[], clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (indexes !== undefined) { this.indexes = indexes; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
         * The list from which item needs to be removed
         * @default undefined
@@ -282,10 +343,15 @@ export declare namespace Lists {
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class RemoveNthItemDto<T> {
-        constructor(list?: T[], nth?: number, offset?: number, clone?: boolean);
+    export class RemoveNthItemDto<T> {
+        constructor(list?: T[], nth?: number, offset?: number, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (nth !== undefined) { this.nth = nth; }
+            if (offset !== undefined) { this.offset = offset; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
         * The list from which item needs to be removed
         * @default undefined
@@ -298,7 +364,7 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        nth: number;
+        nth = 2;
         /**
          * The offset from which to start counting
          * @default 0
@@ -306,15 +372,19 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        offset: number;
+        offset = 0;
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class RandomThresholdDto<T> {
-        constructor(list?: T[], threshold?: number, clone?: boolean);
+    export class RandomThresholdDto<T> {
+        constructor(list?: T[], threshold?: number, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (threshold !== undefined) { this.threshold = threshold; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
         * The list from which item needs to be updated
         * @default undefined
@@ -327,15 +397,18 @@ export declare namespace Lists {
          * @maximum 1
          * @step 1
          */
-        threshold: number;
+        threshold = 1;
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class RemoveDuplicatesDto<T> {
-        constructor(list?: T[], clone?: boolean);
+    export class RemoveDuplicatesDto<T> {
+        constructor(list?: T[], clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
         * The list from which item needs to be removed
         * @default undefined
@@ -345,10 +418,14 @@ export declare namespace Lists {
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class RemoveDuplicatesToleranceDto<T> {
-        constructor(list?: T[], clone?: boolean, tolerance?: number);
+    export class RemoveDuplicatesToleranceDto<T> {
+        constructor(list?: T[], clone?: boolean, tolerance?: number) {
+            if (list !== undefined) { this.list = list; }
+            if (tolerance !== undefined) { this.tolerance = tolerance; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
         * The list from which item needs to be removed
         * @default undefined
@@ -361,15 +438,18 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1e-7
          */
-        tolerance: number;
+        tolerance = 1e-7;
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class GetByPatternDto<T> {
-        constructor(list?: T[], pattern?: boolean[]);
+    export class GetByPatternDto<T> {
+        constructor(list?: T[], pattern?: boolean[]) {
+            if (list !== undefined) { this.list = list; }
+            if (pattern !== undefined) { this.pattern = pattern; }
+        }
         /**
         * The list from which we need to get an item
         * @default undefined
@@ -379,10 +459,15 @@ export declare namespace Lists {
          * The list of booleans to be used as a pattern (true means get, false means skip)
          * @default [true, true, false]
          */
-        pattern: boolean[];
+        pattern: boolean[] = [true, true, false];
     }
-    class GetNthItemDto<T> {
-        constructor(list?: T[], nth?: number, offset?: number, clone?: boolean);
+    export class GetNthItemDto<T> {
+        constructor(list?: T[], nth?: number, offset?: number, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (nth !== undefined) { this.nth = nth; }
+            if (offset !== undefined) { this.offset = offset; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
         * The list from which we need to get an item
         * @default undefined
@@ -395,7 +480,7 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        nth: number;
+        nth = 2;
         /**
          * The offset from which to start counting
          * @default 0
@@ -403,23 +488,28 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        offset: number;
+        offset = 0;
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class GetLongestListLength<T> {
-        constructor(lists?: T[]);
+    export class GetLongestListLength<T> {
+        constructor(lists?: T[]) {
+            if (lists !== undefined) { this.lists = lists; }
+        }
         /**
          * The list from which we need to get an item
          * @default undefined
          */
         lists: T[];
     }
-    class MergeElementsOfLists<T> {
-        constructor(lists?: T[], level?: number);
+    export class MergeElementsOfLists<T> {
+        constructor(lists?: T[], level?: number) {
+            if (lists !== undefined) { this.lists = lists; }
+            if (level !== undefined) { this.level = level; }
+        }
         /**
         * The list from which we need to get an item
         * @default undefined
@@ -432,10 +522,14 @@ export declare namespace Lists {
          * @maximum Infinity
          * @step 1
          */
-        level: number;
+        level = 0;
     }
-    class AddItemDto<T> {
-        constructor(list?: T[], item?: T, clone?: boolean);
+    export class AddItemDto<T> {
+        constructor(list?: T[], item?: T, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (item !== undefined) { this.item = item; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
          * The list to which item needs to be added
          * @default undefined
@@ -450,10 +544,15 @@ export declare namespace Lists {
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
-    class AddItemFirstLastDto<T> {
-        constructor(list?: T[], item?: T, position?: firstLastEnum, clone?: boolean);
+    export class AddItemFirstLastDto<T> {
+        constructor(list?: T[], item?: T, position?: firstLastEnum, clone?: boolean) {
+            if (list !== undefined) { this.list = list; }
+            if (item !== undefined) { this.item = item; }
+            if (position !== undefined) { this.position = position; }
+            if (clone !== undefined) { this.clone = clone; }
+        }
         /**
          * The list to which item needs to be added
          * @default undefined
@@ -468,11 +567,11 @@ export declare namespace Lists {
          * The option if the item needs to be added at the beginning or the end of the list
          * @default last
          */
-        position: firstLastEnum;
+        position: firstLastEnum = firstLastEnum.last;
         /**
          * Tries to make structured clone of the incoming list data in the component, sometimes it may not be possible due to circular structures or other types of error
          * @default true
          */
-        clone?: boolean;
+        clone? = true;
     }
 }