@abyss-project/tools 1.0.0 → 1.0.1

package/src/index.ts

@@ -1,541 +1,746 @@
-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 drawApi from './api/draw.api';
-import * as drawPublicApi from './api/draw.public.api';
-import * as retrospectiveApi from './api/retrospective.api';
-import * as retrospectiveCardApi from './api/retrospective-card.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 memoApi from './api/memo.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 userTagApi from './api/user-tag.api';
-
-export * from './api';
-export * from './types';
-export * from './utils';
-export * from './constants';
-export * from './server-sent-events';
-
-const DEFAULT_BASE_URL = 'https://tools-api.abyss-project.fr/api/';
-
-export const API_KEY_HEADER = 'abyss-tools-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 AbyssToolsCoreSDK = {
-  abyss: {
-    admin: {
-      activateUserService: typeof abyssAdminApi.activateUserServiceAbyssAdmin;
-      deleteUser: typeof abyssAdminApi.deleteUserAbyssAdmin;
-      syncOrganization: typeof abyssAdminApi.syncOrganizationAbyssAdmin;
-      deleteOrganization: typeof abyssAdminApi.deleteOrganizationAbyssAdmin;
-      syncProject: typeof abyssAdminApi.syncProjectAbyssAdmin;
-      deleteProject: typeof abyssAdminApi.deleteProjectAbyssAdmin;
-    };
-  };
-  board: {
-    getBoard: typeof boardApi.getBoard;
-    getBySlugBoard: typeof boardApi.getBySlugBoard;
-    listBoard: typeof boardApi.listBoard;
-    listBoardProject: typeof boardApi.listBoardProject;
-    deleteBoard: typeof boardApi.deleteBoard;
-    updateBoard: typeof boardApi.updateBoard;
-    createBoard: typeof boardApi.createBoard;
-    createForProjectBoard: typeof boardApi.createForProjectBoard;
-    getNextCardPreviewBoard: typeof boardApi.getNextCardPreviewBoard;
-  };
-  boardColumn: {
-    getBoardColumn: typeof boardColumnApi.getBoardColumn;
-    deleteBoardColumn: typeof boardColumnApi.deleteBoardColumn;
-    updateBoardColumn: typeof boardColumnApi.updateBoardColumn;
-    createBoardColumn: typeof boardColumnApi.createBoardColumn;
-  };
-  boardCard: {
-    getBoardCard: typeof boardCardApi.getBoardCard;
-    getAllBoardCard: typeof boardCardApi.getAllBoardCard;
-    deleteBoardCard: typeof boardCardApi.deleteBoardCard;
-    updateBoardCard: typeof boardCardApi.updateBoardCard;
-    restoreBoardCard: typeof boardCardApi.restoreBoardCard;
-    createBoardCard: typeof boardCardApi.createBoardCard;
-    addMemberBoardCard: typeof boardCardApi.addMemberBoardCard;
-    removeMemberBoardCard: typeof boardCardApi.removeMemberBoardCard;
-    moveToBoardBoardCard: typeof boardCardApi.moveToBoardBoardCard;
-    searchBoardCard: typeof boardCardApi.searchBoardCard;
-  };
-  boardLabel: {
-    getBoardLabel: typeof boardLabelApi.getBoardLabel;
-    deleteBoardLabel: typeof boardLabelApi.deleteBoardLabel;
-    updateBoardLabel: typeof boardLabelApi.updateBoardLabel;
-    createBoardLabel: typeof boardLabelApi.createBoardLabel;
-    addBoardLabel: typeof boardLabelApi.addBoardLabel;
-    removeBoardLabel: typeof boardLabelApi.removeBoardLabel;
-    listBoardLabels: typeof boardLabelApi.listBoardLabels;
-  };
-  boardCardComment: {
-    getBoardCardComment: typeof boardCardCommentApi.getBoardCardComment;
-    deleteBoardCardComment: typeof boardCardCommentApi.deleteBoardCardComment;
-    updateBoardCardComment: typeof boardCardCommentApi.updateBoardCardComment;
-    createBoardCardComment: typeof boardCardCommentApi.createBoardCardComment;
-  };
-  boardCardChecklist: {
-    getBoardCardChecklist: typeof boardCardChecklistApi.getBoardCardChecklist;
-    deleteBoardCardChecklist: typeof boardCardChecklistApi.deleteBoardCardChecklist;
-    updateBoardCardChecklist: typeof boardCardChecklistApi.updateBoardCardChecklist;
-    createBoardCardChecklist: typeof boardCardChecklistApi.createBoardCardChecklist;
-    addRowBoardCardChecklist: typeof boardCardChecklistApi.addRowBoardCardChecklist;
-    removeRowBoardCardChecklist: typeof boardCardChecklistApi.removeRowBoardCardChecklist;
-    updateRowBoardCardChecklist: typeof boardCardChecklistApi.updateRowBoardCardChecklist;
-  };
-  boardCardDocument: {
-    getBoardCardDocument: typeof boardCardDocumentApi.getBoardCardDocument;
-    deleteBoardCardDocument: typeof boardCardDocumentApi.deleteBoardCardDocument;
-    getUploadPreSignedUrlBoardCardDocument: typeof boardCardDocumentApi.getUploadPreSignedUrlBoardCardDocument;
-    cloudImportBoardCardDocument: typeof boardCardDocumentApi.cloudImportBoardCardDocument;
-  };
-  draw: {
-    paginateDraw: typeof drawApi.paginateDraw;
-    paginateProjectDraw: typeof drawApi.paginateProjectDraw;
-    getDraw: typeof drawApi.getDraw;
-    deleteDraw: typeof drawApi.deleteDraw;
-    updateDraw: typeof drawApi.updateDraw;
-    createDraw: typeof drawApi.createDraw;
-    createForProjectDraw: typeof drawApi.createForProjectDraw;
-    public: {
-      getDrawPublic: typeof drawPublicApi.getDrawPublic;
-      deleteDrawPublic: typeof drawPublicApi.deleteDrawPublic;
-      updateDrawPublic: typeof drawPublicApi.updateDrawPublic;
-      createDrawPublic: typeof drawPublicApi.createDrawPublic;
-    };
-  };
-  retrospective: {
-    getRetrospective: typeof retrospectiveApi.getRetrospective;
-    paginateProjectRetrospective: typeof retrospectiveApi.paginateProjectRetrospective;
-    paginateRetrospective: typeof retrospectiveApi.paginateRetrospective;
-    createForProjectRetrospective: typeof retrospectiveApi.createForProjectRetrospective;
-    createRetrospective: typeof retrospectiveApi.createRetrospective;
-    updateRetrospective: typeof retrospectiveApi.updateRetrospective;
-    deleteRetrospective: typeof retrospectiveApi.deleteRetrospective;
-    public: {
-      getRetrospectivePublic: typeof retrospectivePublicApi.getRetrospectivePublic;
-      updateRetrospectivePublic: typeof retrospectivePublicApi.updateRetrospectivePublic;
-      createSectionRetrospectivePublic: typeof retrospectivePublicApi.createSectionRetrospectivePublic;
-      updateSectionRetrospectivePublic: typeof retrospectivePublicApi.updateSectionRetrospectivePublic;
-      deleteSectionRetrospectivePublic: typeof retrospectivePublicApi.deleteSectionRetrospectivePublic;
-      joinMemberRetrospectivePublic: typeof retrospectivePublicApi.joinMemberRetrospectivePublic;
-      updateMemberRetrospectivePublic: typeof retrospectivePublicApi.updateMemberRetrospectivePublic;
-      createCardRetrospectivePublic: typeof retrospectivePublicApi.createCardRetrospectivePublic;
-      updateCardRetrospectivePublic: typeof retrospectivePublicApi.updateCardRetrospectivePublic;
-      deleteCardRetrospectivePublic: typeof retrospectivePublicApi.deleteCardRetrospectivePublic;
-    };
-  };
-  retrospectiveCard: {
-    getRetrospectiveCard: typeof retrospectiveCardApi.getRetrospectiveCard;
-    paginateRetrospectiveCard: typeof retrospectiveCardApi.paginateRetrospectiveCard;
-    createRetrospectiveCard: typeof retrospectiveCardApi.createRetrospectiveCard;
-    updateRetrospectiveCard: typeof retrospectiveCardApi.updateRetrospectiveCard;
-    deleteRetrospectiveCard: typeof retrospectiveCardApi.deleteRetrospectiveCard;
-  };
-  retrospectiveMember: {
-    getRetrospectiveMember: typeof retrospectiveMemberApi.getRetrospectiveMember;
-    listRetrospectiveMember: typeof retrospectiveMemberApi.listRetrospectiveMember;
-    joinRetrospectiveMember: typeof retrospectiveMemberApi.joinRetrospectiveMember;
-    updateRetrospectiveMember: typeof retrospectiveMemberApi.updateRetrospectiveMember;
-  };
-  retrospectiveSection: {
-    getRetrospectiveSection: typeof retrospectiveSectionApi.getRetrospectiveSection;
-    paginateRetrospectiveSection: typeof retrospectiveSectionApi.paginateRetrospectiveSection;
-    createRetrospectiveSection: typeof retrospectiveSectionApi.createRetrospectiveSection;
-    updateRetrospectiveSection: typeof retrospectiveSectionApi.updateRetrospectiveSection;
-    deleteRetrospectiveSection: typeof retrospectiveSectionApi.deleteRetrospectiveSection;
-  };
-  atlas: {
-    paginateAtlas: typeof atlasApi.paginateAtlas;
-    paginateProjectAtlas: typeof atlasApi.paginateProjectAtlas;
-    getAtlas: typeof atlasApi.getAtlas;
-    deleteAtlas: typeof atlasApi.deleteAtlas;
-    updateAtlas: typeof atlasApi.updateAtlas;
-    createAtlas: typeof atlasApi.createAtlas;
-    createForProjectAtlas: typeof atlasApi.createForProjectAtlas;
-    public: {
-      getAtlasPublic: typeof atlasPublicApi.getAtlasPublic;
-      getPageAtlasPublic: typeof atlasPublicApi.getPageAtlasPublic;
-      searchContentAtlasPublic: typeof atlasPublicApi.searchContentAtlasPublic;
-    };
-  };
-  atlasGroup: {
-    paginateAtlasGroup: typeof atlasGroupApi.paginateAtlasGroup;
-    getAtlasGroup: typeof atlasGroupApi.getAtlasGroup;
-    deleteAtlasGroup: typeof atlasGroupApi.deleteAtlasGroup;
-    updateAtlasGroup: typeof atlasGroupApi.updateAtlasGroup;
-    createAtlasGroup: typeof atlasGroupApi.createAtlasGroup;
-  };
-  atlasPage: {
-    paginateAtlasPage: typeof atlasPageApi.paginateAtlasPage;
-    getAtlasPage: typeof atlasPageApi.getAtlasPage;
-    deleteAtlasPage: typeof atlasPageApi.deleteAtlasPage;
-    updateAtlasPage: typeof atlasPageApi.updateAtlasPage;
-    createAtlasPage: typeof atlasPageApi.createAtlasPage;
-    updateAtlasPageContent: typeof atlasPageApi.updateAtlasPageContent;
-    searchAtlasContent: typeof atlasPageApi.searchAtlasContent;
-    getAtlasPageContentHistory: typeof atlasPageApi.getAtlasPageContentHistory;
-    restoreAtlasPageContent: typeof atlasPageApi.restoreAtlasPageContent;
-  };
-  atlasDocument: {
-    getAtlasDocument: typeof atlasDocumentApi.getAtlasDocument;
-    deleteAtlasDocument: typeof atlasDocumentApi.deleteAtlasDocument;
-    getUploadPreSignedUrlAtlasDocument: typeof atlasDocumentApi.getUploadPreSignedUrlAtlasDocument;
-    paginateAtlasDocument: typeof atlasDocumentApi.paginateAtlasDocument;
-    listAtlasDocument: typeof atlasDocumentApi.listAtlasDocument;
-  };
-  memo: {
-    paginateMemo: typeof memoApi.paginateMemo;
-    paginateProjectMemo: typeof memoApi.paginateProjectMemo;
-    getMemo: typeof memoApi.getMemo;
-    deleteMemo: typeof memoApi.deleteMemo;
-    updateMemo: typeof memoApi.updateMemo;
-    createMemo: typeof memoApi.createMemo;
-    createForProjectMemo: typeof memoApi.createForProjectMemo;
-  };
-  shortLink: {
-    get: typeof shortLinkApiModule.shortLinkApi.get;
-    paginate: typeof shortLinkApiModule.shortLinkApi.paginate;
-    paginateProject: typeof shortLinkApiModule.shortLinkApi.paginateProject;
-    create: typeof shortLinkApiModule.shortLinkApi.create;
-    createForProject: typeof shortLinkApiModule.shortLinkApi.createForProject;
-    update: typeof shortLinkApiModule.shortLinkApi.update;
-    delete: typeof shortLinkApiModule.shortLinkApi.delete;
-    getStats: typeof shortLinkApiModule.shortLinkApi.getStats;
-    getClicks: typeof shortLinkApiModule.shortLinkApi.getClicks;
-    admin: {
-      paginate: typeof shortLinkAdminApiModule.shortLinkAdminApi.paginate;
-      get: typeof shortLinkAdminApiModule.shortLinkAdminApi.get;
-      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: {
-    getOrganizationToolsMetrics: typeof metricsApi.getOrganizationToolsMetrics;
-  };
-  userTag: {
-    listUserTag: typeof userTagApi.listUserTag;
-    createUserTag: typeof userTagApi.createUserTag;
-    updateUserTag: typeof userTagApi.updateUserTag;
-    deleteUserTag: typeof userTagApi.deleteUserTag;
-    assignTag: typeof userTagApi.assignTag;
-    unassignTag: typeof userTagApi.unassignTag;
-    getUserTagStats: typeof userTagApi.getUserTagStats;
-    getEntityTags: typeof userTagApi.getEntityTags;
-  };
-};
-
-export class AbyssToolsCore {
-  private static config = {
-    token: '',
-    apiKey: '',
-    adminToken: '',
-    baseURL: DEFAULT_BASE_URL,
-  };
-  static axios = axios.create({
-    baseURL: this.config.baseURL,
-    withCredentials: true,
-  });
-
-  private static _sdk: AbyssToolsCoreSDK | null = null;
-
-  public static get sdk(): AbyssToolsCoreSDK {
-    if (!AbyssToolsCore._sdk) {
-      AbyssToolsCore._sdk = AbyssToolsCore.buildSDK();
-    }
-    return AbyssToolsCore._sdk;
-  }
-
-  private static buildSDK(): AbyssToolsCoreSDK {
-    return {
-      abyss: {
-        admin: {
-          activateUserService: abyssAdminApi.activateUserServiceAbyssAdmin,
-          deleteUser: abyssAdminApi.deleteUserAbyssAdmin,
-          syncOrganization: abyssAdminApi.syncOrganizationAbyssAdmin,
-          deleteOrganization: abyssAdminApi.deleteOrganizationAbyssAdmin,
-          syncProject: abyssAdminApi.syncProjectAbyssAdmin,
-          deleteProject: abyssAdminApi.deleteProjectAbyssAdmin,
-        },
-      },
-      board: {
-        getBoard: boardApi.getBoard,
-        getBySlugBoard: boardApi.getBySlugBoard,
-        listBoard: boardApi.listBoard,
-        listBoardProject: boardApi.listBoardProject,
-        deleteBoard: boardApi.deleteBoard,
-        updateBoard: boardApi.updateBoard,
-        createBoard: boardApi.createBoard,
-        createForProjectBoard: boardApi.createForProjectBoard,
-        getNextCardPreviewBoard: boardApi.getNextCardPreviewBoard,
-      },
-      boardColumn: {
-        getBoardColumn: boardColumnApi.getBoardColumn,
-        deleteBoardColumn: boardColumnApi.deleteBoardColumn,
-        updateBoardColumn: boardColumnApi.updateBoardColumn,
-        createBoardColumn: boardColumnApi.createBoardColumn,
-      },
-      boardCard: {
-        getBoardCard: boardCardApi.getBoardCard,
-        getAllBoardCard: boardCardApi.getAllBoardCard,
-        deleteBoardCard: boardCardApi.deleteBoardCard,
-        updateBoardCard: boardCardApi.updateBoardCard,
-        restoreBoardCard: boardCardApi.restoreBoardCard,
-        createBoardCard: boardCardApi.createBoardCard,
-        addMemberBoardCard: boardCardApi.addMemberBoardCard,
-        removeMemberBoardCard: boardCardApi.removeMemberBoardCard,
-        moveToBoardBoardCard: boardCardApi.moveToBoardBoardCard,
-        searchBoardCard: boardCardApi.searchBoardCard,
-      },
-      boardLabel: {
-        getBoardLabel: boardLabelApi.getBoardLabel,
-        deleteBoardLabel: boardLabelApi.deleteBoardLabel,
-        updateBoardLabel: boardLabelApi.updateBoardLabel,
-        createBoardLabel: boardLabelApi.createBoardLabel,
-        addBoardLabel: boardLabelApi.addBoardLabel,
-        removeBoardLabel: boardLabelApi.removeBoardLabel,
-        listBoardLabels: boardLabelApi.listBoardLabels,
-      },
-      boardCardComment: {
-        getBoardCardComment: boardCardCommentApi.getBoardCardComment,
-        deleteBoardCardComment: boardCardCommentApi.deleteBoardCardComment,
-        updateBoardCardComment: boardCardCommentApi.updateBoardCardComment,
-        createBoardCardComment: boardCardCommentApi.createBoardCardComment,
-      },
-      boardCardChecklist: {
-        getBoardCardChecklist: boardCardChecklistApi.getBoardCardChecklist,
-        deleteBoardCardChecklist: boardCardChecklistApi.deleteBoardCardChecklist,
-        updateBoardCardChecklist: boardCardChecklistApi.updateBoardCardChecklist,
-        createBoardCardChecklist: boardCardChecklistApi.createBoardCardChecklist,
-        addRowBoardCardChecklist: boardCardChecklistApi.addRowBoardCardChecklist,
-        removeRowBoardCardChecklist: boardCardChecklistApi.removeRowBoardCardChecklist,
-        updateRowBoardCardChecklist: boardCardChecklistApi.updateRowBoardCardChecklist,
-      },
-      boardCardDocument: {
-        getBoardCardDocument: boardCardDocumentApi.getBoardCardDocument,
-        deleteBoardCardDocument: boardCardDocumentApi.deleteBoardCardDocument,
-        getUploadPreSignedUrlBoardCardDocument:
-          boardCardDocumentApi.getUploadPreSignedUrlBoardCardDocument,
-        cloudImportBoardCardDocument: boardCardDocumentApi.cloudImportBoardCardDocument,
-      },
-      draw: {
-        paginateDraw: drawApi.paginateDraw,
-        paginateProjectDraw: drawApi.paginateProjectDraw,
-        getDraw: drawApi.getDraw,
-        deleteDraw: drawApi.deleteDraw,
-        updateDraw: drawApi.updateDraw,
-        createDraw: drawApi.createDraw,
-        createForProjectDraw: drawApi.createForProjectDraw,
-        public: {
-          getDrawPublic: drawPublicApi.getDrawPublic,
-          deleteDrawPublic: drawPublicApi.deleteDrawPublic,
-          updateDrawPublic: drawPublicApi.updateDrawPublic,
-          createDrawPublic: drawPublicApi.createDrawPublic,
-        },
-      },
-      retrospective: {
-        getRetrospective: retrospectiveApi.getRetrospective,
-        paginateProjectRetrospective: retrospectiveApi.paginateProjectRetrospective,
-        paginateRetrospective: retrospectiveApi.paginateRetrospective,
-        createForProjectRetrospective: retrospectiveApi.createForProjectRetrospective,
-        createRetrospective: retrospectiveApi.createRetrospective,
-        updateRetrospective: retrospectiveApi.updateRetrospective,
-        deleteRetrospective: retrospectiveApi.deleteRetrospective,
-        public: {
-          getRetrospectivePublic: retrospectivePublicApi.getRetrospectivePublic,
-          updateRetrospectivePublic: retrospectivePublicApi.updateRetrospectivePublic,
-          createSectionRetrospectivePublic: retrospectivePublicApi.createSectionRetrospectivePublic,
-          updateSectionRetrospectivePublic: retrospectivePublicApi.updateSectionRetrospectivePublic,
-          deleteSectionRetrospectivePublic: retrospectivePublicApi.deleteSectionRetrospectivePublic,
-          joinMemberRetrospectivePublic: retrospectivePublicApi.joinMemberRetrospectivePublic,
-          updateMemberRetrospectivePublic: retrospectivePublicApi.updateMemberRetrospectivePublic,
-          createCardRetrospectivePublic: retrospectivePublicApi.createCardRetrospectivePublic,
-          updateCardRetrospectivePublic: retrospectivePublicApi.updateCardRetrospectivePublic,
-          deleteCardRetrospectivePublic: retrospectivePublicApi.deleteCardRetrospectivePublic,
-        },
-      },
-      retrospectiveCard: {
-        getRetrospectiveCard: retrospectiveCardApi.getRetrospectiveCard,
-        paginateRetrospectiveCard: retrospectiveCardApi.paginateRetrospectiveCard,
-        createRetrospectiveCard: retrospectiveCardApi.createRetrospectiveCard,
-        updateRetrospectiveCard: retrospectiveCardApi.updateRetrospectiveCard,
-        deleteRetrospectiveCard: retrospectiveCardApi.deleteRetrospectiveCard,
-      },
-      retrospectiveMember: {
-        getRetrospectiveMember: retrospectiveMemberApi.getRetrospectiveMember,
-        listRetrospectiveMember: retrospectiveMemberApi.listRetrospectiveMember,
-        joinRetrospectiveMember: retrospectiveMemberApi.joinRetrospectiveMember,
-        updateRetrospectiveMember: retrospectiveMemberApi.updateRetrospectiveMember,
-      },
-      retrospectiveSection: {
-        getRetrospectiveSection: retrospectiveSectionApi.getRetrospectiveSection,
-        paginateRetrospectiveSection: retrospectiveSectionApi.paginateRetrospectiveSection,
-        createRetrospectiveSection: retrospectiveSectionApi.createRetrospectiveSection,
-        updateRetrospectiveSection: retrospectiveSectionApi.updateRetrospectiveSection,
-        deleteRetrospectiveSection: retrospectiveSectionApi.deleteRetrospectiveSection,
-      },
-      atlas: {
-        paginateAtlas: atlasApi.paginateAtlas,
-        paginateProjectAtlas: atlasApi.paginateProjectAtlas,
-        getAtlas: atlasApi.getAtlas,
-        deleteAtlas: atlasApi.deleteAtlas,
-        updateAtlas: atlasApi.updateAtlas,
-        createAtlas: atlasApi.createAtlas,
-        createForProjectAtlas: atlasApi.createForProjectAtlas,
-        public: {
-          getAtlasPublic: atlasPublicApi.getAtlasPublic,
-          getPageAtlasPublic: atlasPublicApi.getPageAtlasPublic,
-          searchContentAtlasPublic: atlasPublicApi.searchContentAtlasPublic,
-        },
-      },
-      atlasGroup: {
-        paginateAtlasGroup: atlasGroupApi.paginateAtlasGroup,
-        getAtlasGroup: atlasGroupApi.getAtlasGroup,
-        deleteAtlasGroup: atlasGroupApi.deleteAtlasGroup,
-        updateAtlasGroup: atlasGroupApi.updateAtlasGroup,
-        createAtlasGroup: atlasGroupApi.createAtlasGroup,
-      },
-      atlasPage: {
-        paginateAtlasPage: atlasPageApi.paginateAtlasPage,
-        getAtlasPage: atlasPageApi.getAtlasPage,
-        deleteAtlasPage: atlasPageApi.deleteAtlasPage,
-        updateAtlasPage: atlasPageApi.updateAtlasPage,
-        createAtlasPage: atlasPageApi.createAtlasPage,
-        updateAtlasPageContent: atlasPageApi.updateAtlasPageContent,
-        searchAtlasContent: atlasPageApi.searchAtlasContent,
-        getAtlasPageContentHistory: atlasPageApi.getAtlasPageContentHistory,
-        restoreAtlasPageContent: atlasPageApi.restoreAtlasPageContent,
-      },
-      atlasDocument: {
-        getAtlasDocument: atlasDocumentApi.getAtlasDocument,
-        deleteAtlasDocument: atlasDocumentApi.deleteAtlasDocument,
-        getUploadPreSignedUrlAtlasDocument: atlasDocumentApi.getUploadPreSignedUrlAtlasDocument,
-        paginateAtlasDocument: atlasDocumentApi.paginateAtlasDocument,
-        listAtlasDocument: atlasDocumentApi.listAtlasDocument,
-      },
-      memo: {
-        paginateMemo: memoApi.paginateMemo,
-        paginateProjectMemo: memoApi.paginateProjectMemo,
-        getMemo: memoApi.getMemo,
-        deleteMemo: memoApi.deleteMemo,
-        updateMemo: memoApi.updateMemo,
-        createMemo: memoApi.createMemo,
-        createForProjectMemo: memoApi.createForProjectMemo,
-      },
-      shortLink: {
-        get: shortLinkApiModule.shortLinkApi.get,
-        paginate: shortLinkApiModule.shortLinkApi.paginate,
-        paginateProject: shortLinkApiModule.shortLinkApi.paginateProject,
-        create: shortLinkApiModule.shortLinkApi.create,
-        createForProject: shortLinkApiModule.shortLinkApi.createForProject,
-        update: shortLinkApiModule.shortLinkApi.update,
-        delete: shortLinkApiModule.shortLinkApi.delete,
-        getStats: shortLinkApiModule.shortLinkApi.getStats,
-        getClicks: shortLinkApiModule.shortLinkApi.getClicks,
-        admin: {
-          paginate: shortLinkAdminApiModule.shortLinkAdminApi.paginate,
-          get: shortLinkAdminApiModule.shortLinkAdminApi.get,
-          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: {
-        getOrganizationToolsMetrics: metricsApi.getOrganizationToolsMetrics,
-      },
-      userTag: {
-        listUserTag: userTagApi.listUserTag,
-        createUserTag: userTagApi.createUserTag,
-        updateUserTag: userTagApi.updateUserTag,
-        deleteUserTag: userTagApi.deleteUserTag,
-        assignTag: userTagApi.assignTag,
-        unassignTag: userTagApi.unassignTag,
-        getUserTagStats: userTagApi.getUserTagStats,
-        getEntityTags: userTagApi.getEntityTags,
-      },
-    };
-  }
-
-  public static enableAxiosRetry(axiosRetryConfig?: IAxiosRetryConfig): void {
-    axiosRetry(AbyssToolsCore.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 {
-    AbyssToolsCore._sdk = null;
-
-    AbyssToolsCore.config = { ...AbyssToolsCore.config, ...config };
-
-    if (config.baseURL) {
-      AbyssToolsCore.axios.defaults.baseURL = config.baseURL;
-    }
-
-    if (config.token) {
-      AbyssToolsCore.axios.defaults.headers.common.Authorization = `Bearer ${config.token}`;
-    }
-
-    if (config.apiKey) {
-      AbyssToolsCore.axios.defaults.headers.common[API_KEY_HEADER] = `${config.apiKey}`;
-    }
-
-    if (config.adminToken) {
-      AbyssToolsCore.axios.defaults.headers.common[ADMIN_TOKEN_HEADER] = `${config.adminToken}`;
-    }
-  }
-
-  public static getConfig(): CoreConfig {
-    return AbyssToolsCore.config;
-  }
-}
+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 drawApi from './api/draw.api';
+import * as drawPublicApi from './api/draw.public.api';
+import * as retrospectiveApi from './api/retrospective.api';
+import * as retrospectiveCardApi from './api/retrospective-card.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 memoApi from './api/memo.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 rcbApi from './api/rcb.api';
+
+export * from './api';
+export * from './types';
+export * from './utils';
+export * from './constants';
+export * from './server-sent-events';
+
+const DEFAULT_BASE_URL = 'https://tools-api.abyss-project.fr/api/';
+
+export const API_KEY_HEADER = 'abyss-tools-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 AbyssToolsCoreSDK = {
+  abyss: {
+    admin: {
+      activateUserService: typeof abyssAdminApi.activateUserServiceAbyssAdmin;
+      deleteUser: typeof abyssAdminApi.deleteUserAbyssAdmin;
+      syncOrganization: typeof abyssAdminApi.syncOrganizationAbyssAdmin;
+      deleteOrganization: typeof abyssAdminApi.deleteOrganizationAbyssAdmin;
+      syncProject: typeof abyssAdminApi.syncProjectAbyssAdmin;
+      deleteProject: typeof abyssAdminApi.deleteProjectAbyssAdmin;
+      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;
+  };
+  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;
+    public: {
+      get: typeof drawPublicApi.getDrawPublic;
+      delete: typeof drawPublicApi.deleteDrawPublic;
+      update: typeof drawPublicApi.updateDrawPublic;
+      create: typeof drawPublicApi.createDrawPublic;
+    };
+  };
+  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;
+    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;
+    };
+  };
+  retrospectiveCard: {
+    get: typeof retrospectiveCardApi.getRetrospectiveCard;
+    paginate: typeof retrospectiveCardApi.paginateRetrospectiveCard;
+    create: typeof retrospectiveCardApi.createRetrospectiveCard;
+    update: typeof retrospectiveCardApi.updateRetrospectiveCard;
+    delete: typeof retrospectiveCardApi.deleteRetrospectiveCard;
+  };
+  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;
+    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;
+  };
+  memo: {
+    paginate: typeof memoApi.paginateMemo;
+    paginateProject: typeof memoApi.paginateProjectMemo;
+    paginateOrganization: typeof memoApi.paginateOrganizationMemo;
+    get: typeof memoApi.getMemo;
+    delete: typeof memoApi.deleteMemo;
+    update: typeof memoApi.updateMemo;
+    create: typeof memoApi.createMemo;
+    createForOrganization: typeof memoApi.createForOrganizationMemo;
+    transfer: typeof memoApi.transferMemo;
+    countOrganization: typeof memoApi.countOrganizationMemo;
+  };
+  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;
+      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: {
+    getOrganizationTools: typeof metricsApi.getOrganizationToolsMetrics;
+    getProjectTools: typeof metricsApi.getProjectToolsMetrics;
+  };
+  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;
+  };
+  rcb: {
+    health: typeof rcbApi.healthRcb;
+    stats: typeof rcbApi.statsRcb;
+    changelog: typeof rcbApi.changelogRcb;
+    /** Direct aliases kept for back-compat with existing front-v2 code. */
+    detect: typeof rcbApi.detectRcb;
+    quota: typeof rcbApi.getQuotaRcb;
+    extract: {
+      sync: typeof rcbApi.extractSyncRcb;
+      queue: typeof rcbApi.extractQueueRcb;
+      bulk: typeof rcbApi.extractBulkRcb;
+      detect: typeof rcbApi.detectRcb;
+      detectBulk: typeof rcbApi.detectBulkRcb;
+    };
+    files: {
+      list: typeof rcbApi.listFilesRcb;
+      listShared: typeof rcbApi.listSharedFilesRcb;
+      get: typeof rcbApi.getFileRcb;
+      patch: typeof rcbApi.patchFileRcb;
+      listExtractions: typeof rcbApi.listFileExtractionsRcb;
+      downloadBundle: typeof rcbApi.downloadFileBundleRcb;
+    };
+    extractions: {
+      get: typeof rcbApi.getExtractionRcb;
+      patch: typeof rcbApi.patchExtractionRcb;
+      searchRecords: typeof rcbApi.searchExtractionRecordsRcb;
+      export: typeof rcbApi.exportExtractionRcb;
+      asyncExport: typeof rcbApi.asyncExportExtractionRcb;
+      getExportJob: typeof rcbApi.getExportJobRcb;
+      diff: typeof rcbApi.diffExtractionsRcb;
+    };
+    templates: {
+      list: typeof rcbApi.listTemplatesRcb;
+      get: typeof rcbApi.getTemplateRcb;
+      create: typeof rcbApi.createTemplateRcb;
+      update: typeof rcbApi.updateTemplateRcb;
+      patchMeta: typeof rcbApi.patchTemplateMetaRcb;
+      delete: typeof rcbApi.deleteTemplateRcb;
+      listVersions: typeof rcbApi.listTemplateVersionsRcb;
+      exportCollection: typeof rcbApi.exportTemplateCollectionRcb;
+      importCollection: typeof rcbApi.importTemplateCollectionRcb;
+    };
+    jobs: {
+      get: typeof rcbApi.getJobRcb;
+      retry: typeof rcbApi.retryJobRcb;
+      cancel: typeof rcbApi.cancelJobRcb;
+    };
+    feedback: {
+      submit: typeof rcbApi.submitFeedbackRcb;
+      list: typeof rcbApi.listFeedbackRcb;
+      get: typeof rcbApi.getFeedbackRcb;
+      patch: typeof rcbApi.patchFeedbackRcb;
+    };
+    usage: {
+      list: typeof rcbApi.listUsageRcb;
+      summary: typeof rcbApi.summaryUsageRcb;
+      quota: typeof rcbApi.getQuotaRcb;
+    };
+    share: {
+      mint: typeof rcbApi.mintShareExtractionRcb;
+      revoke: typeof rcbApi.revokeShareExtractionRcb;
+      public: { get: typeof rcbApi.getSharedExtractionRcbPublic };
+    };
+    // Webhook delivery history (existing).
+    webhookDeliveries: {
+      list: typeof rcbApi.listWebhookDeliveriesRcb;
+      get: typeof rcbApi.getWebhookDeliveryRcb;
+      replay: typeof rcbApi.replayWebhookDeliveryRcb;
+    };
+    // Webhook subscriptions (NEW — managed registrations).
+    webhook: {
+      paginate: typeof rcbApi.paginateRcbWebhook;
+      get: typeof rcbApi.getRcbWebhook;
+      create: typeof rcbApi.createRcbWebhook;
+      update: typeof rcbApi.updateRcbWebhook;
+      delete: typeof rcbApi.deleteRcbWebhook;
+      resetSecret: typeof rcbApi.resetSecretRcbWebhook;
+    };
+  };
+};
+
+export class AbyssToolsCore {
+  private static config = {
+    token: '',
+    apiKey: '',
+    adminToken: '',
+    baseURL: DEFAULT_BASE_URL,
+  };
+  static axios = axios.create({
+    baseURL: this.config.baseURL,
+    withCredentials: true,
+  });
+
+  private static _sdk: AbyssToolsCoreSDK | null = null;
+
+  public static get sdk(): AbyssToolsCoreSDK {
+    if (!AbyssToolsCore._sdk) {
+      AbyssToolsCore._sdk = AbyssToolsCore.buildSDK();
+    }
+    return AbyssToolsCore._sdk;
+  }
+
+  private static buildSDK(): AbyssToolsCoreSDK {
+    return {
+      abyss: {
+        admin: {
+          activateUserService: abyssAdminApi.activateUserServiceAbyssAdmin,
+          deleteUser: abyssAdminApi.deleteUserAbyssAdmin,
+          syncOrganization: abyssAdminApi.syncOrganizationAbyssAdmin,
+          deleteOrganization: abyssAdminApi.deleteOrganizationAbyssAdmin,
+          syncProject: abyssAdminApi.syncProjectAbyssAdmin,
+          deleteProject: abyssAdminApi.deleteProjectAbyssAdmin,
+          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,
+      },
+      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,
+        public: {
+          get: drawPublicApi.getDrawPublic,
+          delete: drawPublicApi.deleteDrawPublic,
+          update: drawPublicApi.updateDrawPublic,
+          create: drawPublicApi.createDrawPublic,
+        },
+      },
+      retrospective: {
+        get: retrospectiveApi.getRetrospective,
+        paginateProject: retrospectiveApi.paginateProjectRetrospective,
+        paginateOrganization: retrospectiveApi.paginateOrganizationRetrospective,
+        paginate: retrospectiveApi.paginateRetrospective,
+        create: retrospectiveApi.createRetrospective,
+        createForOrganization: retrospectiveApi.createForOrganizationRetrospective,
+        update: retrospectiveApi.updateRetrospective,
+        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,
+        },
+      },
+      retrospectiveCard: {
+        get: retrospectiveCardApi.getRetrospectiveCard,
+        paginate: retrospectiveCardApi.paginateRetrospectiveCard,
+        create: retrospectiveCardApi.createRetrospectiveCard,
+        update: retrospectiveCardApi.updateRetrospectiveCard,
+        delete: retrospectiveCardApi.deleteRetrospectiveCard,
+      },
+      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,
+        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,
+      },
+      memo: {
+        paginate: memoApi.paginateMemo,
+        paginateProject: memoApi.paginateProjectMemo,
+        paginateOrganization: memoApi.paginateOrganizationMemo,
+        get: memoApi.getMemo,
+        delete: memoApi.deleteMemo,
+        update: memoApi.updateMemo,
+        create: memoApi.createMemo,
+        createForOrganization: memoApi.createForOrganizationMemo,
+        transfer: memoApi.transferMemo,
+        countOrganization: memoApi.countOrganizationMemo,
+      },
+      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,
+          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: {
+        getOrganizationTools: metricsApi.getOrganizationToolsMetrics,
+        getProjectTools: metricsApi.getProjectToolsMetrics,
+      },
+      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,
+      },
+      rcb: {
+        health: rcbApi.healthRcb,
+        stats: rcbApi.statsRcb,
+        changelog: rcbApi.changelogRcb,
+        detect: rcbApi.detectRcb,
+        quota: rcbApi.getQuotaRcb,
+        extract: {
+          sync: rcbApi.extractSyncRcb,
+          queue: rcbApi.extractQueueRcb,
+          bulk: rcbApi.extractBulkRcb,
+          detect: rcbApi.detectRcb,
+          detectBulk: rcbApi.detectBulkRcb,
+        },
+        files: {
+          list: rcbApi.listFilesRcb,
+          listShared: rcbApi.listSharedFilesRcb,
+          get: rcbApi.getFileRcb,
+          patch: rcbApi.patchFileRcb,
+          listExtractions: rcbApi.listFileExtractionsRcb,
+          downloadBundle: rcbApi.downloadFileBundleRcb,
+        },
+        extractions: {
+          get: rcbApi.getExtractionRcb,
+          patch: rcbApi.patchExtractionRcb,
+          searchRecords: rcbApi.searchExtractionRecordsRcb,
+          export: rcbApi.exportExtractionRcb,
+          asyncExport: rcbApi.asyncExportExtractionRcb,
+          getExportJob: rcbApi.getExportJobRcb,
+          diff: rcbApi.diffExtractionsRcb,
+        },
+        templates: {
+          list: rcbApi.listTemplatesRcb,
+          get: rcbApi.getTemplateRcb,
+          create: rcbApi.createTemplateRcb,
+          update: rcbApi.updateTemplateRcb,
+          patchMeta: rcbApi.patchTemplateMetaRcb,
+          delete: rcbApi.deleteTemplateRcb,
+          listVersions: rcbApi.listTemplateVersionsRcb,
+          exportCollection: rcbApi.exportTemplateCollectionRcb,
+          importCollection: rcbApi.importTemplateCollectionRcb,
+        },
+        jobs: {
+          get: rcbApi.getJobRcb,
+          retry: rcbApi.retryJobRcb,
+          cancel: rcbApi.cancelJobRcb,
+        },
+        feedback: {
+          submit: rcbApi.submitFeedbackRcb,
+          list: rcbApi.listFeedbackRcb,
+          get: rcbApi.getFeedbackRcb,
+          patch: rcbApi.patchFeedbackRcb,
+        },
+        usage: {
+          list: rcbApi.listUsageRcb,
+          summary: rcbApi.summaryUsageRcb,
+          quota: rcbApi.getQuotaRcb,
+        },
+        share: {
+          mint: rcbApi.mintShareExtractionRcb,
+          revoke: rcbApi.revokeShareExtractionRcb,
+          public: { get: rcbApi.getSharedExtractionRcbPublic },
+        },
+        webhookDeliveries: {
+          list: rcbApi.listWebhookDeliveriesRcb,
+          get: rcbApi.getWebhookDeliveryRcb,
+          replay: rcbApi.replayWebhookDeliveryRcb,
+        },
+        webhook: {
+          paginate: rcbApi.paginateRcbWebhook,
+          get: rcbApi.getRcbWebhook,
+          create: rcbApi.createRcbWebhook,
+          update: rcbApi.updateRcbWebhook,
+          delete: rcbApi.deleteRcbWebhook,
+          resetSecret: rcbApi.resetSecretRcbWebhook,
+        },
+      },
+    };
+  }
+
+  public static enableAxiosRetry(axiosRetryConfig?: IAxiosRetryConfig): void {
+    axiosRetry(AbyssToolsCore.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 {
+    AbyssToolsCore._sdk = null;
+
+    AbyssToolsCore.config = { ...AbyssToolsCore.config, ...config };
+
+    if (config.baseURL) {
+      AbyssToolsCore.axios.defaults.baseURL = config.baseURL;
+    }
+
+    if (config.token) {
+      AbyssToolsCore.axios.defaults.headers.common.Authorization = `Bearer ${config.token}`;
+    }
+
+    if (config.apiKey) {
+      AbyssToolsCore.axios.defaults.headers.common[API_KEY_HEADER] = `${config.apiKey}`;
+    }
+
+    if (config.adminToken) {
+      AbyssToolsCore.axios.defaults.headers.common[ADMIN_TOKEN_HEADER] = `${config.adminToken}`;
+    }
+  }
+
+  public static getConfig(): CoreConfig {
+    return AbyssToolsCore.config;
+  }
+}