@dative-gpi/foundation-core-domain 0.0.8 → 0.0.9

package/models/actions/actionDetails.ts

@@ -0,0 +1,10 @@
+import { ActionInfos, ActionInfosDTO } from "./actionInfos";
+
+export class ActionDetails extends ActionInfos {
+    constructor(params: ActionDetailsDTO) {
+        super(params);
+    }
+}
+
+export interface ActionDetailsDTO extends ActionInfosDTO {
+}

package/models/actions/actionInfos.ts

@@ -0,0 +1,28 @@
+import { ActionType } from "../enums/actionEnums";
+
+export class ActionInfos {
+    extensionId?: string;
+    actionType: ActionType;
+    path: string;
+    uri: string;
+    label: string;
+    icon: string;
+    
+    constructor(params: ActionInfosDTO) {
+        this.extensionId = params.extensionId;
+        this.actionType = params.actionType;
+        this.path = params.path;
+        this.uri = params.uri;
+        this.label = params.label;
+        this.icon = params.icon;
+    }
+}
+
+export interface ActionInfosDTO {
+    extensionId?: string;
+    actionType: ActionType;
+    path: string;
+    uri: string;
+    label: string;
+    icon: string;
+}

package/models/actions/index.ts

@@ -0,0 +1,2 @@
+export * from "./actionDetails";
+export * from "./actionInfos";

package/models/alerts/alertInfos.ts

@@ -1,5 +1,7 @@
+import { AlertStatus, Criticity } from "@dative-gpi/foundation-shared-domain/models";
+import { DatesTools } from "@dative-gpi/foundation-shared-services/tools";
+
 import { AlertDataDefinition, AlertDataDefinitionDTO } from "./alertDataDefinition";
-import { AlertStatus, Criticity } from "../enums/alertEnums";
 import { AlertState, AlertStateDTO } from "./alertState";
 import { SelectedEntities } from "../enums/sharedEnums";
 import { DateVariable } from "../shared/dateVariable";
@@ -54,15 +56,15 @@ export class AlertInfos {
         this.acknowledgingUserImageBlurHash = params.acknowledgingUserImageBlurHash;
         this.acknowledgingUserImageWidth = params.acknowledgingUserImageWidth;
         this.acknowledgingUserImageHeight = params.acknowledgingUserImageHeight;
-        this.acknowledgingTimestamp = params.acknowledgingTimestamp;
+        this.acknowledgingTimestamp = params.acknowledgingTimestamp ? DatesTools.utcToEpoch(params.acknowledgingTimestamp) : undefined;
         this.initialState = new AlertState(params.initialState);
-        this.triggerSourceTimestamp = params.triggerSourceTimestamp;
-        this.triggerEnqueuedTimestamp = params.triggerEnqueuedTimestamp;
-        this.triggerProcessedTimestamp = params.triggerProcessedTimestamp;
+        this.triggerSourceTimestamp = params.triggerSourceTimestamp ? DatesTools.utcToEpoch(params.triggerSourceTimestamp) : undefined;
+        this.triggerEnqueuedTimestamp = params.triggerEnqueuedTimestamp ? DatesTools.utcToEpoch(params.triggerEnqueuedTimestamp) : undefined;
+        this.triggerProcessedTimestamp = params.triggerProcessedTimestamp ? DatesTools.utcToEpoch(params.triggerProcessedTimestamp) : undefined;
         this.lastState = new AlertState(params.lastState);
-        this.currentSourceTimestamp = params.currentSourceTimestamp;
-        this.currentEnqueuedTimestamp = params.currentEnqueuedTimestamp;
-        this.currentProcessedTimestamp = params.currentProcessedTimestamp;
+        this.currentSourceTimestamp = params.currentSourceTimestamp ? DatesTools.utcToEpoch(params.currentSourceTimestamp) : undefined;
+        this.currentEnqueuedTimestamp = params.currentEnqueuedTimestamp ? DatesTools.utcToEpoch(params.currentEnqueuedTimestamp) : undefined;
+        this.currentProcessedTimestamp = params.currentProcessedTimestamp ? DatesTools.utcToEpoch(params.currentProcessedTimestamp) : undefined;
         this.status = params.status;
         this.tags = params.tags;
         this.history = params.history.map(dto => new AlertState(dto));
@@ -88,15 +90,15 @@ export interface AlertInfosDTO {
     acknowledgingUserImageBlurHash?: string;
     acknowledgingUserImageWidth?: number;
     acknowledgingUserImageHeight?: number;
-    acknowledgingTimestamp?: number;
+    acknowledgingTimestamp?: string;
     initialState: AlertStateDTO;
-    triggerSourceTimestamp?: number;
-    triggerEnqueuedTimestamp?: number;
-    triggerProcessedTimestamp?: number;
+    triggerSourceTimestamp?: string;
+    triggerEnqueuedTimestamp?: string;
+    triggerProcessedTimestamp?: string;
     lastState: AlertStateDTO;
-    currentSourceTimestamp?: number;
-    currentEnqueuedTimestamp?: number;
-    currentProcessedTimestamp?: number;
+    currentSourceTimestamp?: string;
+    currentEnqueuedTimestamp?: string;
+    currentProcessedTimestamp?: string;
     status: AlertStatus;
     tags: string[];
     history: AlertStateDTO[];

package/models/alerts/alertState.ts

@@ -1,5 +1,7 @@
+import { AlertStatus } from "@dative-gpi/foundation-shared-domain/models";
+import { DatesTools } from "@dative-gpi/foundation-shared-services/tools";
+
 import { AlertDataDefinition, AlertDataDefinitionDTO } from "./alertDataDefinition";
-import { AlertStatus } from "../enums/alertEnums";
 
 export class AlertState {
     id: string;
@@ -12,9 +14,9 @@ export class AlertState {
     constructor(params: AlertStateDTO) {
         this.id = params.id;
         this.status = params.status;
-        this.sourceTimestamp = params.sourceTimestamp;
-        this.enqueuedTimestamp = params.enqueuedTimestamp;
-        this.processedTimestamp = params.processedTimestamp;
+        this.sourceTimestamp = DatesTools.utcToEpoch(params.sourceTimestamp);
+        this.enqueuedTimestamp = DatesTools.utcToEpoch(params.enqueuedTimestamp);
+        this.processedTimestamp = DatesTools.utcToEpoch(params.processedTimestamp);
         this.metadataValues = params.metadataValues?.map(dto => new AlertDataDefinition(dto));
     }
 }
@@ -22,8 +24,8 @@ export class AlertState {
 export interface AlertStateDTO {
     id: string;
     status: AlertStatus;
-    sourceTimestamp: number;
-    enqueuedTimestamp: number;
-    processedTimestamp: number;
+    sourceTimestamp: string;
+    enqueuedTimestamp: string;
+    processedTimestamp: string;
     metadataValues?: AlertDataDefinitionDTO[];
 }

package/models/authTokens/authTokenInfos.ts

@@ -1,3 +1,5 @@
+import { DatesTools } from "@dative-gpi/foundation-shared-services/tools";
+
 export class AuthTokenInfos {
     id: string;
     userId?: string;
@@ -9,8 +11,8 @@ export class AuthTokenInfos {
         this.id = params.id;
         this.userId = params.userId;
         this.label = params.label;
-        this.creationDate = params.creationDate;
-        this.dateMax = params.dateMax;
+        this.creationDate = DatesTools.utcToEpoch(params.creationDate);
+        this.dateMax = DatesTools.utcToEpoch(params.dateMax);
     }
 }
 
@@ -18,8 +20,8 @@ export interface AuthTokenInfosDTO {
     id: string;
     userId?: string;
     label: string;
-    creationDate: number;
-    dateMax: number;
+    creationDate: string;
+    dateMax: string;
 }
 
 export interface AuthTokenFilters {

package/models/chartOrganisationTypes/chartOrganisationTypeDetails.ts

@@ -0,0 +1,61 @@
+import { ChartVariable, ChartVariableDTO, CreateChartVariableDTO } from "../charts/chartVariable";
+import { ChartOrganisationTypeInfos, ChartOrganisationTypeInfosDTO } from "./chartOrganisationTypeInfos";
+import { ChartAxis, ChartAxisDTO, CreateChartAxisDTO } from "../charts/chartAxis";
+import { ChartPlot, ChartPlotDTO, CreateChartPlotDTO } from "../charts/chartPlot";
+import { CreateChartTranslationDTO } from "../charts/chartTranslation";
+import { ColorSets } from "../enums/chartEnums";
+
+export class ChartOrganisationTypeDetails extends ChartOrganisationTypeInfos {
+    colorSet: ColorSets;
+    colorSeed: string;
+    xAxis: ChartAxis;
+    aggregates?: boolean;
+    dynamicVariables?: boolean;
+    chartVariables: ChartVariable[];
+    chartPlots: ChartPlot[];
+
+    constructor(params: ChartOrganisationTypeDetailsDTO) {
+        super(params);
+    
+        this.colorSet = params.colorSet as ColorSets;
+        this.colorSeed = params.colorSeed;
+        this.xAxis = new ChartAxis(params.xAxis);
+        this.aggregates = params.aggregates;
+        this.dynamicVariables = params.dynamicVariables;
+        this.chartVariables = params.chartVariables.map(cv => new ChartVariable(cv));
+        this.chartPlots = params.chartPlots.map(cp => new ChartPlot(cp));
+    }
+}
+
+export interface ChartOrganisationTypeDetailsDTO extends ChartOrganisationTypeInfosDTO {
+    colorSet: number;
+    colorSeed: string;
+    xAxis?: ChartAxisDTO;
+    aggregates?: boolean;
+    dynamicVariables?: boolean;
+    chartVariables: ChartVariableDTO[];
+    chartPlots: ChartPlotDTO[];
+}
+
+export interface CreateChartOrganisationTypeDTO {
+    chartOrganisationId: string;
+    organisationTypeId?: string;
+}
+
+export interface UpdateChartOrganisationTypeDTO {
+    code: string;
+    icon: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: number;
+    colorSet: number;
+    colorSeed: string;
+    xAxis?: CreateChartAxisDTO;
+    aggregates?: boolean;
+    dynamicVariables?: boolean;
+    chartVariables: CreateChartVariableDTO[];
+    chartPlots: CreateChartPlotDTO[];
+    labelDefault: string;
+    titleDefault: string;
+    translations: CreateChartTranslationDTO[];
+}

package/models/chartOrganisationTypes/chartOrganisationTypeInfos.ts

@@ -0,0 +1,66 @@
+import { ChartTranslation, ChartTranslationDTO } from "../charts/chartTranslation";
+import { ChartModelLabel, ChartModelLabelDTO } from "../charts/chartModelLabel";
+import { ApplicationScope } from "../enums/applicationEnums";
+import { ChartType } from "../enums/chartEnums";
+
+export class ChartOrganisationTypeInfos {
+    id: string;
+    chartId: string;
+    organisationTypeId: string;
+    organisationTypeLabel: string;
+    scope: ApplicationScope;
+    icon: string;
+    code: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: ChartType;
+    modelsLabels: ChartModelLabel[];
+    label: string;
+    title: string;
+    labelDefault: string;
+    titleDefault: string;
+    translations: ChartTranslation[];
+
+    constructor(params: ChartOrganisationTypeInfosDTO) {
+        this.id = params.id;
+        this.chartId = params.chartId;
+        this.organisationTypeId = params.organisationTypeId;
+        this.organisationTypeLabel = params.organisationTypeLabel;
+        this.scope = params.scope;
+        this.icon = params.icon;
+        this.code = params.code;
+        this.tags = params.tags.slice();
+        this.multiple = params.multiple;
+        this.chartType = params.chartType;
+        this.modelsLabels = params.modelsLabels.map((modelLabel) => new ChartModelLabel(modelLabel));
+        this.label = params.label;
+        this.title = params.title;
+        this.labelDefault = params.labelDefault;
+        this.titleDefault = params.titleDefault;
+        this.translations = params.translations.map((translation) => new ChartTranslation(translation));
+    }
+}
+
+export interface ChartOrganisationTypeInfosDTO {
+    id: string;
+    chartId: string;
+    organisationTypeId: string;
+    organisationTypeLabel: string;
+    scope: ApplicationScope;
+    icon: string;
+    code: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: ChartType;
+    modelsLabels: ChartModelLabelDTO[];
+    label: string;
+    title: string;
+    labelDefault: string;
+    titleDefault: string;
+    translations: ChartTranslationDTO[];
+}
+
+export interface ChartOrganisationTypeFilters {
+    modelsIds?: string[];
+    search?: string;
+}

package/models/chartOrganisationTypes/index.ts

@@ -0,0 +1,2 @@
+export * from "./chartOrganisationTypeDetails";
+export * from "./chartOrganisationTypeInfos";

package/models/chartOrganisations/chartOrganisationDetails.ts

@@ -0,0 +1,65 @@
+import { ChartVariable, ChartVariableDTO, CreateChartVariableDTO } from "../charts/chartVariable";
+import { ChartOrganisationInfos, ChartOrganisationInfosDTO } from "./chartOrganisationInfos";
+import { ChartAxis, ChartAxisDTO, CreateChartAxisDTO } from "../charts/chartAxis";
+import { ChartPlot, ChartPlotDTO, CreateChartPlotDTO } from "../charts/chartPlot";
+import { CreateChartTranslationDTO } from "../charts/chartTranslation";
+import { ColorSets } from "../enums/chartEnums";
+
+export class ChartOrganisationDetails extends ChartOrganisationInfos {
+    colorSet: ColorSets;
+    colorSeed: string;
+    xAxis: ChartAxis;
+    aggregates?: boolean;
+    dynamicVariables?: boolean;
+    chartVariables: ChartVariable[];
+    chartPlots: ChartPlot[];
+
+    constructor(params: ChartOrganisationDetailsDTO) {
+        super(params);
+    
+        this.colorSet = params.colorSet as ColorSets;
+        this.colorSeed = params.colorSeed;
+        this.xAxis = new ChartAxis(params.xAxis);
+        this.aggregates = params.aggregates;
+        this.dynamicVariables = params.dynamicVariables;
+        this.chartVariables = params.chartVariables.map(cv => new ChartVariable(cv));
+        this.chartPlots = params.chartPlots.map(cp => new ChartPlot(cp));
+    }
+}
+
+export interface ChartOrganisationDetailsDTO extends ChartOrganisationInfosDTO {
+    colorSet: number;
+    colorSeed: string;
+    xAxis?: ChartAxisDTO;
+    aggregates?: boolean;
+    dynamicVariables?: boolean;
+    chartVariables: ChartVariableDTO[];
+    chartPlots: ChartPlotDTO[];
+}
+
+export interface CreateChartOrganisationDTO {
+    code: string;
+    icon: string;
+    tags: string[];
+    labelDefault: string;
+    titleDefault: string;
+    translations: CreateChartTranslationDTO[];
+}
+
+export interface UpdateChartOrganisationDTO {
+    code: string;
+    icon: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: number;
+    colorSet: number;
+    colorSeed: string;
+    xAxis?: CreateChartAxisDTO;
+    aggregates?: boolean;
+    dynamicVariables?: boolean;
+    chartVariables: CreateChartVariableDTO[];
+    chartPlots: CreateChartPlotDTO[];
+    labelDefault: string;
+    titleDefault: string;
+    translations: CreateChartTranslationDTO[];
+}

package/models/chartOrganisations/chartOrganisationInfos.ts

@@ -0,0 +1,63 @@
+import { ChartTranslation, ChartTranslationDTO } from "../charts/chartTranslation";
+import { ChartModelLabel, ChartModelLabelDTO } from "../charts/chartModelLabel";
+import { ApplicationScope } from "../enums/applicationEnums";
+import { ChartType } from "../enums/chartEnums";
+
+export class ChartOrganisationInfos {
+    id: string;
+    chartId: string;
+    organisationId: string;
+    scope: ApplicationScope;
+    icon: string;
+    code: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: ChartType;
+    modelsLabels: ChartModelLabel[];
+    label: string;
+    title: string;
+    labelDefault: string;
+    titleDefault: string;
+    translations: ChartTranslation[];
+
+    constructor(params: ChartOrganisationInfosDTO) {
+        this.id = params.id;
+        this.chartId = params.chartId;
+        this.organisationId = params.organisationId;
+        this.scope = params.scope;
+        this.icon = params.icon;
+        this.code = params.code;
+        this.tags = params.tags.slice();
+        this.multiple = params.multiple;
+        this.chartType = params.chartType;
+        this.modelsLabels = params.modelsLabels.map((modelLabel) => new ChartModelLabel(modelLabel));
+        this.label = params.label;
+        this.title = params.title;
+        this.labelDefault = params.labelDefault;
+        this.titleDefault = params.titleDefault;
+        this.translations = params.translations.map((translation) => new ChartTranslation(translation));
+    }
+}
+
+export interface ChartOrganisationInfosDTO {
+    id: string;
+    chartId: string;
+    organisationId: string;
+    scope: ApplicationScope;
+    icon: string;
+    code: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: ChartType;
+    modelsLabels: ChartModelLabelDTO[];
+    label: string;
+    title: string;
+    labelDefault: string;
+    titleDefault: string;
+    translations: ChartTranslationDTO[];
+}
+
+export interface ChartOrganisationFilters {
+    modelsIds?: string[];
+    search?: string;
+}

package/models/chartOrganisations/index.ts

@@ -0,0 +1,2 @@
+export * from "./chartOrganisationDetails";
+export * from "./chartOrganisationInfos";

package/models/charts/chartAxis.ts

@@ -0,0 +1,57 @@
+import { ChartValueRange, ChartValueRangeDTO, CreateChartValueRangeDTO } from "./chartValueRange";
+import { CreateChartTimeRangeDTO, ChartTimeRange, ChartTimeRangeDTO } from "./chartTimeRange";
+import { AxisType } from "../enums/chartEnums";
+
+export class ChartAxis {
+    type: AxisType;
+    logarithmic: boolean;
+    boundaries: boolean;
+    min?: number;
+    max?: number;
+    unit?: string;
+    valueRanges: ChartValueRange[];
+    timeRanges: ChartTimeRange[];
+
+    constructor(params?: ChartAxisDTO) {
+        if (params == null) {
+            this.type = AxisType.None;
+            this.logarithmic = false;
+            this.boundaries = false;
+            this.unit = "";
+            this.valueRanges = [];
+            this.timeRanges = [];
+        }
+        else {
+            this.type = params.type as AxisType;
+            this.logarithmic = params.logarithmic;
+            this.boundaries = params.boundaries;
+            this.min = params.min;
+            this.max = params.max;
+            this.unit = params.unit;
+            this.valueRanges = params.valueRanges.map(vr => new ChartValueRange(vr));
+            this.timeRanges = params.timeRanges.map(tr => new ChartTimeRange(tr));
+        }
+    }
+}
+
+export interface ChartAxisDTO {
+    type: AxisType;
+    logarithmic: boolean;
+    boundaries: boolean;
+    min?: number;
+    max?: number;
+    unit?: string;
+    valueRanges: ChartValueRangeDTO[];
+    timeRanges: ChartTimeRangeDTO[];
+}
+
+export interface CreateChartAxisDTO {
+    type: AxisType;
+    logarithmic: boolean;
+    boundaries: boolean;
+    min?: number;
+    max?: number;
+    unit?: string;
+    valueRanges: CreateChartValueRangeDTO[];
+    timeRanges: CreateChartTimeRangeDTO[];
+}

package/models/charts/chartDetails.ts

@@ -0,0 +1,53 @@
+import { ChartVariable, ChartVariableDTO } from "./chartVariable";
+import { ApplicationScope } from "../enums/applicationEnums";
+import { ChartType, ColorSets } from "../enums/chartEnums";
+import { ChartInfos, ChartInfosDTO } from "./chartInfos";
+import { ChartTranslationDTO } from "./chartTranslation";
+import { ChartAxis, ChartAxisDTO  } from "./chartAxis";
+import { ChartModelLabelDTO } from "./chartModelLabel";
+import { ChartPlot, ChartPlotDTO } from "./chartPlot";
+
+export class ChartDetails extends ChartInfos {
+  colorSet: ColorSets;
+  colorSeed: string;
+  xAxis: ChartAxis;
+  aggregates?: boolean;
+  dynamicVariables?: boolean;
+  chartVariables: ChartVariable[];
+  chartPlots: ChartPlot[];
+
+  constructor(params: ChartDetailsDTO) {
+    super(params);
+    
+    this.colorSet = params.colorSet as ColorSets;
+    this.colorSeed = params.colorSeed;
+    this.xAxis = new ChartAxis(params.xAxis);
+    this.aggregates = params.aggregates;
+    this.dynamicVariables = params.dynamicVariables;
+    this.chartVariables = params.chartVariables.map(cv => new ChartVariable(cv));
+    this.chartPlots = params.chartPlots.map(cp => new ChartPlot(cp));
+  }
+}
+
+export interface ChartDetailsDTO extends ChartInfosDTO {
+    id: string;
+    scope: ApplicationScope;
+    icon: string;
+    code: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: ChartType;
+    modelsLabels: ChartModelLabelDTO[];
+    label: string;
+    title: string;
+    labelDefault: string;
+    titleDefault: string;
+    translations: ChartTranslationDTO[];
+    colorSet: number;
+    colorSeed: string;
+    xAxis?: ChartAxisDTO;
+    aggregates?: boolean;
+    dynamicVariables?: boolean;
+    chartVariables: ChartVariableDTO[];
+    chartPlots: ChartPlotDTO[];
+}

package/models/charts/chartFilter.ts

@@ -0,0 +1,30 @@
+import { ChartFilterValue, ChartFilterValueDTO, CreateChartFilterValueDTO } from "./chartFilterValue";
+import { FilterType } from "../enums/sharedEnums";
+
+export class ChartFilter {
+  dataDefinitionId: string;
+  filterType: FilterType;
+  filterValues: ChartFilterValue[];
+  filterDynamic: boolean;
+
+  constructor(params: ChartFilterDTO) {
+    this.dataDefinitionId = params.dataDefinitionId;
+    this.filterType = params.filterType as FilterType;
+    this.filterValues = params.filterValues.map(fv => new ChartFilterValue(fv));
+    this.filterDynamic = params.filterDynamic;
+  }
+}
+
+export interface ChartFilterDTO {
+  dataDefinitionId: string;
+  filterType: number;
+  filterValues: ChartFilterValueDTO[];
+  filterDynamic: boolean;
+}
+
+export interface CreateChartFilterDTO {
+  dataDefinitionId: string;
+  filterType: FilterType;
+  filterValues: CreateChartFilterValueDTO[];
+  filterDynamic: boolean;
+}

package/models/charts/chartFilterValue.ts

@@ -0,0 +1,23 @@
+export class ChartFilterValue {
+    id?: string;
+    label: string;
+    isCustom: boolean;
+  
+    constructor(params: ChartFilterValueDTO) {
+      this.id = params.id;
+      this.label = params.label;
+      this.isCustom = params.isCustom;
+    }
+  }
+  
+  export interface ChartFilterValueDTO {
+    id?: string;
+    label: string;
+    isCustom: boolean;
+  }
+  
+  export interface CreateChartFilterValueDTO {
+    id?: string;
+    label: string;
+    isCustom: boolean;
+  }

package/models/charts/chartInfos.ts

@@ -0,0 +1,52 @@
+import { ChartTranslation, ChartTranslationDTO } from "./chartTranslation";
+import { ChartModelLabel, ChartModelLabelDTO } from "./chartModelLabel";
+import { ApplicationScope } from "../enums/applicationEnums";
+import { ChartType } from "../enums/chartEnums";
+
+export class ChartInfos {
+    id: string;
+    scope: ApplicationScope;
+    icon: string;
+    code: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: ChartType;
+    modelsLabels: ChartModelLabel[];
+    label: string;
+    title: string;
+    labelDefault: string;
+    titleDefault: string;
+    translations: ChartTranslation[];
+
+    constructor(params: ChartInfosDTO) {
+        this.id = params.id;
+        this.scope = params.scope;
+        this.icon = params.icon;
+        this.code = params.code;
+        this.tags = params.tags.slice();
+        this.multiple = params.multiple;
+        this.chartType = params.chartType;
+        this.modelsLabels = params.modelsLabels.map((modelLabel) => new ChartModelLabel(modelLabel));
+        this.label = params.label;
+        this.title = params.title;
+        this.labelDefault = params.labelDefault;
+        this.titleDefault = params.titleDefault;
+        this.translations = params.translations.map((translation) => new ChartTranslation(translation));
+    }
+}
+
+export interface ChartInfosDTO {
+    id: string;
+    scope: ApplicationScope;
+    icon: string;
+    code: string;
+    tags: string[];
+    multiple: boolean;
+    chartType: ChartType;
+    modelsLabels: ChartModelLabelDTO[];
+    label: string;
+    title: string;
+    labelDefault: string;
+    titleDefault: string;
+    translations: ChartTranslationDTO[];
+}

package/models/charts/chartModelLabel.ts

@@ -0,0 +1,14 @@
+export class ChartModelLabel {
+    id: string;
+    label: string;
+
+    constructor(params: ChartModelLabelDTO) {
+        this.id = params.id;
+        this.label = params.label;
+    }
+}
+
+export interface ChartModelLabelDTO {
+    id: string;
+    label: string;
+}

package/models/charts/chartModifier.ts

@@ -0,0 +1,19 @@
+export class ChartModifier {
+    dataDefinitionId: string;
+    hideLabel: boolean;
+  
+    constructor(params: ChartModifierDTO) {
+      this.dataDefinitionId = params.dataDefinitionId;
+      this.hideLabel = params.hideLabel;
+    }
+  }
+  
+  export interface ChartModifierDTO {
+    dataDefinitionId: string;
+    hideLabel: boolean;
+  }
+  
+  export interface CreateChartModifierDTO {
+    dataDefinitionId: string;
+    hideLabel: boolean;
+  }