@devtable/dashboard 5.7.1 → 5.8.0

package/dist/model/views/view/panels/index.d.ts

@@ -54,6 +54,74 @@ export declare const PanelsModel: import("mobx-state-tree").IModelType<{
             };
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
     }, {
+        readonly query: ({
+            id: string;
+            type: import("../../../queries/types").DataSourceType;
+            key: string;
+            sql: string;
+            state: "idle" | "loading" | "error";
+            data: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>>, [undefined]>>;
+            error: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            readonly valid: string;
+            readonly configurations: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            readonly formattedSQL: any;
+        } & {
+            readonly json: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            setID(id: string): void;
+            setKey(key: string): void;
+            setType(type: import("../../../queries/types").DataSourceType): void;
+            setSQL(sql: string): void;
+            fetchData: () => Promise<void>;
+        } & {
+            afterCreate(): void;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").ISimpleType<string>;
+            type: import("mobx-state-tree").ISimpleType<import("../../../queries/types").DataSourceType>;
+            key: import("mobx-state-tree").ISimpleType<string>;
+            sql: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            state: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<"idle" | "loading" | "error">, [undefined]>;
+            data: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>>, [undefined]>;
+            error: import("mobx-state-tree").IType<any, any, any>;
+        }, {
+            readonly valid: string;
+            readonly configurations: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            readonly formattedSQL: any;
+        } & {
+            readonly json: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            setID(id: string): void;
+            setKey(key: string): void;
+            setType(type: import("../../../queries/types").DataSourceType): void;
+            setSQL(sql: string): void;
+            fetchData: () => Promise<void>;
+        } & {
+            afterCreate(): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined;
         readonly json: {
             id: string;
             title: string;
@@ -223,6 +291,74 @@ export declare const PanelsModel: import("mobx-state-tree").IModelType<{
             };
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
     } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        readonly query: ({
+            id: string;
+            type: import("../../../queries/types").DataSourceType;
+            key: string;
+            sql: string;
+            state: "idle" | "loading" | "error";
+            data: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>>, [undefined]>>;
+            error: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            readonly valid: string;
+            readonly configurations: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            readonly formattedSQL: any;
+        } & {
+            readonly json: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            setID(id: string): void;
+            setKey(key: string): void;
+            setType(type: import("../../../queries/types").DataSourceType): void;
+            setSQL(sql: string): void;
+            fetchData: () => Promise<void>;
+        } & {
+            afterCreate(): void;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").ISimpleType<string>;
+            type: import("mobx-state-tree").ISimpleType<import("../../../queries/types").DataSourceType>;
+            key: import("mobx-state-tree").ISimpleType<string>;
+            sql: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            state: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<"idle" | "loading" | "error">, [undefined]>;
+            data: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>>, [undefined]>;
+            error: import("mobx-state-tree").IType<any, any, any>;
+        }, {
+            readonly valid: string;
+            readonly configurations: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            readonly formattedSQL: any;
+        } & {
+            readonly json: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            setID(id: string): void;
+            setKey(key: string): void;
+            setType(type: import("../../../queries/types").DataSourceType): void;
+            setSQL(sql: string): void;
+            fetchData: () => Promise<void>;
+        } & {
+            afterCreate(): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined;
         readonly json: {
             id: string;
             title: string;
@@ -305,6 +441,74 @@ export declare const PanelsModel: import("mobx-state-tree").IModelType<{
             };
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
     }, {
+        readonly query: ({
+            id: string;
+            type: import("../../../queries/types").DataSourceType;
+            key: string;
+            sql: string;
+            state: "idle" | "loading" | "error";
+            data: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>>, [undefined]>>;
+            error: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            readonly valid: string;
+            readonly configurations: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            readonly formattedSQL: any;
+        } & {
+            readonly json: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            setID(id: string): void;
+            setKey(key: string): void;
+            setType(type: import("../../../queries/types").DataSourceType): void;
+            setSQL(sql: string): void;
+            fetchData: () => Promise<void>;
+        } & {
+            afterCreate(): void;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").ISimpleType<string>;
+            type: import("mobx-state-tree").ISimpleType<import("../../../queries/types").DataSourceType>;
+            key: import("mobx-state-tree").ISimpleType<string>;
+            sql: import("mobx-state-tree").ISimpleType<string>;
+        } & {
+            state: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<"idle" | "loading" | "error">, [undefined]>;
+            data: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>>, [undefined]>;
+            error: import("mobx-state-tree").IType<any, any, any>;
+        }, {
+            readonly valid: string;
+            readonly configurations: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            readonly formattedSQL: any;
+        } & {
+            readonly json: {
+                id: string;
+                type: import("../../../queries/types").DataSourceType;
+                key: string;
+                sql: string;
+            };
+        } & {
+            setID(id: string): void;
+            setKey(key: string): void;
+            setType(type: import("../../../queries/types").DataSourceType): void;
+            setSQL(sql: string): void;
+            fetchData: () => Promise<void>;
+        } & {
+            afterCreate(): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined;
         readonly json: {
             id: string;
             title: string;

package/dist/model/views/view/panels/panel.d.ts

@@ -53,6 +53,74 @@ export declare const PanelModel: import("mobx-state-tree").IModelType<{
         };
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 }, {
+    readonly query: ({
+        id: string;
+        type: import("../../../queries/types").DataSourceType;
+        key: string;
+        sql: string;
+        state: "idle" | "loading" | "error";
+        data: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>>, [undefined]>>;
+        error: any;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        readonly valid: string;
+        readonly configurations: {
+            id: string;
+            type: import("../../../queries/types").DataSourceType;
+            key: string;
+            sql: string;
+        };
+    } & {
+        readonly formattedSQL: any;
+    } & {
+        readonly json: {
+            id: string;
+            type: import("../../../queries/types").DataSourceType;
+            key: string;
+            sql: string;
+        };
+    } & {
+        setID(id: string): void;
+        setKey(key: string): void;
+        setType(type: import("../../../queries/types").DataSourceType): void;
+        setSQL(sql: string): void;
+        fetchData: () => Promise<void>;
+    } & {
+        afterCreate(): void;
+    } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+        id: import("mobx-state-tree").ISimpleType<string>;
+        type: import("mobx-state-tree").ISimpleType<import("../../../queries/types").DataSourceType>;
+        key: import("mobx-state-tree").ISimpleType<string>;
+        sql: import("mobx-state-tree").ISimpleType<string>;
+    } & {
+        state: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<"idle" | "loading" | "error">, [undefined]>;
+        data: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IType<string[] | number[], string[] | number[], string[] | number[]>>, [undefined]>;
+        error: import("mobx-state-tree").IType<any, any, any>;
+    }, {
+        readonly valid: string;
+        readonly configurations: {
+            id: string;
+            type: import("../../../queries/types").DataSourceType;
+            key: string;
+            sql: string;
+        };
+    } & {
+        readonly formattedSQL: any;
+    } & {
+        readonly json: {
+            id: string;
+            type: import("../../../queries/types").DataSourceType;
+            key: string;
+            sql: string;
+        };
+    } & {
+        setID(id: string): void;
+        setKey(key: string): void;
+        setType(type: import("../../../queries/types").DataSourceType): void;
+        setSQL(sql: string): void;
+        fetchData: () => Promise<void>;
+    } & {
+        afterCreate(): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined;
     readonly json: {
         id: string;
         title: string;

package/dist/panel/plugin-adaptor.d.ts

@@ -1,7 +1,9 @@
 import React from 'react';
 import { IConfigComponentProps, IViewComponentProps } from '../plugins/viz-manager/components';
 import { IVizConfig } from '../types';
-export declare function PluginVizConfigComponent({ setVizConf, ...props }: IConfigComponentProps & {
+declare type SetVizConfType = {
     setVizConf: (val: React.SetStateAction<IVizConfig['conf']>) => void;
-}): JSX.Element;
-export declare function PluginVizViewComponent(props: IViewComponentProps): JSX.Element;
+};
+export declare function PluginVizConfigComponent({ setVizConf, ...props }: IConfigComponentProps & SetVizConfType): JSX.Element;
+export declare function PluginVizViewComponent(props: IViewComponentProps & SetVizConfType): JSX.Element;
+export {};

package/dist/panel/use-config-viz-instance-service.d.ts

@@ -0,0 +1,3 @@
+import { IPanelInfo } from '~/plugins';
+import { IServiceLocator } from '~/service-locator';
+export declare function useConfigVizInstanceService(panel: IPanelInfo): (services: IServiceLocator) => IServiceLocator;

package/dist/pareto.structure.64175247.mjs

@@ -0,0 +1,11 @@
+const t = `
+{
+  name?: string;
+  actor: string;
+  contributor: string;
+  eloc: number;
+}
+`;
+export {
+  t as default
+};

package/dist/pareto.structure.870fcfae.mjs

@@ -0,0 +1,11 @@
+const t = `
+{
+  name?: string;
+  actor: string;
+  contributor: string;
+  eloc: number;
+}
+`;
+export {
+  t as default
+};

package/dist/plugins/instance-migrator/index.d.ts

@@ -0,0 +1,29 @@
+import { IServiceLocator } from '~/service-locator';
+import { IVizOperationManager, IVizTriggerManager, VizInstance } from '~/types/plugin';
+import { IVizManager } from '../viz-manager';
+export declare enum MigrationResultType {
+    migrated = "migrated",
+    nothingToMigrate = "nothingToMigrate",
+    checkFailed = "checkFailed",
+    migrationFailed = "migrationFailed"
+}
+export declare enum MigrationStatus {
+    notStarted = "notStarted",
+    inProgress = "inProgress",
+    done = "done"
+}
+export declare class InstanceMigrator {
+    protected vizInstance: VizInstance;
+    protected operationManager: IVizOperationManager;
+    protected triggerManager: IVizTriggerManager;
+    protected vizManager: IVizManager;
+    protected runningMigration?: Promise<MigrationResultType>;
+    status: MigrationStatus;
+    constructor(serviceLocator: IServiceLocator);
+    createMigrationTask(): Promise<MigrationResultType>;
+    runMigration(): Promise<MigrationResultType>;
+    protected runInteractionMigration(): Promise<void>;
+    protected runInstanceMigration(): Promise<void>;
+    private instanceNeedMigration;
+    private interactionNeedMigration;
+}

package/dist/plugins/plugin-context.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="react" />
-import { IPluginManager } from '~/types/plugin';
+import { InstanceMigrator } from '~/plugins/instance-migrator';
+import { IPluginManager, IVizInteractionManager, IVizOperationManager, IVizTriggerManager, VizInstance } from '~/types/plugin';
 import { IColorManager } from './color-manager';
 import { PluginManager } from './plugin-manager';
 import { VizManager } from './viz-manager';
@@ -9,6 +10,22 @@ interface IPluginContextProps {
     colorManager: IColorManager;
 }
 export declare const pluginManager: PluginManager;
+/**
+ * All available tokens of services, it also serves as an overview of the
+ * plugin system
+ */
+export declare const tokens: {
+    pluginManager: import("~/service-locator").Token<IPluginManager>;
+    vizManager: import("~/service-locator").Token<VizManager>;
+    colorManager: import("~/service-locator").Token<IColorManager>;
+    instanceScope: {
+        vizInstance: import("~/service-locator").Token<VizInstance>;
+        interactionManager: import("~/service-locator").Token<IVizInteractionManager>;
+        migrator: import("~/service-locator").Token<InstanceMigrator>;
+        operationManager: import("~/service-locator").Token<IVizOperationManager>;
+        triggerManager: import("~/service-locator").Token<IVizTriggerManager>;
+    };
+};
 export declare const createPluginContext: () => IPluginContextProps;
 export declare const PluginContext: import("react").Context<IPluginContextProps>;
 export {};

package/dist/plugins/plugin-data-migrator/version-based-migrator.d.ts

@@ -1,4 +1,4 @@
-import { IVizComponentMigrator, VizComponentMigrationContext } from '~/types/plugin';
+import { IConfigMigrator, IConfigMigrationContext } from '~/types/plugin';
 import { PluginDataMigrator } from './plugin-data-migrator';
 /**
  * Instance version is read from the `instanceData.version` field.
@@ -8,11 +8,11 @@ import { PluginDataMigrator } from './plugin-data-migrator';
  * You can implement the `configVersions` method to
  * specify how migrations are performed.
  */
-export declare abstract class VersionBasedMigrator extends PluginDataMigrator implements IVizComponentMigrator {
+export declare abstract class VersionBasedMigrator extends PluginDataMigrator implements IConfigMigrator {
     abstract readonly VERSION: number;
     abstract configVersions(): void;
     constructor();
     version(version: number, handler: (data: $TSFixMe) => $TSFixMe): PluginDataMigrator;
-    migrate({ instanceData }: VizComponentMigrationContext): Promise<void>;
-    needMigration({ instanceData }: VizComponentMigrationContext): Promise<boolean>;
+    migrate({ configData }: IConfigMigrationContext): Promise<void>;
+    needMigration({ configData }: IConfigMigrationContext): Promise<boolean>;
 }

package/dist/plugins/viz-components/expert-system/index.d.ts

@@ -0,0 +1,2 @@
+import { VizComponent } from '../../../types/plugin';
+export declare const ExpertSystemVizComponent: VizComponent;

package/dist/plugins/viz-components/expert-system/metric-set-selector.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { EMetricSet, IExpertSystemConf } from './type';
+interface IMetricSetSelector {
+    conf: IExpertSystemConf;
+    setConfByKey: (key: string, val: EMetricSet) => void;
+}
+export declare const MetricSetSelector: ({ conf, setConfByKey }: IMetricSetSelector) => JSX.Element;
+export {};

package/dist/plugins/viz-components/expert-system/request/call-expert-system.d.ts

@@ -0,0 +1,6 @@
+interface ICallExpertSystem {
+    baseURL?: string;
+    payload: $TSFixMe;
+}
+export declare const callExpertSystem: ({ baseURL, payload }: ICallExpertSystem) => () => Promise<any>;
+export {};

package/dist/plugins/viz-components/expert-system/request/payload/comparison/efficiency.d.ts

@@ -0,0 +1,10 @@
+export declare type TDataForComparisonEfficiency = {
+    name?: string;
+    actor: string;
+    eloc_type: 'accumulated' | 'new';
+    ref_date: string;
+    eloc: number;
+};
+export declare function comparison_efficiency(data: TDataForComparisonEfficiency[]): {
+    efficiency: any[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/comparison/index.d.ts

@@ -0,0 +1,8 @@
+import { IExpertSystemConf } from '../../../type';
+import { TDataForComparisonEfficiency } from './efficiency';
+export declare type TComparisonData = $TSFixMe | TDataForComparisonEfficiency[];
+export declare function buildPayloadForComparison(conf: IExpertSystemConf, data: TComparisonData): {
+    comparison: {
+        efficiency: any[];
+    };
+};

package/dist/plugins/viz-components/expert-system/request/payload/dev_load/heatmap.d.ts

@@ -0,0 +1,9 @@
+export declare type TDataForHeatmap = {
+    name?: string;
+    actor: string;
+    ref_date: string;
+    eloc: number;
+};
+export declare function dev_load_heatmap(data: TDataForHeatmap[]): {
+    heatmap: any[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/dev_load/index.d.ts

@@ -0,0 +1,14 @@
+import { IExpertSystemConf } from '../../../type';
+import { TDataForHeatmap } from './heatmap';
+import { TDataForPareto } from './pareto';
+import { TDataForProductivity } from './productivity';
+export declare type TDevLoadData = $TSFixMe | TDataForProductivity[] | TDataForHeatmap[] | TDataForPareto[];
+export declare function buildPayloadForDevLoad(conf: IExpertSystemConf, data: TDevLoadData): {
+    dev_load: {
+        productivity: any[];
+    } | {
+        heatmap: any[];
+    } | {
+        pareto: any[];
+    };
+};

package/dist/plugins/viz-components/expert-system/request/payload/dev_load/pareto.d.ts

@@ -0,0 +1,9 @@
+export declare type TDataForPareto = {
+    name?: string;
+    actor: string;
+    contributor: string;
+    eloc: number;
+};
+export declare function dev_load_pareto(data: TDataForPareto[]): {
+    pareto: any[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/dev_load/productivity.d.ts

@@ -0,0 +1,11 @@
+export declare type TDataForProductivity = {
+    name?: string;
+    actor: string;
+    ref_date: string;
+    baseline: number;
+    eloc: number;
+    eloc_type: 'current' | 'previous';
+};
+export declare function dev_load_productivity(data: TDataForProductivity[]): {
+    productivity: any[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/index.d.ts

@@ -0,0 +1,2 @@
+import { IExpertSystemConf } from '../../type';
+export declare function buildPayload(conf: IExpertSystemConf, data: any): {};

package/dist/plugins/viz-components/expert-system/request/payload/performance/efficiency.d.ts

@@ -0,0 +1,10 @@
+export declare type TDataForEfficiency = {
+    name?: string;
+    actor: string;
+    eloc_type: 'accumulated' | 'new';
+    ref_date: string;
+    eloc: number;
+};
+export declare function performance_efficiency(data: TDataForEfficiency[]): {
+    efficiency: any[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/performance/index.d.ts

@@ -0,0 +1,31 @@
+import { IExpertSystemConf } from '../../../type';
+import { TDataForQuality } from './quality';
+export declare type TPerformanceData = $TSFixMe | TDataForQuality[];
+export declare function buildPayloadForPerformance(conf: IExpertSystemConf, data: TPerformanceData): {
+    performance: {
+        quality: {
+            actor: string;
+            actor_type: string;
+            code: {
+                issues: {
+                    blocker: number;
+                    critical: number;
+                    info: number;
+                    major: number;
+                    minor: number;
+                };
+                doc_coverage: number;
+                test_coverage: number;
+                dryness: number;
+                modularity: number;
+                issues_density: number;
+            };
+        }[];
+    } | {
+        quality_history: any[];
+    } | {
+        efficiency: any[];
+    } | {
+        pareto: any[];
+    };
+};

package/dist/plugins/viz-components/expert-system/request/payload/performance/pareto.d.ts

@@ -0,0 +1,9 @@
+export declare type TDataForPareto = {
+    name?: string;
+    actor: string;
+    contributor: string;
+    eloc: number;
+};
+export declare function performance_pareto(data: TDataForPareto[]): {
+    pareto: any[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/performance/quality.d.ts

@@ -0,0 +1,34 @@
+export declare type TDataForQuality = {
+    name?: string;
+    actor: string;
+    doc_coverage: number;
+    test_coverage: number;
+    dryness: number;
+    modularity: number;
+    issues_density: number;
+    issues_blocker: number;
+    issues_critical: number;
+    issues_info: number;
+    issues_major: number;
+    issues_minor: number;
+};
+export declare function performance_quality(data: TDataForQuality[]): {
+    quality: {
+        actor: string;
+        actor_type: string;
+        code: {
+            issues: {
+                blocker: number;
+                critical: number;
+                info: number;
+                major: number;
+                minor: number;
+            };
+            doc_coverage: number;
+            test_coverage: number;
+            dryness: number;
+            modularity: number;
+            issues_density: number;
+        };
+    }[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/performance/quality_history.d.ts

@@ -0,0 +1,12 @@
+export declare type TDataForQualityHistory = {
+    name?: string;
+    actor: string;
+    val_type: 'doc_coverage' | 'test_coverage' | 'dryness' | 'modularity' | 'blocker_issues' | 'critical_issues' | 'major_issues' | 'minor_issues' | 'info_issues' | 'issues_density';
+    baseline_lower: number;
+    baseline_upper: number;
+    ref_date: string;
+    val: number;
+};
+export declare function performance_quality_history(data: TDataForQualityHistory[]): {
+    quality_history: any[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/personal_report/commits.d.ts

@@ -0,0 +1,11 @@
+export declare type TDataForCommits = {
+    name?: string;
+    actor: string;
+    repos: number;
+    range_days: number;
+    ref_date: string;
+    eloc: number;
+};
+export declare function personal_report_commits(data: TDataForCommits[]): {
+    commits: any[];
+};

package/dist/plugins/viz-components/expert-system/request/payload/personal_report/index.d.ts

@@ -0,0 +1,14 @@
+import { IExpertSystemConf } from '../../../type';
+import { TDataForPersonalReportQuality } from './quality';
+import { TDataForCommits } from './commits';
+import { TDataForSkills } from './skills';
+export declare type TPersonalReportData = $TSFixMe | TDataForSkills[] | TDataForPersonalReportQuality[] | TDataForCommits[];
+export declare function buildPayloadForPersonalReport(conf: IExpertSystemConf, data: TPersonalReportData): {
+    personal_report: {
+        skills: any[];
+    } | {
+        quality: any[];
+    } | {
+        commits: any[];
+    };
+};