@abyss-project/main 1.0.64 → 1.0.66

package/dist/api/atlas-group.api.d.ts

@@ -0,0 +1,6 @@
+import { ICreateAtlasGroupBody, ICreateAtlasGroupParams, ICreateAtlasGroupResponse, IDeleteAtlasGroupParams, IDeleteAtlasGroupResponse, IGetAtlasGroupParams, IGetAtlasGroupResponse, IPaginateAtlasGroupParams, IPaginateAtlasGroupQuery, IPaginateAtlasGroupResponse, IUpdateAtlasGroupBody, IUpdateAtlasGroupParams, IUpdateAtlasGroupResponse } from '../types';
+export declare const paginateAtlasGroup: (params: IPaginateAtlasGroupParams, query: IPaginateAtlasGroupQuery) => Promise<IPaginateAtlasGroupResponse>;
+export declare const getAtlasGroup: (params: IGetAtlasGroupParams) => Promise<IGetAtlasGroupResponse>;
+export declare const deleteAtlasGroup: (params: IDeleteAtlasGroupParams) => Promise<IDeleteAtlasGroupResponse>;
+export declare const updateAtlasGroup: (params: IUpdateAtlasGroupParams, body: IUpdateAtlasGroupBody) => Promise<IUpdateAtlasGroupResponse>;
+export declare const createAtlasGroup: (params: ICreateAtlasGroupParams, body: ICreateAtlasGroupBody) => Promise<ICreateAtlasGroupResponse>;

package/dist/api/atlas-group.api.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAtlasGroup = exports.updateAtlasGroup = exports.deleteAtlasGroup = exports.getAtlasGroup = exports.paginateAtlasGroup = void 0;
+const __1 = require("..");
+const paginateAtlasGroup = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`atlas/${params.atlasId}/group/paginate`, { params: query })).data;
+};
+exports.paginateAtlasGroup = paginateAtlasGroup;
+const getAtlasGroup = async (params) => {
+    return (await __1.AbyssCore.axios.get(`atlas/${params.atlasId}/group/${params.atlasGroupId}`)).data;
+};
+exports.getAtlasGroup = getAtlasGroup;
+const deleteAtlasGroup = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`atlas/${params.atlasId}/group/${params.atlasGroupId}`)).data;
+};
+exports.deleteAtlasGroup = deleteAtlasGroup;
+const updateAtlasGroup = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`atlas/${params.atlasId}/group/${params.atlasGroupId}`, body)).data;
+};
+exports.updateAtlasGroup = updateAtlasGroup;
+const createAtlasGroup = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`atlas/${params.atlasId}/group`, body)).data;
+};
+exports.createAtlasGroup = createAtlasGroup;

package/dist/api/atlas-page-content.api.js

@@ -0,0 +1 @@
+"use strict";

package/dist/api/atlas-page.api.d.ts

@@ -0,0 +1,10 @@
+import { ICreateAtlasPageBody, ICreateAtlasPageParams, ICreateAtlasPageResponse, IDeleteAtlasPageParams, IDeleteAtlasPageResponse, IGetAtlasPageParams, IGetAtlasPageResponse, IPaginateAtlasPageParams, IPaginateAtlasPageQuery, IPaginateAtlasPageResponse, IUpdateAtlasPageBody, IUpdateAtlasPageParams, IUpdateAtlasPageResponse, IUpdateAtlasPageContentParams, IUpdateAtlasPageContentBody, IUpdateAtlasPageContentResponse, ISearchAtlasContentParams, ISearchAtlasContentQuery, ISearchAtlasContentResponse, IGetAtlasPageContentHistoryParams, IGetAtlasPageContentHistoryQuery, IGetAtlasPageContentHistoryResponse, IRestoreAtlasPageContentParams, IRestoreAtlasPageContentResponse } from '../types';
+export declare const paginateAtlasPage: (params: IPaginateAtlasPageParams, query: IPaginateAtlasPageQuery) => Promise<IPaginateAtlasPageResponse>;
+export declare const getAtlasPage: (params: IGetAtlasPageParams) => Promise<IGetAtlasPageResponse>;
+export declare const deleteAtlasPage: (params: IDeleteAtlasPageParams) => Promise<IDeleteAtlasPageResponse>;
+export declare const updateAtlasPage: (params: IUpdateAtlasPageParams, body: IUpdateAtlasPageBody) => Promise<IUpdateAtlasPageResponse>;
+export declare const createAtlasPage: (params: ICreateAtlasPageParams, body: ICreateAtlasPageBody) => Promise<ICreateAtlasPageResponse>;
+export declare const updateAtlasPageContent: (params: IUpdateAtlasPageContentParams, body: IUpdateAtlasPageContentBody) => Promise<IUpdateAtlasPageContentResponse>;
+export declare const searchAtlasContent: (params: ISearchAtlasContentParams, query: ISearchAtlasContentQuery) => Promise<ISearchAtlasContentResponse>;
+export declare const getAtlasPageContentHistory: (params: IGetAtlasPageContentHistoryParams, query: IGetAtlasPageContentHistoryQuery) => Promise<IGetAtlasPageContentHistoryResponse>;
+export declare const restoreAtlasPageContent: (params: IRestoreAtlasPageContentParams) => Promise<IRestoreAtlasPageContentResponse>;

package/dist/api/atlas-page.api.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreAtlasPageContent = exports.getAtlasPageContentHistory = exports.searchAtlasContent = exports.updateAtlasPageContent = exports.createAtlasPage = exports.updateAtlasPage = exports.deleteAtlasPage = exports.getAtlasPage = exports.paginateAtlasPage = void 0;
+const __1 = require("..");
+const paginateAtlasPage = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`atlas/${params.atlasId}/page/paginate`, {
+        params: query,
+    })).data;
+};
+exports.paginateAtlasPage = paginateAtlasPage;
+const getAtlasPage = async (params) => {
+    return (await __1.AbyssCore.axios.get(`atlas/${params.atlasId}/page/${params.atlasPageId}`)).data;
+};
+exports.getAtlasPage = getAtlasPage;
+const deleteAtlasPage = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`atlas/${params.atlasId}/page/${params.atlasPageId}`)).data;
+};
+exports.deleteAtlasPage = deleteAtlasPage;
+const updateAtlasPage = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`atlas/${params.atlasId}/page/${params.atlasPageId}`, body)).data;
+};
+exports.updateAtlasPage = updateAtlasPage;
+const createAtlasPage = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`atlas/${params.atlasId}/page`, body)).data;
+};
+exports.createAtlasPage = createAtlasPage;
+const updateAtlasPageContent = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`atlas/${params.atlasId}/page/${params.atlasPageId}/content`, body)).data;
+};
+exports.updateAtlasPageContent = updateAtlasPageContent;
+const searchAtlasContent = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`atlas/${params.atlasId}/page/search`, {
+        params: query,
+    })).data;
+};
+exports.searchAtlasContent = searchAtlasContent;
+const getAtlasPageContentHistory = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`atlas/${params.atlasId}/page/${params.atlasPageId}/content/history`, {
+        params: query,
+    })).data;
+};
+exports.getAtlasPageContentHistory = getAtlasPageContentHistory;
+const restoreAtlasPageContent = async (params) => {
+    return (await __1.AbyssCore.axios.put(`atlas/${params.atlasId}/page/${params.atlasPageId}/content/restore/${params.version}`)).data;
+};
+exports.restoreAtlasPageContent = restoreAtlasPageContent;

package/dist/api/atlas.api.d.ts

@@ -0,0 +1,8 @@
+import { ICreateAtlasBody, ICreateAtlasResponse, ICreateForProjectAtlasParams, IDeleteAtlasParams, IDeleteAtlasResponse, IGetAtlasParams, IGetAtlasResponse, IPaginateAtlasQuery, IPaginateAtlasResponse, IPaginateProjectAtlasParams, IUpdateAtlasBody, IUpdateAtlasParams, IUpdateAtlasResponse } from '../types';
+export declare const paginateAtlas: (query: IPaginateAtlasQuery) => Promise<IPaginateAtlasResponse>;
+export declare const paginateProjectAtlas: (params: IPaginateProjectAtlasParams, query: IPaginateAtlasQuery) => Promise<IPaginateAtlasResponse>;
+export declare const getAtlas: (params: IGetAtlasParams) => Promise<IGetAtlasResponse>;
+export declare const deleteAtlas: (params: IDeleteAtlasParams) => Promise<IDeleteAtlasResponse>;
+export declare const updateAtlas: (params: IUpdateAtlasParams, body: IUpdateAtlasBody) => Promise<IUpdateAtlasResponse>;
+export declare const createAtlas: (body: ICreateAtlasBody) => Promise<ICreateAtlasResponse>;
+export declare const createForProjectAtlas: (params: ICreateForProjectAtlasParams, body: ICreateAtlasBody) => Promise<ICreateAtlasResponse>;

package/dist/api/atlas.api.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createForProjectAtlas = exports.createAtlas = exports.updateAtlas = exports.deleteAtlas = exports.getAtlas = exports.paginateProjectAtlas = exports.paginateAtlas = void 0;
+const __1 = require("..");
+const paginateAtlas = async (query) => {
+    return (await __1.AbyssCore.axios.get(`atlas/paginate`, { params: query }))
+        .data;
+};
+exports.paginateAtlas = paginateAtlas;
+const paginateProjectAtlas = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`project/${params.projectId}/atlas/paginate`, {
+        params: query,
+    })).data;
+};
+exports.paginateProjectAtlas = paginateProjectAtlas;
+const getAtlas = async (params) => {
+    return (await __1.AbyssCore.axios.get(`atlas/${params.atlasId}`)).data;
+};
+exports.getAtlas = getAtlas;
+const deleteAtlas = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`atlas/${params.atlasId}`)).data;
+};
+exports.deleteAtlas = deleteAtlas;
+const updateAtlas = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`atlas/${params.atlasId}`, body)).data;
+};
+exports.updateAtlas = updateAtlas;
+const createAtlas = async (body) => {
+    return (await __1.AbyssCore.axios.post(`atlas`, body)).data;
+};
+exports.createAtlas = createAtlas;
+const createForProjectAtlas = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`atlas/project/${params.projectId}`, body)).data;
+};
+exports.createForProjectAtlas = createForProjectAtlas;

package/dist/api/atlas.public.api.d.ts

@@ -0,0 +1,4 @@
+import { IGetAtlasPublicParams, IGetAtlasPublicResponse, IGetPageAtlasPublicParams, IGetPageAtlasPublicResponse, ISearchContentAtlasPublicParams, ISearchContentAtlasPublicQuery, ISearchContentAtlasPublicResponse } from '../types';
+export declare const getAtlasPublic: (params: IGetAtlasPublicParams) => Promise<IGetAtlasPublicResponse>;
+export declare const getPageAtlasPublic: (params: IGetPageAtlasPublicParams) => Promise<IGetPageAtlasPublicResponse>;
+export declare const searchContentAtlasPublic: (params: ISearchContentAtlasPublicParams, query: ISearchContentAtlasPublicQuery) => Promise<ISearchContentAtlasPublicResponse>;

package/dist/api/atlas.public.api.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchContentAtlasPublic = exports.getPageAtlasPublic = exports.getAtlasPublic = void 0;
+const __1 = require("..");
+const getAtlasPublic = async (params) => {
+    return (await __1.AbyssCore.axios.get(`atlas/public/${params.publicAccessToken}`)).data;
+};
+exports.getAtlasPublic = getAtlasPublic;
+const getPageAtlasPublic = async (params) => {
+    return (await __1.AbyssCore.axios.get(`atlas/public/${params.publicAccessToken}/page/${params.atlasPageId}`)).data;
+};
+exports.getPageAtlasPublic = getPageAtlasPublic;
+const searchContentAtlasPublic = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`atlas/public/${params.publicAccessToken}/search`, {
+        params: query,
+    })).data;
+};
+exports.searchContentAtlasPublic = searchContentAtlasPublic;

package/dist/api/board-card.api.d.ts

@@ -1,4 +1,4 @@
-import { IAddMemberBoardCardParams, IAddMemberBoardCardResponse, ICreateBoardCardBody, ICreateBoardCardParams, ICreateBoardCardResponse, IDeleteBoardCardParams, IDeleteBoardCardResponse, IGetAllBoardCardParams, IGetAllBoardCardQuery, IGetAllBoardCardResponse, IGetBoardCardParams, IGetBoardCardResponse, IMoveToBoardBoardCardBody, IMoveToBoardBoardCardParams, IMoveToBoardBoardCardResponse, IRemoveMemberBoardCardParams, IRemoveMemberBoardCardResponse, IRestoreBoardCardBody, IRestoreBoardCardParams, IRestoreBoardCardResponse, IUpdateBoardCardBody, IUpdateBoardCardParams, IUpdateBoardCardResponse } from '../types';
+import { IAddMemberBoardCardParams, IAddMemberBoardCardResponse, ICreateBoardCardBody, ICreateBoardCardParams, ICreateBoardCardResponse, IDeleteBoardCardParams, IDeleteBoardCardResponse, IGetAllBoardCardParams, IGetAllBoardCardQuery, IGetAllBoardCardResponse, IGetBoardCardParams, IGetBoardCardResponse, IMoveToBoardBoardCardBody, IMoveToBoardBoardCardParams, IMoveToBoardBoardCardResponse, IRemoveMemberBoardCardParams, IRemoveMemberBoardCardResponse, IRestoreBoardCardBody, IRestoreBoardCardParams, IRestoreBoardCardResponse, IUpdateBoardCardBody, IUpdateBoardCardParams, IUpdateBoardCardResponse, ISearchBoardCardParams, ISearchBoardCardQuery, ISearchBoardCardResponse } from '../types';
 export declare const getBoardCard: (params: IGetBoardCardParams) => Promise<IGetBoardCardResponse>;
 export declare const getAllBoardCard: (params: IGetAllBoardCardParams, query: IGetAllBoardCardQuery) => Promise<IGetAllBoardCardResponse>;
 export declare const deleteBoardCard: (params: IDeleteBoardCardParams) => Promise<IDeleteBoardCardResponse>;
@@ -8,3 +8,4 @@ export declare const createBoardCard: (params: ICreateBoardCardParams, body: ICr
 export declare const addMemberBoardCard: (params: IAddMemberBoardCardParams) => Promise<IAddMemberBoardCardResponse>;
 export declare const removeMemberBoardCard: (params: IRemoveMemberBoardCardParams) => Promise<IRemoveMemberBoardCardResponse>;
 export declare const moveToBoardBoardCard: (params: IMoveToBoardBoardCardParams, body: IMoveToBoardBoardCardBody) => Promise<IMoveToBoardBoardCardResponse>;
+export declare const searchBoardCard: (params: ISearchBoardCardParams, query: ISearchBoardCardQuery) => Promise<ISearchBoardCardResponse>;

package/dist/api/board-card.api.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.moveToBoardBoardCard = exports.removeMemberBoardCard = exports.addMemberBoardCard = exports.createBoardCard = exports.restoreBoardCard = exports.updateBoardCard = exports.deleteBoardCard = exports.getAllBoardCard = exports.getBoardCard = void 0;
+exports.searchBoardCard = exports.moveToBoardBoardCard = exports.removeMemberBoardCard = exports.addMemberBoardCard = exports.createBoardCard = exports.restoreBoardCard = exports.updateBoardCard = exports.deleteBoardCard = exports.getAllBoardCard = exports.getBoardCard = void 0;
 const __1 = require("..");
 const getBoardCard = async (params) => {
     return (await __1.AbyssCore.axios.get(`board/${params.boardId}/card/${params.boardCardId}`)).data;
@@ -40,3 +40,9 @@ const moveToBoardBoardCard = async (params, body) => {
     return (await __1.AbyssCore.axios.post(`board/${params.boardId}/card/${params.boardCardId}/move-to-board`, body)).data;
 };
 exports.moveToBoardBoardCard = moveToBoardBoardCard;
+const searchBoardCard = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`board/${params.boardId}/card/search`, {
+        params: query,
+    })).data;
+};
+exports.searchBoardCard = searchBoardCard;

package/dist/api/index.d.ts

@@ -31,3 +31,13 @@ export * from './board-card-checklist.api';
 export * from './board-card-document.api';
 export * from './draw.api';
 export * from './draw.public.api';
+export * from './retrospective.api';
+export * from './retrospective-card.api';
+export * from './retrospective-member.api';
+export * from './retrospective-section.api';
+export * from './retrospective.public.api';
+export * from './atlas.api';
+export * from './atlas-group.api';
+export * from './atlas-page.api';
+export * from './atlas.public.api';
+export * from './memo.api';

package/dist/api/index.js

@@ -47,3 +47,13 @@ __exportStar(require("./board-card-checklist.api"), exports);
 __exportStar(require("./board-card-document.api"), exports);
 __exportStar(require("./draw.api"), exports);
 __exportStar(require("./draw.public.api"), exports);
+__exportStar(require("./retrospective.api"), exports);
+__exportStar(require("./retrospective-card.api"), exports);
+__exportStar(require("./retrospective-member.api"), exports);
+__exportStar(require("./retrospective-section.api"), exports);
+__exportStar(require("./retrospective.public.api"), exports);
+__exportStar(require("./atlas.api"), exports);
+__exportStar(require("./atlas-group.api"), exports);
+__exportStar(require("./atlas-page.api"), exports);
+__exportStar(require("./atlas.public.api"), exports);
+__exportStar(require("./memo.api"), exports);

package/dist/api/memo.api.d.ts

@@ -0,0 +1,8 @@
+import { ICreateMemoBody, ICreateMemoResponse, ICreateForProjectMemoParams, IDeleteMemoParams, IDeleteMemoResponse, IGetMemoParams, IGetMemoResponse, IPaginateMemoQuery, IPaginateMemoResponse, IPaginateProjectMemoParams, IUpdateMemoBody, IUpdateMemoParams, IUpdateMemoResponse } from '../types';
+export declare const paginateMemo: (query: IPaginateMemoQuery) => Promise<IPaginateMemoResponse>;
+export declare const paginateProjectMemo: (params: IPaginateProjectMemoParams, query: IPaginateMemoQuery) => Promise<IPaginateMemoResponse>;
+export declare const getMemo: (params: IGetMemoParams) => Promise<IGetMemoResponse>;
+export declare const deleteMemo: (params: IDeleteMemoParams) => Promise<IDeleteMemoResponse>;
+export declare const updateMemo: (params: IUpdateMemoParams, body: IUpdateMemoBody) => Promise<IUpdateMemoResponse>;
+export declare const createMemo: (body: ICreateMemoBody) => Promise<ICreateMemoResponse>;
+export declare const createForProjectMemo: (params: ICreateForProjectMemoParams, body: ICreateMemoBody) => Promise<ICreateMemoResponse>;

package/dist/api/memo.api.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createForProjectMemo = exports.createMemo = exports.updateMemo = exports.deleteMemo = exports.getMemo = exports.paginateProjectMemo = exports.paginateMemo = void 0;
+const __1 = require("..");
+const paginateMemo = async (query) => {
+    return (await __1.AbyssCore.axios.get(`memo/paginate`, { params: query }))
+        .data;
+};
+exports.paginateMemo = paginateMemo;
+const paginateProjectMemo = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`project/${params.projectId}/memo/paginate`, {
+        params: query,
+    })).data;
+};
+exports.paginateProjectMemo = paginateProjectMemo;
+const getMemo = async (params) => {
+    return (await __1.AbyssCore.axios.get(`memo/${params.memoId}`)).data;
+};
+exports.getMemo = getMemo;
+const deleteMemo = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`memo/${params.memoId}`)).data;
+};
+exports.deleteMemo = deleteMemo;
+const updateMemo = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`memo/${params.memoId}`, body)).data;
+};
+exports.updateMemo = updateMemo;
+const createMemo = async (body) => {
+    return (await __1.AbyssCore.axios.post(`memo`, body)).data;
+};
+exports.createMemo = createMemo;
+const createForProjectMemo = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`memo/project/${params.projectId}`, body))
+        .data;
+};
+exports.createForProjectMemo = createForProjectMemo;

package/dist/api/retrospective-card.api.d.ts

@@ -0,0 +1,6 @@
+import { IGetRetrospectiveCardParams, IGetRetrospectiveCardResponse, IPaginateRetrospectiveCardParams, IPaginateRetrospectiveCardQuery, IPaginateRetrospectiveCardResponse, ICreateRetrospectiveCardParams, ICreateRetrospectiveCardBody, ICreateRetrospectiveCardResponse, IUpdateRetrospectiveCardParams, IUpdateRetrospectiveCardBody, IUpdateRetrospectiveCardResponse, IDeleteRetrospectiveCardParams, IDeleteRetrospectiveCardResponse } from '../types';
+export declare const getRetrospectiveCard: (params: IGetRetrospectiveCardParams) => Promise<IGetRetrospectiveCardResponse>;
+export declare const paginateRetrospectiveCard: (params: IPaginateRetrospectiveCardParams, query?: IPaginateRetrospectiveCardQuery) => Promise<IPaginateRetrospectiveCardResponse>;
+export declare const createRetrospectiveCard: (params: ICreateRetrospectiveCardParams, body: ICreateRetrospectiveCardBody) => Promise<ICreateRetrospectiveCardResponse>;
+export declare const updateRetrospectiveCard: (params: IUpdateRetrospectiveCardParams, body: IUpdateRetrospectiveCardBody) => Promise<IUpdateRetrospectiveCardResponse>;
+export declare const deleteRetrospectiveCard: (params: IDeleteRetrospectiveCardParams) => Promise<IDeleteRetrospectiveCardResponse>;

package/dist/api/retrospective-card.api.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteRetrospectiveCard = exports.updateRetrospectiveCard = exports.createRetrospectiveCard = exports.paginateRetrospectiveCard = exports.getRetrospectiveCard = void 0;
+const __1 = require("..");
+const getRetrospectiveCard = async (params) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/${params.retrospectiveId}/card/${params.retrospectiveCardId}`)).data;
+};
+exports.getRetrospectiveCard = getRetrospectiveCard;
+const paginateRetrospectiveCard = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/${params.retrospectiveId}/card/paginate`, {
+        params: query,
+    })).data;
+};
+exports.paginateRetrospectiveCard = paginateRetrospectiveCard;
+const createRetrospectiveCard = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`retrospective/${params.retrospectiveId}/card`, body)).data;
+};
+exports.createRetrospectiveCard = createRetrospectiveCard;
+const updateRetrospectiveCard = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`retrospective/${params.retrospectiveId}/card/${params.retrospectiveCardId}`, body)).data;
+};
+exports.updateRetrospectiveCard = updateRetrospectiveCard;
+const deleteRetrospectiveCard = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`retrospective/${params.retrospectiveId}/card/${params.retrospectiveCardId}`)).data;
+};
+exports.deleteRetrospectiveCard = deleteRetrospectiveCard;

package/dist/api/retrospective-member.api.d.ts

@@ -0,0 +1,5 @@
+import { IGetRetrospectiveMemberParams, IGetRetrospectiveMemberResponse, IListRetrospectiveMemberParams, IListRetrospectiveMemberResponse, IJoinRetrospectiveMemberParams, IJoinRetrospectiveMemberResponse, IUpdateRetrospectiveMemberParams, IUpdateRetrospectiveMemberBody, IUpdateRetrospectiveMemberResponse } from '../types';
+export declare const getRetrospectiveMember: (params: IGetRetrospectiveMemberParams) => Promise<IGetRetrospectiveMemberResponse>;
+export declare const listRetrospectiveMember: (params: IListRetrospectiveMemberParams) => Promise<IListRetrospectiveMemberResponse>;
+export declare const joinRetrospectiveMember: (params: IJoinRetrospectiveMemberParams) => Promise<IJoinRetrospectiveMemberResponse>;
+export declare const updateRetrospectiveMember: (params: IUpdateRetrospectiveMemberParams, body: IUpdateRetrospectiveMemberBody) => Promise<IUpdateRetrospectiveMemberResponse>;

package/dist/api/retrospective-member.api.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateRetrospectiveMember = exports.joinRetrospectiveMember = exports.listRetrospectiveMember = exports.getRetrospectiveMember = void 0;
+const __1 = require("..");
+const getRetrospectiveMember = async (params) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/${params.retrospectiveId}/member/${params.retrospectiveMemberId}`)).data;
+};
+exports.getRetrospectiveMember = getRetrospectiveMember;
+const listRetrospectiveMember = async (params) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/${params.retrospectiveId}/member/list`)).data;
+};
+exports.listRetrospectiveMember = listRetrospectiveMember;
+const joinRetrospectiveMember = async (params) => {
+    return (await __1.AbyssCore.axios.post(`retrospective/${params.retrospectiveId}/member/join`)).data;
+};
+exports.joinRetrospectiveMember = joinRetrospectiveMember;
+const updateRetrospectiveMember = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`retrospective/${params.retrospectiveId}/member`, body)).data;
+};
+exports.updateRetrospectiveMember = updateRetrospectiveMember;

package/dist/api/retrospective-section.api.d.ts

@@ -0,0 +1,6 @@
+import { IGetRetrospectiveSectionParams, IGetRetrospectiveSectionResponse, IPaginateRetrospectiveSectionParams, IPaginateRetrospectiveSectionQuery, IPaginateRetrospectiveSectionResponse, ICreateRetrospectiveSectionParams, ICreateRetrospectiveSectionBody, ICreateRetrospectiveSectionResponse, IUpdateRetrospectiveSectionParams, IUpdateRetrospectiveSectionBody, IUpdateRetrospectiveSectionResponse, IDeleteRetrospectiveSectionParams, IDeleteRetrospectiveSectionResponse } from '../types';
+export declare const getRetrospectiveSection: (params: IGetRetrospectiveSectionParams) => Promise<IGetRetrospectiveSectionResponse>;
+export declare const paginateRetrospectiveSection: (params: IPaginateRetrospectiveSectionParams, query?: IPaginateRetrospectiveSectionQuery) => Promise<IPaginateRetrospectiveSectionResponse>;
+export declare const createRetrospectiveSection: (params: ICreateRetrospectiveSectionParams, body: ICreateRetrospectiveSectionBody) => Promise<ICreateRetrospectiveSectionResponse>;
+export declare const updateRetrospectiveSection: (params: IUpdateRetrospectiveSectionParams, body: IUpdateRetrospectiveSectionBody) => Promise<IUpdateRetrospectiveSectionResponse>;
+export declare const deleteRetrospectiveSection: (params: IDeleteRetrospectiveSectionParams) => Promise<IDeleteRetrospectiveSectionResponse>;

package/dist/api/retrospective-section.api.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteRetrospectiveSection = exports.updateRetrospectiveSection = exports.createRetrospectiveSection = exports.paginateRetrospectiveSection = exports.getRetrospectiveSection = void 0;
+const __1 = require("..");
+const getRetrospectiveSection = async (params) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/${params.retrospectiveId}/section/${params.retrospectiveSectionId}`)).data;
+};
+exports.getRetrospectiveSection = getRetrospectiveSection;
+const paginateRetrospectiveSection = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/${params.retrospectiveId}/section/paginate`, {
+        params: query,
+    })).data;
+};
+exports.paginateRetrospectiveSection = paginateRetrospectiveSection;
+const createRetrospectiveSection = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`retrospective/${params.retrospectiveId}/section`, body)).data;
+};
+exports.createRetrospectiveSection = createRetrospectiveSection;
+const updateRetrospectiveSection = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`retrospective/${params.retrospectiveId}/section/${params.retrospectiveSectionId}`, body)).data;
+};
+exports.updateRetrospectiveSection = updateRetrospectiveSection;
+const deleteRetrospectiveSection = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`retrospective/${params.retrospectiveId}/section/${params.retrospectiveSectionId}`)).data;
+};
+exports.deleteRetrospectiveSection = deleteRetrospectiveSection;

package/dist/api/retrospective.api.d.ts

@@ -0,0 +1,8 @@
+import { IGetRetrospectiveParams, IGetRetrospectiveResponse, IPaginateProjectRetrospectiveParams, IPaginateRetrospectiveQuery, IPaginateRetrospectiveResponse, ICreateForProjectRetrospectiveParams, ICreateRetrospectiveBody, ICreateRetrospectiveResponse, IUpdateRetrospectiveParams, IUpdateRetrospectiveBody, IUpdateRetrospectiveResponse, IDeleteRetrospectiveParams, IDeleteRetrospectiveResponse } from '../types';
+export declare const getRetrospective: (params: IGetRetrospectiveParams) => Promise<IGetRetrospectiveResponse>;
+export declare const paginateProjectRetrospective: (params: IPaginateProjectRetrospectiveParams, query?: IPaginateRetrospectiveQuery) => Promise<IPaginateRetrospectiveResponse>;
+export declare const paginateRetrospective: (query?: IPaginateRetrospectiveQuery) => Promise<IPaginateRetrospectiveResponse>;
+export declare const createForProjectRetrospective: (params: ICreateForProjectRetrospectiveParams, body: ICreateRetrospectiveBody) => Promise<ICreateRetrospectiveResponse>;
+export declare const createRetrospective: (body: ICreateRetrospectiveBody) => Promise<ICreateRetrospectiveResponse>;
+export declare const updateRetrospective: (params: IUpdateRetrospectiveParams, body: IUpdateRetrospectiveBody) => Promise<IUpdateRetrospectiveResponse>;
+export declare const deleteRetrospective: (params: IDeleteRetrospectiveParams) => Promise<IDeleteRetrospectiveResponse>;

package/dist/api/retrospective.api.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteRetrospective = exports.updateRetrospective = exports.createRetrospective = exports.createForProjectRetrospective = exports.paginateRetrospective = exports.paginateProjectRetrospective = exports.getRetrospective = void 0;
+const __1 = require("..");
+const getRetrospective = async (params) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/${params.retrospectiveId}`)).data;
+};
+exports.getRetrospective = getRetrospective;
+const paginateProjectRetrospective = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`project/${params.projectId}/retrospective/paginate`, { params: query })).data;
+};
+exports.paginateProjectRetrospective = paginateProjectRetrospective;
+const paginateRetrospective = async (query) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/paginate`, {
+        params: query,
+    })).data;
+};
+exports.paginateRetrospective = paginateRetrospective;
+const createForProjectRetrospective = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`project/${params.projectId}/retrospective`, body)).data;
+};
+exports.createForProjectRetrospective = createForProjectRetrospective;
+const createRetrospective = async (body) => {
+    return (await __1.AbyssCore.axios.post(`retrospective`, body)).data;
+};
+exports.createRetrospective = createRetrospective;
+const updateRetrospective = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`retrospective/${params.retrospectiveId}`, body)).data;
+};
+exports.updateRetrospective = updateRetrospective;
+const deleteRetrospective = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`retrospective/${params.retrospectiveId}`)).data;
+};
+exports.deleteRetrospective = deleteRetrospective;

package/dist/api/retrospective.public.api.d.ts

@@ -0,0 +1,11 @@
+import { IGetRetrospectivePublicParams, IGetRetrospectivePublicResponse, IUpdateRetrospectivePublicParams, IUpdateRetrospectivePublicBody, IUpdateRetrospectivePublicResponse, ICreateSectionRetrospectivePublicParams, ICreateSectionRetrospectivePublicBody, ICreateSectionRetrospectivePublicResponse, IUpdateSectionRetrospectivePublicParams, IUpdateSectionRetrospectivePublicBody, IUpdateSectionRetrospectivePublicResponse, IDeleteSectionRetrospectivePublicParams, IDeleteSectionRetrospectivePublicResponse, IJoinMemberRetrospectivePublicParams, IJoinMemberRetrospectivePublicResponse, IUpdateMemberRetrospectivePublicParams, IUpdateMemberRetrospectivePublicBody, IUpdateMemberRetrospectivePublicResponse, ICreateCardRetrospectivePublicParams, ICreateCardRetrospectivePublicBody, ICreateCardRetrospectivePublicResponse, IUpdateCardRetrospectivePublicParams, IUpdateCardRetrospectivePublicBody, IUpdateCardRetrospectivePublicResponse, IDeleteCardRetrospectivePublicParams, IDeleteCardRetrospectivePublicResponse } from '../types';
+export declare const getRetrospectivePublic: (params: IGetRetrospectivePublicParams) => Promise<IGetRetrospectivePublicResponse>;
+export declare const updateRetrospectivePublic: (params: IUpdateRetrospectivePublicParams, body: IUpdateRetrospectivePublicBody) => Promise<IUpdateRetrospectivePublicResponse>;
+export declare const createSectionRetrospectivePublic: (params: ICreateSectionRetrospectivePublicParams, body: ICreateSectionRetrospectivePublicBody) => Promise<ICreateSectionRetrospectivePublicResponse>;
+export declare const updateSectionRetrospectivePublic: (params: IUpdateSectionRetrospectivePublicParams, body: IUpdateSectionRetrospectivePublicBody) => Promise<IUpdateSectionRetrospectivePublicResponse>;
+export declare const deleteSectionRetrospectivePublic: (params: IDeleteSectionRetrospectivePublicParams) => Promise<IDeleteSectionRetrospectivePublicResponse>;
+export declare const joinMemberRetrospectivePublic: (params: IJoinMemberRetrospectivePublicParams) => Promise<IJoinMemberRetrospectivePublicResponse>;
+export declare const updateMemberRetrospectivePublic: (params: IUpdateMemberRetrospectivePublicParams, body: IUpdateMemberRetrospectivePublicBody) => Promise<IUpdateMemberRetrospectivePublicResponse>;
+export declare const createCardRetrospectivePublic: (params: ICreateCardRetrospectivePublicParams, body: ICreateCardRetrospectivePublicBody) => Promise<ICreateCardRetrospectivePublicResponse>;
+export declare const updateCardRetrospectivePublic: (params: IUpdateCardRetrospectivePublicParams, body: IUpdateCardRetrospectivePublicBody) => Promise<IUpdateCardRetrospectivePublicResponse>;
+export declare const deleteCardRetrospectivePublic: (params: IDeleteCardRetrospectivePublicParams) => Promise<IDeleteCardRetrospectivePublicResponse>;

package/dist/api/retrospective.public.api.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteCardRetrospectivePublic = exports.updateCardRetrospectivePublic = exports.createCardRetrospectivePublic = exports.updateMemberRetrospectivePublic = exports.joinMemberRetrospectivePublic = exports.deleteSectionRetrospectivePublic = exports.updateSectionRetrospectivePublic = exports.createSectionRetrospectivePublic = exports.updateRetrospectivePublic = exports.getRetrospectivePublic = void 0;
+const __1 = require("..");
+const getRetrospectivePublic = async (params) => {
+    return (await __1.AbyssCore.axios.get(`retrospective/public/${params.accessToken}`)).data;
+};
+exports.getRetrospectivePublic = getRetrospectivePublic;
+const updateRetrospectivePublic = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`retrospective/public/${params.accessToken}`, body)).data;
+};
+exports.updateRetrospectivePublic = updateRetrospectivePublic;
+const createSectionRetrospectivePublic = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`retrospective/public/${params.accessToken}/section`, body)).data;
+};
+exports.createSectionRetrospectivePublic = createSectionRetrospectivePublic;
+const updateSectionRetrospectivePublic = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`retrospective/public/${params.accessToken}/section/${params.retrospectiveSectionId}`, body)).data;
+};
+exports.updateSectionRetrospectivePublic = updateSectionRetrospectivePublic;
+const deleteSectionRetrospectivePublic = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`retrospective/public/${params.accessToken}/section/${params.retrospectiveSectionId}`)).data;
+};
+exports.deleteSectionRetrospectivePublic = deleteSectionRetrospectivePublic;
+const joinMemberRetrospectivePublic = async (params) => {
+    return (await __1.AbyssCore.axios.post(`retrospective/public/${params.accessToken}/member/join`)).data;
+};
+exports.joinMemberRetrospectivePublic = joinMemberRetrospectivePublic;
+const updateMemberRetrospectivePublic = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`retrospective/public/${params.accessToken}/member`, body)).data;
+};
+exports.updateMemberRetrospectivePublic = updateMemberRetrospectivePublic;
+const createCardRetrospectivePublic = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`retrospective/public/${params.accessToken}/card`, body)).data;
+};
+exports.createCardRetrospectivePublic = createCardRetrospectivePublic;
+const updateCardRetrospectivePublic = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`retrospective/public/${params.accessToken}/card/${params.retrospectiveCardId}`, body)).data;
+};
+exports.updateCardRetrospectivePublic = updateCardRetrospectivePublic;
+const deleteCardRetrospectivePublic = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`retrospective/public/${params.accessToken}/card/${params.retrospectiveCardId}`)).data;
+};
+exports.deleteCardRetrospectivePublic = deleteCardRetrospectivePublic;

package/dist/constants/index.d.ts

@@ -1 +1,2 @@
 export * from './board.constants';
+export * from './memo.constants';

package/dist/constants/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./board.constants"), exports);
+__exportStar(require("./memo.constants"), exports);

package/dist/constants/memo.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MIN_MEMO_TITLE_LENGTH = 3;
+export declare const MAX_MEMO_TITLE_LENGTH = 100;
+export declare const MAX_MEMO_CONTENT_LENGTH = 10000;

package/dist/constants/memo.constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_MEMO_CONTENT_LENGTH = exports.MAX_MEMO_TITLE_LENGTH = exports.MIN_MEMO_TITLE_LENGTH = void 0;
+exports.MIN_MEMO_TITLE_LENGTH = 3;
+exports.MAX_MEMO_TITLE_LENGTH = 100;
+exports.MAX_MEMO_CONTENT_LENGTH = 10000;

package/dist/index.d.ts

@@ -9,11 +9,13 @@ export * from './server-sent-events';
 export declare const DISCORD_URL = "https://discord.gg/PVMNgxJb8W";
 export declare const API_KEY_PROJECT_HEADER = "abyss-main-project-api-key";
 export declare const ADMIN_TOKEN_HEADER = "abyss-admin-token";
+export declare const ABYSS_USER_ANONYMOUS_IDENTIFIER = "abyss_user_anonymous_identifier";
 type CoreConfig = {
     token?: string;
     projectApiKey?: string;
     adminToken?: string;
     baseURL?: string;
+    abyssUserAnonymousIdentifier?: string;
 };
 export declare class AbyssCore {
     private static config;

package/dist/index.js

@@ -30,7 +30,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbyssCore = exports.ADMIN_TOKEN_HEADER = exports.API_KEY_PROJECT_HEADER = exports.DISCORD_URL = void 0;
+exports.AbyssCore = exports.ABYSS_USER_ANONYMOUS_IDENTIFIER = exports.ADMIN_TOKEN_HEADER = exports.API_KEY_PROJECT_HEADER = exports.DISCORD_URL = void 0;
 const axios_1 = __importDefault(require("axios"));
 const axios_retry_1 = __importStar(require("axios-retry"));
 __exportStar(require("./api"), exports);
@@ -44,6 +44,7 @@ const DEFAULT_BASE_URL = 'https://app-api.abyss-project.fr/api/';
 exports.DISCORD_URL = 'https://discord.gg/PVMNgxJb8W';
 exports.API_KEY_PROJECT_HEADER = 'abyss-main-project-api-key';
 exports.ADMIN_TOKEN_HEADER = 'abyss-admin-token';
+exports.ABYSS_USER_ANONYMOUS_IDENTIFIER = 'abyss_user_anonymous_identifier';
 const NUMBER_RETRY_API = 10;
 const BASE_DELAY_BETWEEN_RETRY = 5000;
 const RETRY_CODES = [
@@ -77,6 +78,9 @@ class AbyssCore {
         if (config.adminToken) {
             _a.axios.defaults.headers.common[exports.ADMIN_TOKEN_HEADER] = `${config.adminToken}`;
         }
+        if (config.abyssUserAnonymousIdentifier) {
+            _a.axios.defaults.headers.common[exports.ABYSS_USER_ANONYMOUS_IDENTIFIER] = `${config.abyssUserAnonymousIdentifier}`;
+        }
     }
     static getConfig() {
         return _a.config;
@@ -90,5 +94,6 @@ AbyssCore.config = {
     applicationId: '',
     adminToken: '',
     baseURL: DEFAULT_BASE_URL,
+    abyssUserAnonymousIdentifier: '',
 };
 AbyssCore.axios = axios_1.default.create({ baseURL: _a.config.baseURL });

package/dist/server-sent-events/index.d.ts

@@ -3,5 +3,7 @@ export * from './protocols';
 export declare enum SSEChannels {
     BOARD = "sse:board",
     BOARD_CARD = "sse:board-card",
-    USER_NOTIFICATION = "sse:user-notification"
+    USER_NOTIFICATION = "sse:user-notification",
+    RETROSPECTIVE = "sse:retrospective",
+    ATLAS = "sse:atlas"
 }

package/dist/server-sent-events/index.js

@@ -22,4 +22,6 @@ var SSEChannels;
     SSEChannels["BOARD"] = "sse:board";
     SSEChannels["BOARD_CARD"] = "sse:board-card";
     SSEChannels["USER_NOTIFICATION"] = "sse:user-notification";
+    SSEChannels["RETROSPECTIVE"] = "sse:retrospective";
+    SSEChannels["ATLAS"] = "sse:atlas";
 })(SSEChannels || (exports.SSEChannels = SSEChannels = {}));