@privateaim/client-vue 0.8.20 → 0.8.21

package/dist/components/analysis/steps/FAnalysisSteps.vue.d.ts

@@ -0,0 +1,392 @@
+import type { Analysis } from '@privateaim/core-kit';
+import type { PropType } from 'vue';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+    configurationNodesLink: {
+        type: StringConstructor;
+    };
+    configurationCodeLink: {
+        type: StringConstructor;
+    };
+    configurationImageLink: {
+        type: StringConstructor;
+    };
+}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "failed" | "executed")[], "updated" | "failed" | "executed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Analysis>;
+        required: true;
+    };
+    configurationNodesLink: {
+        type: StringConstructor;
+    };
+    configurationCodeLink: {
+        type: StringConstructor;
+    };
+    configurationImageLink: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{
+    onUpdated?: (...args: any[]) => any;
+    onFailed?: (...args: any[]) => any;
+    onExecuted?: (...args: any[]) => any;
+}>, {}, {}, {
+    FAnalysisRunStep: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<Analysis>;
+            required: true;
+        };
+    }>, {
+        handleUpdated: (item: Analysis) => void;
+        handleFailed: (e: Error) => void;
+        handleExecuted: (type: string, command: string) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "failed" | "executed")[], "updated" | "failed" | "executed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<Analysis>;
+            required: true;
+        };
+    }>> & Readonly<{
+        onUpdated?: (...args: any[]) => any;
+        onFailed?: (...args: any[]) => any;
+        onExecuted?: (...args: any[]) => any;
+    }>, {}, {}, {
+        FAnalysisRunStatus: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            status: {
+                type: PropType<`${import("@privateaim/core-kit").AnalysisRunStatus}`>;
+                default: any;
+            };
+        }>, {
+            classSuffix: import("vue").ComputedRef<"warning" | "success" | "danger" | "info" | "primary">;
+            statusText: import("vue").ComputedRef<"failed" | "none" | "starting..." | "stopping..." | "started" | "stopped" | "finished">;
+            iconClass: import("vue").ComputedRef<"fa fa-check" | "fa fa-times" | "fa fa-rotate fa-spin" | "fa fa-circle">;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            status: {
+                type: PropType<`${import("@privateaim/core-kit").AnalysisRunStatus}`>;
+                default: any;
+            };
+        }>> & Readonly<{}>, {
+            status: "failed" | "starting" | "started" | "stopping" | "stopped" | "finished" | "running";
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    FAnalysisBuildStep: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<Analysis>;
+            required: true;
+        };
+    }>, {
+        handleUpdated: (item: Analysis) => void;
+        handleFailed: (e: Error) => void;
+        handleExecuted: (type: string, command: string) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "failed" | "executed")[], "updated" | "failed" | "executed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<Analysis>;
+            required: true;
+        };
+    }>> & Readonly<{
+        onUpdated?: (...args: any[]) => any;
+        onFailed?: (...args: any[]) => any;
+        onExecuted?: (...args: any[]) => any;
+    }>, {}, {}, {
+        FAnalysisBuildStatus: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            status: {
+                type: PropType<`${import("@privateaim/core-kit").AnalysisBuildStatus}`>;
+                default: any;
+            };
+        }>, {
+            statusText: import("vue").ComputedRef<"failed" | "none" | "starting..." | "stopping..." | "started" | "stopped" | "finished">;
+            classSuffix: import("vue").ComputedRef<"warning" | "success" | "danger" | "info" | "primary">;
+            iconClass: import("vue").ComputedRef<"fa fa-check" | "fa fa-times" | "fa fa-rotate fa-spin" | "fa fa-circle">;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            status: {
+                type: PropType<`${import("@privateaim/core-kit").AnalysisBuildStatus}`>;
+                default: any;
+            };
+        }>> & Readonly<{}>, {
+            status: "failed" | "starting" | "started" | "stopping" | "stopped" | "finished";
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        FAnalysisCommand: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            command: {
+                type: PropType<`${import("@privateaim/core-kit").AnalysisAPICommand}`>;
+                required: true;
+            };
+            elementType: {
+                type: PropType<`${import("../../../index.js").ActionCommandElementType}`>;
+                default: import("../../../index.js").ActionCommandElementType;
+            };
+            withIcon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            withText: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "failed" | "executed")[], "updated" | "failed" | "executed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            command: {
+                type: PropType<`${import("@privateaim/core-kit").AnalysisAPICommand}`>;
+                required: true;
+            };
+            elementType: {
+                type: PropType<`${import("../../../index.js").ActionCommandElementType}`>;
+                default: import("../../../index.js").ActionCommandElementType;
+            };
+            withIcon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            withText: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdated?: (...args: any[]) => any;
+            onFailed?: (...args: any[]) => any;
+            onExecuted?: (...args: any[]) => any;
+        }>, {
+            withText: boolean;
+            elementType: "link" | "button" | "dropDownItem";
+            withIcon: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    FAnalysisConfigurationStep: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<Analysis>;
+            required: true;
+        };
+        nodesLink: {
+            type: StringConstructor;
+        };
+        imageLink: {
+            type: StringConstructor;
+        };
+    }>, {
+        handleUpdated: (item: Analysis) => void;
+        handleFailed: (e: Error) => void;
+        handleExecuted: (type: string, command: string) => void;
+        passed: import("vue").ComputedRef<boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "failed" | "executed" | "jumpTo")[], "updated" | "failed" | "executed" | "jumpTo", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<Analysis>;
+            required: true;
+        };
+        nodesLink: {
+            type: StringConstructor;
+        };
+        imageLink: {
+            type: StringConstructor;
+        };
+    }>> & Readonly<{
+        onUpdated?: (...args: any[]) => any;
+        onFailed?: (...args: any[]) => any;
+        onExecuted?: (...args: any[]) => any;
+        onJumpTo?: (...args: any[]) => any;
+    }>, {}, {}, {
+        FAnalysisCommand: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            command: {
+                type: PropType<`${import("@privateaim/core-kit").AnalysisAPICommand}`>;
+                required: true;
+            };
+            elementType: {
+                type: PropType<`${import("../../../index.js").ActionCommandElementType}`>;
+                default: import("../../../index.js").ActionCommandElementType;
+            };
+            withIcon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            withText: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "failed" | "executed")[], "updated" | "failed" | "executed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            command: {
+                type: PropType<`${import("@privateaim/core-kit").AnalysisAPICommand}`>;
+                required: true;
+            };
+            elementType: {
+                type: PropType<`${import("../../../index.js").ActionCommandElementType}`>;
+                default: import("../../../index.js").ActionCommandElementType;
+            };
+            withIcon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            withText: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdated?: (...args: any[]) => any;
+            onFailed?: (...args: any[]) => any;
+            onExecuted?: (...args: any[]) => any;
+        }>, {
+            withText: boolean;
+            elementType: "link" | "button" | "dropDownItem";
+            withIcon: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        FAnalysisConfigurationNodesStep: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            passed: import("vue").ComputedRef<boolean>;
+            hasAggregator: import("vue").ComputedRef<boolean>;
+            hasDefault: import("vue").ComputedRef<boolean>;
+            message: import("vue").ComputedRef<string>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tag: string;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        FAnalysisConfigurationEntrypointStep: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            passed: import("vue").ComputedRef<boolean>;
+            message: import("vue").ComputedRef<string>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tag: string;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        FAnalysisConfigurationImageStep: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            passed: boolean;
+            message: import("vue").ComputedRef<string>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Analysis>;
+                required: true;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tag: string;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        VCLink: import("vue").DefineComponent<{
+            active: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            href: {
+                type: StringConstructor;
+                default: any;
+            };
+            prefetch: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            target: {
+                type: StringConstructor;
+                default: string;
+            };
+            to: {
+                type: PropType<string | Record<string, any>>;
+                default: any;
+            };
+            query: {
+                type: PropType<import("@vuecs/link").LinkQuery>;
+            };
+        }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "clicked")[], "click" | "clicked", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            active: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            href: {
+                type: StringConstructor;
+                default: any;
+            };
+            prefetch: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            target: {
+                type: StringConstructor;
+                default: string;
+            };
+            to: {
+                type: PropType<string | Record<string, any>>;
+                default: any;
+            };
+            query: {
+                type: PropType<import("@vuecs/link").LinkQuery>;
+            };
+        }>> & {
+            onClick?: (...args: any[]) => any;
+            onClicked?: (...args: any[]) => any;
+        }, {
+            active: boolean;
+            disabled: boolean;
+            href: string;
+            prefetch: boolean;
+            target: string;
+            to: any;
+        }, {}>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;
+//# sourceMappingURL=FAnalysisSteps.vue.d.ts.map

package/dist/components/analysis/steps/FAnalysisSteps.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAnalysisSteps.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/analysis/steps/FAnalysisSteps.vue"],"names":[],"mappings":"AA6DA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAOpC,QAAA,MAAM,YAAY;;cAQU,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;cAAlB,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAfzB,GAAG;yBACC,GAAG;;;;;;;;;;oEA+B1B,CAAC;wBA8FkB,OAAO,YAAY;AAAxC,wBAAyC"}

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

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

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

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

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

@@ -9,13 +9,16 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: ArrayConstructor;
         required: true;
     };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>, {
     drop: () => Promise<void>;
     marked: import("vue").ComputedRef<boolean>;
-    markToggle: () => void;
-    isMatch: import("vue").Ref<boolean, boolean>;
-    toggle: () => Promise<void>;
+    mark: () => void;
     busy: import("vue").Ref<boolean, boolean>;
+    update: (entity: Partial<AnalysisBucketFile>) => Promise<void>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     check: (_entity?: AnalysisBucketFile) => true;
     failed: (item: Error) => true;
@@ -32,6 +35,10 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: ArrayConstructor;
         required: true;
     };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>> & Readonly<{
     onCreated?: (item: AnalysisBucketFile) => any;
     onUpdated?: (item: AnalysisBucketFile) => any;
@@ -39,7 +46,49 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     onResolved?: (_item: AnalysisBucketFile) => any;
     onDeleted?: (item: AnalysisBucketFile) => any;
     onFailed?: (item: Error) => any;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>, {
+    readonly: boolean;
+}, {}, {
+    FAnalysisBucketFileDownload: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<AnalysisBucketFile>;
+            required: true;
+        };
+        elementType: {
+            type: PropType<`${import("../../core").ActionCommandElementType}`>;
+            default: import("../../core").ActionCommandElementType;
+        };
+        withIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        withText: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<AnalysisBucketFile>;
+            required: true;
+        };
+        elementType: {
+            type: PropType<`${import("../../core").ActionCommandElementType}`>;
+            default: import("../../core").ActionCommandElementType;
+        };
+        withIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        withText: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        withText: boolean;
+        elementType: "link" | "button" | "dropDownItem";
+        withIcon: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;
 //# sourceMappingURL=FAnalysisBucketFile.vue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FAnalysisBucketFile.vue.d.ts","sourceRoot":"","sources":["../../../src/components/analysis-bucket-file/FAnalysisBucketFile.vue"],"names":[],"mappings":"AAoKA,OAAO,KAAK,EACR,kBAAkB,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAUpC,QAAA,MAAM,YAAY;;cAGU,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;sBAW9B,kBAAkB;;;;;;;;cAXhB,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;iFAoFtD,CAAC;wBA2LkB,OAAO,YAAY;AAAxC,wBAAyC"}
+{"version":3,"file":"FAnalysisBucketFile.vue.d.ts","sourceRoot":"","sources":["../../../src/components/analysis-bucket-file/FAnalysisBucketFile.vue"],"names":[],"mappings":"AAoJA,OAAO,KAAK,EACR,kBAAkB,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AASpC,QAAA,MAAM,YAAY;;cAIU,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;qBA0DlB,OAAO,CAAC,kBAAkB,CAAC;;sBA3CvC,kBAAkB;;;;;;;;cAfhB,QAAQ,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAuEtD,CAAC;wBAiLkB,OAAO,YAAY;AAAxC,wBAAyC"}

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

@@ -1 +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;;;;;;;;;;;;;;;4EAqCjE,CAAC;AAEH,OAAO,EACH,2BAA2B,GAC9B,CAAC"}
+{"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;;;;;;;;;;;;;;;4EAsCjE,CAAC;AAEH,OAAO,EACH,2BAA2B,GAC9B,CAAC"}

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

@@ -6,8 +6,9 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: PropType<AnalysisBucket>;
         required: true;
     };
-    fileEntity: {
-        type: PropType<AnalysisBucketFile>;
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
     };
 }>, {
     busy: import("vue").Ref<boolean, boolean>;
@@ -262,14 +263,14 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     fileListQuery: import("vue").ComputedRef<BuildInput<AnalysisBucketFile>>;
     modal: import("vue").Ref<boolean, boolean>;
     toggleModal: () => void;
-    entrypointFile: import("vue").Ref<AnalysisBucketFile, AnalysisBucketFile>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("created" | "updated" | "deleted" | "failed" | "uploaded" | "setEntrypointFile")[], "created" | "updated" | "deleted" | "failed" | "uploaded" | "setEntrypointFile", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("created" | "updated" | "deleted" | "failed" | "uploaded")[], "created" | "updated" | "deleted" | "failed" | "uploaded", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     entity: {
         type: PropType<AnalysisBucket>;
         required: true;
     };
-    fileEntity: {
-        type: PropType<AnalysisBucketFile>;
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
     };
 }>> & Readonly<{
     onCreated?: (...args: any[]) => any;
@@ -277,8 +278,9 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     onUpdated?: (...args: any[]) => any;
     onFailed?: (...args: any[]) => any;
     onUploaded?: (...args: any[]) => any;
-    onSetEntrypointFile?: (...args: any[]) => any;
-}>, {}, {}, {
+}>, {
+    readonly: boolean;
+}, {}, {
     BModal: {
         new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
             modelValue?: Exclude<import("bootstrap-vue-next").BModalProps["modelValue"], undefined>;
@@ -363,8 +365,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
             onShown?: ((value: import("bootstrap-vue-next").BvTriggerableEvent) => any) | undefined;
             "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
         }>, {
-            hide: (trigger?: string, noTriggerEmit
-            /** @type {__VLS_StyleScopedClasses['fa']} */ ? /** @type {__VLS_StyleScopedClasses['fa']} */: boolean) => Promise<string>;
+            hide: (trigger?: string, noTriggerEmit?: boolean) => Promise<string>;
             id: import("vue").ComputedRef<string>;
             show: (resolveOnHide?: boolean) => Promise<boolean | string>;
             toggle: (resolveOnHide?: boolean) => Promise<boolean | string>;
@@ -1028,8 +1029,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
             onShown?: ((value: import("bootstrap-vue-next").BvTriggerableEvent) => any) | undefined;
             "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
         }>, {
-            hide: (trigger?: string, noTriggerEmit
-            /** @type {__VLS_StyleScopedClasses['fa']} */ ? /** @type {__VLS_StyleScopedClasses['fa']} */: boolean) => Promise<string>;
+            hide: (trigger?: string, noTriggerEmit?: boolean) => Promise<string>;
             id: import("vue").ComputedRef<string>;
             show: (resolveOnHide?: boolean) => Promise<boolean | string>;
             toggle: (resolveOnHide?: boolean) => Promise<boolean | string>;
@@ -1184,8 +1184,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         onShown?: ((value: import("bootstrap-vue-next").BvTriggerableEvent) => any) | undefined;
         "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     }>, {
-        hide: (trigger?: string, noTriggerEmit
-        /** @type {__VLS_StyleScopedClasses['fa']} */ ? /** @type {__VLS_StyleScopedClasses['fa']} */: boolean) => Promise<string>;
+        hide: (trigger?: string, noTriggerEmit?: boolean) => Promise<string>;
         id: import("vue").ComputedRef<string>;
         show: (resolveOnHide?: boolean) => Promise<boolean | string>;
         toggle: (resolveOnHide?: boolean) => Promise<boolean | string>;
@@ -1471,13 +1470,16 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
             type: ArrayConstructor;
             required: true;
         };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
     }>, {
         drop: () => Promise<void>;
         marked: import("vue").ComputedRef<boolean>;
-        markToggle: () => void;
-        isMatch: import("vue").Ref<boolean, boolean>;
-        toggle: () => Promise<void>;
+        mark: () => void;
         busy: import("vue").Ref<boolean, boolean>;
+        update: (entity: Partial<AnalysisBucketFile>) => Promise<void>;
     }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
         check: (_entity?: AnalysisBucketFile) => true;
         failed: (item: Error) => true;
@@ -1494,6 +1496,10 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
             type: ArrayConstructor;
             required: true;
         };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
     }>> & Readonly<{
         onCreated?: (item: AnalysisBucketFile) => any;
         onUpdated?: (item: AnalysisBucketFile) => any;
@@ -1501,7 +1507,49 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         onResolved?: (_item: AnalysisBucketFile) => any;
         onDeleted?: (item: AnalysisBucketFile) => any;
         onFailed?: (item: Error) => any;
-    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }>, {
+        readonly: boolean;
+    }, {}, {
+        FAnalysisBucketFileDownload: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<AnalysisBucketFile>;
+                required: true;
+            };
+            elementType: {
+                type: PropType<`${import("../../core").ActionCommandElementType}`>;
+                default: import("../../core").ActionCommandElementType;
+            };
+            withIcon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            withText: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<AnalysisBucketFile>;
+                required: true;
+            };
+            elementType: {
+                type: PropType<`${import("../../core").ActionCommandElementType}`>;
+                default: import("../../core").ActionCommandElementType;
+            };
+            withIcon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            withText: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            withText: boolean;
+            elementType: "link" | "button" | "dropDownItem";
+            withIcon: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;