attlaz-client 1.7.1 → 1.7.2

package/dist/Service/NotificationsEndpoint.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationsEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Notification_1 = require("../Model/Notification");
-class NotificationsEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Notification } from '../Model/Notification';
+export class NotificationsEndpoint extends Endpoint {
     getAll(unacknowledgedOnly = false) {
         return new Promise((resolve, reject) => {
             this.httpClient.request('/notifications?unacknowledgedOnly=' + unacknowledgedOnly).then((rawNotifications) => {
@@ -11,7 +8,7 @@ class NotificationsEndpoint extends Endpoint_1.Endpoint {
                 for (let rawNotification of rawNotifications) {
                     //TODO: parse to objects
                     // subscribers.push(rawSubscriber);
-                    let notification = new Notification_1.Notification();
+                    let notification = new Notification();
                     notification.id = rawNotification.id;
                     notification.user = rawNotification.user;
                     notification.type = rawNotification.type;
@@ -44,4 +41,3 @@ class NotificationsEndpoint extends Endpoint_1.Endpoint {
         });
     }
 }
-exports.NotificationsEndpoint = NotificationsEndpoint;

package/dist/Service/PlatformEndpoint.js

@@ -1,21 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlatformEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Platform_1 = require("../Model/Worker/Platform");
-const PlatformImage_1 = require("../Model/Worker/PlatformImage");
-class PlatformEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Platform } from '../Model/Worker/Platform';
+import { PlatformImage } from '../Model/Worker/PlatformImage';
+export class PlatformEndpoint extends Endpoint {
     async getAll() {
         let cmd = '/platforms';
         const result = await this.request(cmd);
-        result.setData(this.parseCollection(result, Platform_1.Platform.parse));
+        result.setData(this.parseCollection(result, Platform.parse));
         return result;
     }
     async getPlatformImages(platformId) {
         let cmd = '/platforms/' + platformId + '/images';
         const result = await this.request(cmd);
-        result.setData(this.parseCollection(result, PlatformImage_1.PlatformImage.parse));
+        result.setData(this.parseCollection(result, PlatformImage.parse));
         return result;
     }
 }
-exports.PlatformEndpoint = PlatformEndpoint;

package/dist/Service/PlatformLanguageEndpoint.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlatformLanguageEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const PlatformLanguage_1 = require("../Model/Project/PlatformLanguage");
-class PlatformLanguageEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { PlatformLanguage } from '../Model/Project/PlatformLanguage';
+export class PlatformLanguageEndpoint extends Endpoint {
     async getAll() {
         let cmd = '/platformlanguages';
         const result = await this.request(cmd);
-        result.setData(this.parseCollection(result, PlatformLanguage_1.PlatformLanguage.parse));
+        result.setData(this.parseCollection(result, PlatformLanguage.parse));
         return result;
     }
 }
-exports.PlatformLanguageEndpoint = PlatformLanguageEndpoint;

package/dist/Service/ProjectDeployEndpoint.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectDeployEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const ProjectDeploy_1 = require("../Model/Project/ProjectDeploy");
-const Utils_1 = require("../Utils");
-class ProjectDeployEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { ProjectDeploy } from '../Model/Project/ProjectDeploy';
+import { Utils } from '../Utils';
+export class ProjectDeployEndpoint extends Endpoint {
     async getById(deployId) {
         try {
             const rawProjectDeploy = await this.httpClient.request('/deploys/' + deployId);
-            if (Utils_1.Utils.isNullOrUndefined(rawProjectDeploy)) {
+            if (Utils.isNullOrUndefined(rawProjectDeploy)) {
                 throw new Error('Unable to get deploy');
             }
-            return ProjectDeploy_1.ProjectDeploy.parse(rawProjectDeploy);
+            return ProjectDeploy.parse(rawProjectDeploy);
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -25,7 +22,7 @@ class ProjectDeployEndpoint extends Endpoint_1.Endpoint {
             const rawProjectDeploys = await this.httpClient.request('/projectenvironments/' + projectEnvironmentId + '/deploys');
             let projectDeploys = [];
             for (let rawProjectDeploy of rawProjectDeploys) {
-                projectDeploys.push(ProjectDeploy_1.ProjectDeploy.parse(rawProjectDeploy));
+                projectDeploys.push(ProjectDeploy.parse(rawProjectDeploy));
             }
             return projectDeploys;
         }
@@ -51,4 +48,3 @@ class ProjectDeployEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.ProjectDeployEndpoint = ProjectDeployEndpoint;

package/dist/Service/ProjectEndpoint.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Project_1 = require("../Model/Project/Project");
-const Utils_1 = require("../Utils");
-class ProjectEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Project } from '../Model/Project/Project';
+import { Utils } from '../Utils';
+export class ProjectEndpoint extends Endpoint {
     getAll() {
         return new Promise((resolve, reject) => {
             this.httpClient.request('projects').then((rawProjects) => {
                 let projects = [];
                 for (let rawProject of rawProjects) {
-                    projects.push(Project_1.Project.parse(rawProject));
+                    projects.push(Project.parse(rawProject));
                 }
                 resolve(projects);
             }).catch((reason) => {
@@ -26,7 +23,7 @@ class ProjectEndpoint extends Endpoint_1.Endpoint {
             this.httpClient.request('teams/' + teamId + '/projects').then((rawProjects) => {
                 let projects = [];
                 for (let rawProject of rawProjects) {
-                    projects.push(Project_1.Project.parse(rawProject));
+                    projects.push(Project.parse(rawProject));
                 }
                 resolve(projects);
             }).catch((reason) => {
@@ -40,10 +37,10 @@ class ProjectEndpoint extends Endpoint_1.Endpoint {
     async getById(projectId) {
         try {
             const rawProject = await this.httpClient.request('projects/' + projectId + '');
-            if (Utils_1.Utils.isNullOrUndefined(rawProject)) {
+            if (Utils.isNullOrUndefined(rawProject)) {
                 throw new Error('Unable to get project');
             }
-            return Project_1.Project.parse(rawProject);
+            return Project.parse(rawProject);
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -55,7 +52,7 @@ class ProjectEndpoint extends Endpoint_1.Endpoint {
     save(project) {
         return new Promise((resolve, reject) => {
             this.httpClient.request('projects/', project, 'POST').then((rawProject) => {
-                resolve(Project_1.Project.parse(rawProject));
+                resolve(Project.parse(rawProject));
             }).catch((reason) => {
                 if (this.httpClient.isDebugEnabled()) {
                     console.error('Failed to save project: ', reason);
@@ -65,4 +62,3 @@ class ProjectEndpoint extends Endpoint_1.Endpoint {
         });
     }
 }
-exports.ProjectEndpoint = ProjectEndpoint;

package/dist/Service/ProjectEnvironmentEndpoint.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectEnvironmentEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-class ProjectEnvironmentEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+export class ProjectEnvironmentEndpoint extends Endpoint {
     async getByProject(id) {
         try {
             const rawProjectEnvironments = await this.httpClient.request('/projects/' + id + '/environments');
@@ -48,4 +45,3 @@ class ProjectEnvironmentEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.ProjectEnvironmentEndpoint = ProjectEnvironmentEndpoint;

package/dist/Service/QueueEndpoint.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Utils_1 = require("../Utils");
-const QueueStatus_1 = require("../Model/Queue/QueueStatus");
-class QueueEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Utils } from '../Utils';
+import { QueueStatus } from '../Model/Queue/QueueStatus';
+export class QueueEndpoint extends Endpoint {
     async getByProjectEnvironment(projectEnvironmentId) {
         try {
             let url = '/projectenvironments/' + projectEnvironmentId + '/queues';
             const result = await this.request(url);
-            if (Utils_1.Utils.isNullOrUndefined(result)) {
+            if (Utils.isNullOrUndefined(result)) {
                 // return null;
             }
             else {
-                result.setData(QueueStatus_1.QueueStatus.parse(result.getData()));
+                result.setData(QueueStatus.parse(result.getData()));
             }
             return result;
         }
@@ -25,4 +22,3 @@ class QueueEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.QueueEndpoint = QueueEndpoint;

package/dist/Service/SourcesAccountEndpoint.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SourcesAccountEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const SourcesAccount_1 = require("../Model/SourcesAccount");
-const SourcesAccountRepository_1 = require("../Model/SourcesAccountRepository");
-const Utils_1 = require("../Utils");
-class SourcesAccountEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { SourcesAccount } from '../Model/SourcesAccount';
+import { SourcesAccountRepository } from '../Model/SourcesAccountRepository';
+import { Utils } from '../Utils';
+export class SourcesAccountEndpoint extends Endpoint {
     async getAll() {
         const rawSourcesAccounts = await this.httpClient.request('sourcesaccounts');
         let sourcesAccounts = [];
         for (let rawSourcesAccount of rawSourcesAccounts) {
-            sourcesAccounts.push(SourcesAccount_1.SourcesAccount.parse(rawSourcesAccount));
+            sourcesAccounts.push(SourcesAccount.parse(rawSourcesAccount));
         }
         return sourcesAccounts;
     }
@@ -18,14 +15,13 @@ class SourcesAccountEndpoint extends Endpoint_1.Endpoint {
         const rawSourcesAccountRepositories = await this.httpClient.request('sourcesaccounts/' + sourcesAccountId + '/repositories');
         let sourcesAccountRepositories = [];
         for (let rawSourcesAccountRepository of rawSourcesAccountRepositories) {
-            sourcesAccountRepositories.push(SourcesAccountRepository_1.SourcesAccountRepository.parse(rawSourcesAccountRepository));
+            sourcesAccountRepositories.push(SourcesAccountRepository.parse(rawSourcesAccountRepository));
         }
         return sourcesAccountRepositories;
     }
     async getRepositoryBranches(sourcesAccountId, repositoryKey) {
-        repositoryKey = Utils_1.Utils.base64encode(repositoryKey);
+        repositoryKey = Utils.base64encode(repositoryKey);
         const rawBranches = await this.httpClient.request('sourcesaccounts/' + sourcesAccountId + '/repositories/' + repositoryKey + '/branches');
         return rawBranches;
     }
 }
-exports.SourcesAccountEndpoint = SourcesAccountEndpoint;

package/dist/Service/StorageEndpoint.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-class StorageEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+export class StorageEndpoint extends Endpoint {
     async getInformation(projectEnvironmentId, storageType) {
         let cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType;
         try {
@@ -36,4 +33,3 @@ class StorageEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.StorageEndpoint = StorageEndpoint;

package/dist/Service/SubscriberEndpoint.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubscriberEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Subscriber_1 = require("../Model/Messaging/Subscriber");
-const Utils_1 = require("../Utils");
-class SubscriberEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Subscriber } from '../Model/Messaging/Subscriber';
+import { Utils } from '../Utils';
+export class SubscriberEndpoint extends Endpoint {
     getSubscribersByTask(taskId, projectEnvironmentId = null) {
         return new Promise((resolve, reject) => {
             let parameters = null;
-            if (!Utils_1.Utils.isNullOrUndefined(projectEnvironmentId)) {
+            if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
                 parameters = { environment: projectEnvironmentId };
             }
             this.httpClient.request('/tasks/' + taskId + '/subscribers', parameters).then((rawSubscribers) => {
                 let subscribers = [];
                 for (let rawSubscriber of rawSubscribers) {
-                    subscribers.push(Subscriber_1.Subscriber.parseRaw(rawSubscriber));
+                    subscribers.push(Subscriber.parseRaw(rawSubscriber));
                 }
                 resolve(subscribers);
             }).catch((reason) => {
@@ -30,7 +27,7 @@ class SubscriberEndpoint extends Endpoint_1.Endpoint {
             this.httpClient.request('/channels/' + channelId + '/subscribers').then((rawSubscribers) => {
                 let subscribers = [];
                 for (let rawSubscriber of rawSubscribers) {
-                    subscribers.push(Subscriber_1.Subscriber.parseRaw(rawSubscriber));
+                    subscribers.push(Subscriber.parseRaw(rawSubscriber));
                 }
                 resolve(subscribers);
             }).catch((reason) => {
@@ -55,4 +52,3 @@ class SubscriberEndpoint extends Endpoint_1.Endpoint {
         });
     }
 }
-exports.SubscriberEndpoint = SubscriberEndpoint;

package/dist/Service/TaskEndpoint.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Task_1 = require("../Model/Task");
-const Utils_1 = require("../Utils");
-const TaskSummary_1 = require("../Model/TaskSummary");
-class TaskEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Task } from '../Model/Task';
+import { Utils } from '../Utils';
+import { TaskSummary } from '../Model/TaskSummary';
+export class TaskEndpoint extends Endpoint {
     getTasks(projectId) {
         return new Promise((resolve, reject) => {
             this.httpClient.request('projects/' + projectId + '/tasks').then((rawTasks) => {
                 let tasks = [];
                 for (let rawTask of rawTasks) {
-                    tasks.push(Task_1.Task.parse(rawTask));
+                    tasks.push(Task.parse(rawTask));
                 }
                 resolve(tasks);
             }).catch((reason) => {
@@ -25,10 +22,10 @@ class TaskEndpoint extends Endpoint_1.Endpoint {
     async getTask(taskId) {
         try {
             const rawTask = await this.httpClient.request('/tasks/' + taskId);
-            if (Utils_1.Utils.isNullOrUndefined(rawTask)) {
+            if (Utils.isNullOrUndefined(rawTask)) {
                 throw new Error('Task not found');
             }
-            return Task_1.Task.parse(rawTask);
+            return Task.parse(rawTask);
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -40,13 +37,13 @@ class TaskEndpoint extends Endpoint_1.Endpoint {
     getTaskSummaries(projectId, projectEnvironmentId = null) {
         return new Promise((resolve, reject) => {
             let parameters = null;
-            if (!Utils_1.Utils.isNullOrUndefined(projectEnvironmentId)) {
+            if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
                 parameters = { environment: projectEnvironmentId };
             }
             this.httpClient.request('projects/' + projectId + '/tasksummaries', parameters).then((rawTaskSummaries) => {
                 let tasks = [];
                 for (let rawTaskSummary of rawTaskSummaries) {
-                    tasks.push(TaskSummary_1.TaskSummary.parse(rawTaskSummary));
+                    tasks.push(TaskSummary.parse(rawTaskSummary));
                 }
                 resolve(tasks);
             }).catch((reason) => {
@@ -59,15 +56,15 @@ class TaskEndpoint extends Endpoint_1.Endpoint {
     }
     async getTaskSummary(taskId, projectEnvironmentId = null) {
         let parameters = null;
-        if (!Utils_1.Utils.isNullOrUndefined(projectEnvironmentId)) {
+        if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
             parameters = { environment: projectEnvironmentId };
         }
         try {
             const rawTaskSummary = await this.httpClient.request('tasks/' + taskId + '/summaries', parameters);
-            if (Utils_1.Utils.isNullOrUndefined(rawTaskSummary)) {
+            if (Utils.isNullOrUndefined(rawTaskSummary)) {
                 throw new Error('Task not found');
             }
-            return TaskSummary_1.TaskSummary.parse(rawTaskSummary);
+            return TaskSummary.parse(rawTaskSummary);
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -80,7 +77,7 @@ class TaskEndpoint extends Endpoint_1.Endpoint {
         return new Promise((resolve, reject) => {
             let url = '/projects/' + task.project + '/tasks';
             this.httpClient.request(url, task, 'POST').then((result) => {
-                resolve(Task_1.Task.parse(result));
+                resolve(Task.parse(result));
             }).catch((reason) => {
                 if (this.httpClient.isDebugEnabled()) {
                     console.error('Failed to save task: ', reason);
@@ -90,4 +87,3 @@ class TaskEndpoint extends Endpoint_1.Endpoint {
         });
     }
 }
-exports.TaskEndpoint = TaskEndpoint;

package/dist/Service/TaskExecutionEndpoint.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskExecutionEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const TaskExecution_1 = require("../Model/TaskExecution");
-const Utils_1 = require("../Utils");
-const TaskExecutionSummary_1 = require("../Model/TaskExecutionSummary");
-const TaskExecutionHistory_1 = require("../Model/TaskExecutionHistory");
-class TaskExecutionEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { TaskExecution } from '../Model/TaskExecution';
+import { Utils } from '../Utils';
+import { TaskExecutionSummary } from '../Model/TaskExecutionSummary';
+import { TaskExecutionHistory } from '../Model/TaskExecutionHistory';
+export class TaskExecutionEndpoint extends Endpoint {
     getTaskExecutions(taskId) {
         return new Promise((resolve, reject) => {
             this.httpClient.request('/tasks/' + taskId + '/executions').then((rawTaskExecutions) => {
                 let taskExecutions = [];
                 for (let rawTaskExecution of rawTaskExecutions) {
-                    taskExecutions.push(TaskExecution_1.TaskExecution.parse(rawTaskExecution));
+                    taskExecutions.push(TaskExecution.parse(rawTaskExecution));
                 }
                 resolve(taskExecutions);
             }).catch((reason) => {
@@ -38,7 +35,7 @@ class TaskExecutionEndpoint extends Endpoint_1.Endpoint {
                 }
                 params.to = to.toISOString();
             }
-            if (!Utils_1.Utils.isNullOrUndefined(projectEnvironmentId)) {
+            if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
                 if (params === null || params === undefined) {
                     params = {};
                 }
@@ -47,7 +44,7 @@ class TaskExecutionEndpoint extends Endpoint_1.Endpoint {
             const rawTaskExecutions = await this.httpClient.request('/tasks/' + taskId + '/executionsummaries', params);
             let taskExecutions = [];
             for (let rawTaskExecution of rawTaskExecutions) {
-                taskExecutions.push(TaskExecutionSummary_1.TaskExecutionSummary.parse(rawTaskExecution));
+                taskExecutions.push(TaskExecutionSummary.parse(rawTaskExecution));
             }
             return taskExecutions;
         }
@@ -64,7 +61,7 @@ class TaskExecutionEndpoint extends Endpoint_1.Endpoint {
             if (rawTaskExecution === null || rawTaskExecution === undefined) {
                 return null;
             }
-            return TaskExecutionSummary_1.TaskExecutionSummary.parse(rawTaskExecution);
+            return TaskExecutionSummary.parse(rawTaskExecution);
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -81,7 +78,7 @@ class TaskExecutionEndpoint extends Endpoint_1.Endpoint {
             this.httpClient.request('/taskexecutions/' + taskExecutionId + '/history').then((rawTaskExecutionHistories) => {
                 let taskExecutionHistories = [];
                 for (let rawTaskExecutionHistory of rawTaskExecutionHistories) {
-                    taskExecutionHistories.push(TaskExecutionHistory_1.TaskExecutionHistory.parse(rawTaskExecutionHistory));
+                    taskExecutionHistories.push(TaskExecutionHistory.parse(rawTaskExecutionHistory));
                 }
                 resolve(taskExecutionHistories);
             }).catch((reason) => {
@@ -97,14 +94,13 @@ class TaskExecutionEndpoint extends Endpoint_1.Endpoint {
             throw new Error('Task execution id cannot be empty');
         }
         let params = {};
-        if (!Utils_1.Utils.isNullOrUndefined(status)) {
+        if (!Utils.isNullOrUndefined(status)) {
             params.status = status;
         }
-        if (!Utils_1.Utils.isNullOrUndefined(time)) {
+        if (!Utils.isNullOrUndefined(time)) {
             params.time = time;
         }
         const rawTaskExecution = await this.httpClient.request('/taskexecutions/' + taskExecutionId + '', params, 'POST');
-        return TaskExecution_1.TaskExecution.parse(rawTaskExecution);
+        return TaskExecution.parse(rawTaskExecution);
     }
 }
-exports.TaskExecutionEndpoint = TaskExecutionEndpoint;

package/dist/Service/TaskExecutionRequestEndpoint.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskExecutionRequestEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-class TaskExecutionRequestEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+export class TaskExecutionRequestEndpoint extends Endpoint {
     async postTaskExecutionRequest(taskId, params, wait = false) {
         let url = '/tasks/' + taskId + '/taskexecutionrequests';
         if (wait) {
@@ -22,4 +19,3 @@ class TaskExecutionRequestEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.TaskExecutionRequestEndpoint = TaskExecutionRequestEndpoint;

package/dist/Service/TaskExecutionStatsEndpoint.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskExecutionStatsEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const DataResult_1 = require("../Model/Result/DataResult");
-class TaskExecutionStatsEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { DataResult } from '../Model/Result/DataResult';
+export class TaskExecutionStatsEndpoint extends Endpoint {
     async create(taskExecutionStats) {
         let url = '/taskexecutions/' + taskExecutionStats.taskExecution + '/stats';
         try {
             const result = await this.request(url, taskExecutionStats, 'POST');
-            return new DataResult_1.DataResult(taskExecutionStats);
+            return new DataResult(taskExecutionStats);
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {
@@ -18,4 +15,3 @@ class TaskExecutionStatsEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.TaskExecutionStatsEndpoint = TaskExecutionStatsEndpoint;

package/dist/Service/TeamMemberEndpoint.js

@@ -1,32 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamMemberEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const TeamMember_1 = require("../Model/Team/TeamMember");
-const Utils_1 = require("../Utils");
-const TeamMemberRole_1 = require("../Model/Team/TeamMemberRole");
-const TeamMemberInviteState_1 = require("../Model/Team/TeamMemberInviteState");
-const State_1 = require("../Model/State");
-class TeamMemberEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { TeamMember } from '../Model/Team/TeamMember';
+import { Utils } from '../Utils';
+import { TeamMemberRole } from '../Model/Team/TeamMemberRole';
+import { TeamMemberInviteState } from '../Model/Team/TeamMemberInviteState';
+import { State } from '../Model/State';
+export class TeamMemberEndpoint extends Endpoint {
     async getByTeam(teamId) {
         let cmd = '/teams/' + teamId + '/members';
         const rawMembers = await this.httpClient.request(cmd);
         const result = [];
         for (let rawMember of rawMembers) {
-            const member = new TeamMember_1.TeamMember();
+            const member = new TeamMember();
             member.id = rawMember.id;
             member.email = rawMember.email;
-            member.invite = Utils_1.Utils.isTrue(rawMember.invite);
+            member.invite = Utils.isTrue(rawMember.invite);
             if (rawMember.last_login !== null && rawMember.last_login !== undefined) {
-                member.last_login = Utils_1.Utils.parseRawDate(rawMember.last_login);
+                member.last_login = Utils.parseRawDate(rawMember.last_login);
             }
             member.name = rawMember.name;
-            member.role = TeamMemberRole_1.TeamMemberRole.fromString(rawMember.role);
+            member.role = TeamMemberRole.fromString(rawMember.role);
             if (member.invite) {
-                member.state = TeamMemberInviteState_1.TeamMemberInviteState.fromString(rawMember.state);
+                member.state = TeamMemberInviteState.fromString(rawMember.state);
             }
             else {
-                member.state = State_1.State.fromString(rawMember.state);
+                member.state = State.fromString(rawMember.state);
             }
             result.push(member);
         }
@@ -62,11 +59,10 @@ class TeamMemberEndpoint extends Endpoint_1.Endpoint {
                 inviter_name: rawInvite.inviter_name,
                 inviter_email: rawInvite.inviter_email,
                 team_name: rawInvite.team_name,
-                state: TeamMemberInviteState_1.TeamMemberInviteState.fromString(rawInvite.state)
+                state: TeamMemberInviteState.fromString(rawInvite.state)
             };
             return teamMemberInvite;
         }
         return null;
     }
 }
-exports.TeamMemberEndpoint = TeamMemberEndpoint;

package/dist/Service/TeamsEndpoint.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamsEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Team_1 = require("../Model/Team/Team");
-const State_1 = require("../Model/State");
-class TeamsEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Team } from '../Model/Team/Team';
+import { State } from '../Model/State';
+export class TeamsEndpoint extends Endpoint {
     async getAll() {
         try {
             const rawTeams = await this.httpClient.request('/teams');
             let teams = [];
             for (let rawTeam of rawTeams) {
-                let team = new Team_1.Team();
+                let team = new Team();
                 team.id = rawTeam.id;
                 team.name = rawTeam.name;
-                team.state = State_1.State.fromString(rawTeam.state);
+                team.state = State.fromString(rawTeam.state);
                 teams.push(team);
             }
             return teams;
@@ -26,4 +23,3 @@ class TeamsEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.TeamsEndpoint = TeamsEndpoint;