@attlaz/client 1.77.1

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

@@ -0,0 +1,3 @@
+export declare class ObjectWrapper {
+    static wrap<T>(raw: T, strict?: boolean): T;
+}

package/dist/Model/Result/ObjectWrapper.js

@@ -0,0 +1,20 @@
+export class ObjectWrapper {
+    static wrap(raw, strict = false) {
+        const handler = {
+            get(target, property, receiver) {
+                const value = target[property];
+                if (value === undefined) {
+                    if (strict) {
+                        throw new Error('Property "' + property + '" does not exist');
+                    }
+                    else {
+                        console.warn('Unable to get property on object.', { property: property, object: raw });
+                    }
+                }
+                return value;
+            },
+        };
+        const wrapper = new Proxy(raw, handler);
+        return wrapper;
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare class ResultError {
+    message: string;
+    constructor(message: string);
+}

package/dist/Model/Result/ResultError.js

@@ -0,0 +1,6 @@
+export class ResultError {
+    message;
+    constructor(message) {
+        this.message = message;
+    }
+}

package/dist/Model/Runner/RunnerImage.d.ts

@@ -0,0 +1,13 @@
+import { StateAware } from '../StateAware.js';
+import { State } from '../State.js';
+export declare class RunnerImage implements StateAware {
+    id: string;
+    name: string;
+    image: string;
+    version: string;
+    buildDate: Date;
+    deprecated: boolean;
+    endOfSupport: Date | null;
+    endOfLife: Date | null;
+    state: State;
+}

package/dist/Model/Runner/RunnerImage.js

@@ -0,0 +1,12 @@
+import { State } from '../State.js';
+export class RunnerImage {
+    id;
+    name;
+    image;
+    version;
+    buildDate;
+    deprecated = false;
+    endOfSupport = null;
+    endOfLife = null;
+    state = State.Active;
+}

package/dist/Model/Search/SearchResult.d.ts

@@ -0,0 +1,23 @@
+import { Adapter } from '../Adapter/Adapter.js';
+import { AdapterConnection } from '../Adapter/AdapterConnection.js';
+import { CodeSource } from '../Deployment/CodeSource.js';
+import { CodeSourceAccount } from '../Deployment/CodeSourceAccount.js';
+import { EntityType } from '../EntityType.js';
+import { Flow } from '../Flow/Flow.js';
+import { FlowRun } from '../Flow/FlowRun.js';
+import { Channel } from '../Messaging/Channel/Channel.js';
+import { Subscriber } from '../Messaging/Subscriber.js';
+import { CodeDeploy } from '../Project/CodeDeploy.js';
+import { Project } from '../Project/Project.js';
+import { ProjectEnvironment } from '../Project/ProjectEnvironment.js';
+import { Trigger } from '../Trigger/Trigger.js';
+import { Workspace } from '../Workspace/Workspace.js';
+import { WorkspaceMember } from '../Workspace/WorkspaceMember.js';
+export declare class SearchResult {
+    type: EntityType;
+    label: string;
+    description: string;
+    entity: Workspace | WorkspaceMember | Project | ProjectEnvironment | Flow | FlowRun | Trigger | Channel | Subscriber | Adapter | AdapterConnection | CodeSourceAccount | CodeSource | CodeDeploy;
+    score: number;
+    static parse(rawResult: Record<string, unknown>): SearchResult;
+}

package/dist/Model/Search/SearchResult.js

@@ -0,0 +1,94 @@
+import { Adapter } from '../Adapter/Adapter.js';
+import { AdapterConnection } from '../Adapter/AdapterConnection.js';
+import { CodeSource } from '../Deployment/CodeSource.js';
+import { CodeSourceAccount } from '../Deployment/CodeSourceAccount.js';
+import { EntityType } from '../EntityType.js';
+import { Flow } from '../Flow/Flow.js';
+import { FlowRun } from '../Flow/FlowRun.js';
+import { Channel } from '../Messaging/Channel/Channel.js';
+import { Subscriber } from '../Messaging/Subscriber.js';
+import { CodeDeploy } from '../Project/CodeDeploy.js';
+import { Project } from '../Project/Project.js';
+import { ProjectEnvironment } from '../Project/ProjectEnvironment.js';
+import { Trigger } from '../Trigger/Trigger.js';
+import { Workspace } from '../Workspace/Workspace.js';
+import { WorkspaceMember } from '../Workspace/WorkspaceMember.js';
+export class SearchResult {
+    type;
+    label;
+    description;
+    entity;
+    score;
+    static parse(rawResult) {
+        const searchResult = new SearchResult();
+        searchResult.type = EntityType.fromString(rawResult.entity_type);
+        // searchResult.entity = rawResult.entity;
+        searchResult.label = rawResult.label;
+        searchResult.description = rawResult.description;
+        searchResult.score = rawResult.score;
+        const rawEntity = rawResult.entity;
+        switch (searchResult.type) {
+            case EntityType.Organisation:
+                // TODO: implement
+                searchResult.entity = rawEntity;
+                break;
+            case EntityType.Workspace:
+                searchResult.entity = Workspace.parse(rawEntity);
+                break;
+            case EntityType.Project:
+                searchResult.entity = Project.parse(rawEntity);
+                break;
+            case EntityType.ProjectEnvironment:
+                searchResult.entity = ProjectEnvironment.parse(rawEntity);
+                break;
+            case EntityType.Flow:
+                searchResult.entity = Flow.parse(rawEntity);
+                break;
+            case EntityType.FlowRun:
+                searchResult.entity = FlowRun.parse(rawEntity);
+                break;
+            case EntityType.WorkspaceMember:
+                searchResult.entity = WorkspaceMember.parse(rawEntity);
+                break;
+            case EntityType.Adapter:
+                searchResult.entity = Adapter.parse(rawEntity);
+                break;
+            case EntityType.AdapterConnection:
+                searchResult.entity = AdapterConnection.parse(rawEntity);
+                break;
+            case EntityType.Channel:
+                searchResult.entity = Channel.parse(rawEntity);
+                break;
+            case EntityType.ChannelSubscriber:
+                searchResult.entity = Subscriber.parseRaw(rawEntity);
+                break;
+            case EntityType.Trigger:
+                searchResult.entity = Trigger.parse(rawEntity);
+                break;
+            case EntityType.CodeSourceAccount:
+                searchResult.entity = CodeSourceAccount.parse(rawEntity);
+                break;
+            case EntityType.CodeSource:
+                searchResult.entity = CodeSource.parse(rawEntity);
+                break;
+            case EntityType.CodeSourceDeploy:
+                searchResult.entity = CodeDeploy.parse(rawEntity);
+                break;
+            case EntityType.StorageBucket:
+                // TODO: implement
+                searchResult.entity = rawEntity;
+                break;
+            case EntityType.LogStream:
+                // TODO: implement
+                searchResult.entity = rawEntity;
+                break;
+            case EntityType.RunnerPool:
+                // TODO: implement
+                searchResult.entity = rawEntity;
+                break;
+            default:
+                throw new Error('Unknown search result type "' + searchResult.type + '"');
+        }
+        return searchResult;
+    }
+}

package/dist/Model/State.d.ts

@@ -0,0 +1,8 @@
+export declare enum State {
+    Active = "active",
+    Inactive = "inactive",
+    Removed = "removed"
+}
+export declare namespace State {
+    const fromString: (input: string) => State;
+}

package/dist/Model/State.js

@@ -0,0 +1,16 @@
+import { Utils } from '../Utils.js';
+export var State;
+(function (State) {
+    State["Active"] = "active";
+    State["Inactive"] = "inactive";
+    State["Removed"] = "removed";
+})(State || (State = {}));
+(function (State) {
+    State.fromString = (input) => {
+        const result = Utils.parseEnum(input, State);
+        if (result === null) {
+            throw new Error('Unable to parse State from string: Unknown State "' + input + '"');
+        }
+        return result;
+    };
+})(State || (State = {}));

package/dist/Model/StateAware.d.ts

@@ -0,0 +1,4 @@
+import { State } from './State.js';
+export interface StateAware {
+    state: State;
+}

package/dist/Model/StateAware.js

@@ -0,0 +1 @@
+export {};

package/dist/Model/Storage/StorageInformation.d.ts

@@ -0,0 +1,10 @@
+export declare class StorageInformation {
+    bytes: number;
+    bytes_limit: number | null;
+    items: number;
+    buckets: {
+        name: string;
+        bytes: number;
+        items: number;
+    }[];
+}

package/dist/Model/Storage/StorageInformation.js

@@ -0,0 +1,7 @@
+export class StorageInformation {
+    bytes;
+    // null = explicitly unlimited at some scope in the configuration chain.
+    bytes_limit;
+    items;
+    buckets;
+}

package/dist/Model/Storage/StorageItem.d.ts

@@ -0,0 +1,9 @@
+export declare class StorageItem {
+    key: string;
+    bytes: number;
+    created: Date | null;
+    updated: Date | null;
+    expiration: Date | null;
+    value: string | number | boolean | null | any;
+    static parse(raw: any): StorageItem;
+}

package/dist/Model/Storage/StorageItem.js

@@ -0,0 +1,21 @@
+import { Utils } from '../../Utils.js';
+export class StorageItem {
+    // public id: string | null = null;
+    key;
+    bytes;
+    created;
+    updated;
+    expiration;
+    value;
+    static parse(raw) {
+        const storageItem = new StorageItem();
+        // storageItem.id = raw.id === null || raw.id === undefined ? null : raw.id;
+        storageItem.key = raw.key;
+        storageItem.bytes = raw.bytes;
+        storageItem.value = raw.value;
+        storageItem.created = raw.created === null ? null : Utils.parseRawDate(raw.created);
+        storageItem.updated = raw.updated === null ? null : Utils.parseRawDate(raw.updated);
+        storageItem.expiration = raw.expiration === null ? null : Utils.parseRawDate(raw.expiration);
+        return storageItem;
+    }
+}

package/dist/Model/Storage/StorageItemInformation.d.ts

@@ -0,0 +1,8 @@
+export declare class StorageItemInformation {
+    key: string;
+    bytes: number;
+    created: Date | null;
+    updated: Date | null;
+    expiration: Date | null;
+    static parse(raw: Record<string, unknown>): StorageItemInformation;
+}

package/dist/Model/Storage/StorageItemInformation.js

@@ -0,0 +1,19 @@
+import { Utils } from '../../Utils.js';
+export class StorageItemInformation {
+    // public id: string | null = null;
+    key;
+    bytes;
+    created;
+    updated;
+    expiration;
+    static parse(raw) {
+        const storageItemInformation = new StorageItemInformation();
+        // storageItemInformation.id = raw.id;
+        storageItemInformation.key = raw.key;
+        storageItemInformation.bytes = raw.bytes;
+        storageItemInformation.created = raw.created === null ? null : Utils.parseRawDate(raw.created);
+        storageItemInformation.updated = raw.updated === null ? null : Utils.parseRawDate(raw.updated);
+        storageItemInformation.expiration = raw.expiration === null ? null : Utils.parseRawDate(raw.expiration);
+        return storageItemInformation;
+    }
+}

package/dist/Model/Storage/StorageType.d.ts

@@ -0,0 +1,9 @@
+export declare enum StorageType {
+    Cache = "cache",
+    Persistent = "persistent",
+    Vault = "vault",
+    Infrastructure = "infrastructure"
+}
+export declare namespace StorageType {
+    const fromString: (input: string) => StorageType;
+}

package/dist/Model/Storage/StorageType.js

@@ -0,0 +1,17 @@
+import { Utils } from '../../Utils.js';
+export var StorageType;
+(function (StorageType) {
+    StorageType["Cache"] = "cache";
+    StorageType["Persistent"] = "persistent";
+    StorageType["Vault"] = "vault";
+    StorageType["Infrastructure"] = "infrastructure";
+})(StorageType || (StorageType = {}));
+(function (StorageType) {
+    StorageType.fromString = (input) => {
+        const result = Utils.parseEnum(input, StorageType);
+        if (result === null) {
+            throw new Error('Unable to parse StorageType from string: Unknown StorageType "' + input + '"');
+        }
+        return result;
+    };
+})(StorageType || (StorageType = {}));

package/dist/Model/Trigger/Trigger.d.ts

@@ -0,0 +1,18 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { DataValueCollection } from '../DataValueCollection.js';
+import { ApiRecord } from '../ApiRecord.js';
+export declare class Trigger extends MetaDataAware implements StateAware {
+    id: string;
+    type: string;
+    projectEnvironmentId: string;
+    flowId: string;
+    target: string;
+    arguments: {};
+    data: DataValueCollection;
+    state: State;
+    constructor(id: string, type: string, projectEnvironmentId: string, flowId: string, data: DataValueCollection);
+    static parse(rawTrigger: ApiRecord): Trigger;
+    getData(): DataValueCollection;
+}

package/dist/Model/Trigger/Trigger.js

@@ -0,0 +1,34 @@
+import { State } from '../State.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { DataValueCollection } from '../DataValueCollection.js';
+export class Trigger extends MetaDataAware {
+    id;
+    type;
+    projectEnvironmentId;
+    flowId;
+    target;
+    arguments;
+    data;
+    state = State.Active;
+    constructor(id, type, projectEnvironmentId, flowId, data) {
+        super();
+        this.id = id;
+        this.type = type;
+        this.projectEnvironmentId = projectEnvironmentId;
+        this.flowId = flowId;
+        this.data = data;
+        this.arguments = {};
+    }
+    static parse(rawTrigger) {
+        const flowId = rawTrigger.flow;
+        const parsedData = DataValueCollection.fromObject(rawTrigger.data);
+        const trigger = new Trigger(rawTrigger.id, rawTrigger.type, rawTrigger.project_environment, flowId, parsedData);
+        trigger.target = rawTrigger.target;
+        trigger.arguments = rawTrigger.arguments;
+        trigger.state = State.fromString(rawTrigger.state);
+        return trigger;
+    }
+    getData() {
+        return this.data;
+    }
+}

package/dist/Model/User/User.d.ts

@@ -0,0 +1,18 @@
+import { StateAware } from '../StateAware.js';
+import { State } from '../State.js';
+export declare class User implements StateAware {
+    id: string;
+    name: string;
+    emailIsVerified: boolean;
+    email: string;
+    phone: string;
+    language: string;
+    time_zone: string;
+    locale: string;
+    date_format: string | null;
+    time_format: string | null;
+    number_format: string | null;
+    picture: string;
+    state: State;
+    static parse(rawUser: any): User;
+}

package/dist/Model/User/User.js

@@ -0,0 +1,33 @@
+import { State } from '../State.js';
+export class User {
+    id;
+    name;
+    emailIsVerified;
+    email;
+    phone;
+    language;
+    time_zone;
+    locale;
+    date_format = null;
+    time_format = null;
+    number_format = null;
+    picture;
+    state = State.Active;
+    static parse(rawUser) {
+        const user = new User();
+        user.id = rawUser.id;
+        user.name = rawUser.name;
+        user.email = rawUser.email;
+        user.emailIsVerified = rawUser.email_is_verified;
+        user.phone = rawUser.phone;
+        user.language = rawUser.language;
+        user.time_zone = rawUser.time_zone;
+        user.locale = rawUser.locale;
+        user.date_format = rawUser.date_format;
+        user.time_format = rawUser.time_format;
+        user.number_format = rawUser.number_format;
+        user.picture = rawUser.picture;
+        user.state = State.fromString(rawUser.state);
+        return user;
+    }
+}

package/dist/Model/User/UserAction.d.ts

@@ -0,0 +1,14 @@
+import { DataValueCollection } from '../DataValueCollection.js';
+export declare class UserAction {
+    id: string;
+    userId: string;
+    workspaceId: string;
+    action: string;
+    entityId: string;
+    entityType: string;
+    description: string;
+    ip: string;
+    time: Date;
+    result: string;
+    data: DataValueCollection;
+}

package/dist/Model/User/UserAction.js

@@ -0,0 +1,13 @@
+export class UserAction {
+    id;
+    userId;
+    workspaceId;
+    action;
+    entityId;
+    entityType;
+    description;
+    ip;
+    time;
+    result;
+    data;
+}

package/dist/Model/User/UserActionFilter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Filters for the audit-log list. userIds is multi-value; entityId is a single prefixed entity id;
+ * timeFrom/timeTo bound the action time (inclusive). All optional.
+ */
+export interface UserActionFilter {
+    userIds?: string[];
+    entityId?: string;
+    timeFrom?: Date;
+    timeTo?: Date;
+}

package/dist/Model/User/UserActionFilter.js

@@ -0,0 +1 @@
+export {};

package/dist/Model/User/UserAuthProvider.d.ts

@@ -0,0 +1,12 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+export declare class UserAuthProvider implements StateAware {
+    id: string;
+    userId: string;
+    provider: string;
+    providerUserId: string;
+    providerUserEmail: string;
+    lastUsed: Date | null;
+    state: State;
+    static parse(raw: any): UserAuthProvider;
+}

package/dist/Model/User/UserAuthProvider.js

@@ -0,0 +1,22 @@
+import { State } from '../State.js';
+import { Utils } from '../../Utils.js';
+export class UserAuthProvider {
+    id;
+    userId;
+    provider;
+    providerUserId;
+    providerUserEmail;
+    lastUsed = null;
+    state = State.Active;
+    static parse(raw) {
+        const userAuthProvider = new UserAuthProvider();
+        userAuthProvider.id = raw.id;
+        userAuthProvider.userId = raw.user;
+        userAuthProvider.provider = raw.provider;
+        userAuthProvider.providerUserId = raw.provider_user;
+        userAuthProvider.providerUserEmail = raw.provider_user_email;
+        userAuthProvider.lastUsed = Utils.parseRawDate(raw.last_used);
+        userAuthProvider.state = State.fromString(raw.state);
+        return userAuthProvider;
+    }
+}

package/dist/Model/User/UserNotificationSession.d.ts

@@ -0,0 +1,13 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+export declare class UserNotificationSession implements StateAware {
+    id: string;
+    session: string;
+    subscription: unknown;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt: Date;
+    state: State;
+    os: string;
+    browser: string;
+}

package/dist/Model/User/UserNotificationSession.js

@@ -0,0 +1,11 @@
+export class UserNotificationSession {
+    id;
+    session;
+    subscription;
+    createdAt;
+    updatedAt;
+    expiresAt;
+    state;
+    os;
+    browser;
+}

package/dist/Model/User/UserSummary.d.ts

@@ -0,0 +1,13 @@
+import { State } from '../State.js';
+export type UserSummaryType = 'user' | 'system';
+/**
+ * Display-safe view of a user (no email/PII). Resolved via UserEndpoint.getSummaries().
+ * `state` drives the badge (reuses the global State enum); `null` = not resolvable for this caller.
+ * `displayName` is always safe to show ("System", "Removed user", "Unknown user" for the edge cases).
+ */
+export declare class UserSummary {
+    id: string;
+    type: UserSummaryType;
+    state: State | null;
+    displayName: string;
+}

package/dist/Model/User/UserSummary.js

@@ -0,0 +1,11 @@
+/**
+ * Display-safe view of a user (no email/PII). Resolved via UserEndpoint.getSummaries().
+ * `state` drives the badge (reuses the global State enum); `null` = not resolvable for this caller.
+ * `displayName` is always safe to show ("System", "Removed user", "Unknown user" for the edge cases).
+ */
+export class UserSummary {
+    id;
+    type;
+    state;
+    displayName;
+}

package/dist/Model/Worker/InfrastructureConfiguration.d.ts

@@ -0,0 +1,16 @@
+export declare class InfrastructureConfiguration {
+    static readonly KEY_FLOW_RUN_ENABLED: string;
+    static readonly KEY_FLOW_RUN_VERSION: string;
+    static readonly KEY_FLOW_RUN_WORKER_IMAGE: string;
+    static readonly KEY_FLOW_RUN_WORKER_NAME: string;
+    static readonly KEY_FLOW_RUN_WORKER_SCALE: string;
+    static readonly KEY_FLOW_RUN_WORKER_SCALE_LIMIT: string;
+    static readonly KEY_FLOW_RUN_RUNNER_ENDPOINT: string;
+    static readonly KEY_FLOW_RUN_RUNNER_TOKEN: string;
+    static readonly KEY_FLOW_RUN_CODE_ENDPOINT: string;
+    static readonly KEY_FLOW_RUN_CODE_TOKEN: string;
+    static readonly KEY_FLOW_RUN_WORKER_MEMORY_LIMIT: string;
+    static readonly KEY_FLOW_RUN_WORKER_CPU_LIMIT: string;
+    static readonly KEY_FLOW_RUN_QUEUE_NAME: string;
+    static readonly KEY_FLOW_RUN_QUEUE_SUFFIX: string;
+}

package/dist/Model/Worker/InfrastructureConfiguration.js

@@ -0,0 +1,20 @@
+export class InfrastructureConfiguration {
+    static KEY_FLOW_RUN_ENABLED = 'flow_run_enabled';
+    static KEY_FLOW_RUN_VERSION = 'flow_run_version';
+    static KEY_FLOW_RUN_WORKER_IMAGE = 'flow_run_worker_image';
+    static KEY_FLOW_RUN_WORKER_NAME = 'flow_run_worker_name';
+    static KEY_FLOW_RUN_WORKER_SCALE = 'flow_run_worker_scale';
+    static KEY_FLOW_RUN_WORKER_SCALE_LIMIT = 'flow_run_worker_scale_limit';
+    // Endpoint the runner process itself calls back to
+    static KEY_FLOW_RUN_RUNNER_ENDPOINT = 'flow_run_runner_endpoint';
+    // OAuthAccessTokenId the runner authenticates with
+    static KEY_FLOW_RUN_RUNNER_TOKEN = 'flow_run_runner_token';
+    // Endpoint injected into the customer flow code
+    static KEY_FLOW_RUN_CODE_ENDPOINT = 'flow_run_code_endpoint';
+    // OAuthAccessTokenId injected into the customer flow code
+    static KEY_FLOW_RUN_CODE_TOKEN = 'flow_run_code_token';
+    static KEY_FLOW_RUN_WORKER_MEMORY_LIMIT = 'flow_run_worker_memory_limit';
+    static KEY_FLOW_RUN_WORKER_CPU_LIMIT = 'flow_run_worker_cpu_limit';
+    static KEY_FLOW_RUN_QUEUE_NAME = 'flow_run_queue_name';
+    static KEY_FLOW_RUN_QUEUE_SUFFIX = 'flow_run_queue_suffix';
+}

package/dist/Model/Worker/Platform.d.ts

@@ -0,0 +1,13 @@
+import { State } from '../State.js';
+import { StateAware } from '../StateAware.js';
+export declare class Platform implements StateAware {
+    id: string;
+    name: string;
+    languageId: string;
+    released: Date;
+    endOfSupport: Date;
+    endOfLife: Date;
+    activeImage: string | null;
+    state: State;
+    static parse(raw: any): Platform;
+}

package/dist/Model/Worker/Platform.js

@@ -0,0 +1,24 @@
+import { State } from '../State.js';
+import { Utils } from '../../Utils.js';
+export class Platform {
+    id;
+    name;
+    languageId;
+    released;
+    endOfSupport;
+    endOfLife;
+    activeImage;
+    state = State.Active;
+    static parse(raw) {
+        const platform = new Platform();
+        platform.id = raw.id;
+        platform.name = raw.name;
+        platform.languageId = raw.language;
+        platform.released = Utils.parseRawDate(raw.released);
+        platform.endOfSupport = Utils.parseRawDate(raw.end_of_support);
+        platform.endOfLife = Utils.parseRawDate(raw.end_of_life);
+        platform.activeImage = raw.active_image;
+        platform.state = State.fromString(raw.state);
+        return platform;
+    }
+}