@attlaz/client 1.77.1

package/dist/Model/Messaging/Channel/PushChannelData.d.ts

@@ -0,0 +1,5 @@
+import { ChannelData } from './ChannelData.js';
+export declare class PushChannelData extends ChannelData {
+    userId: string;
+    constructor(userId: string);
+}

package/dist/Model/Messaging/Channel/PushChannelData.js

@@ -0,0 +1,9 @@
+import { ChannelData } from './ChannelData.js';
+import { ChannelType } from './ChannelType.js';
+export class PushChannelData extends ChannelData {
+    userId;
+    constructor(userId) {
+        super(ChannelType.Push);
+        this.userId = userId;
+    }
+}

package/dist/Model/Messaging/Channel/SlackChannelData.d.ts

@@ -0,0 +1,10 @@
+import { ChannelData } from './ChannelData.js';
+export declare class SlackChannelData extends ChannelData {
+    access_token: string;
+    webhook: string;
+    channel_id: string;
+    channel_name: string;
+    team_id: string;
+    team_name: string;
+    constructor(accessToken: string, webhook: string, channelId: string, channelName: string, teamId: string, teamName: string);
+}

package/dist/Model/Messaging/Channel/SlackChannelData.js

@@ -0,0 +1,19 @@
+import { ChannelData } from './ChannelData.js';
+import { ChannelType } from './ChannelType.js';
+export class SlackChannelData extends ChannelData {
+    access_token;
+    webhook;
+    channel_id;
+    channel_name;
+    team_id;
+    team_name;
+    constructor(accessToken, webhook, channelId, channelName, teamId, teamName) {
+        super(ChannelType.Slack);
+        this.access_token = accessToken;
+        this.webhook = webhook;
+        this.channel_id = channelId;
+        this.channel_name = channelName;
+        this.team_id = teamId;
+        this.team_name = teamName;
+    }
+}

package/dist/Model/Messaging/Channel/SmsChannelData.d.ts

@@ -0,0 +1,5 @@
+import { ChannelData } from './ChannelData.js';
+export declare class SmsChannelData extends ChannelData {
+    phonenumber: string;
+    constructor(phonenumber: string);
+}

package/dist/Model/Messaging/Channel/SmsChannelData.js

@@ -0,0 +1,9 @@
+import { ChannelData } from './ChannelData.js';
+import { ChannelType } from './ChannelType.js';
+export class SmsChannelData extends ChannelData {
+    phonenumber;
+    constructor(phonenumber) {
+        super(ChannelType.SMS);
+        this.phonenumber = phonenumber;
+    }
+}

package/dist/Model/Messaging/Channel/WebhookChannelData.d.ts

@@ -0,0 +1,6 @@
+import { ChannelData } from './ChannelData.js';
+export declare class WebhookChannelData extends ChannelData {
+    url: string;
+    method: string;
+    constructor(url: string, method?: string);
+}

package/dist/Model/Messaging/Channel/WebhookChannelData.js

@@ -0,0 +1,11 @@
+import { ChannelData } from './ChannelData.js';
+import { ChannelType } from './ChannelType.js';
+export class WebhookChannelData extends ChannelData {
+    url;
+    method;
+    constructor(url, method = 'GET') {
+        super(ChannelType.Webhook);
+        this.url = url;
+        this.method = method;
+    }
+}

package/dist/Model/Messaging/ChannelHistory.d.ts

@@ -0,0 +1,10 @@
+export declare class ChannelHistory {
+    id: string;
+    subscriberId: string;
+    channelId: string;
+    time: Date;
+    message: unknown;
+    result: unknown;
+    status: string;
+    static parse(rawChannelHistory: Record<string, unknown>): ChannelHistory;
+}

package/dist/Model/Messaging/ChannelHistory.js

@@ -0,0 +1,31 @@
+import { Utils } from '../../Utils.js';
+export class ChannelHistory {
+    id;
+    subscriberId;
+    channelId;
+    time;
+    message;
+    result;
+    status;
+    // public constructor(id: number, subscriber: string, channel: number, time: Date, message: string = '', success: boolean = true, result: string = '') {
+    //     this.id = id;
+    //     this.subscriber = subscriber;
+    //     this.channel = channel;
+    //     this.time = time;
+    //     this.message = message;
+    //     this.success = success;
+    //     this.result = result;
+    //
+    // }
+    static parse(rawChannelHistory) {
+        const log = new ChannelHistory();
+        log.id = rawChannelHistory.id;
+        log.subscriberId = rawChannelHistory.subscriber;
+        log.channelId = rawChannelHistory.channel;
+        log.time = Utils.parseRawDate(rawChannelHistory.time);
+        log.message = rawChannelHistory.message;
+        log.result = rawChannelHistory.result;
+        log.status = rawChannelHistory.status;
+        return log;
+    }
+}

package/dist/Model/Messaging/Subscriber.d.ts

@@ -0,0 +1,19 @@
+import { State } from '../State.js';
+import { EventType } from '../Event/EventType.js';
+import { LogLevel } from '../Log/LogLevel.js';
+import { StateAware } from '../StateAware.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+export declare class Subscriber extends MetaDataAware implements StateAware {
+    id: string;
+    eventTypes: EventType[];
+    projectEnvironmentId: string;
+    flowId: string;
+    channelIds: string[];
+    logLevelThreshold: LogLevel;
+    state: State;
+    constructor(id: string, eventTypes: EventType[], projectEnvironmentId: string, flowId: string, channelIds: string[], logLevelThreshold?: LogLevel);
+    static parseRaw(rawSubscriber: ApiRecord): Subscriber;
+    getLogLevelThreshold(): LogLevel;
+    hasLogLevelThreshold(): boolean;
+}

package/dist/Model/Messaging/Subscriber.js

@@ -0,0 +1,35 @@
+import { State } from '../State.js';
+import { LogLevel } from '../Log/LogLevel.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+export class Subscriber extends MetaDataAware {
+    id;
+    eventTypes;
+    projectEnvironmentId;
+    flowId;
+    // public flowRunId: string;
+    channelIds;
+    logLevelThreshold;
+    state = State.Active;
+    constructor(id, eventTypes, projectEnvironmentId, flowId, channelIds, logLevelThreshold = LogLevel.Debug) {
+        super();
+        this.id = id;
+        this.eventTypes = eventTypes;
+        this.projectEnvironmentId = projectEnvironmentId;
+        this.flowId = flowId;
+        // this.flowRunId = flowRunId;
+        this.channelIds = channelIds;
+        this.logLevelThreshold = logLevelThreshold;
+    }
+    static parseRaw(rawSubscriber) {
+        let subscriber = new Subscriber(rawSubscriber.id, rawSubscriber.event_types, rawSubscriber.project_environment, rawSubscriber.flow, rawSubscriber.channels, rawSubscriber.log_level_threshold);
+        subscriber = MetaDataAware.parseMetaData(subscriber, rawSubscriber);
+        subscriber.state = State.fromString(rawSubscriber.state);
+        return subscriber;
+    }
+    getLogLevelThreshold() {
+        return this.logLevelThreshold;
+    }
+    hasLogLevelThreshold() {
+        return this.logLevelThreshold !== null;
+    }
+}

package/dist/Model/Pagination/CursorPagination.d.ts

@@ -0,0 +1,5 @@
+export declare class CursorPagination {
+    limit: number | null;
+    startingAfter: string | null;
+    endingBefore: string | null;
+}

package/dist/Model/Pagination/CursorPagination.js

@@ -0,0 +1,5 @@
+export class CursorPagination {
+    limit = null;
+    startingAfter = null;
+    endingBefore = null;
+}

package/dist/Model/Pagination/Filters.d.ts

@@ -0,0 +1,20 @@
+export declare class Filters {
+    /**
+     * gte = greater than or equal
+     * gt = greater than
+     * lte = less than or equal
+     * lt = more than
+     * eq = equal
+     * in = in
+     */
+    private readonly filters;
+    addEqualFilter(field: string, value: string | number): void;
+    addBetweenFilter(field: string, valueA: string | number, valueB: string | number): void;
+    toArray(): Filter[];
+}
+type Filter = {
+    field: string;
+    method: string;
+    value: string | number;
+};
+export {};

package/dist/Model/Pagination/Filters.js

@@ -0,0 +1,33 @@
+export class Filters {
+    /**
+     * gte = greater than or equal
+     * gt = greater than
+     * lte = less than or equal
+     * lt = more than
+     * eq = equal
+     * in = in
+     */
+    filters = [];
+    addEqualFilter(field, value) {
+        this.filters.push({
+            field: field,
+            method: 'eq',
+            value: value,
+        });
+    }
+    addBetweenFilter(field, valueA, valueB) {
+        this.filters.push({
+            field: field,
+            method: 'gte',
+            value: valueA,
+        });
+        this.filters.push({
+            field: field,
+            method: 'lte',
+            value: valueB,
+        });
+    }
+    toArray() {
+        return this.filters;
+    }
+}

package/dist/Model/Project/CodeDeploy.d.ts

@@ -0,0 +1,28 @@
+import { ApiRecord } from '../ApiRecord.js';
+import { CodeDeployStatus } from './CodeDeployStatus.js';
+import { ProjectDeployCommit } from './ProjectDeployCommit.js';
+export declare class CodeDeploy {
+    id: string;
+    codeSourceId: string;
+    platformId: string;
+    buildStrategyId: string;
+    userId: string;
+    requested: Date;
+    started: Date | null;
+    finished: Date | null;
+    status: CodeDeployStatus;
+    archiveChecksum: string | null;
+    archiveType: string | null;
+    archiveSize: number | null;
+    checksum: string | null;
+    size: number | null;
+    storageBucketId: string | null;
+    storageItemId: string | null;
+    commits: ProjectDeployCommit[];
+    path: string | null;
+    commitHash: string | null;
+    errors: {
+        message: string;
+    }[] | null;
+    static parse(rawCodeDeploy: ApiRecord): CodeDeploy;
+}

package/dist/Model/Project/CodeDeploy.js

@@ -0,0 +1,57 @@
+import { Utils } from '../../Utils.js';
+import { CodeDeployStatus } from './CodeDeployStatus.js';
+import { ProjectDeployCommit } from './ProjectDeployCommit.js';
+export class CodeDeploy {
+    id;
+    codeSourceId;
+    platformId;
+    buildStrategyId;
+    userId;
+    requested;
+    started = null;
+    finished = null;
+    status = CodeDeployStatus.Unknown;
+    archiveChecksum = null;
+    archiveType = null;
+    archiveSize = null;
+    checksum = null;
+    size = null;
+    storageBucketId = null;
+    storageItemId = null;
+    commits = [];
+    path = null;
+    commitHash = null;
+    errors = null;
+    static parse(rawCodeDeploy) {
+        const projectDeploy = new CodeDeploy();
+        projectDeploy.id = rawCodeDeploy.id;
+        projectDeploy.codeSourceId = rawCodeDeploy.code_source;
+        projectDeploy.platformId = rawCodeDeploy.platform;
+        projectDeploy.buildStrategyId = rawCodeDeploy.build_strategy;
+        projectDeploy.userId = rawCodeDeploy.user;
+        projectDeploy.requested = Utils.parseRawDate(rawCodeDeploy.requested);
+        projectDeploy.started = rawCodeDeploy.started === null ? null : Utils.parseRawDate(rawCodeDeploy.started);
+        projectDeploy.finished = rawCodeDeploy.finished === null ? null : Utils.parseRawDate(rawCodeDeploy.finished);
+        projectDeploy.status = CodeDeployStatus.fromString(rawCodeDeploy.status);
+        projectDeploy.archiveChecksum = rawCodeDeploy.archive_checksum;
+        projectDeploy.archiveType = rawCodeDeploy.archive_type;
+        projectDeploy.archiveSize = rawCodeDeploy.archive_size === null ? null : Utils.parseInt(rawCodeDeploy.archive_size);
+        projectDeploy.checksum = rawCodeDeploy.checksum;
+        projectDeploy.size = rawCodeDeploy.size === null ? null : Utils.parseInt(rawCodeDeploy.size);
+        projectDeploy.storageBucketId = rawCodeDeploy.storage_bucket;
+        projectDeploy.storageItemId = rawCodeDeploy.storage_item;
+        projectDeploy.commitHash = rawCodeDeploy.commit_hash;
+        const rawProjectDeployCommits = rawCodeDeploy.commits;
+        for (const rawProjectDeployCommit of rawProjectDeployCommits) {
+            const projectDeployCommit = new ProjectDeployCommit();
+            projectDeployCommit.hash = rawProjectDeployCommit.commit_hash;
+            projectDeployCommit.date = Utils.parseRawDate(rawProjectDeployCommit.commit_date);
+            projectDeployCommit.message = rawProjectDeployCommit.commit_message;
+            projectDeployCommit.authorName = rawProjectDeployCommit.commit_author_name;
+            projectDeployCommit.authorEmail = rawProjectDeployCommit.commit_author_email;
+            projectDeploy.commits.push(projectDeployCommit);
+        }
+        projectDeploy.errors = rawCodeDeploy.errors;
+        return projectDeploy;
+    }
+}

package/dist/Model/Project/CodeDeployStatus.d.ts

@@ -0,0 +1,12 @@
+export declare enum CodeDeployStatus {
+    Unknown = "unknown",
+    Pending = "pending",
+    Canceled = "canceled",
+    Running = "running",
+    Failed = "failed",
+    Stopped = "stopped",
+    Complete = "complete"
+}
+export declare namespace CodeDeployStatus {
+    const fromString: (input: string) => CodeDeployStatus;
+}

package/dist/Model/Project/CodeDeployStatus.js

@@ -0,0 +1,20 @@
+import { Utils } from '../../Utils.js';
+export var CodeDeployStatus;
+(function (CodeDeployStatus) {
+    CodeDeployStatus["Unknown"] = "unknown";
+    CodeDeployStatus["Pending"] = "pending";
+    CodeDeployStatus["Canceled"] = "canceled";
+    CodeDeployStatus["Running"] = "running";
+    CodeDeployStatus["Failed"] = "failed";
+    CodeDeployStatus["Stopped"] = "stopped";
+    CodeDeployStatus["Complete"] = "complete";
+})(CodeDeployStatus || (CodeDeployStatus = {}));
+(function (CodeDeployStatus) {
+    CodeDeployStatus.fromString = (input) => {
+        const result = Utils.parseEnum(input, CodeDeployStatus);
+        if (result === null) {
+            throw new Error('Unable to parse CodeDeployStatus from string: Unknown CodeDeployStatus "' + input + '"');
+        }
+        return result;
+    };
+})(CodeDeployStatus || (CodeDeployStatus = {}));

package/dist/Model/Project/PlatformLanguage.d.ts

@@ -0,0 +1,11 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+export declare class PlatformLanguage implements StateAware {
+    id: string;
+    key: string;
+    name: string;
+    description: string;
+    state: State;
+    constructor(id: string, name: string);
+    static parse(rawLanguage: Record<string, unknown>): PlatformLanguage;
+}

package/dist/Model/Project/PlatformLanguage.js

@@ -0,0 +1,19 @@
+import { State } from '../State.js';
+export class PlatformLanguage {
+    id;
+    key;
+    name;
+    description = '';
+    state = State.Active;
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+    }
+    static parse(rawLanguage) {
+        const language = new PlatformLanguage(rawLanguage.id, rawLanguage.name);
+        language.key = rawLanguage.key;
+        language.description = rawLanguage.description;
+        language.state = State.fromString(rawLanguage.state);
+        return language;
+    }
+}

package/dist/Model/Project/Project.d.ts

@@ -0,0 +1,13 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+export declare class Project extends MetaDataAware implements StateAware {
+    id: string;
+    key: string;
+    workspaceId: string;
+    defaultEnvironmentId: string;
+    state: State;
+    constructor(id: string, key: string, name: string);
+    static parse(rawProject: ApiRecord): Project;
+}

package/dist/Model/Project/Project.js

@@ -0,0 +1,26 @@
+import { State } from '../State.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+export class Project extends MetaDataAware {
+    id;
+    key;
+    workspaceId;
+    defaultEnvironmentId;
+    state = State.Active;
+    constructor(id, key, name) {
+        super();
+        this.id = id;
+        this.key = key;
+        this.name = name;
+    }
+    static parse(rawProject) {
+        let project = new Project(rawProject.id, rawProject.key, rawProject.name);
+        project = MetaDataAware.parseMetaData(project, rawProject);
+        project.workspaceId = rawProject.workspace;
+        // if (rawProject.default !== null && rawProject.default !== undefined) {
+        //     project.default = Utils.isTrue(rawProject.default);
+        // }
+        project.defaultEnvironmentId = rawProject.default_environment;
+        project.state = State.fromString(rawProject.state);
+        return project;
+    }
+}

package/dist/Model/Project/ProjectDeployCommit.d.ts

@@ -0,0 +1,7 @@
+export declare class ProjectDeployCommit {
+    hash: string;
+    date: Date;
+    message: string;
+    authorName: string;
+    authorEmail: string;
+}

package/dist/Model/Project/ProjectDeployCommit.js

@@ -0,0 +1,7 @@
+export class ProjectDeployCommit {
+    hash;
+    date;
+    message;
+    authorName;
+    authorEmail;
+}

package/dist/Model/Project/ProjectEnvironment.d.ts

@@ -0,0 +1,16 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { ProjectEnvironmentType } from './ProjectEnvironmentType.js';
+export declare class ProjectEnvironment extends MetaDataAware implements StateAware {
+    id: string;
+    key: string;
+    projectId: string;
+    codeSourceId: string | null;
+    parentId: string | null;
+    defaultRunnerPoolId: string | null;
+    type: ProjectEnvironmentType;
+    state: State;
+    static parse(rawProjectEnvironment: ApiRecord): ProjectEnvironment;
+}

package/dist/Model/Project/ProjectEnvironment.js

@@ -0,0 +1,25 @@
+import { State } from '../State.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { ProjectEnvironmentType } from './ProjectEnvironmentType.js';
+export class ProjectEnvironment extends MetaDataAware {
+    id;
+    key;
+    projectId;
+    codeSourceId = null;
+    parentId = null;
+    defaultRunnerPoolId = null;
+    type = ProjectEnvironmentType.Production;
+    state = State.Active;
+    static parse(rawProjectEnvironment) {
+        const projectEnvironment = MetaDataAware.parseMetaData(new ProjectEnvironment(), rawProjectEnvironment);
+        projectEnvironment.id = rawProjectEnvironment.id;
+        projectEnvironment.key = rawProjectEnvironment.key;
+        projectEnvironment.projectId = rawProjectEnvironment.project;
+        projectEnvironment.codeSourceId = rawProjectEnvironment.code_source;
+        projectEnvironment.parentId = rawProjectEnvironment.parent;
+        projectEnvironment.defaultRunnerPoolId = rawProjectEnvironment.default_runner_pool;
+        projectEnvironment.type = ProjectEnvironmentType.fromString(rawProjectEnvironment.type);
+        projectEnvironment.state = State.fromString(rawProjectEnvironment.state);
+        return projectEnvironment;
+    }
+}

package/dist/Model/Project/ProjectEnvironmentType.d.ts

@@ -0,0 +1,8 @@
+export declare enum ProjectEnvironmentType {
+    Production = "prod",
+    Test = "test",
+    Local = "locl"
+}
+export declare namespace ProjectEnvironmentType {
+    const fromString: (input: string) => ProjectEnvironmentType;
+}

package/dist/Model/Project/ProjectEnvironmentType.js

@@ -0,0 +1,16 @@
+import { Utils } from '../../Utils.js';
+export var ProjectEnvironmentType;
+(function (ProjectEnvironmentType) {
+    ProjectEnvironmentType["Production"] = "prod";
+    ProjectEnvironmentType["Test"] = "test";
+    ProjectEnvironmentType["Local"] = "locl";
+})(ProjectEnvironmentType || (ProjectEnvironmentType = {}));
+(function (ProjectEnvironmentType) {
+    ProjectEnvironmentType.fromString = (input) => {
+        const result = Utils.parseEnum(input, ProjectEnvironmentType);
+        if (result === null) {
+            throw new Error('Unable to parse ProjectEnvironmentType from string: Unknown ProjectEnvironmentType "' + input + '"');
+        }
+        return result;
+    };
+})(ProjectEnvironmentType || (ProjectEnvironmentType = {}));

package/dist/Model/ProviderToken/ProviderToken.d.ts

@@ -0,0 +1,11 @@
+import { ApiRecord } from '../ApiRecord.js';
+export declare class ProviderToken {
+    id: string;
+    state: string;
+    details: {
+        name: string;
+        id: string;
+        icon: string | null;
+    } | null;
+    static parse(rawToken: ApiRecord): ProviderToken;
+}

package/dist/Model/ProviderToken/ProviderToken.js

@@ -0,0 +1,12 @@
+export class ProviderToken {
+    id;
+    state;
+    details;
+    static parse(rawToken) {
+        const token = new ProviderToken();
+        token.id = rawToken.id;
+        token.state = rawToken.state;
+        token.details = rawToken.details;
+        return token;
+    }
+}

package/dist/Model/ProviderToken/ProviderTokenAccessToken.d.ts

@@ -0,0 +1,6 @@
+import { ApiRecord } from '../ApiRecord.js';
+export declare class ProviderTokenAccessToken {
+    accessToken: string;
+    expiresAt: Date | null;
+    static parse(rawToken: ApiRecord): ProviderTokenAccessToken;
+}

package/dist/Model/ProviderToken/ProviderTokenAccessToken.js

@@ -0,0 +1,11 @@
+export class ProviderTokenAccessToken {
+    accessToken;
+    // When the access token expires — lets callers cache it for the run instead of re-fetching per call.
+    expiresAt = null;
+    static parse(rawToken) {
+        const token = new ProviderTokenAccessToken();
+        token.accessToken = rawToken.access_token;
+        token.expiresAt = rawToken.expires_at !== undefined && rawToken.expires_at !== null ? new Date(rawToken.expires_at) : null;
+        return token;
+    }
+}

package/dist/Model/Result/CollectionResult.d.ts

@@ -0,0 +1,7 @@
+export declare class CollectionResult<T> {
+    private data;
+    hasMore: boolean;
+    constructor(data?: T[] | null, hasMore?: boolean);
+    setData(data: T[], hasMore: boolean): void;
+    getData(): T[];
+}

package/dist/Model/Result/CollectionResult.js

@@ -0,0 +1,27 @@
+export class CollectionResult {
+    data;
+    hasMore = false;
+    constructor(data = null, hasMore = false) {
+        this.data = data === null ? [] : data;
+        this.hasMore = hasMore;
+    }
+    // public static parse<T>(raw: any): DataResult<T> {
+    //     const result: DataResult<T> = new DataResult<T>();
+    //     const data: any = raw.data;
+    //     result.setData(data);
+    //
+    //     const errors: any[] = raw.errors;
+    //     for (const error of errors) {
+    //         result.addError(error);
+    //     }
+    //
+    //     return result;
+    // }
+    setData(data, hasMore) {
+        this.data = data;
+        this.hasMore = hasMore;
+    }
+    getData() {
+        return this.data;
+    }
+}

package/dist/Model/Result/ObjectResult.d.ts

@@ -0,0 +1,5 @@
+export declare class ObjectResult<T> {
+    private data;
+    setData(data: T | null): void;
+    getData(): T | null;
+}

package/dist/Model/Result/ObjectResult.js

@@ -0,0 +1,21 @@
+export class ObjectResult {
+    data;
+    // public static parse<T>(raw: any): DataResult<T> {
+    //     const result: DataResult<T> = new DataResult<T>();
+    //     const data: any = raw.data;
+    //     result.setData(data);
+    //
+    //     const errors: any[] = raw.errors;
+    //     for (const error of errors) {
+    //         result.addError(error);
+    //     }
+    //
+    //     return result;
+    // }
+    setData(data) {
+        this.data = data;
+    }
+    getData() {
+        return this.data;
+    }
+}