@bitbybit-dev/base 0.19.8 → 0.20.0

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

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