@privateaim/client-vue 0.8.2

package/dist/components/analysis/FAnalysisImageCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisImageCommand.d.ts","sourceRoot":"","sources":["../../../src/components/analysis/FAnalysisImageCommand.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAe,MAAM,sBAAsB,CAAC;AAC5E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;cAqBR,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;cAA5B,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;;;AAfxD,wBA+IG"}

package/dist/components/analysis/FAnalysisItem.d.ts

@@ -0,0 +1,22 @@
+import type { PropType } from 'vue';
+import type { Analysis } from '@privateaim/core-kit';
+declare const FAnalysisItem: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("failed" | "deleted" | "updated" | "executed")[], "failed" | "deleted" | "updated" | "executed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+}>> & {
+    onFailed?: (...args: any[]) => any;
+    onDeleted?: (...args: any[]) => any;
+    onUpdated?: (...args: any[]) => any;
+    onExecuted?: (...args: any[]) => any;
+}, {}, {}>;
+export { FAnalysisItem, };
+//# sourceMappingURL=FAnalysisItem.d.ts.map

package/dist/components/analysis/FAnalysisItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisItem.d.ts","sourceRoot":"","sources":["../../../src/components/analysis/FAnalysisItem.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,KAAK,CAAC;AAIhD,OAAO,KAAK,EACR,QAAQ,EACX,MAAM,sBAAsB,CAAC;AAQ9B,QAAA,MAAM,aAAa;;cAQS,QAAQ,CAAC,QAAQ,CAAC;;;;;;;cAAlB,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;UAsC5C,CAAC;AAEH,OAAO,EACH,aAAa,GAChB,CAAC"}

package/dist/components/analysis/FAnalysisItemCard.vue.d.ts

@@ -0,0 +1,42 @@
+import type { Analysis } from '@privateaim/core-kit';
+import type { PropType, SlotsType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+    busy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    extendedView: import("vue").Ref<boolean>;
+    toggleView: () => void;
+    canDelete: import("vue").Ref<boolean>;
+    handleDeleted: (data: Analysis) => void;
+    handleExecuted: (component: string, command: string) => void;
+    handleFailed: (error: Error) => void;
+    handleUpdated: (data: Analysis) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("failed" | "deleted" | "updated" | "executed")[], "failed" | "deleted" | "updated" | "executed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+    busy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onFailed?: (...args: any[]) => any;
+    onDeleted?: (...args: any[]) => any;
+    onUpdated?: (...args: any[]) => any;
+    onExecuted?: (...args: any[]) => any;
+}, {
+    busy: boolean;
+}, SlotsType<{
+    itemActions: {
+        data: Analysis;
+    };
+}>>;
+export default _default;
+//# sourceMappingURL=FAnalysisItemCard.vue.d.ts.map

package/dist/components/analysis/FAnalysisItemCard.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisItemCard.vue.d.ts","sourceRoot":"","sources":["../../../src/components/analysis/FAnalysisItemCard.vue"],"names":[],"mappings":"AAqLA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIrD,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;;;cAmBnB,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;;;;0BAsBT,QAAQ;gCAIF,MAAM,WAAW,MAAM;0BAI7B,KAAK;0BAIL,QAAQ;;;cAlCjB,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;iBAUH;QAC/B,IAAI,EAAE,QAAQ,CAAA;KACjB;;AAvBT,wBA4DG"}

package/dist/components/analysis/FAnalysisName.d.ts

@@ -0,0 +1,38 @@
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+    entityName: {
+        type: PropType<string | null | undefined>;
+        default: any;
+    };
+    editable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("failed" | "updated")[], "failed" | "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+    entityName: {
+        type: PropType<string | null | undefined>;
+        default: any;
+    };
+    editable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onFailed?: (...args: any[]) => any;
+    onUpdated?: (...args: any[]) => any;
+}, {
+    entityName: string;
+    editable: boolean;
+}, {}>;
+export default _default;
+//# sourceMappingURL=FAnalysisName.d.ts.map

package/dist/components/analysis/FAnalysisName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisName.d.ts","sourceRoot":"","sources":["../../../src/components/analysis/FAnalysisName.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,KAAK,CAAC;;;;;;;cAepB,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;cAAnC,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;;;;;;;;;;;;;;AAP/D,wBA+HG"}

package/dist/components/analysis/FAnalysisPipeline.vue.d.ts

@@ -0,0 +1,49 @@
+import type { Analysis } from '@privateaim/core-kit';
+import { AnalysisAPICommand, AnalysisBuildStatus, AnalysisConfigurationStatus, AnalysisResultStatus, AnalysisRunStatus } from '@privateaim/core-kit';
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    listDirection: {
+        type: StringConstructor;
+        default: string;
+    };
+    withCommand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+}, {
+    trainBuildStatus: typeof AnalysisBuildStatus;
+    trainConfigurationStatus: typeof AnalysisConfigurationStatus;
+    trainRunStatus: typeof AnalysisRunStatus;
+    trainResultStatus: typeof AnalysisResultStatus;
+    trainCommand: typeof AnalysisAPICommand;
+    busy: boolean;
+    handleUpdated: (item: Analysis) => void;
+    handleFailed: (e: Error) => void;
+    handleExecuted: (type: string, command: string) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("failed" | "updated" | "executed")[], "failed" | "updated" | "executed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    listDirection: {
+        type: StringConstructor;
+        default: string;
+    };
+    withCommand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+}>> & {
+    onFailed?: (...args: any[]) => any;
+    onUpdated?: (...args: any[]) => any;
+    onExecuted?: (...args: any[]) => any;
+}, {
+    listDirection: string;
+    withCommand: boolean;
+}, {}>;
+export default _default;
+//# sourceMappingURL=FAnalysisPipeline.vue.d.ts.map

package/dist/components/analysis/FAnalysisPipeline.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisPipeline.vue.d.ts","sourceRoot":"","sources":["../../../src/components/analysis/FAnalysisPipeline.vue"],"names":[],"mappings":"AAwKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EACH,kBAAkB,EAClB,mBAAmB,EACnB,2BAA2B,EAC3B,oBAAoB,EACpB,iBAAiB,EACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;;;;;;;;;;;cAsBR,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;;;0BAST,QAAQ;sBAGZ,KAAK;2BANA,MAAM,WAAW,MAAM;;;;;;;;;;;cANjC,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;;;;AAhB9C,wBA8CG"}

package/dist/components/analysis/index.d.ts

@@ -0,0 +1,8 @@
+export * from './wizard';
+export { default as FAnalysisBasicForm } from './FAnalysisBasicForm.vue';
+export { default as FAnalysis } from './FAnalysis';
+export { FAnalysisItem } from './FAnalysisItem';
+export { default as FAnalyses } from './FAnalyses';
+export { default as FAnalysisName } from './FAnalysisName';
+export { default as FAnalysisPipeline } from './FAnalysisPipeline.vue';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/analysis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/analysis/index.ts"],"names":[],"mappings":"AAOA,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/components/analysis/wizard/FAnalysisWizard.vue.d.ts

@@ -0,0 +1,32 @@
+import type { PropType, Ref } from 'vue';
+import type { Analysis, AnalysisBucketFile } from '@privateaim/core-kit';
+declare const _default: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+}, {
+    startIndex: Ref<number>;
+    handleFailed: (e?: Error | null) => void;
+    handleUpdated: (entity: Analysis) => void;
+    handleWizardChangedEvent: (prevIndex: number, nextIndex: number) => void;
+    handleWizardFinishedEvent: () => void;
+    handleWizardErrorEvent: (e?: Error) => void;
+    prevWizardStep: () => void;
+    nextWizardStep: () => void;
+    passWizardStep: () => Promise<boolean>;
+    entrypointFile: Ref<AnalysisBucketFile>;
+    setEntrypointFile: (item?: AnalysisBucketFile) => void;
+    wizardNode: Ref<any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("failed" | "updated" | "finished")[], "failed" | "updated" | "finished", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+}>> & {
+    onFailed?: (...args: any[]) => any;
+    onUpdated?: (...args: any[]) => any;
+    onFinished?: (...args: any[]) => any;
+}, {}, {}>;
+export default _default;
+//# sourceMappingURL=FAnalysisWizard.vue.d.ts.map

package/dist/components/analysis/wizard/FAnalysisWizard.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisWizard.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/analysis/wizard/FAnalysisWizard.vue"],"names":[],"mappings":"AA4UA,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AASzC,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;;;cAmB7C,QAAQ,CAAC,QAAQ,CAAC;;;;;uBAiFZ,KAAK,GAAG,IAAI;4BANP,QAAQ;0CAyGM,MAAM,aAAa,MAAM;;iCAKlC,KAAK;;;0BA9Eb,OAAO,CAAC,OAAO,CAAC;;+BAiEV,kBAAkB;;;;cA5KhC,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;AAZ9C,wBAkOG"}

package/dist/components/analysis/wizard/FAnalysisWizardStepBase.vue.d.ts

@@ -0,0 +1,24 @@
+import type { Analysis, AnalysisNode, MasterImage } from '@privateaim/core-kit';
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+}, {
+    handleFailed: (e: Error) => void;
+    handleMasterImageSelected: (item: MasterImage) => Promise<void>;
+    handleAnalysisNodeCreated: (item: AnalysisNode) => void;
+    handleAnalysisNodeDeleted: (item: AnalysisNode) => void;
+    FAnalysisNodes: import("vue").Ref<Record<string, any>>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("failed" | "updated")[], "failed" | "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+}>> & {
+    onFailed?: (...args: any[]) => any;
+    onUpdated?: (...args: any[]) => any;
+}, {}, {}>;
+export default _default;
+//# sourceMappingURL=FAnalysisWizardStepBase.vue.d.ts.map

package/dist/components/analysis/wizard/FAnalysisWizardStepBase.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisWizardStepBase.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/analysis/wizard/FAnalysisWizardStepBase.vue"],"names":[],"mappings":"AA6JA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;;;cAqBR,QAAQ,CAAC,QAAQ,CAAC;;;;sBA2Cb,KAAK;sCApCiB,WAAW;sCAgBjB,YAAY;sCAUZ,YAAY;;;;cAjCjC,QAAQ,CAAC,QAAQ,CAAC;;;;;;;AAX9C,wBAkEG"}

package/dist/components/analysis/wizard/FAnalysisWizardStepFiles.vue.d.ts

@@ -0,0 +1,73 @@
+import { AnalysisBucketType } from '@privateaim/core-kit';
+import type { Analysis, AnalysisBucket, AnalysisBucketFile } from '@privateaim/core-kit';
+import type { FiltersBuildInput } from 'rapiq';
+import { type PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+    entrypointEntity: {
+        type: PropType<AnalysisBucketFile>;
+    };
+}, {
+    handleFailed: (e: Error) => void;
+    handleEntrypointChanged: (e: AnalysisBucketFile) => void;
+    queryFilters: import("vue").ComputedRef<{
+        analysis_id: string;
+        type: AnalysisBucketType.CODE;
+    }>;
+    analysisBucketNode: import("vue").Ref<import("vue").DefineComponent<{
+        entity: {
+            type: PropType<AnalysisBucket>;
+        };
+        entityId: {
+            type: StringConstructor;
+        };
+        queryFilters: {
+            type: PropType<FiltersBuildInput<AnalysisBucket>>;
+        };
+        queryFields: {
+            type: PropType<import("rapiq").FieldsBuildInput<AnalysisBucket>>;
+        };
+        query: {
+            type: PropType<import("rapiq").BuildInput<AnalysisBucket>>;
+        };
+    }, () => import("vue").VNodeChild, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../../index.js").EntityManagerEventsType<AnalysisBucket>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<AnalysisBucket>;
+        };
+        entityId: {
+            type: StringConstructor;
+        };
+        queryFilters: {
+            type: PropType<FiltersBuildInput<AnalysisBucket>>;
+        };
+        queryFields: {
+            type: PropType<import("rapiq").FieldsBuildInput<AnalysisBucket>>;
+        };
+        query: {
+            type: PropType<import("rapiq").BuildInput<AnalysisBucket>>;
+        };
+    }>> & {
+        onFailed?: (item: Error) => any;
+        onCreated?: (item: AnalysisBucket) => any;
+        onDeleted?: (item: AnalysisBucket) => any;
+        onUpdated?: (item: AnalysisBucket) => any;
+        onResolved?: (_item: AnalysisBucket) => any;
+    }, {}, import("vue").SlotsType<import("../../../index.js").EntityManagerSlotsType<AnalysisBucket>>>>;
+    retry: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("failed" | "entrypointChanged")[], "failed" | "entrypointChanged", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+    entrypointEntity: {
+        type: PropType<AnalysisBucketFile>;
+    };
+}>> & {
+    onFailed?: (...args: any[]) => any;
+    onEntrypointChanged?: (...args: any[]) => any;
+}, {}, {}>;
+export default _default;
+//# sourceMappingURL=FAnalysisWizardStepFiles.vue.d.ts.map

package/dist/components/analysis/wizard/FAnalysisWizardStepFiles.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisWizardStepFiles.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/analysis/wizard/FAnalysisWizardStepFiles.vue"],"names":[],"mappings":"AA4GA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,EACH,KAAK,QAAQ,EAChB,MAAM,KAAK,CAAC;;;cAae,QAAQ,CAAC,QAAQ,CAAC;;;;cAIlB,QAAQ,CAAC,kBAAkB,CAAC;;;sBAWvB,KAAK;iCAIM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAnBlC,QAAQ,CAAC,QAAQ,CAAC;;;;cAIlB,QAAQ,CAAC,kBAAkB,CAAC;;;;;;AAZxD,wBA8CG"}

package/dist/components/analysis/wizard/FAnalysisWizardStepFinal.vue.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;
+//# sourceMappingURL=FAnalysisWizardStepFinal.vue.d.ts.map

package/dist/components/analysis/wizard/FAnalysisWizardStepFinal.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisWizardStepFinal.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/analysis/wizard/FAnalysisWizardStepFinal.vue"],"names":[],"mappings":";AAwDA,wBAKG"}

package/dist/components/analysis/wizard/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FAnalysisWizard } from './FAnalysisWizard.vue';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/analysis/wizard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/analysis/wizard/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/components/analysis-bucket/FAnalysisBucket.d.ts

@@ -0,0 +1,44 @@
+import type { AnalysisBucket } from '@privateaim/core-kit';
+import type { SlotsType } from 'vue';
+import type { EntityManagerSlotsType } from '../../core';
+declare const _default: import("vue").DefineComponent<{
+    entity: {
+        type: import("vue").PropType<AnalysisBucket>;
+    };
+    entityId: {
+        type: StringConstructor;
+    };
+    queryFilters: {
+        type: import("vue").PropType<import("rapiq").FiltersBuildInput<AnalysisBucket>>;
+    };
+    queryFields: {
+        type: import("vue").PropType<import("rapiq").FieldsBuildInput<AnalysisBucket>>;
+    };
+    query: {
+        type: import("vue").PropType<import("rapiq").BuildInput<AnalysisBucket>>;
+    };
+}, () => import("vue").VNodeChild, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../core").EntityManagerEventsType<AnalysisBucket>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: import("vue").PropType<AnalysisBucket>;
+    };
+    entityId: {
+        type: StringConstructor;
+    };
+    queryFilters: {
+        type: import("vue").PropType<import("rapiq").FiltersBuildInput<AnalysisBucket>>;
+    };
+    queryFields: {
+        type: import("vue").PropType<import("rapiq").FieldsBuildInput<AnalysisBucket>>;
+    };
+    query: {
+        type: import("vue").PropType<import("rapiq").BuildInput<AnalysisBucket>>;
+    };
+}>> & {
+    onFailed?: (item: Error) => any;
+    onCreated?: (item: AnalysisBucket) => any;
+    onDeleted?: (item: AnalysisBucket) => any;
+    onUpdated?: (item: AnalysisBucket) => any;
+    onResolved?: (_item: AnalysisBucket) => any;
+}, {}, SlotsType<EntityManagerSlotsType<AnalysisBucket>>>;
+export default _default;
+//# sourceMappingURL=FAnalysisBucket.d.ts.map

package/dist/components/analysis-bucket/FAnalysisBucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisBucket.d.ts","sourceRoot":"","sources":["../../../src/components/analysis-bucket/FAnalysisBucket.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAO3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOzD,wBAeG"}

package/dist/components/analysis-bucket/FAnalysisBucketDownload.d.ts

@@ -0,0 +1,44 @@
+import type { AnalysisBucket } from '@privateaim/core-kit';
+import type { PropType } from 'vue';
+import { ActionCommandElementType } from '../../core';
+declare const FAnalysisBucketDownload: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<AnalysisBucket>;
+        required: true;
+    };
+    elementType: {
+        type: PropType<`${ActionCommandElementType}`>;
+        default: ActionCommandElementType;
+    };
+    withIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => import("vue").VNodeChild, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<AnalysisBucket>;
+        required: true;
+    };
+    elementType: {
+        type: PropType<`${ActionCommandElementType}`>;
+        default: ActionCommandElementType;
+    };
+    withIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    withText: boolean;
+    elementType: "link" | "button" | "dropDownItem";
+    withIcon: boolean;
+}, {}>;
+export { FAnalysisBucketDownload, };
+//# sourceMappingURL=FAnalysisBucketDownload.d.ts.map

package/dist/components/analysis-bucket/FAnalysisBucketDownload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisBucketDownload.d.ts","sourceRoot":"","sources":["../../../src/components/analysis-bucket/FAnalysisBucketDownload.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC,OAAO,EAAE,wBAAwB,EAAgD,MAAM,YAAY,CAAC;AAEpG,QAAA,MAAM,uBAAuB;;cAGD,QAAQ,CAAC,cAAc,CAAC;;;;cAIxB,QAAQ,CAAC,GAAG,wBAAwB,EAAE,CAAC;;;;;;;;;;;;;cAJvC,QAAQ,CAAC,cAAc,CAAC;;;;cAIxB,QAAQ,CAAC,GAAG,wBAAwB,EAAE,CAAC;;;;;;;;;;;;;;;MAyCjE,CAAC;AAEH,OAAO,EACH,uBAAuB,GAC1B,CAAC"}

package/dist/components/analysis-bucket/index.d.ts

@@ -0,0 +1,3 @@
+export { default as FAnalysisBucket } from './FAnalysisBucket';
+export { FAnalysisBucketDownload } from './FAnalysisBucketDownload';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/analysis-bucket/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/analysis-bucket/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/components/analysis-bucket-file/FAnalysisBucketFile.vue.d.ts

@@ -0,0 +1,52 @@
+import type { AnalysisBucketFile } from '@privateaim/core-kit';
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<AnalysisBucketFile>;
+        required: true;
+    };
+    filesSelected: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    fileSelectedId: {
+        type: StringConstructor;
+    };
+}, {
+    drop: () => Promise<void>;
+    marked: import("vue").ComputedRef<boolean>;
+    markToggle: () => void;
+    isMatch: import("vue").ComputedRef<boolean>;
+    toggle: () => void;
+    busy: import("vue").Ref<boolean>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    toggle: (_entity?: AnalysisBucketFile) => true;
+    check: (_entity?: AnalysisBucketFile) => true;
+    failed: (item: Error) => true;
+    created: (item: AnalysisBucketFile) => true;
+    deleted: (item: AnalysisBucketFile) => true;
+    updated: (item: AnalysisBucketFile) => true;
+    resolved: (_item: AnalysisBucketFile) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<AnalysisBucketFile>;
+        required: true;
+    };
+    filesSelected: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    fileSelectedId: {
+        type: StringConstructor;
+    };
+}>> & {
+    onFailed?: (item: Error) => any;
+    onToggle?: (_entity?: AnalysisBucketFile) => any;
+    onCreated?: (item: AnalysisBucketFile) => any;
+    onDeleted?: (item: AnalysisBucketFile) => any;
+    onUpdated?: (item: AnalysisBucketFile) => any;
+    onResolved?: (_item: AnalysisBucketFile) => any;
+    onCheck?: (_entity?: AnalysisBucketFile) => any;
+}, {}, {}>;
+export default _default;
+//# sourceMappingURL=FAnalysisBucketFile.vue.d.ts.map

package/dist/components/analysis-bucket-file/FAnalysisBucketFile.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisBucketFile.vue.d.ts","sourceRoot":"","sources":["../../../src/components/analysis-bucket-file/FAnalysisBucketFile.vue"],"names":[],"mappings":"AAiIA,OAAO,KAAK,EACR,kBAAkB,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;;;cASR,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;uBAc7B,kBAAkB;sBAEnB,kBAAkB;;;;;;;;cAhBhB,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;AAHxD,wBAyDG"}

package/dist/components/analysis-bucket-file/FAnalysisBucketFileDownload.d.ts

@@ -0,0 +1,44 @@
+import type { AnalysisBucketFile } from '@privateaim/core-kit';
+import type { PropType } from 'vue';
+import { ActionCommandElementType } from '../../core';
+declare const FAnalysisBucketFileDownload: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<AnalysisBucketFile>;
+        required: true;
+    };
+    elementType: {
+        type: PropType<`${ActionCommandElementType}`>;
+        default: ActionCommandElementType;
+    };
+    withIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => import("vue").VNodeChild, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<AnalysisBucketFile>;
+        required: true;
+    };
+    elementType: {
+        type: PropType<`${ActionCommandElementType}`>;
+        default: ActionCommandElementType;
+    };
+    withIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    withText: boolean;
+    elementType: "link" | "button" | "dropDownItem";
+    withIcon: boolean;
+}, {}>;
+export { FAnalysisBucketFileDownload, };
+//# sourceMappingURL=FAnalysisBucketFileDownload.d.ts.map

package/dist/components/analysis-bucket-file/FAnalysisBucketFileDownload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisBucketFileDownload.d.ts","sourceRoot":"","sources":["../../../src/components/analysis-bucket-file/FAnalysisBucketFileDownload.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC,OAAO,EAAE,wBAAwB,EAAgD,MAAM,YAAY,CAAC;AAEpG,QAAA,MAAM,2BAA2B;;cAGL,QAAQ,CAAC,kBAAkB,CAAC;;;;cAI5B,QAAQ,CAAC,GAAG,wBAAwB,EAAE,CAAC;;;;;;;;;;;;;cAJvC,QAAQ,CAAC,kBAAkB,CAAC;;;;cAI5B,QAAQ,CAAC,GAAG,wBAAwB,EAAE,CAAC;;;;;;;;;;;;;;;MAqCjE,CAAC;AAEH,OAAO,EACH,2BAA2B,GAC9B,CAAC"}