@abyss-project/workspace 0.0.0-stage → 1.0.0

package/src/index.ts

@@ -0,0 +1,630 @@
+import axios from 'axios';
+import axiosRetry, { IAxiosRetryConfig, isNetworkOrIdempotentRequestError } from 'axios-retry';
+import * as abyssAdminApi from './api/abyss.admin.api';
+import * as boardApi from './api/board.api';
+import * as boardColumnApi from './api/board-column.api';
+import * as boardCardApi from './api/board-card.api';
+import * as boardLabelApi from './api/board-label.api';
+import * as boardCardCommentApi from './api/board-card-comment.api';
+import * as boardCardChecklistApi from './api/board-card-checklist.api';
+import * as boardCardDocumentApi from './api/board-card-document.api';
+import * as boardCardLinkApi from './api/board-card-link.api';
+import * as drawApi from './api/draw.api';
+import * as drawPublicApi from './api/draw.public.api';
+import * as drawImageApi from './api/draw-image.api';
+import * as retrospectiveApi from './api/retrospective.api';
+import * as retrospectiveCardApi from './api/retrospective-card.api';
+import * as retrospectiveActionApi from './api/retrospective-action.api';
+import * as retrospectiveMemberApi from './api/retrospective-member.api';
+import * as retrospectiveSectionApi from './api/retrospective-section.api';
+import * as retrospectivePublicApi from './api/retrospective.public.api';
+import * as atlasApi from './api/atlas.api';
+import * as atlasGroupApi from './api/atlas-group.api';
+import * as atlasPageApi from './api/atlas-page.api';
+import * as atlasDocumentApi from './api/atlas-document.api';
+import * as atlasPublicApi from './api/atlas.public.api';
+import * as shortLinkApiModule from './api/short-link.api';
+import * as shortLinkAdminApiModule from './api/short-link.admin.api';
+import * as shortLinkPublicApiModule from './api/short-link.public.api';
+import * as metricsApi from './api/metrics.api';
+import * as organizationApi from './api/organization.api';
+import * as tagApi from './api/tag.api';
+import * as monitorApi from './api/monitor.api';
+
+export * from './api';
+export * from './types';
+export * from './utils';
+export * from './constants';
+export * from './server-sent-events';
+
+const DEFAULT_BASE_URL = 'https://workspace-api.abyss-project.fr/api/';
+
+export const API_KEY_HEADER = 'abyss-api-key';
+export const ADMIN_TOKEN_HEADER = 'abyss-admin-token';
+
+const NUMBER_RETRY_API = 10;
+const BASE_DELAY_BETWEEN_RETRY = 5000;
+const RETRY_CODES = [
+  502, // Bad Gateway
+  503, // Service Unavailable
+];
+
+type CoreConfig = {
+  token?: string;
+  apiKey?: string;
+  adminToken?: string;
+  baseURL?: string;
+};
+
+type AbyssWorkspaceCoreSDK = {
+  abyss: {
+    admin: {
+      activateUserService: typeof abyssAdminApi.activateUserServiceAbyssAdmin;
+      syncOrganization: typeof abyssAdminApi.syncOrganizationAbyssAdmin;
+      syncProject: typeof abyssAdminApi.syncProjectAbyssAdmin;
+      getProjectContentSummary: typeof abyssAdminApi.getProjectContentSummary;
+    };
+  };
+  board: {
+    get: typeof boardApi.getBoard;
+    getBySlug: typeof boardApi.getBySlugBoard;
+    list: typeof boardApi.listBoard;
+    listProject: typeof boardApi.listBoardProject;
+    listOrganization: typeof boardApi.listBoardOrganization;
+    paginateOrganization: typeof boardApi.paginateOrganizationBoard;
+    delete: typeof boardApi.deleteBoard;
+    update: typeof boardApi.updateBoard;
+    create: typeof boardApi.createBoard;
+    createForOrganization: typeof boardApi.createForOrganizationBoard;
+    getNextCardPreview: typeof boardApi.getNextCardPreviewBoard;
+    transfer: typeof boardApi.transferBoard;
+    countOrganization: typeof boardApi.countOrganizationBoard;
+  };
+  boardColumn: {
+    get: typeof boardColumnApi.getBoardColumn;
+    delete: typeof boardColumnApi.deleteBoardColumn;
+    update: typeof boardColumnApi.updateBoardColumn;
+    create: typeof boardColumnApi.createBoardColumn;
+  };
+  boardCard: {
+    get: typeof boardCardApi.getBoardCard;
+    getAll: typeof boardCardApi.getAllBoardCard;
+    delete: typeof boardCardApi.deleteBoardCard;
+    update: typeof boardCardApi.updateBoardCard;
+    restore: typeof boardCardApi.restoreBoardCard;
+    create: typeof boardCardApi.createBoardCard;
+    addMember: typeof boardCardApi.addMemberBoardCard;
+    removeMember: typeof boardCardApi.removeMemberBoardCard;
+    moveToBoard: typeof boardCardApi.moveToBoardBoardCard;
+    search: typeof boardCardApi.searchBoardCard;
+  };
+  boardLabel: {
+    get: typeof boardLabelApi.getBoardLabel;
+    delete: typeof boardLabelApi.deleteBoardLabel;
+    update: typeof boardLabelApi.updateBoardLabel;
+    create: typeof boardLabelApi.createBoardLabel;
+    add: typeof boardLabelApi.addBoardLabel;
+    remove: typeof boardLabelApi.removeBoardLabel;
+    list: typeof boardLabelApi.listBoardLabels;
+  };
+  boardCardComment: {
+    get: typeof boardCardCommentApi.getBoardCardComment;
+    delete: typeof boardCardCommentApi.deleteBoardCardComment;
+    update: typeof boardCardCommentApi.updateBoardCardComment;
+    create: typeof boardCardCommentApi.createBoardCardComment;
+  };
+  boardCardChecklist: {
+    get: typeof boardCardChecklistApi.getBoardCardChecklist;
+    delete: typeof boardCardChecklistApi.deleteBoardCardChecklist;
+    update: typeof boardCardChecklistApi.updateBoardCardChecklist;
+    create: typeof boardCardChecklistApi.createBoardCardChecklist;
+    addRow: typeof boardCardChecklistApi.addRowBoardCardChecklist;
+    removeRow: typeof boardCardChecklistApi.removeRowBoardCardChecklist;
+    updateRow: typeof boardCardChecklistApi.updateRowBoardCardChecklist;
+  };
+  boardCardDocument: {
+    get: typeof boardCardDocumentApi.getBoardCardDocument;
+    delete: typeof boardCardDocumentApi.deleteBoardCardDocument;
+    getUploadPreSignedUrl: typeof boardCardDocumentApi.getUploadPreSignedUrlBoardCardDocument;
+    cloudImport: typeof boardCardDocumentApi.cloudImportBoardCardDocument;
+  };
+  boardCardLink: {
+    create: typeof boardCardLinkApi.createBoardCardLink;
+    delete: typeof boardCardLinkApi.deleteBoardCardLink;
+    list: typeof boardCardLinkApi.listBoardCardLink;
+    backlinks: typeof boardCardLinkApi.backlinksBoardCardLink;
+  };
+  draw: {
+    paginate: typeof drawApi.paginateDraw;
+    paginateProject: typeof drawApi.paginateProjectDraw;
+    paginateOrganization: typeof drawApi.paginateOrganizationDraw;
+    get: typeof drawApi.getDraw;
+    delete: typeof drawApi.deleteDraw;
+    update: typeof drawApi.updateDraw;
+    create: typeof drawApi.createDraw;
+    createForOrganization: typeof drawApi.createForOrganizationDraw;
+    transfer: typeof drawApi.transferDraw;
+    countOrganization: typeof drawApi.countOrganizationDraw;
+    image: {
+      getUploadSession: typeof drawImageApi.getUploadSessionDrawImage;
+      get: typeof drawImageApi.getDrawImage;
+    };
+    public: {
+      get: typeof drawPublicApi.getDrawPublic;
+      delete: typeof drawPublicApi.deleteDrawPublic;
+      update: typeof drawPublicApi.updateDrawPublic;
+      create: typeof drawPublicApi.createDrawPublic;
+      image: {
+        getUploadSession: typeof drawImageApi.getUploadSessionDrawImagePublic;
+        get: typeof drawImageApi.getDrawImagePublic;
+      };
+    };
+  };
+  retrospective: {
+    get: typeof retrospectiveApi.getRetrospective;
+    paginateProject: typeof retrospectiveApi.paginateProjectRetrospective;
+    paginateOrganization: typeof retrospectiveApi.paginateOrganizationRetrospective;
+    paginate: typeof retrospectiveApi.paginateRetrospective;
+    create: typeof retrospectiveApi.createRetrospective;
+    createForOrganization: typeof retrospectiveApi.createForOrganizationRetrospective;
+    update: typeof retrospectiveApi.updateRetrospective;
+    updatePhase: typeof retrospectiveApi.updateRetrospectivePhase;
+    delete: typeof retrospectiveApi.deleteRetrospective;
+    transfer: typeof retrospectiveApi.transferRetrospective;
+    countOrganization: typeof retrospectiveApi.countOrganizationRetrospective;
+    public: {
+      get: typeof retrospectivePublicApi.getRetrospectivePublic;
+      update: typeof retrospectivePublicApi.updateRetrospectivePublic;
+      createSection: typeof retrospectivePublicApi.createSectionRetrospectivePublic;
+      updateSection: typeof retrospectivePublicApi.updateSectionRetrospectivePublic;
+      deleteSection: typeof retrospectivePublicApi.deleteSectionRetrospectivePublic;
+      joinMember: typeof retrospectivePublicApi.joinMemberRetrospectivePublic;
+      updateMember: typeof retrospectivePublicApi.updateMemberRetrospectivePublic;
+      createCard: typeof retrospectivePublicApi.createCardRetrospectivePublic;
+      updateCard: typeof retrospectivePublicApi.updateCardRetrospectivePublic;
+      deleteCard: typeof retrospectivePublicApi.deleteCardRetrospectivePublic;
+      addCardVote: typeof retrospectivePublicApi.addCardVoteRetrospectivePublic;
+      removeCardVote: typeof retrospectivePublicApi.removeCardVoteRetrospectivePublic;
+      createAction: typeof retrospectivePublicApi.createActionRetrospectivePublic;
+      updateAction: typeof retrospectivePublicApi.updateActionRetrospectivePublic;
+      deleteAction: typeof retrospectivePublicApi.deleteActionRetrospectivePublic;
+    };
+  };
+  retrospectiveCard: {
+    get: typeof retrospectiveCardApi.getRetrospectiveCard;
+    paginate: typeof retrospectiveCardApi.paginateRetrospectiveCard;
+    create: typeof retrospectiveCardApi.createRetrospectiveCard;
+    update: typeof retrospectiveCardApi.updateRetrospectiveCard;
+    delete: typeof retrospectiveCardApi.deleteRetrospectiveCard;
+    addVote: typeof retrospectiveCardApi.addRetrospectiveCardVote;
+    removeVote: typeof retrospectiveCardApi.removeRetrospectiveCardVote;
+  };
+  retrospectiveAction: {
+    create: typeof retrospectiveActionApi.createRetrospectiveAction;
+    update: typeof retrospectiveActionApi.updateRetrospectiveAction;
+    delete: typeof retrospectiveActionApi.deleteRetrospectiveAction;
+  };
+  retrospectiveMember: {
+    get: typeof retrospectiveMemberApi.getRetrospectiveMember;
+    list: typeof retrospectiveMemberApi.listRetrospectiveMember;
+    join: typeof retrospectiveMemberApi.joinRetrospectiveMember;
+    update: typeof retrospectiveMemberApi.updateRetrospectiveMember;
+  };
+  retrospectiveSection: {
+    get: typeof retrospectiveSectionApi.getRetrospectiveSection;
+    paginate: typeof retrospectiveSectionApi.paginateRetrospectiveSection;
+    create: typeof retrospectiveSectionApi.createRetrospectiveSection;
+    update: typeof retrospectiveSectionApi.updateRetrospectiveSection;
+    delete: typeof retrospectiveSectionApi.deleteRetrospectiveSection;
+  };
+  atlas: {
+    paginate: typeof atlasApi.paginateAtlas;
+    paginateProject: typeof atlasApi.paginateProjectAtlas;
+    paginateOrganization: typeof atlasApi.paginateOrganizationAtlas;
+    get: typeof atlasApi.getAtlas;
+    delete: typeof atlasApi.deleteAtlas;
+    update: typeof atlasApi.updateAtlas;
+    create: typeof atlasApi.createAtlas;
+    createForOrganization: typeof atlasApi.createForOrganizationAtlas;
+    transfer: typeof atlasApi.transferAtlas;
+    countOrganization: typeof atlasApi.countOrganizationAtlas;
+    public: {
+      get: typeof atlasPublicApi.getAtlasPublic;
+      getPage: typeof atlasPublicApi.getPageAtlasPublic;
+      searchContent: typeof atlasPublicApi.searchContentAtlasPublic;
+    };
+  };
+  atlasGroup: {
+    paginate: typeof atlasGroupApi.paginateAtlasGroup;
+    get: typeof atlasGroupApi.getAtlasGroup;
+    delete: typeof atlasGroupApi.deleteAtlasGroup;
+    update: typeof atlasGroupApi.updateAtlasGroup;
+    create: typeof atlasGroupApi.createAtlasGroup;
+  };
+  atlasPage: {
+    paginate: typeof atlasPageApi.paginateAtlasPage;
+    get: typeof atlasPageApi.getAtlasPage;
+    delete: typeof atlasPageApi.deleteAtlasPage;
+    update: typeof atlasPageApi.updateAtlasPage;
+    create: typeof atlasPageApi.createAtlasPage;
+    duplicate: typeof atlasPageApi.duplicateAtlasPage;
+    updateContent: typeof atlasPageApi.updateAtlasPageContent;
+    searchContent: typeof atlasPageApi.searchAtlasContent;
+    getContentHistory: typeof atlasPageApi.getAtlasPageContentHistory;
+    restoreContent: typeof atlasPageApi.restoreAtlasPageContent;
+  };
+  atlasDocument: {
+    get: typeof atlasDocumentApi.getAtlasDocument;
+    delete: typeof atlasDocumentApi.deleteAtlasDocument;
+    getUploadPreSignedUrl: typeof atlasDocumentApi.getUploadPreSignedUrlAtlasDocument;
+    paginate: typeof atlasDocumentApi.paginateAtlasDocument;
+    list: typeof atlasDocumentApi.listAtlasDocument;
+    getPublicAccessId: typeof atlasDocumentApi.getPublicAccessIdAtlasDocument;
+  };
+  shortLink: {
+    get: typeof shortLinkApiModule.shortLinkApi.get;
+    paginate: typeof shortLinkApiModule.shortLinkApi.paginate;
+    paginateProject: typeof shortLinkApiModule.shortLinkApi.paginateProject;
+    paginateOrganization: typeof shortLinkApiModule.shortLinkApi.paginateOrganization;
+    create: typeof shortLinkApiModule.shortLinkApi.create;
+    createForOrganization: typeof shortLinkApiModule.shortLinkApi.createForOrganization;
+    update: typeof shortLinkApiModule.shortLinkApi.update;
+    delete: typeof shortLinkApiModule.shortLinkApi.delete;
+    getStats: typeof shortLinkApiModule.shortLinkApi.getStats;
+    getClicks: typeof shortLinkApiModule.shortLinkApi.getClicks;
+    transfer: typeof shortLinkApiModule.shortLinkApi.transfer;
+    countOrganization: typeof shortLinkApiModule.shortLinkApi.countOrganization;
+    admin: {
+      paginate: typeof shortLinkAdminApiModule.shortLinkAdminApi.paginate;
+      get: typeof shortLinkAdminApiModule.shortLinkAdminApi.get;
+      getCampaignStats: typeof shortLinkAdminApiModule.shortLinkAdminApi.getCampaignStats;
+      setProtection: typeof shortLinkAdminApiModule.shortLinkAdminApi.setProtection;
+      update: typeof shortLinkAdminApiModule.shortLinkAdminApi.update;
+      delete: typeof shortLinkAdminApiModule.shortLinkAdminApi.delete;
+    };
+    public: {
+      createAnonymous: typeof shortLinkPublicApiModule.shortLinkPublicApi.createAnonymous;
+      redirect: typeof shortLinkPublicApiModule.shortLinkPublicApi.redirect;
+      getStats: typeof shortLinkPublicApiModule.shortLinkPublicApi.getStats;
+      getClicks: typeof shortLinkPublicApiModule.shortLinkPublicApi.getClicks;
+      renew: typeof shortLinkPublicApiModule.shortLinkPublicApi.renew;
+    };
+  };
+  metrics: {
+    getOrganization: typeof metricsApi.getOrganizationWorkspaceMetrics;
+    getProject: typeof metricsApi.getProjectWorkspaceMetrics;
+  };
+  monitor: {
+    up: typeof monitorApi.upMonitor;
+  };
+  tag: {
+    list: typeof tagApi.listTag;
+    create: typeof tagApi.createTag;
+    update: typeof tagApi.updateTag;
+    delete: typeof tagApi.deleteTag;
+    assign: typeof tagApi.assignTag;
+    unassign: typeof tagApi.unassignTag;
+    getStats: typeof tagApi.getTagStats;
+    getEntityTags: typeof tagApi.getEntityTags;
+  };
+  organization: {
+    recent: typeof organizationApi.recentOrganization;
+  };
+};
+
+export class AbyssWorkspaceCore {
+  private static config = {
+    token: '',
+    apiKey: '',
+    adminToken: '',
+    baseURL: DEFAULT_BASE_URL,
+  };
+  static axios = axios.create({
+    baseURL: this.config.baseURL,
+    withCredentials: true,
+  });
+
+  private static _sdk: AbyssWorkspaceCoreSDK | null = null;
+
+  public static get sdk(): AbyssWorkspaceCoreSDK {
+    if (!AbyssWorkspaceCore._sdk) {
+      AbyssWorkspaceCore._sdk = AbyssWorkspaceCore.buildSDK();
+    }
+    return AbyssWorkspaceCore._sdk;
+  }
+
+  private static buildSDK(): AbyssWorkspaceCoreSDK {
+    return {
+      abyss: {
+        admin: {
+          activateUserService: abyssAdminApi.activateUserServiceAbyssAdmin,
+          syncOrganization: abyssAdminApi.syncOrganizationAbyssAdmin,
+          syncProject: abyssAdminApi.syncProjectAbyssAdmin,
+          getProjectContentSummary: abyssAdminApi.getProjectContentSummary,
+        },
+      },
+      board: {
+        get: boardApi.getBoard,
+        getBySlug: boardApi.getBySlugBoard,
+        list: boardApi.listBoard,
+        listProject: boardApi.listBoardProject,
+        listOrganization: boardApi.listBoardOrganization,
+        paginateOrganization: boardApi.paginateOrganizationBoard,
+        delete: boardApi.deleteBoard,
+        update: boardApi.updateBoard,
+        create: boardApi.createBoard,
+        createForOrganization: boardApi.createForOrganizationBoard,
+        getNextCardPreview: boardApi.getNextCardPreviewBoard,
+        transfer: boardApi.transferBoard,
+        countOrganization: boardApi.countOrganizationBoard,
+      },
+      boardColumn: {
+        get: boardColumnApi.getBoardColumn,
+        delete: boardColumnApi.deleteBoardColumn,
+        update: boardColumnApi.updateBoardColumn,
+        create: boardColumnApi.createBoardColumn,
+      },
+      boardCard: {
+        get: boardCardApi.getBoardCard,
+        getAll: boardCardApi.getAllBoardCard,
+        delete: boardCardApi.deleteBoardCard,
+        update: boardCardApi.updateBoardCard,
+        restore: boardCardApi.restoreBoardCard,
+        create: boardCardApi.createBoardCard,
+        addMember: boardCardApi.addMemberBoardCard,
+        removeMember: boardCardApi.removeMemberBoardCard,
+        moveToBoard: boardCardApi.moveToBoardBoardCard,
+        search: boardCardApi.searchBoardCard,
+      },
+      boardLabel: {
+        get: boardLabelApi.getBoardLabel,
+        delete: boardLabelApi.deleteBoardLabel,
+        update: boardLabelApi.updateBoardLabel,
+        create: boardLabelApi.createBoardLabel,
+        add: boardLabelApi.addBoardLabel,
+        remove: boardLabelApi.removeBoardLabel,
+        list: boardLabelApi.listBoardLabels,
+      },
+      boardCardComment: {
+        get: boardCardCommentApi.getBoardCardComment,
+        delete: boardCardCommentApi.deleteBoardCardComment,
+        update: boardCardCommentApi.updateBoardCardComment,
+        create: boardCardCommentApi.createBoardCardComment,
+      },
+      boardCardChecklist: {
+        get: boardCardChecklistApi.getBoardCardChecklist,
+        delete: boardCardChecklistApi.deleteBoardCardChecklist,
+        update: boardCardChecklistApi.updateBoardCardChecklist,
+        create: boardCardChecklistApi.createBoardCardChecklist,
+        addRow: boardCardChecklistApi.addRowBoardCardChecklist,
+        removeRow: boardCardChecklistApi.removeRowBoardCardChecklist,
+        updateRow: boardCardChecklistApi.updateRowBoardCardChecklist,
+      },
+      boardCardDocument: {
+        get: boardCardDocumentApi.getBoardCardDocument,
+        delete: boardCardDocumentApi.deleteBoardCardDocument,
+        getUploadPreSignedUrl: boardCardDocumentApi.getUploadPreSignedUrlBoardCardDocument,
+        cloudImport: boardCardDocumentApi.cloudImportBoardCardDocument,
+      },
+      boardCardLink: {
+        create: boardCardLinkApi.createBoardCardLink,
+        delete: boardCardLinkApi.deleteBoardCardLink,
+        list: boardCardLinkApi.listBoardCardLink,
+        backlinks: boardCardLinkApi.backlinksBoardCardLink,
+      },
+      draw: {
+        paginate: drawApi.paginateDraw,
+        paginateProject: drawApi.paginateProjectDraw,
+        paginateOrganization: drawApi.paginateOrganizationDraw,
+        get: drawApi.getDraw,
+        delete: drawApi.deleteDraw,
+        update: drawApi.updateDraw,
+        create: drawApi.createDraw,
+        createForOrganization: drawApi.createForOrganizationDraw,
+        transfer: drawApi.transferDraw,
+        countOrganization: drawApi.countOrganizationDraw,
+        image: {
+          getUploadSession: drawImageApi.getUploadSessionDrawImage,
+          get: drawImageApi.getDrawImage,
+        },
+        public: {
+          get: drawPublicApi.getDrawPublic,
+          delete: drawPublicApi.deleteDrawPublic,
+          update: drawPublicApi.updateDrawPublic,
+          create: drawPublicApi.createDrawPublic,
+          image: {
+            getUploadSession: drawImageApi.getUploadSessionDrawImagePublic,
+            get: drawImageApi.getDrawImagePublic,
+          },
+        },
+      },
+      retrospective: {
+        get: retrospectiveApi.getRetrospective,
+        paginateProject: retrospectiveApi.paginateProjectRetrospective,
+        paginateOrganization: retrospectiveApi.paginateOrganizationRetrospective,
+        paginate: retrospectiveApi.paginateRetrospective,
+        create: retrospectiveApi.createRetrospective,
+        createForOrganization: retrospectiveApi.createForOrganizationRetrospective,
+        update: retrospectiveApi.updateRetrospective,
+        updatePhase: retrospectiveApi.updateRetrospectivePhase,
+        delete: retrospectiveApi.deleteRetrospective,
+        transfer: retrospectiveApi.transferRetrospective,
+        countOrganization: retrospectiveApi.countOrganizationRetrospective,
+        public: {
+          get: retrospectivePublicApi.getRetrospectivePublic,
+          update: retrospectivePublicApi.updateRetrospectivePublic,
+          createSection: retrospectivePublicApi.createSectionRetrospectivePublic,
+          updateSection: retrospectivePublicApi.updateSectionRetrospectivePublic,
+          deleteSection: retrospectivePublicApi.deleteSectionRetrospectivePublic,
+          joinMember: retrospectivePublicApi.joinMemberRetrospectivePublic,
+          updateMember: retrospectivePublicApi.updateMemberRetrospectivePublic,
+          createCard: retrospectivePublicApi.createCardRetrospectivePublic,
+          updateCard: retrospectivePublicApi.updateCardRetrospectivePublic,
+          deleteCard: retrospectivePublicApi.deleteCardRetrospectivePublic,
+          addCardVote: retrospectivePublicApi.addCardVoteRetrospectivePublic,
+          removeCardVote: retrospectivePublicApi.removeCardVoteRetrospectivePublic,
+          createAction: retrospectivePublicApi.createActionRetrospectivePublic,
+          updateAction: retrospectivePublicApi.updateActionRetrospectivePublic,
+          deleteAction: retrospectivePublicApi.deleteActionRetrospectivePublic,
+        },
+      },
+      retrospectiveCard: {
+        get: retrospectiveCardApi.getRetrospectiveCard,
+        paginate: retrospectiveCardApi.paginateRetrospectiveCard,
+        create: retrospectiveCardApi.createRetrospectiveCard,
+        update: retrospectiveCardApi.updateRetrospectiveCard,
+        delete: retrospectiveCardApi.deleteRetrospectiveCard,
+        addVote: retrospectiveCardApi.addRetrospectiveCardVote,
+        removeVote: retrospectiveCardApi.removeRetrospectiveCardVote,
+      },
+      retrospectiveAction: {
+        create: retrospectiveActionApi.createRetrospectiveAction,
+        update: retrospectiveActionApi.updateRetrospectiveAction,
+        delete: retrospectiveActionApi.deleteRetrospectiveAction,
+      },
+      retrospectiveMember: {
+        get: retrospectiveMemberApi.getRetrospectiveMember,
+        list: retrospectiveMemberApi.listRetrospectiveMember,
+        join: retrospectiveMemberApi.joinRetrospectiveMember,
+        update: retrospectiveMemberApi.updateRetrospectiveMember,
+      },
+      retrospectiveSection: {
+        get: retrospectiveSectionApi.getRetrospectiveSection,
+        paginate: retrospectiveSectionApi.paginateRetrospectiveSection,
+        create: retrospectiveSectionApi.createRetrospectiveSection,
+        update: retrospectiveSectionApi.updateRetrospectiveSection,
+        delete: retrospectiveSectionApi.deleteRetrospectiveSection,
+      },
+      atlas: {
+        paginate: atlasApi.paginateAtlas,
+        paginateProject: atlasApi.paginateProjectAtlas,
+        paginateOrganization: atlasApi.paginateOrganizationAtlas,
+        get: atlasApi.getAtlas,
+        delete: atlasApi.deleteAtlas,
+        update: atlasApi.updateAtlas,
+        create: atlasApi.createAtlas,
+        createForOrganization: atlasApi.createForOrganizationAtlas,
+        transfer: atlasApi.transferAtlas,
+        countOrganization: atlasApi.countOrganizationAtlas,
+        public: {
+          get: atlasPublicApi.getAtlasPublic,
+          getPage: atlasPublicApi.getPageAtlasPublic,
+          searchContent: atlasPublicApi.searchContentAtlasPublic,
+        },
+      },
+      atlasGroup: {
+        paginate: atlasGroupApi.paginateAtlasGroup,
+        get: atlasGroupApi.getAtlasGroup,
+        delete: atlasGroupApi.deleteAtlasGroup,
+        update: atlasGroupApi.updateAtlasGroup,
+        create: atlasGroupApi.createAtlasGroup,
+      },
+      atlasPage: {
+        paginate: atlasPageApi.paginateAtlasPage,
+        get: atlasPageApi.getAtlasPage,
+        delete: atlasPageApi.deleteAtlasPage,
+        update: atlasPageApi.updateAtlasPage,
+        create: atlasPageApi.createAtlasPage,
+        duplicate: atlasPageApi.duplicateAtlasPage,
+        updateContent: atlasPageApi.updateAtlasPageContent,
+        searchContent: atlasPageApi.searchAtlasContent,
+        getContentHistory: atlasPageApi.getAtlasPageContentHistory,
+        restoreContent: atlasPageApi.restoreAtlasPageContent,
+      },
+      atlasDocument: {
+        get: atlasDocumentApi.getAtlasDocument,
+        delete: atlasDocumentApi.deleteAtlasDocument,
+        getUploadPreSignedUrl: atlasDocumentApi.getUploadPreSignedUrlAtlasDocument,
+        paginate: atlasDocumentApi.paginateAtlasDocument,
+        list: atlasDocumentApi.listAtlasDocument,
+        getPublicAccessId: atlasDocumentApi.getPublicAccessIdAtlasDocument,
+      },
+      shortLink: {
+        get: shortLinkApiModule.shortLinkApi.get,
+        paginate: shortLinkApiModule.shortLinkApi.paginate,
+        paginateProject: shortLinkApiModule.shortLinkApi.paginateProject,
+        paginateOrganization: shortLinkApiModule.shortLinkApi.paginateOrganization,
+        create: shortLinkApiModule.shortLinkApi.create,
+        createForOrganization: shortLinkApiModule.shortLinkApi.createForOrganization,
+        update: shortLinkApiModule.shortLinkApi.update,
+        delete: shortLinkApiModule.shortLinkApi.delete,
+        getStats: shortLinkApiModule.shortLinkApi.getStats,
+        getClicks: shortLinkApiModule.shortLinkApi.getClicks,
+        transfer: shortLinkApiModule.shortLinkApi.transfer,
+        countOrganization: shortLinkApiModule.shortLinkApi.countOrganization,
+        admin: {
+          paginate: shortLinkAdminApiModule.shortLinkAdminApi.paginate,
+          get: shortLinkAdminApiModule.shortLinkAdminApi.get,
+          getCampaignStats: shortLinkAdminApiModule.shortLinkAdminApi.getCampaignStats,
+          setProtection: shortLinkAdminApiModule.shortLinkAdminApi.setProtection,
+          update: shortLinkAdminApiModule.shortLinkAdminApi.update,
+          delete: shortLinkAdminApiModule.shortLinkAdminApi.delete,
+        },
+        public: {
+          createAnonymous: shortLinkPublicApiModule.shortLinkPublicApi.createAnonymous,
+          redirect: shortLinkPublicApiModule.shortLinkPublicApi.redirect,
+          getStats: shortLinkPublicApiModule.shortLinkPublicApi.getStats,
+          getClicks: shortLinkPublicApiModule.shortLinkPublicApi.getClicks,
+          renew: shortLinkPublicApiModule.shortLinkPublicApi.renew,
+        },
+      },
+      metrics: {
+        getOrganization: metricsApi.getOrganizationWorkspaceMetrics,
+        getProject: metricsApi.getProjectWorkspaceMetrics,
+      },
+      monitor: {
+        up: monitorApi.upMonitor,
+      },
+      tag: {
+        list: tagApi.listTag,
+        create: tagApi.createTag,
+        update: tagApi.updateTag,
+        delete: tagApi.deleteTag,
+        assign: tagApi.assignTag,
+        unassign: tagApi.unassignTag,
+        getStats: tagApi.getTagStats,
+        getEntityTags: tagApi.getEntityTags,
+      },
+      organization: {
+        recent: organizationApi.recentOrganization,
+      },
+    };
+  }
+
+  public static enableAxiosRetry(axiosRetryConfig?: IAxiosRetryConfig): void {
+    axiosRetry(AbyssWorkspaceCore.axios, {
+      retries: NUMBER_RETRY_API,
+      retryDelay: (retryCount) => retryCount * BASE_DELAY_BETWEEN_RETRY,
+      retryCondition: (error) =>
+        isNetworkOrIdempotentRequestError(error) ||
+        RETRY_CODES.includes(error.response?.status || 502),
+      ...axiosRetryConfig,
+    });
+  }
+
+  public static setConfig(config: CoreConfig): void {
+    AbyssWorkspaceCore._sdk = null;
+
+    AbyssWorkspaceCore.config = { ...AbyssWorkspaceCore.config, ...config };
+
+    if (config.baseURL) {
+      AbyssWorkspaceCore.axios.defaults.baseURL = config.baseURL;
+    }
+
+    if (config.token) {
+      AbyssWorkspaceCore.axios.defaults.headers.common.Authorization = `Bearer ${config.token}`;
+    }
+
+    if (config.apiKey) {
+      AbyssWorkspaceCore.axios.defaults.headers.common[API_KEY_HEADER] = `${config.apiKey}`;
+    }
+
+    if (config.adminToken) {
+      AbyssWorkspaceCore.axios.defaults.headers.common[ADMIN_TOKEN_HEADER] = `${config.adminToken}`;
+    }
+  }
+
+  public static getConfig(): CoreConfig {
+    return AbyssWorkspaceCore.config;
+  }
+}

package/src/server-sent-events/index.ts

@@ -0,0 +1,13 @@
+export * from './server-sent-events.manager';
+export * from './protocols';
+
+export enum SSEChannels {
+  BOARD = 'sse:board',
+  BOARD_CARD = 'sse:board-card',
+  USER_NOTIFICATION = 'sse:user-notification',
+  RETROSPECTIVE = 'sse:retrospective',
+  ATLAS = 'sse:atlas',
+
+  // AbyssCloud
+  CLOUD = 'sse:cloud',
+}