@saritasa/crm-delmar-core-sdk 0.0.180 → 0.0.182

package/README.md

@@ -1,5 +1,5 @@
-# @@saritasa/crm-delmar-core-sdk@0.0.180
+# @@saritasa/crm-delmar-core-sdk@0.0.182
 
 ```bash
-npm install @saritasa/crm-delmar-core-sdk@0.0.180 --save
+npm install @saritasa/crm-delmar-core-sdk@0.0.182 --save
 ```

package/api/api.d.ts

@@ -16,6 +16,12 @@ export * from "./departments-api.serviceInterface";
 export * from "./dismissal-reasons-api.service";
 import { DismissalReasonsApiService } from "./dismissal-reasons-api.service";
 export * from "./dismissal-reasons-api.serviceInterface";
+export * from "./export-job-reports-departments-api.service";
+import { ExportJobReportsDepartmentsApiService } from "./export-job-reports-departments-api.service";
+export * from "./export-job-reports-departments-api.serviceInterface";
+export * from "./export-job-reports-users-api.service";
+import { ExportJobReportsUsersApiService } from "./export-job-reports-users-api.service";
+export * from "./export-job-reports-users-api.serviceInterface";
 export * from "./export-jobs-api.service";
 import { ExportJobsApiService } from "./export-jobs-api.service";
 export * from "./export-jobs-api.serviceInterface";
@@ -112,4 +118,4 @@ export * from "./who-am-i-api.serviceInterface";
 export * from "./work-types-api.service";
 import { WorkTypesApiService } from "./work-types-api.service";
 export * from "./work-types-api.serviceInterface";
-export declare const APIS: (typeof BranchPeriodsApiService | typeof BranchesApiService | typeof ClientNotesApiService | typeof ClientsApiService | typeof DepartmentsApiService | typeof DismissalReasonsApiService | typeof ExportJobsApiService | typeof ExportProjectsApiService | typeof ExportTasksApiService | typeof ExportUserPeriodsApiService | typeof ExportUsersApiService | typeof JiraClientApiService | typeof JiraInstancesApiService | typeof JobsApiService | typeof LocationsApiService | typeof NotificationsApiService | typeof PermissionDataApiService | typeof ProfileApiService | typeof ProjectNotesApiService | typeof ProjectPrioritiesApiService | typeof ProjectResourcesApiService | typeof ProjectsApiService | typeof RolesApiService | typeof S3ApiService | typeof SearchPeriodsApiService | typeof SsoApiService | typeof TasksApiService | typeof TokenApiService | typeof UserCapacitiesApiService | typeof UserLoginsApiService | typeof UserPeriodsApiService | typeof UserScoresApiService | typeof UserTimezoneSettingApiService | typeof UserTimezonesApiService | typeof UsersApiService | typeof VendorsApiService | typeof WhoAmIApiService | typeof WorkTypesApiService)[];
+export declare const APIS: (typeof BranchPeriodsApiService | typeof BranchesApiService | typeof ClientNotesApiService | typeof ClientsApiService | typeof DepartmentsApiService | typeof DismissalReasonsApiService | typeof ExportJobReportsDepartmentsApiService | typeof ExportJobReportsUsersApiService | typeof ExportJobsApiService | typeof ExportProjectsApiService | typeof ExportTasksApiService | typeof ExportUserPeriodsApiService | typeof ExportUsersApiService | typeof JiraClientApiService | typeof JiraInstancesApiService | typeof JobsApiService | typeof LocationsApiService | typeof NotificationsApiService | typeof PermissionDataApiService | typeof ProfileApiService | typeof ProjectNotesApiService | typeof ProjectPrioritiesApiService | typeof ProjectResourcesApiService | typeof ProjectsApiService | typeof RolesApiService | typeof S3ApiService | typeof SearchPeriodsApiService | typeof SsoApiService | typeof TasksApiService | typeof TokenApiService | typeof UserCapacitiesApiService | typeof UserLoginsApiService | typeof UserPeriodsApiService | typeof UserScoresApiService | typeof UserTimezoneSettingApiService | typeof UserTimezonesApiService | typeof UsersApiService | typeof VendorsApiService | typeof WhoAmIApiService | typeof WorkTypesApiService)[];

package/api/export-job-reports-departments-api.service.d.ts

@@ -0,0 +1,103 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { ExportJobDto } from "../model/export-job.dto";
+import { PaginatedExportJobListDto } from "../model/paginated-export-job-list.dto";
+import { Configuration } from "../configuration";
+import { ExportJobReportsDepartmentsApiServiceInterface, ExportJobReportsDepartmentsCancelCreateRequestParams, ExportJobReportsDepartmentsListRequestParams, ExportJobReportsDepartmentsRetrieveRequestParams, ExportJobReportsDepartmentsStartCreateRequestParams } from "./export-job-reports-departments-api.serviceInterface";
+import * as i0 from "@angular/core";
+export declare class ExportJobReportsDepartmentsApiService implements ExportJobReportsDepartmentsApiServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Cancel export job that is in progress.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    exportJobReportsDepartmentsCancelCreate(requestParameters: ExportJobReportsDepartmentsCancelCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ExportJobDto>;
+    exportJobReportsDepartmentsCancelCreate(requestParameters: ExportJobReportsDepartmentsCancelCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ExportJobDto>>;
+    exportJobReportsDepartmentsCancelCreate(requestParameters: ExportJobReportsDepartmentsCancelCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ExportJobDto>>;
+    /**
+     * Viewset for exporting job reports by departments.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    exportJobReportsDepartmentsList(requestParameters?: ExportJobReportsDepartmentsListRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<PaginatedExportJobListDto>;
+    exportJobReportsDepartmentsList(requestParameters?: ExportJobReportsDepartmentsListRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PaginatedExportJobListDto>>;
+    exportJobReportsDepartmentsList(requestParameters?: ExportJobReportsDepartmentsListRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PaginatedExportJobListDto>>;
+    /**
+     * Viewset for exporting job reports by departments.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    exportJobReportsDepartmentsRetrieve(requestParameters: ExportJobReportsDepartmentsRetrieveRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ExportJobDto>;
+    exportJobReportsDepartmentsRetrieve(requestParameters: ExportJobReportsDepartmentsRetrieveRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ExportJobDto>>;
+    exportJobReportsDepartmentsRetrieve(requestParameters: ExportJobReportsDepartmentsRetrieveRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ExportJobDto>>;
+    /**
+     * Validate request data and start ExportJob.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    exportJobReportsDepartmentsStartCreate(requestParameters: ExportJobReportsDepartmentsStartCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ExportJobDto>;
+    exportJobReportsDepartmentsStartCreate(requestParameters: ExportJobReportsDepartmentsStartCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ExportJobDto>>;
+    exportJobReportsDepartmentsStartCreate(requestParameters: ExportJobReportsDepartmentsStartCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ExportJobDto>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportJobReportsDepartmentsApiService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportJobReportsDepartmentsApiService>;
+}

package/api/export-job-reports-departments-api.serviceInterface.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Delmar Api
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { ExportJobDto } from "../model/models";
+import { PaginatedExportJobListDto } from "../model/models";
+import { ReportByDepartmentsResourceCreateExportJobRequestDto } from "../model/models";
+import { Configuration } from "../configuration";
+export interface ExportJobReportsDepartmentsCancelCreateRequestParams {
+    id: number;
+}
+export interface ExportJobReportsDepartmentsListRequestParams {
+    limit?: number;
+    offset?: number;
+    ordering?: string;
+    search?: string;
+}
+export interface ExportJobReportsDepartmentsRetrieveRequestParams {
+    id: number;
+}
+export interface ExportJobReportsDepartmentsStartCreateRequestParams {
+    reportByDepartmentsResourceCreateExportJobRequestDto: ReportByDepartmentsResourceCreateExportJobRequestDto;
+    billedBy?: number;
+    billedByIn?: Array<number>;
+    branch?: number;
+    branchIn?: Array<number>;
+    createdBy?: number;
+    createdByIn?: Array<number>;
+    dateGte?: string;
+    dateLte?: string;
+    id?: number;
+    idIn?: Array<number>;
+    isBillable?: boolean;
+    ordering?: string;
+    search?: string;
+    task?: number;
+    taskIn?: Array<number>;
+    taskProject?: number;
+    taskProjectClient?: number;
+    taskProjectClientIn?: Array<number>;
+    taskProjectIn?: Array<number>;
+    timeSpan?: "day" | "month" | "quarter" | "week";
+    totalType?: "all" | "billable" | "unbillable";
+    type?: "architecture" | "code_optimization" | "coding" | "design" | "project_management" | "unknown" | "validation_and_verification";
+    typeIn?: Array<string>;
+    updatedBy?: number;
+    updatedByIn?: Array<number>;
+    workType?: number;
+    workTypeIn?: Array<number>;
+}
+export interface ExportJobReportsDepartmentsApiServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     *
+     * Cancel export job that is in progress.
+     * @param requestParameters
+     */
+    exportJobReportsDepartmentsCancelCreate(requestParameters: ExportJobReportsDepartmentsCancelCreateRequestParams, extraHttpRequestParams?: any): Observable<ExportJobDto>;
+    /**
+     *
+     * Viewset for exporting job reports by departments.
+     * @param requestParameters
+     */
+    exportJobReportsDepartmentsList(requestParameters: ExportJobReportsDepartmentsListRequestParams, extraHttpRequestParams?: any): Observable<PaginatedExportJobListDto>;
+    /**
+     *
+     * Viewset for exporting job reports by departments.
+     * @param requestParameters
+     */
+    exportJobReportsDepartmentsRetrieve(requestParameters: ExportJobReportsDepartmentsRetrieveRequestParams, extraHttpRequestParams?: any): Observable<ExportJobDto>;
+    /**
+     *
+     * Validate request data and start ExportJob.
+     * @param requestParameters
+     */
+    exportJobReportsDepartmentsStartCreate(requestParameters: ExportJobReportsDepartmentsStartCreateRequestParams, extraHttpRequestParams?: any): Observable<ExportJobDto>;
+}

package/api/export-job-reports-users-api.service.d.ts

@@ -0,0 +1,103 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { ExportJobDto } from "../model/export-job.dto";
+import { PaginatedExportJobListDto } from "../model/paginated-export-job-list.dto";
+import { Configuration } from "../configuration";
+import { ExportJobReportsUsersApiServiceInterface, ExportJobReportsUsersCancelCreateRequestParams, ExportJobReportsUsersListRequestParams, ExportJobReportsUsersRetrieveRequestParams, ExportJobReportsUsersStartCreateRequestParams } from "./export-job-reports-users-api.serviceInterface";
+import * as i0 from "@angular/core";
+export declare class ExportJobReportsUsersApiService implements ExportJobReportsUsersApiServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Cancel export job that is in progress.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    exportJobReportsUsersCancelCreate(requestParameters: ExportJobReportsUsersCancelCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ExportJobDto>;
+    exportJobReportsUsersCancelCreate(requestParameters: ExportJobReportsUsersCancelCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ExportJobDto>>;
+    exportJobReportsUsersCancelCreate(requestParameters: ExportJobReportsUsersCancelCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ExportJobDto>>;
+    /**
+     * Viewset for exporting job reports by users.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    exportJobReportsUsersList(requestParameters?: ExportJobReportsUsersListRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<PaginatedExportJobListDto>;
+    exportJobReportsUsersList(requestParameters?: ExportJobReportsUsersListRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PaginatedExportJobListDto>>;
+    exportJobReportsUsersList(requestParameters?: ExportJobReportsUsersListRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PaginatedExportJobListDto>>;
+    /**
+     * Viewset for exporting job reports by users.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    exportJobReportsUsersRetrieve(requestParameters: ExportJobReportsUsersRetrieveRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ExportJobDto>;
+    exportJobReportsUsersRetrieve(requestParameters: ExportJobReportsUsersRetrieveRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ExportJobDto>>;
+    exportJobReportsUsersRetrieve(requestParameters: ExportJobReportsUsersRetrieveRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ExportJobDto>>;
+    /**
+     * Validate request data and start ExportJob.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    exportJobReportsUsersStartCreate(requestParameters: ExportJobReportsUsersStartCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ExportJobDto>;
+    exportJobReportsUsersStartCreate(requestParameters: ExportJobReportsUsersStartCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ExportJobDto>>;
+    exportJobReportsUsersStartCreate(requestParameters: ExportJobReportsUsersStartCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ExportJobDto>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportJobReportsUsersApiService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportJobReportsUsersApiService>;
+}

package/api/export-job-reports-users-api.serviceInterface.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Delmar Api
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { ExportJobDto } from "../model/models";
+import { PaginatedExportJobListDto } from "../model/models";
+import { ReportByUsersResourceCreateExportJobRequestDto } from "../model/models";
+import { Configuration } from "../configuration";
+export interface ExportJobReportsUsersCancelCreateRequestParams {
+    id: number;
+}
+export interface ExportJobReportsUsersListRequestParams {
+    limit?: number;
+    offset?: number;
+    ordering?: string;
+    search?: string;
+}
+export interface ExportJobReportsUsersRetrieveRequestParams {
+    id: number;
+}
+export interface ExportJobReportsUsersStartCreateRequestParams {
+    reportByUsersResourceCreateExportJobRequestDto: ReportByUsersResourceCreateExportJobRequestDto;
+    billedBy?: number;
+    billedByIn?: Array<number>;
+    branch?: number;
+    branchIn?: Array<number>;
+    createdBy?: number;
+    createdByIn?: Array<number>;
+    dateGte?: string;
+    dateLte?: string;
+    id?: number;
+    idIn?: Array<number>;
+    isBillable?: boolean;
+    ordering?: string;
+    search?: string;
+    task?: number;
+    taskIn?: Array<number>;
+    taskProject?: number;
+    taskProjectClient?: number;
+    taskProjectClientIn?: Array<number>;
+    taskProjectIn?: Array<number>;
+    timeSpan?: "day" | "month" | "quarter" | "week";
+    totalType?: "all" | "billable" | "unbillable";
+    type?: "architecture" | "code_optimization" | "coding" | "design" | "project_management" | "unknown" | "validation_and_verification";
+    typeIn?: Array<string>;
+    updatedBy?: number;
+    updatedByIn?: Array<number>;
+    workType?: number;
+    workTypeIn?: Array<number>;
+}
+export interface ExportJobReportsUsersApiServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     *
+     * Cancel export job that is in progress.
+     * @param requestParameters
+     */
+    exportJobReportsUsersCancelCreate(requestParameters: ExportJobReportsUsersCancelCreateRequestParams, extraHttpRequestParams?: any): Observable<ExportJobDto>;
+    /**
+     *
+     * Viewset for exporting job reports by users.
+     * @param requestParameters
+     */
+    exportJobReportsUsersList(requestParameters: ExportJobReportsUsersListRequestParams, extraHttpRequestParams?: any): Observable<PaginatedExportJobListDto>;
+    /**
+     *
+     * Viewset for exporting job reports by users.
+     * @param requestParameters
+     */
+    exportJobReportsUsersRetrieve(requestParameters: ExportJobReportsUsersRetrieveRequestParams, extraHttpRequestParams?: any): Observable<ExportJobDto>;
+    /**
+     *
+     * Validate request data and start ExportJob.
+     * @param requestParameters
+     */
+    exportJobReportsUsersStartCreate(requestParameters: ExportJobReportsUsersStartCreateRequestParams, extraHttpRequestParams?: any): Observable<ExportJobDto>;
+}

package/esm2022/api/api.mjs

@@ -16,6 +16,12 @@ export * from "./departments-api.serviceInterface";
 export * from "./dismissal-reasons-api.service";
 import { DismissalReasonsApiService } from "./dismissal-reasons-api.service";
 export * from "./dismissal-reasons-api.serviceInterface";
+export * from "./export-job-reports-departments-api.service";
+import { ExportJobReportsDepartmentsApiService } from "./export-job-reports-departments-api.service";
+export * from "./export-job-reports-departments-api.serviceInterface";
+export * from "./export-job-reports-users-api.service";
+import { ExportJobReportsUsersApiService } from "./export-job-reports-users-api.service";
+export * from "./export-job-reports-users-api.serviceInterface";
 export * from "./export-jobs-api.service";
 import { ExportJobsApiService } from "./export-jobs-api.service";
 export * from "./export-jobs-api.serviceInterface";
@@ -119,6 +125,8 @@ export const APIS = [
     ClientsApiService,
     DepartmentsApiService,
     DismissalReasonsApiService,
+    ExportJobReportsDepartmentsApiService,
+    ExportJobReportsUsersApiService,
     ExportJobsApiService,
     ExportProjectsApiService,
     ExportTasksApiService,
@@ -152,4 +160,4 @@ export const APIS = [
     WhoAmIApiService,
     WorkTypesApiService,
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../api/api.ts"],"names":[],"mappings":"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","sourcesContent":["export * from \"./branch-periods-api.service\";\nimport { BranchPeriodsApiService } from \"./branch-periods-api.service\";\nexport * from \"./branch-periods-api.serviceInterface\";\nexport * from \"./branches-api.service\";\nimport { BranchesApiService } from \"./branches-api.service\";\nexport * from \"./branches-api.serviceInterface\";\nexport * from \"./client-notes-api.service\";\nimport { ClientNotesApiService } from \"./client-notes-api.service\";\nexport * from \"./client-notes-api.serviceInterface\";\nexport * from \"./clients-api.service\";\nimport { ClientsApiService } from \"./clients-api.service\";\nexport * from \"./clients-api.serviceInterface\";\nexport * from \"./departments-api.service\";\nimport { DepartmentsApiService } from \"./departments-api.service\";\nexport * from \"./departments-api.serviceInterface\";\nexport * from \"./dismissal-reasons-api.service\";\nimport { DismissalReasonsApiService } from \"./dismissal-reasons-api.service\";\nexport * from \"./dismissal-reasons-api.serviceInterface\";\nexport * from \"./export-jobs-api.service\";\nimport { ExportJobsApiService } from \"./export-jobs-api.service\";\nexport * from \"./export-jobs-api.serviceInterface\";\nexport * from \"./export-projects-api.service\";\nimport { ExportProjectsApiService } from \"./export-projects-api.service\";\nexport * from \"./export-projects-api.serviceInterface\";\nexport * from \"./export-tasks-api.service\";\nimport { ExportTasksApiService } from \"./export-tasks-api.service\";\nexport * from \"./export-tasks-api.serviceInterface\";\nexport * from \"./export-user-periods-api.service\";\nimport { ExportUserPeriodsApiService } from \"./export-user-periods-api.service\";\nexport * from \"./export-user-periods-api.serviceInterface\";\nexport * from \"./export-users-api.service\";\nimport { ExportUsersApiService } from \"./export-users-api.service\";\nexport * from \"./export-users-api.serviceInterface\";\nexport * from \"./jira-client-api.service\";\nimport { JiraClientApiService } from \"./jira-client-api.service\";\nexport * from \"./jira-client-api.serviceInterface\";\nexport * from \"./jira-instances-api.service\";\nimport { JiraInstancesApiService } from \"./jira-instances-api.service\";\nexport * from \"./jira-instances-api.serviceInterface\";\nexport * from \"./jobs-api.service\";\nimport { JobsApiService } from \"./jobs-api.service\";\nexport * from \"./jobs-api.serviceInterface\";\nexport * from \"./locations-api.service\";\nimport { LocationsApiService } from \"./locations-api.service\";\nexport * from \"./locations-api.serviceInterface\";\nexport * from \"./notifications-api.service\";\nimport { NotificationsApiService } from \"./notifications-api.service\";\nexport * from \"./notifications-api.serviceInterface\";\nexport * from \"./permission-data-api.service\";\nimport { PermissionDataApiService } from \"./permission-data-api.service\";\nexport * from \"./permission-data-api.serviceInterface\";\nexport * from \"./profile-api.service\";\nimport { ProfileApiService } from \"./profile-api.service\";\nexport * from \"./profile-api.serviceInterface\";\nexport * from \"./project-notes-api.service\";\nimport { ProjectNotesApiService } from \"./project-notes-api.service\";\nexport * from \"./project-notes-api.serviceInterface\";\nexport * from \"./project-priorities-api.service\";\nimport { ProjectPrioritiesApiService } from \"./project-priorities-api.service\";\nexport * from \"./project-priorities-api.serviceInterface\";\nexport * from \"./project-resources-api.service\";\nimport { ProjectResourcesApiService } from \"./project-resources-api.service\";\nexport * from \"./project-resources-api.serviceInterface\";\nexport * from \"./projects-api.service\";\nimport { ProjectsApiService } from \"./projects-api.service\";\nexport * from \"./projects-api.serviceInterface\";\nexport * from \"./roles-api.service\";\nimport { RolesApiService } from \"./roles-api.service\";\nexport * from \"./roles-api.serviceInterface\";\nexport * from \"./s3-api.service\";\nimport { S3ApiService } from \"./s3-api.service\";\nexport * from \"./s3-api.serviceInterface\";\nexport * from \"./search-periods-api.service\";\nimport { SearchPeriodsApiService } from \"./search-periods-api.service\";\nexport * from \"./search-periods-api.serviceInterface\";\nexport * from \"./sso-api.service\";\nimport { SsoApiService } from \"./sso-api.service\";\nexport * from \"./sso-api.serviceInterface\";\nexport * from \"./tasks-api.service\";\nimport { TasksApiService } from \"./tasks-api.service\";\nexport * from \"./tasks-api.serviceInterface\";\nexport * from \"./token-api.service\";\nimport { TokenApiService } from \"./token-api.service\";\nexport * from \"./token-api.serviceInterface\";\nexport * from \"./user-capacities-api.service\";\nimport { UserCapacitiesApiService } from \"./user-capacities-api.service\";\nexport * from \"./user-capacities-api.serviceInterface\";\nexport * from \"./user-logins-api.service\";\nimport { UserLoginsApiService } from \"./user-logins-api.service\";\nexport * from \"./user-logins-api.serviceInterface\";\nexport * from \"./user-periods-api.service\";\nimport { UserPeriodsApiService } from \"./user-periods-api.service\";\nexport * from \"./user-periods-api.serviceInterface\";\nexport * from \"./user-scores-api.service\";\nimport { UserScoresApiService } from \"./user-scores-api.service\";\nexport * from \"./user-scores-api.serviceInterface\";\nexport * from \"./user-timezone-setting-api.service\";\nimport { UserTimezoneSettingApiService } from \"./user-timezone-setting-api.service\";\nexport * from \"./user-timezone-setting-api.serviceInterface\";\nexport * from \"./user-timezones-api.service\";\nimport { UserTimezonesApiService } from \"./user-timezones-api.service\";\nexport * from \"./user-timezones-api.serviceInterface\";\nexport * from \"./users-api.service\";\nimport { UsersApiService } from \"./users-api.service\";\nexport * from \"./users-api.serviceInterface\";\nexport * from \"./vendors-api.service\";\nimport { VendorsApiService } from \"./vendors-api.service\";\nexport * from \"./vendors-api.serviceInterface\";\nexport * from \"./who-am-i-api.service\";\nimport { WhoAmIApiService } from \"./who-am-i-api.service\";\nexport * from \"./who-am-i-api.serviceInterface\";\nexport * from \"./work-types-api.service\";\nimport { WorkTypesApiService } from \"./work-types-api.service\";\nexport * from \"./work-types-api.serviceInterface\";\nexport const APIS = [\n  BranchPeriodsApiService,\n  BranchesApiService,\n  ClientNotesApiService,\n  ClientsApiService,\n  DepartmentsApiService,\n  DismissalReasonsApiService,\n  ExportJobsApiService,\n  ExportProjectsApiService,\n  ExportTasksApiService,\n  ExportUserPeriodsApiService,\n  ExportUsersApiService,\n  JiraClientApiService,\n  JiraInstancesApiService,\n  JobsApiService,\n  LocationsApiService,\n  NotificationsApiService,\n  PermissionDataApiService,\n  ProfileApiService,\n  ProjectNotesApiService,\n  ProjectPrioritiesApiService,\n  ProjectResourcesApiService,\n  ProjectsApiService,\n  RolesApiService,\n  S3ApiService,\n  SearchPeriodsApiService,\n  SsoApiService,\n  TasksApiService,\n  TokenApiService,\n  UserCapacitiesApiService,\n  UserLoginsApiService,\n  UserPeriodsApiService,\n  UserScoresApiService,\n  UserTimezoneSettingApiService,\n  UserTimezonesApiService,\n  UsersApiService,\n  VendorsApiService,\n  WhoAmIApiService,\n  WorkTypesApiService,\n];\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../api/api.ts"],"names":[],"mappings":"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","sourcesContent":["export * from \"./branch-periods-api.service\";\nimport { BranchPeriodsApiService } from \"./branch-periods-api.service\";\nexport * from \"./branch-periods-api.serviceInterface\";\nexport * from \"./branches-api.service\";\nimport { BranchesApiService } from \"./branches-api.service\";\nexport * from \"./branches-api.serviceInterface\";\nexport * from \"./client-notes-api.service\";\nimport { ClientNotesApiService } from \"./client-notes-api.service\";\nexport * from \"./client-notes-api.serviceInterface\";\nexport * from \"./clients-api.service\";\nimport { ClientsApiService } from \"./clients-api.service\";\nexport * from \"./clients-api.serviceInterface\";\nexport * from \"./departments-api.service\";\nimport { DepartmentsApiService } from \"./departments-api.service\";\nexport * from \"./departments-api.serviceInterface\";\nexport * from \"./dismissal-reasons-api.service\";\nimport { DismissalReasonsApiService } from \"./dismissal-reasons-api.service\";\nexport * from \"./dismissal-reasons-api.serviceInterface\";\nexport * from \"./export-job-reports-departments-api.service\";\nimport { ExportJobReportsDepartmentsApiService } from \"./export-job-reports-departments-api.service\";\nexport * from \"./export-job-reports-departments-api.serviceInterface\";\nexport * from \"./export-job-reports-users-api.service\";\nimport { ExportJobReportsUsersApiService } from \"./export-job-reports-users-api.service\";\nexport * from \"./export-job-reports-users-api.serviceInterface\";\nexport * from \"./export-jobs-api.service\";\nimport { ExportJobsApiService } from \"./export-jobs-api.service\";\nexport * from \"./export-jobs-api.serviceInterface\";\nexport * from \"./export-projects-api.service\";\nimport { ExportProjectsApiService } from \"./export-projects-api.service\";\nexport * from \"./export-projects-api.serviceInterface\";\nexport * from \"./export-tasks-api.service\";\nimport { ExportTasksApiService } from \"./export-tasks-api.service\";\nexport * from \"./export-tasks-api.serviceInterface\";\nexport * from \"./export-user-periods-api.service\";\nimport { ExportUserPeriodsApiService } from \"./export-user-periods-api.service\";\nexport * from \"./export-user-periods-api.serviceInterface\";\nexport * from \"./export-users-api.service\";\nimport { ExportUsersApiService } from \"./export-users-api.service\";\nexport * from \"./export-users-api.serviceInterface\";\nexport * from \"./jira-client-api.service\";\nimport { JiraClientApiService } from \"./jira-client-api.service\";\nexport * from \"./jira-client-api.serviceInterface\";\nexport * from \"./jira-instances-api.service\";\nimport { JiraInstancesApiService } from \"./jira-instances-api.service\";\nexport * from \"./jira-instances-api.serviceInterface\";\nexport * from \"./jobs-api.service\";\nimport { JobsApiService } from \"./jobs-api.service\";\nexport * from \"./jobs-api.serviceInterface\";\nexport * from \"./locations-api.service\";\nimport { LocationsApiService } from \"./locations-api.service\";\nexport * from \"./locations-api.serviceInterface\";\nexport * from \"./notifications-api.service\";\nimport { NotificationsApiService } from \"./notifications-api.service\";\nexport * from \"./notifications-api.serviceInterface\";\nexport * from \"./permission-data-api.service\";\nimport { PermissionDataApiService } from \"./permission-data-api.service\";\nexport * from \"./permission-data-api.serviceInterface\";\nexport * from \"./profile-api.service\";\nimport { ProfileApiService } from \"./profile-api.service\";\nexport * from \"./profile-api.serviceInterface\";\nexport * from \"./project-notes-api.service\";\nimport { ProjectNotesApiService } from \"./project-notes-api.service\";\nexport * from \"./project-notes-api.serviceInterface\";\nexport * from \"./project-priorities-api.service\";\nimport { ProjectPrioritiesApiService } from \"./project-priorities-api.service\";\nexport * from \"./project-priorities-api.serviceInterface\";\nexport * from \"./project-resources-api.service\";\nimport { ProjectResourcesApiService } from \"./project-resources-api.service\";\nexport * from \"./project-resources-api.serviceInterface\";\nexport * from \"./projects-api.service\";\nimport { ProjectsApiService } from \"./projects-api.service\";\nexport * from \"./projects-api.serviceInterface\";\nexport * from \"./roles-api.service\";\nimport { RolesApiService } from \"./roles-api.service\";\nexport * from \"./roles-api.serviceInterface\";\nexport * from \"./s3-api.service\";\nimport { S3ApiService } from \"./s3-api.service\";\nexport * from \"./s3-api.serviceInterface\";\nexport * from \"./search-periods-api.service\";\nimport { SearchPeriodsApiService } from \"./search-periods-api.service\";\nexport * from \"./search-periods-api.serviceInterface\";\nexport * from \"./sso-api.service\";\nimport { SsoApiService } from \"./sso-api.service\";\nexport * from \"./sso-api.serviceInterface\";\nexport * from \"./tasks-api.service\";\nimport { TasksApiService } from \"./tasks-api.service\";\nexport * from \"./tasks-api.serviceInterface\";\nexport * from \"./token-api.service\";\nimport { TokenApiService } from \"./token-api.service\";\nexport * from \"./token-api.serviceInterface\";\nexport * from \"./user-capacities-api.service\";\nimport { UserCapacitiesApiService } from \"./user-capacities-api.service\";\nexport * from \"./user-capacities-api.serviceInterface\";\nexport * from \"./user-logins-api.service\";\nimport { UserLoginsApiService } from \"./user-logins-api.service\";\nexport * from \"./user-logins-api.serviceInterface\";\nexport * from \"./user-periods-api.service\";\nimport { UserPeriodsApiService } from \"./user-periods-api.service\";\nexport * from \"./user-periods-api.serviceInterface\";\nexport * from \"./user-scores-api.service\";\nimport { UserScoresApiService } from \"./user-scores-api.service\";\nexport * from \"./user-scores-api.serviceInterface\";\nexport * from \"./user-timezone-setting-api.service\";\nimport { UserTimezoneSettingApiService } from \"./user-timezone-setting-api.service\";\nexport * from \"./user-timezone-setting-api.serviceInterface\";\nexport * from \"./user-timezones-api.service\";\nimport { UserTimezonesApiService } from \"./user-timezones-api.service\";\nexport * from \"./user-timezones-api.serviceInterface\";\nexport * from \"./users-api.service\";\nimport { UsersApiService } from \"./users-api.service\";\nexport * from \"./users-api.serviceInterface\";\nexport * from \"./vendors-api.service\";\nimport { VendorsApiService } from \"./vendors-api.service\";\nexport * from \"./vendors-api.serviceInterface\";\nexport * from \"./who-am-i-api.service\";\nimport { WhoAmIApiService } from \"./who-am-i-api.service\";\nexport * from \"./who-am-i-api.serviceInterface\";\nexport * from \"./work-types-api.service\";\nimport { WorkTypesApiService } from \"./work-types-api.service\";\nexport * from \"./work-types-api.serviceInterface\";\nexport const APIS = [\n  BranchPeriodsApiService,\n  BranchesApiService,\n  ClientNotesApiService,\n  ClientsApiService,\n  DepartmentsApiService,\n  DismissalReasonsApiService,\n  ExportJobReportsDepartmentsApiService,\n  ExportJobReportsUsersApiService,\n  ExportJobsApiService,\n  ExportProjectsApiService,\n  ExportTasksApiService,\n  ExportUserPeriodsApiService,\n  ExportUsersApiService,\n  JiraClientApiService,\n  JiraInstancesApiService,\n  JobsApiService,\n  LocationsApiService,\n  NotificationsApiService,\n  PermissionDataApiService,\n  ProfileApiService,\n  ProjectNotesApiService,\n  ProjectPrioritiesApiService,\n  ProjectResourcesApiService,\n  ProjectsApiService,\n  RolesApiService,\n  S3ApiService,\n  SearchPeriodsApiService,\n  SsoApiService,\n  TasksApiService,\n  TokenApiService,\n  UserCapacitiesApiService,\n  UserLoginsApiService,\n  UserPeriodsApiService,\n  UserScoresApiService,\n  UserTimezoneSettingApiService,\n  UserTimezonesApiService,\n  UsersApiService,\n  VendorsApiService,\n  WhoAmIApiService,\n  WorkTypesApiService,\n];\n"]}