@attlaz/client 1.77.1

package/dist/Service/InboxEndpoint.js

@@ -0,0 +1,20 @@
+import { Endpoint } from './Endpoint.js';
+import { InboxMessage } from '../Model/Inbox/InboxMessage.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+export class InboxEndpoint extends Endpoint {
+    async getAll(pagination = null, unacknowledgedOnly = false) {
+        const queryString = new QueryString('inbox_messages');
+        queryString.set('unacknowledgedOnly', unacknowledgedOnly);
+        queryString.addPagination(pagination);
+        const result = await this.requestCollection(queryString, InboxMessage.parse);
+        return result;
+    }
+    async save(message) {
+        const result = await this.requestObject('/inbox_messages', message, InboxMessage.parse, 'POST');
+        const savedNotification = result.getData();
+        if (savedNotification === null) {
+            throw new Error('Unable to save inbox message: wrong response from API');
+        }
+        return savedNotification;
+    }
+}

package/dist/Service/LogEndpoint.d.ts

@@ -0,0 +1,18 @@
+import { FilterNode } from '../Model/Filter/FilterNode.js';
+import { Log } from '../Model/Log/Log.js';
+import { LogQuery } from '../Model/Log/LogQuery.js';
+import { LogStream } from '../Model/Log/LogStream.js';
+import { LogStreamId } from '../Model/Log/LogStreamId.js';
+import { LogStreamInformation } from '../Model/Log/LogStreamInformation.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class LogEndpoint extends Endpoint {
+    getLogs(logQuery: LogQuery): Promise<CollectionResult<Log>>;
+    getCursoredLogEntries(logStreamId: LogStreamId, pagination: CursorPagination | null, filter: FilterNode | null): Promise<CollectionResult<Log>>;
+    save(log: Log): Promise<Log>;
+    delete(logId: string): Promise<boolean>;
+    clear(logStreamId: LogStreamId): Promise<boolean>;
+    getInformation(logStreamId: LogStreamId): Promise<LogStreamInformation | null>;
+    getByProject(projectId: string, pagination?: CursorPagination | null): Promise<CollectionResult<LogStream>>;
+}

package/dist/Service/LogEndpoint.js

@@ -0,0 +1,127 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Log } from '../Model/Log/Log.js';
+import { LogStream } from '../Model/Log/LogStream.js';
+import { LogStreamId } from '../Model/Log/LogStreamId.js';
+import { LogStreamInformation } from '../Model/Log/LogStreamInformation.js';
+import { Endpoint } from './Endpoint.js';
+export class LogEndpoint extends Endpoint {
+    async getLogs(logQuery) {
+        const arrQuery = [];
+        if (logQuery.limit !== null) {
+            arrQuery.push('limit=' + logQuery.limit);
+        }
+        if (logQuery.startingAfterId !== null) {
+            arrQuery.push('starting_after=' + logQuery.startingAfterId);
+        }
+        // Resolved
+        if (logQuery.hidden !== null && logQuery.hidden !== undefined) {
+            if (logQuery.hidden) {
+                arrQuery.push('hidden=1');
+            }
+            else {
+                arrQuery.push('hidden=0');
+            }
+        }
+        // LogLevels
+        if (logQuery.logLevels !== null && logQuery.logLevels !== undefined && logQuery.logLevels.length > 0) {
+            arrQuery.push('logLevels=' + logQuery.logLevels.join(','));
+        }
+        // Tags
+        if (logQuery.tags !== null && logQuery.tags !== undefined && logQuery.tags.length > 0) {
+            const arrTags = [];
+            // TODO: map this
+            for (const tag of logQuery.tags) {
+                arrTags.push(tag.key + ':' + tag.values);
+            }
+            const strTags = arrTags.join(',');
+            arrQuery.push('tags=' + strTags);
+        }
+        const cmd = '/logstreams/' + logQuery.logStreamId.toString() + '/logs/?' + arrQuery.join('&');
+        const result = await this.requestCollection(cmd, Log.parse);
+        return result;
+    }
+    async getCursoredLogEntries(logStreamId, pagination, filter) {
+        const queryString = new QueryString('/logstreams/' + logStreamId.toString() + '/logs');
+        queryString.addPagination(pagination);
+        if (filter !== null && filter !== undefined) {
+            queryString.set('filter', JSON.stringify(filter));
+        }
+        const result = await this.requestCollection(queryString, Log.parse);
+        return result;
+    }
+    async save(log) {
+        try {
+            const cmd = '/logstreams/' + log.logStream.toString() + '/logs';
+            const result = await this.requestObject(cmd, log, Log.parse, 'POST');
+            const updatedLogEntry = result.getData();
+            if (updatedLogEntry === null) {
+                throw new Error('Log not updated');
+            }
+            return updatedLogEntry;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save log: ', error);
+            }
+            throw error;
+        }
+    }
+    async delete(logId) {
+        const cmd = '/logstreams/:streamId/logs/' + logId;
+        try {
+            const parser = (raw) => ({ deleted: raw.deleted });
+            const result = await this.requestObject(cmd, null, parser, 'DELETE');
+            const re = result.getData();
+            if (re === null) {
+                console.log('delete log entry wrong data', { result, parsed: re });
+                throw new Error('Unable to delete log entry: wrong response from API');
+            }
+            return re.deleted;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save log: ', e);
+            }
+            throw e;
+        }
+    }
+    async clear(logStreamId) {
+        const cmd = '/logstreams/' + logStreamId.toString() + '/clear';
+        try {
+            const parser = (raw) => ({ cleared: raw.cleared });
+            const result = await this.requestObject(cmd, null, parser, 'POST');
+            const re = result.getData();
+            if (re === null) {
+                console.log('Log stream cleared wrong data', { result, parsed: re });
+                throw new Error('Unable to clear log stream: wrong response from API');
+            }
+            return re.cleared;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save log: ', e);
+            }
+            throw e;
+        }
+    }
+    async getInformation(logStreamId) {
+        try {
+            const url = '/logstreams/' + logStreamId.toString() + '/info';
+            const result = await this.requestObject(url, null, LogStreamInformation.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load log stream information: ', error);
+            }
+            throw error;
+        }
+    }
+    async getByProject(projectId, pagination = null) {
+        const queryString = new QueryString('projects/' + projectId + '/logstreams');
+        queryString.addPagination(pagination);
+        const parser = (raw) => new LogStream(new LogStreamId(raw.id), raw.name);
+        const result = await this.requestCollection(queryString, parser);
+        return result;
+    }
+}

package/dist/Service/PlatformEndpoint.d.ts

@@ -0,0 +1,9 @@
+import { Platform } from '../Model/Worker/Platform.js';
+import { PlatformImage } from '../Model/Worker/PlatformImage.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class PlatformEndpoint extends Endpoint {
+    getAll(workspaceId: string | null, pagination: CursorPagination): Promise<CollectionResult<Platform>>;
+    getPlatformImages(workspaceId: string | null, platformId: string, pagination: CursorPagination): Promise<CollectionResult<PlatformImage>>;
+}

package/dist/Service/PlatformEndpoint.js

@@ -0,0 +1,18 @@
+import { Platform } from '../Model/Worker/Platform.js';
+import { PlatformImage } from '../Model/Worker/PlatformImage.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class PlatformEndpoint extends Endpoint {
+    async getAll(workspaceId, pagination) {
+        const qs = new QueryString('/workspaces/' + (workspaceId === null ? 'all' : workspaceId) + '/platforms');
+        qs.addPagination(pagination);
+        const result = await this.requestCollection(qs, Platform.parse);
+        return result;
+    }
+    async getPlatformImages(workspaceId, platformId, pagination) {
+        const qs = new QueryString('/workspaces/' + (workspaceId === null ? 'all' : workspaceId) + '/platforms/' + platformId + '/images');
+        qs.addPagination(pagination);
+        const result = await this.requestCollection(qs, PlatformImage.parse);
+        return result;
+    }
+}

package/dist/Service/PlatformLanguageEndpoint.d.ts

@@ -0,0 +1,6 @@
+import { PlatformLanguage } from '../Model/Project/PlatformLanguage.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class PlatformLanguageEndpoint extends Endpoint {
+    getAll(workspaceId: string): Promise<CollectionResult<PlatformLanguage>>;
+}

package/dist/Service/PlatformLanguageEndpoint.js

@@ -0,0 +1,7 @@
+import { PlatformLanguage } from '../Model/Project/PlatformLanguage.js';
+import { Endpoint } from './Endpoint.js';
+export class PlatformLanguageEndpoint extends Endpoint {
+    async getAll(workspaceId) {
+        return await this.requestCollection('/workspaces/' + workspaceId + '/platforms/languages', PlatformLanguage.parse);
+    }
+}

package/dist/Service/ProjectEndpoint.d.ts

@@ -0,0 +1,11 @@
+import { Project } from '../Model/Project/Project.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { State } from '../Model/State.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class ProjectEndpoint extends Endpoint {
+    getAll(pagination?: CursorPagination | null): Promise<CollectionResult<Project>>;
+    getByWorkspace(workspaceId: string, pagination?: CursorPagination | null, states?: State[] | null): Promise<CollectionResult<Project>>;
+    getById(projectId: string): Promise<Project | null>;
+    save(project: Project): Promise<Project>;
+}

package/dist/Service/ProjectEndpoint.js

@@ -0,0 +1,63 @@
+import { Project } from '../Model/Project/Project.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class ProjectEndpoint extends Endpoint {
+    async getAll(pagination = null) {
+        try {
+            const queryString = new QueryString('/projects');
+            queryString.addPagination(pagination);
+            const result = await this.requestCollection(queryString, Project.parse);
+            return result;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load projects: ' + e);
+            }
+            throw e;
+        }
+    }
+    async getByWorkspace(workspaceId, pagination = null, states = null) {
+        try {
+            const queryString = new QueryString('workspaces/' + workspaceId + '/projects');
+            queryString.addPagination(pagination);
+            queryString.addStateFilter(states);
+            const result = await this.requestCollection(queryString, Project.parse);
+            return result;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load projects: ' + e);
+            }
+            throw e;
+        }
+    }
+    async getById(projectId) {
+        try {
+            const result = await this.requestObject('projects/' + projectId + '', null, Project.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load project by id: ' + error);
+            }
+            throw error;
+        }
+    }
+    async save(project) {
+        try {
+            const url = '/projects';
+            const result = await this.requestObject(url, project, Project.parse, 'POST');
+            const updatedProject = result.getData();
+            if (updatedProject === null) {
+                throw new Error('Project not updated');
+            }
+            return updatedProject;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save project: ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/ProjectEnvironmentEndpoint.d.ts

@@ -0,0 +1,8 @@
+import { ProjectEnvironment } from '../Model/Project/ProjectEnvironment.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class ProjectEnvironmentEndpoint extends Endpoint {
+    getByProject(id: string): Promise<CollectionResult<ProjectEnvironment>>;
+    getById(id: string): Promise<ProjectEnvironment | null>;
+    save(projectEnvironment: ProjectEnvironment): Promise<ProjectEnvironment>;
+}

package/dist/Service/ProjectEnvironmentEndpoint.js

@@ -0,0 +1,48 @@
+import { ProjectEnvironment } from '../Model/Project/ProjectEnvironment.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
+import { Endpoint } from './Endpoint.js';
+export class ProjectEnvironmentEndpoint extends Endpoint {
+    async getByProject(id) {
+        try {
+            const result = await this.requestCollection('/projects/' + id + '/environments', ProjectEnvironment.parse);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load project environments', error);
+            }
+            throw error;
+        }
+    }
+    async getById(id) {
+        try {
+            const rawProjectEnvironment = await this.requestObject('/projectenvironments/' + id + '', null, ProjectEnvironment.parse);
+            return rawProjectEnvironment.getData();
+        }
+        catch (error) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
+                return null;
+            }
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load project environment by id', error);
+            }
+            throw error;
+        }
+    }
+    async save(projectEnvironment) {
+        try {
+            const result = await this.requestObject('projectenvironments/', projectEnvironment, ProjectEnvironment.parse, 'POST');
+            const createdProjectEnvironment = result.getData();
+            if (createdProjectEnvironment === null) {
+                throw new Error('ProjectEnvironment not created');
+            }
+            return createdProjectEnvironment;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save project environment', error, projectEnvironment);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/ProviderTokenEndpoint.d.ts

@@ -0,0 +1,16 @@
+import { ProviderToken } from '../Model/ProviderToken/ProviderToken.js';
+import { ProviderTokenAccessToken } from '../Model/ProviderToken/ProviderTokenAccessToken.js';
+import { Endpoint } from './Endpoint.js';
+export declare class ProviderTokenEndpoint extends Endpoint {
+    getProviderToken(providerTokenId: string): Promise<ProviderToken | null>;
+    getProviderTokenAccessToken(providerTokenId: string): Promise<ProviderTokenAccessToken | null>;
+    /**
+     * Revoke (remove) a provider token. Optionally pass the adapter-connection configuration that holds
+     * this token — the API also unsets that exact (connection, configuration) row when it references this
+     * token, so disconnecting a connection's auth is a single request.
+     */
+    revokeProviderToken(providerTokenId: string, connectionConfiguration?: {
+        connection: string;
+        configuration: string;
+    } | null): Promise<boolean>;
+}

package/dist/Service/ProviderTokenEndpoint.js

@@ -0,0 +1,43 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { ProviderToken } from '../Model/ProviderToken/ProviderToken.js';
+import { ProviderTokenAccessToken } from '../Model/ProviderToken/ProviderTokenAccessToken.js';
+import { Endpoint } from './Endpoint.js';
+export class ProviderTokenEndpoint extends Endpoint {
+    async getProviderToken(providerTokenId) {
+        const queryString = new QueryString('/provider-tokens/' + providerTokenId);
+        const result = await this.requestObject(queryString, null, ProviderToken.parse);
+        return result.getData();
+    }
+    async getProviderTokenAccessToken(providerTokenId) {
+        const queryString = new QueryString('/provider-tokens/' + providerTokenId + '/access-token');
+        const result = await this.requestObject(queryString, null, ProviderTokenAccessToken.parse);
+        return result.getData();
+    }
+    /**
+     * Revoke (remove) a provider token. Optionally pass the adapter-connection configuration that holds
+     * this token — the API also unsets that exact (connection, configuration) row when it references this
+     * token, so disconnecting a connection's auth is a single request.
+     */
+    async revokeProviderToken(providerTokenId, connectionConfiguration = null) {
+        const queryString = new QueryString('/provider-tokens/' + providerTokenId);
+        if (connectionConfiguration !== null) {
+            queryString.set('connection', connectionConfiguration.connection);
+            queryString.set('configuration', connectionConfiguration.configuration);
+        }
+        try {
+            const parser = (raw) => ({ deleted: raw.deleted });
+            const result = await this.requestObject(queryString, null, parser, 'DELETE');
+            const re = result.getData();
+            if (re === null) {
+                throw new Error('Unable to revoke provider token: wrong response from API');
+            }
+            return re.deleted;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to revoke provider token: ', e);
+            }
+            throw e;
+        }
+    }
+}

package/dist/Service/RunnerEndpoint.d.ts

@@ -0,0 +1,6 @@
+import { Endpoint } from './Endpoint.js';
+import { RunnerImage } from '../Model/Runner/RunnerImage.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+export declare class RunnerEndpoint extends Endpoint {
+    getImages(): Promise<CollectionResult<RunnerImage>>;
+}

package/dist/Service/RunnerEndpoint.js

@@ -0,0 +1,28 @@
+import { Endpoint } from './Endpoint.js';
+import { RunnerImage } from '../Model/Runner/RunnerImage.js';
+import { Utils } from '../Utils.js';
+import { State } from '../Model/State.js';
+export class RunnerEndpoint extends Endpoint {
+    async getImages() {
+        const url = '/runners/images';
+        const parser = (rawImage) => {
+            const runnerImage = new RunnerImage();
+            runnerImage.id = rawImage.id;
+            runnerImage.name = rawImage.name;
+            runnerImage.image = rawImage.image;
+            runnerImage.version = rawImage.image;
+            runnerImage.buildDate = Utils.parseRawDate(rawImage.build_date);
+            runnerImage.deprecated = Utils.isTrue(rawImage.deprecated);
+            if (rawImage.end_of_support !== null && rawImage.end_of_support !== undefined) {
+                runnerImage.endOfSupport = Utils.parseRawDate(rawImage.end_of_support);
+            }
+            if (rawImage.end_of_life !== null && rawImage.end_of_life !== undefined) {
+                runnerImage.endOfLife = Utils.parseRawDate(rawImage.end_of_life);
+            }
+            runnerImage.state = State.fromString(rawImage.state);
+            return runnerImage;
+        };
+        const result = await this.requestCollection(url, parser);
+        return result;
+    }
+}

package/dist/Service/RunnerPoolEndpoint.d.ts

@@ -0,0 +1,9 @@
+import { RunnerPool } from '../Model/Infrastructure/RunnerPool.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class RunnerPoolEndpoint extends Endpoint {
+    getByProjectEnvironment(projectEnvironmentId: string, pagination?: CursorPagination | null): Promise<CollectionResult<RunnerPool>>;
+    getById(queueSpecificationId: string): Promise<RunnerPool | null>;
+    redeploy(runnerPoolId: string): Promise<void>;
+}

package/dist/Service/RunnerPoolEndpoint.js

@@ -0,0 +1,20 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { RunnerPool } from '../Model/Infrastructure/RunnerPool.js';
+import { Endpoint } from './Endpoint.js';
+export class RunnerPoolEndpoint extends Endpoint {
+    async getByProjectEnvironment(projectEnvironmentId, pagination = null) {
+        const queryString = new QueryString('/runner-pools/project-environments/' + projectEnvironmentId + '');
+        queryString.addPagination(pagination);
+        const result = await this.requestCollection(queryString, RunnerPool.parse);
+        return result;
+    }
+    async getById(queueSpecificationId) {
+        const queryString = new QueryString('/runner-pools/' + queueSpecificationId);
+        const result = await this.requestObject(queryString, null, RunnerPool.parse);
+        return result.getData();
+    }
+    async redeploy(runnerPoolId) {
+        const queryString = new QueryString('/runner-pools/' + runnerPoolId + '/redeploy');
+        await this.requestObject(queryString, null, (raw) => raw, 'POST');
+    }
+}

package/dist/Service/SearchEndpoint.d.ts

@@ -0,0 +1,6 @@
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { SearchResult } from '../Model/Search/SearchResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class SearchEndpoint extends Endpoint {
+    search(query: string): Promise<CollectionResult<SearchResult>>;
+}

package/dist/Service/SearchEndpoint.js

@@ -0,0 +1,14 @@
+import { SearchResult } from '../Model/Search/SearchResult.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class SearchEndpoint extends Endpoint {
+    async search(query) {
+        if (query.length > 512) {
+            query = query.substring(0, 512);
+        }
+        const qs = new QueryString('search');
+        qs.set('q', query);
+        const result = await this.requestCollection(qs, SearchResult.parse);
+        return result;
+    }
+}

package/dist/Service/SourcesAccountEndpoint.d.ts

@@ -0,0 +1,16 @@
+import { CodeSourceAccount } from '../Model/Deployment/CodeSourceAccount.js';
+import { CodeSource } from '../Model/Deployment/CodeSource.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { SourcesAccountRepository } from '../Model/Deployment/SourcesAccountRepository.js';
+import { SourcesAccountRepositoryBranch } from '../Model/Deployment/SourcesAccountRepositoryBranch.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class SourcesAccountEndpoint extends Endpoint {
+    getAllCodeSources(workspaceId: string, pagination?: CursorPagination | null): Promise<CollectionResult<CodeSource>>;
+    getAllCodeSourceAccounts(workspaceId: string, pagination?: CursorPagination | null): Promise<CollectionResult<CodeSourceAccount>>;
+    getCodeSourceAccountById(id: string): Promise<CodeSourceAccount | null>;
+    getCodeSourceById(codeSourceId: string): Promise<CodeSource | null>;
+    getRepositories(codeSourceAccountId: string, pagination?: CursorPagination | null): Promise<CollectionResult<SourcesAccountRepository>>;
+    getRepositoryBranches(codeSourceAccountId: string, repositoryKey: string, pagination?: CursorPagination | null): Promise<CollectionResult<SourcesAccountRepositoryBranch>>;
+    saveCodeSource(codeSource: CodeSource): Promise<CodeSource>;
+}

package/dist/Service/SourcesAccountEndpoint.js

@@ -0,0 +1,85 @@
+import { CodeSourceAccount } from '../Model/Deployment/CodeSourceAccount.js';
+import { CodeSource } from '../Model/Deployment/CodeSource.js';
+import { SourcesAccountRepository } from '../Model/Deployment/SourcesAccountRepository.js';
+import { SourcesAccountRepositoryBranch } from '../Model/Deployment/SourcesAccountRepositoryBranch.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
+import { Endpoint } from './Endpoint.js';
+export class SourcesAccountEndpoint extends Endpoint {
+    async getAllCodeSources(workspaceId, pagination = null) {
+        const queryString = new QueryString('workspaces/' + workspaceId + '/codesources');
+        queryString.addPagination(pagination);
+        const result = await this.requestCollection(queryString, CodeSource.parse);
+        return result;
+    }
+    async getAllCodeSourceAccounts(workspaceId, pagination = null) {
+        const queryString = new QueryString('workspaces/' + workspaceId + '/codesourceaccounts');
+        queryString.addPagination(pagination);
+        const result = await this.requestCollection(queryString, CodeSourceAccount.parse);
+        return result;
+    }
+    async getCodeSourceAccountById(id) {
+        try {
+            const rawSourcesAccounts = await this.requestObject('codesourceaccounts/' + id, null, CodeSourceAccount.parse);
+            return rawSourcesAccounts.getData();
+        }
+        catch (error) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
+                return null;
+            }
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load code source account by id', error);
+            }
+            throw error;
+        }
+        // let sourcesAccounts: CodeSourceAccount[] = [];
+        // for (let rawSourcesAccount of rawSourcesAccounts) {
+        //     sourcesAccounts.push(CodeSourceAccount.parse(rawSourcesAccount));
+        // }
+        // return sourcesAccounts;
+    }
+    async getCodeSourceById(codeSourceId) {
+        try {
+            const result = await this.requestObject('/codesources/' + codeSourceId, null, CodeSource.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
+                return null;
+            }
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load code source by id', error);
+            }
+            throw error;
+        }
+    }
+    async getRepositories(codeSourceAccountId, pagination = null) {
+        const queryString = new QueryString('codesourceaccounts/' + codeSourceAccountId + '/repositories');
+        queryString.addPagination(pagination);
+        const rawSourcesAccountRepositories = await this.requestCollection(queryString, SourcesAccountRepository.parse);
+        return rawSourcesAccountRepositories;
+    }
+    async getRepositoryBranches(codeSourceAccountId, repositoryKey, pagination = null) {
+        const queryString = new QueryString('codesourceaccounts/' + codeSourceAccountId + '/repositories/' + repositoryKey + '/branches');
+        queryString.addPagination(pagination);
+        const rawBranches = await this.requestCollection(queryString, SourcesAccountRepositoryBranch.parse);
+        return rawBranches;
+    }
+    async saveCodeSource(codeSource) {
+        try {
+            const url = '/codesources/';
+            const result = await this.requestObject(url, codeSource, CodeSource.parse, 'POST');
+            const updatedCodeSource = result.getData();
+            if (updatedCodeSource === null) {
+                throw new Error('Unable to update code source: wrong response from API');
+            }
+            return updatedCodeSource;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save code source: ', ex);
+            }
+            throw ex;
+        }
+    }
+}

package/dist/Service/StorageEndpoint.d.ts

@@ -0,0 +1,20 @@
+import { StorageType } from '../Model/Storage/StorageType.js';
+import { StorageInformation } from '../Model/Storage/StorageInformation.js';
+import { StorageItem } from '../Model/Storage/StorageItem.js';
+import { StorageItemInformation } from '../Model/Storage/StorageItemInformation.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Endpoint } from './Endpoint.js';
+export declare class StorageEndpoint extends Endpoint {
+    getInformation(projectEnvironmentId: string, storageType: StorageType): Promise<StorageInformation | null>;
+    clearBucket(projectEnvironmentId: string, storageType: StorageType, bucketKey: string): Promise<boolean>;
+    getBucketItemsInformation(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, pagination?: CursorPagination | null): Promise<CollectionResult<StorageItemInformation>>;
+    /** @deprecated Renamed to getBucketItemsInformation. Kept for backwards compatibility. */
+    getPoolItemsInformation(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, pagination?: CursorPagination | null): Promise<CollectionResult<StorageItemInformation>>;
+    /** @deprecated Renamed to clearBucket. Kept for backwards compatibility. */
+    clearPool(projectEnvironmentId: string, storageType: StorageType, bucketKey: string): Promise<boolean>;
+    getItem(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItemKey: string): Promise<StorageItem | null>;
+    getBucketItem(storageBucketId: string, storageItemKey: string): Promise<StorageItem | null>;
+    setItem(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItem: StorageItem): Promise<StorageItem>;
+    deleteItem(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItemKey: string): Promise<boolean>;
+}