attlaz-client 1.7.3 → 1.7.7

package/dist/Service/NotificationsEndpoint.js

@@ -1,6 +1,9 @@
-import { Endpoint } from './Endpoint';
-import { Notification } from '../Model/Notification';
-export class NotificationsEndpoint extends Endpoint {
+"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 {
     getAll(unacknowledgedOnly = false) {
         return new Promise((resolve, reject) => {
             this.httpClient.request('/notifications?unacknowledgedOnly=' + unacknowledgedOnly).then((rawNotifications) => {
@@ -8,7 +11,7 @@ export class NotificationsEndpoint extends Endpoint {
                 for (let rawNotification of rawNotifications) {
                     //TODO: parse to objects
                     // subscribers.push(rawSubscriber);
-                    let notification = new Notification();
+                    let notification = new Notification_1.Notification();
                     notification.id = rawNotification.id;
                     notification.user = rawNotification.user;
                     notification.type = rawNotification.type;
@@ -41,3 +44,4 @@ export class NotificationsEndpoint extends Endpoint {
         });
     }
 }
+exports.NotificationsEndpoint = NotificationsEndpoint;

package/dist/Service/PlatformEndpoint.js

@@ -1,17 +1,21 @@
-import { Endpoint } from './Endpoint';
-import { Platform } from '../Model/Worker/Platform';
-import { PlatformImage } from '../Model/Worker/PlatformImage';
-export class PlatformEndpoint extends Endpoint {
+"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 {
     async getAll() {
         let cmd = '/platforms';
         const result = await this.request(cmd);
-        result.setData(this.parseCollection(result, Platform.parse));
+        result.setData(this.parseCollection(result, Platform_1.Platform.parse));
         return result;
     }
     async getPlatformImages(platformId) {
         let cmd = '/platforms/' + platformId + '/images';
         const result = await this.request(cmd);
-        result.setData(this.parseCollection(result, PlatformImage.parse));
+        result.setData(this.parseCollection(result, PlatformImage_1.PlatformImage.parse));
         return result;
     }
 }
+exports.PlatformEndpoint = PlatformEndpoint;

package/dist/Service/PlatformLanguageEndpoint.js

@@ -1,10 +1,14 @@
-import { Endpoint } from './Endpoint';
-import { PlatformLanguage } from '../Model/Project/PlatformLanguage';
-export class PlatformLanguageEndpoint extends Endpoint {
+"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 {
     async getAll() {
         let cmd = '/platformlanguages';
         const result = await this.request(cmd);
-        result.setData(this.parseCollection(result, PlatformLanguage.parse));
+        result.setData(this.parseCollection(result, PlatformLanguage_1.PlatformLanguage.parse));
         return result;
     }
 }
+exports.PlatformLanguageEndpoint = PlatformLanguageEndpoint;

package/dist/Service/ProjectDeployEndpoint.js

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

package/dist/Service/ProjectEndpoint.js

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

package/dist/Service/ProjectEnvironmentEndpoint.js

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

package/dist/Service/QueueEndpoint.js

@@ -1,16 +1,19 @@
-import { Endpoint } from './Endpoint';
-import { Utils } from '../Utils';
-import { QueueStatus } from '../Model/Queue/QueueStatus';
-export class QueueEndpoint extends Endpoint {
+"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 {
     async getByProjectEnvironment(projectEnvironmentId) {
         try {
             let url = '/projectenvironments/' + projectEnvironmentId + '/queues';
             const result = await this.request(url);
-            if (Utils.isNullOrUndefined(result)) {
+            if (Utils_1.Utils.isNullOrUndefined(result)) {
                 // return null;
             }
             else {
-                result.setData(QueueStatus.parse(result.getData()));
+                result.setData(QueueStatus_1.QueueStatus.parse(result.getData()));
             }
             return result;
         }
@@ -22,3 +25,4 @@ export class QueueEndpoint extends Endpoint {
         }
     }
 }
+exports.QueueEndpoint = QueueEndpoint;

package/dist/Service/SourcesAccountEndpoint.js

@@ -1,13 +1,16 @@
-import { Endpoint } from './Endpoint';
-import { SourcesAccount } from '../Model/SourcesAccount';
-import { SourcesAccountRepository } from '../Model/SourcesAccountRepository';
-import { Utils } from '../Utils';
-export class SourcesAccountEndpoint extends Endpoint {
+"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 {
     async getAll() {
         const rawSourcesAccounts = await this.httpClient.request('sourcesaccounts');
         let sourcesAccounts = [];
         for (let rawSourcesAccount of rawSourcesAccounts) {
-            sourcesAccounts.push(SourcesAccount.parse(rawSourcesAccount));
+            sourcesAccounts.push(SourcesAccount_1.SourcesAccount.parse(rawSourcesAccount));
         }
         return sourcesAccounts;
     }
@@ -15,13 +18,14 @@ export class SourcesAccountEndpoint extends Endpoint {
         const rawSourcesAccountRepositories = await this.httpClient.request('sourcesaccounts/' + sourcesAccountId + '/repositories');
         let sourcesAccountRepositories = [];
         for (let rawSourcesAccountRepository of rawSourcesAccountRepositories) {
-            sourcesAccountRepositories.push(SourcesAccountRepository.parse(rawSourcesAccountRepository));
+            sourcesAccountRepositories.push(SourcesAccountRepository_1.SourcesAccountRepository.parse(rawSourcesAccountRepository));
         }
         return sourcesAccountRepositories;
     }
     async getRepositoryBranches(sourcesAccountId, repositoryKey) {
-        repositoryKey = Utils.base64encode(repositoryKey);
+        repositoryKey = Utils_1.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,5 +1,8 @@
-import { Endpoint } from './Endpoint';
-export class StorageEndpoint extends Endpoint {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageEndpoint = void 0;
+const Endpoint_1 = require("./Endpoint");
+class StorageEndpoint extends Endpoint_1.Endpoint {
     async getInformation(projectEnvironmentId, storageType) {
         let cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType;
         try {
@@ -33,3 +36,4 @@ export class StorageEndpoint extends Endpoint {
         }
     }
 }
+exports.StorageEndpoint = StorageEndpoint;

package/dist/Service/SubscriberEndpoint.js

@@ -1,17 +1,20 @@
-import { Endpoint } from './Endpoint';
-import { Subscriber } from '../Model/Messaging/Subscriber';
-import { Utils } from '../Utils';
-export class SubscriberEndpoint extends Endpoint {
+"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 {
     getSubscribersByTask(taskId, projectEnvironmentId = null) {
         return new Promise((resolve, reject) => {
             let parameters = null;
-            if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
+            if (!Utils_1.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.parseRaw(rawSubscriber));
+                    subscribers.push(Subscriber_1.Subscriber.parseRaw(rawSubscriber));
                 }
                 resolve(subscribers);
             }).catch((reason) => {
@@ -27,7 +30,7 @@ export class SubscriberEndpoint extends Endpoint {
             this.httpClient.request('/channels/' + channelId + '/subscribers').then((rawSubscribers) => {
                 let subscribers = [];
                 for (let rawSubscriber of rawSubscribers) {
-                    subscribers.push(Subscriber.parseRaw(rawSubscriber));
+                    subscribers.push(Subscriber_1.Subscriber.parseRaw(rawSubscriber));
                 }
                 resolve(subscribers);
             }).catch((reason) => {
@@ -52,3 +55,4 @@ export class SubscriberEndpoint extends Endpoint {
         });
     }
 }
+exports.SubscriberEndpoint = SubscriberEndpoint;

package/dist/Service/TaskEndpoint.js

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

package/dist/Service/TaskExecutionEndpoint.js

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

package/dist/Service/TaskExecutionRequestEndpoint.js

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

package/dist/Service/TaskExecutionStatsEndpoint.js

@@ -1,11 +1,14 @@
-import { Endpoint } from './Endpoint';
-import { DataResult } from '../Model/Result/DataResult';
-export class TaskExecutionStatsEndpoint extends Endpoint {
+"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 {
     async create(taskExecutionStats) {
         let url = '/taskexecutions/' + taskExecutionStats.taskExecution + '/stats';
         try {
             const result = await this.request(url, taskExecutionStats, 'POST');
-            return new DataResult(taskExecutionStats);
+            return new DataResult_1.DataResult(taskExecutionStats);
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {
@@ -15,3 +18,4 @@ export class TaskExecutionStatsEndpoint extends Endpoint {
         }
     }
 }
+exports.TaskExecutionStatsEndpoint = TaskExecutionStatsEndpoint;

package/dist/Service/TeamMemberEndpoint.js

@@ -1,29 +1,32 @@
-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 {
+"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 {
     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();
+            const member = new TeamMember_1.TeamMember();
             member.id = rawMember.id;
             member.email = rawMember.email;
-            member.invite = Utils.isTrue(rawMember.invite);
+            member.invite = Utils_1.Utils.isTrue(rawMember.invite);
             if (rawMember.last_login !== null && rawMember.last_login !== undefined) {
-                member.last_login = Utils.parseRawDate(rawMember.last_login);
+                member.last_login = Utils_1.Utils.parseRawDate(rawMember.last_login);
             }
             member.name = rawMember.name;
-            member.role = TeamMemberRole.fromString(rawMember.role);
+            member.role = TeamMemberRole_1.TeamMemberRole.fromString(rawMember.role);
             if (member.invite) {
-                member.state = TeamMemberInviteState.fromString(rawMember.state);
+                member.state = TeamMemberInviteState_1.TeamMemberInviteState.fromString(rawMember.state);
             }
             else {
-                member.state = State.fromString(rawMember.state);
+                member.state = State_1.State.fromString(rawMember.state);
             }
             result.push(member);
         }
@@ -59,10 +62,11 @@ export class TeamMemberEndpoint extends Endpoint {
                 inviter_name: rawInvite.inviter_name,
                 inviter_email: rawInvite.inviter_email,
                 team_name: rawInvite.team_name,
-                state: TeamMemberInviteState.fromString(rawInvite.state)
+                state: TeamMemberInviteState_1.TeamMemberInviteState.fromString(rawInvite.state)
             };
             return teamMemberInvite;
         }
         return null;
     }
 }
+exports.TeamMemberEndpoint = TeamMemberEndpoint;

package/dist/Service/TeamsEndpoint.js

@@ -1,16 +1,19 @@
-import { Endpoint } from './Endpoint';
-import { Team } from '../Model/Team/Team';
-import { State } from '../Model/State';
-export class TeamsEndpoint extends Endpoint {
+"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 {
     async getAll() {
         try {
             const rawTeams = await this.httpClient.request('/teams');
             let teams = [];
             for (let rawTeam of rawTeams) {
-                let team = new Team();
+                let team = new Team_1.Team();
                 team.id = rawTeam.id;
                 team.name = rawTeam.name;
-                team.state = State.fromString(rawTeam.state);
+                team.state = State_1.State.fromString(rawTeam.state);
                 teams.push(team);
             }
             return teams;
@@ -23,3 +26,4 @@ export class TeamsEndpoint extends Endpoint {
         }
     }
 }
+exports.TeamsEndpoint = TeamsEndpoint;