lorgg-v2-components 0.0.22

package/dist/components/library/Filters/FilterDecks/types.d.ts

@@ -0,0 +1,26 @@
+import { DeckFilters } from '../../../types/filters';
+import { PropType } from 'vue';
+export type FilterDecksProps = {
+    filters: DeckFilters;
+    includeDataFilters: boolean;
+};
+export declare const filterDecksProps: {
+    filters: {
+        type: PropType<DeckFilters>;
+        required: boolean;
+        default: {
+            cardFilters: never[];
+            regionFilters: never[];
+            sampleSizeFilters: never[];
+            serverFilters: never[];
+            timeFilters: never[];
+            formatFilters: never[];
+            queueFilters: never[];
+        };
+    };
+    includeDataFilters: {
+        type: BooleanConstructor;
+        required: boolean;
+        default: boolean;
+    };
+};

package/dist/components/library/Filters/FilterFormat/FilterFormat.vue.d.ts

@@ -0,0 +1,44 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterFormat/FilterFormat.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterFormat.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterFormat/FilterFormat.vue"],"names":[],"mappings":"AACA,cAAc,0JAA0J,CAAC;AACzK,OAAO,uKAAuK,CAAC;;AAE/K,wBAA0F"}

package/dist/components/library/Filters/FilterFormat/types.d.ts

@@ -0,0 +1,23 @@
+export type FilterFormatProps = {
+    filterArray: Array<string>;
+};
+export declare const filterFormatProps: {
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterKeywords/FilterKeywords.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterKeywords/FilterKeywords.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterKeywords.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterKeywords/FilterKeywords.vue"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,8JAA8J,CAAC;AACrL,cAAc,8JAA8J,CAAC;AAC7K,eAAe,SAAS,CAAC"}

package/dist/components/library/Filters/FilterKeywords/types.d.ts

@@ -0,0 +1,11 @@
+import { PropType } from 'vue';
+export type FilterKeywordsProps = {
+    filterArray: string[];
+};
+export declare const filterKeywordsProps: {
+    filterArray: {
+        type: PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterManaCost/FilterManaCost.vue.d.ts

@@ -0,0 +1,44 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: {
+            (arrayLength: number): number[];
+            (...items: number[]): number[];
+            new (arrayLength: number): number[];
+            new (...items: number[]): number[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: {
+            (arrayLength: number): number[];
+            (...items: number[]): number[];
+            new (arrayLength: number): number[];
+            new (...items: number[]): number[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: number[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterManaCost/FilterManaCost.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterManaCost.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterManaCost/FilterManaCost.vue"],"names":[],"mappings":"AACA,cAAc,8JAA8J,CAAC;AAC7K,OAAO,2KAA2K,CAAC;;AAEnL,wBAA0F"}

package/dist/components/library/Filters/FilterManaCost/types.d.ts

@@ -0,0 +1,23 @@
+export type FilterProps = {
+    filterArray: Array<number>;
+};
+export declare const filterProps: {
+    filterArray: {
+        type: {
+            (arrayLength: number): number[];
+            (...items: number[]): number[];
+            new (arrayLength: number): number[];
+            new (...items: number[]): number[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterQueues/FilterQueues.vue.d.ts

@@ -0,0 +1,29 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+    availableQueues: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+    availableQueues: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+    availableQueues: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterQueues/FilterQueues.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterQueues.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterQueues/FilterQueues.vue"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,0JAA0J,CAAC;AACjL,cAAc,0JAA0J,CAAC;AACzK,eAAe,SAAS,CAAC"}

package/dist/components/library/Filters/FilterQueues/types.d.ts

@@ -0,0 +1,18 @@
+import { QueueEnum } from '../../../types/jsons';
+import { PropType } from 'vue';
+export type FilterQueuesProps = {
+    filterArray: string[];
+    availableQueues: (string | QueueEnum)[];
+};
+export declare const filterQueuesProps: {
+    filterArray: {
+        type: PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+    availableQueues: {
+        type: PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterRanks/FilterRanks.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterRanks/FilterRanks.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterRanks.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterRanks/FilterRanks.vue"],"names":[],"mappings":"AACA,cAAc,wJAAwJ,CAAC;AACvK,OAAO,qKAAqK,CAAC;;AAE7K,wBAA0F"}

package/dist/components/library/Filters/FilterRanks/types.d.ts

@@ -0,0 +1,11 @@
+import { PropType } from 'vue';
+export type FilterRanksProps = {
+    filterArray: string[];
+};
+export declare const filterRanksProps: {
+    filterArray: {
+        type: PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterRarities/FilterRarities.vue.d.ts

@@ -0,0 +1,44 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterRarities/FilterRarities.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterRarities.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterRarities/FilterRarities.vue"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,8JAA8J,CAAC;AACrL,cAAc,8JAA8J,CAAC;AAC7K,eAAe,SAAS,CAAC"}

package/dist/components/library/Filters/FilterRarities/types.d.ts

@@ -0,0 +1,23 @@
+export type FilterRaritiesProps = {
+    filterArray: Array<string>;
+};
+export declare const filterRaritiesProps: {
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterRegions/FilterRegions.vue.d.ts

@@ -0,0 +1,44 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterRegions/FilterRegions.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterRegions.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterRegions/FilterRegions.vue"],"names":[],"mappings":"AACA,cAAc,4JAA4J,CAAC;AAC3K,OAAO,yKAAyK,CAAC;;AAEjL,wBAA0F"}

package/dist/components/library/Filters/FilterRegions/types.d.ts

@@ -0,0 +1,23 @@
+export type FilterProps = {
+    filterArray: Array<string>;
+};
+export declare const filterProps: {
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterSampleSize/FilterSampleSize.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: import("vue").PropType<number[]>;
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: import("vue").PropType<number[]>;
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: number[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterSampleSize/FilterSampleSize.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterSampleSize.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterSampleSize/FilterSampleSize.vue"],"names":[],"mappings":"AACA,cAAc,kKAAkK,CAAC;AACjL,OAAO,+KAA+K,CAAC;;AAEvL,wBAA0F"}

package/dist/components/library/Filters/FilterSampleSize/types.d.ts

@@ -0,0 +1,11 @@
+import { PropType } from 'vue';
+export type FilterSampleSizeProps = {
+    filterArray: number[];
+};
+export declare const filterSampleSizeProps: {
+    filterArray: {
+        type: PropType<number[]>;
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterServers/FilterServers.vue.d.ts

@@ -0,0 +1,44 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterServers/FilterServers.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterServers.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterServers/FilterServers.vue"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,4JAA4J,CAAC;AACnL,cAAc,4JAA4J,CAAC;AAC3K,eAAe,SAAS,CAAC"}

package/dist/components/library/Filters/FilterServers/types.d.ts

@@ -0,0 +1,23 @@
+export type FilterServersProps = {
+    filterArray: Array<string>;
+};
+export declare const filterServersProps: {
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterSets/FilterSets.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterSets/FilterSets.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterSets.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterSets/FilterSets.vue"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,sJAAsJ,CAAC;AAC7K,cAAc,sJAAsJ,CAAC;AACrK,eAAe,SAAS,CAAC"}

package/dist/components/library/Filters/FilterSets/types.d.ts

@@ -0,0 +1,11 @@
+import { PropType } from 'vue';
+export type FilterSetsProps = {
+    filterArray: string[];
+};
+export declare const filterSetsProps: {
+    filterArray: {
+        type: PropType<string[]>;
+        required: boolean;
+        default: never[];
+    };
+};

package/dist/components/library/Filters/FilterTime/FilterTime.vue.d.ts

@@ -0,0 +1,44 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:filterArray"[], "update:filterArray", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    filterArray: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: boolean;
+        default: never[];
+    };
+}>> & {
+    "onUpdate:filterArray"?: ((...args: any[]) => any) | undefined;
+}, {
+    filterArray: string[];
+}, {}>;
+export default _sfc_main;

package/dist/components/library/Filters/FilterTime/FilterTime.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterTime.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/library/Filters/FilterTime/FilterTime.vue"],"names":[],"mappings":"AACA,cAAc,sJAAsJ,CAAC;AACrK,OAAO,mKAAmK,CAAC;;AAE3K,wBAA0F"}