@abyss-project/main 1.0.63 → 1.0.65

package/dist/api/draw.api.d.ts

@@ -0,0 +1,8 @@
+import { ICreateDrawBody, ICreateDrawResponse, ICreateForProjectDrawParams, IDeleteDrawParams, IDeleteDrawResponse, IGetDrawParams, IGetDrawResponse, IPaginateDrawQuery, IPaginateDrawResponse, IPaginateProjectDrawParams, IUpdateDrawBody, IUpdateDrawParams, IUpdateDrawResponse } from '../types';
+export declare const paginateDraw: (query: IPaginateDrawQuery) => Promise<IPaginateDrawResponse>;
+export declare const paginateProjectDraw: (params: IPaginateProjectDrawParams, query: IPaginateDrawQuery) => Promise<IPaginateDrawResponse>;
+export declare const getDraw: (params: IGetDrawParams) => Promise<IGetDrawResponse>;
+export declare const deleteDraw: (params: IDeleteDrawParams) => Promise<IDeleteDrawResponse>;
+export declare const updateDraw: (params: IUpdateDrawParams, body: IUpdateDrawBody) => Promise<IUpdateDrawResponse>;
+export declare const createDraw: (body: ICreateDrawBody) => Promise<ICreateDrawResponse>;
+export declare const createForProjectDraw: (params: ICreateForProjectDrawParams, body: ICreateDrawBody) => Promise<ICreateDrawResponse>;

package/dist/api/draw.api.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createForProjectDraw = exports.createDraw = exports.updateDraw = exports.deleteDraw = exports.getDraw = exports.paginateProjectDraw = exports.paginateDraw = void 0;
+const __1 = require("..");
+const paginateDraw = async (query) => {
+    return (await __1.AbyssCore.axios.get(`draw/paginate`, { params: query }))
+        .data;
+};
+exports.paginateDraw = paginateDraw;
+const paginateProjectDraw = async (params, query) => {
+    return (await __1.AbyssCore.axios.get(`project/${params.projectId}/draw/paginate`, {
+        params: query,
+    })).data;
+};
+exports.paginateProjectDraw = paginateProjectDraw;
+const getDraw = async (params) => {
+    return (await __1.AbyssCore.axios.get(`draw/${params.drawId}`)).data;
+};
+exports.getDraw = getDraw;
+const deleteDraw = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`draw/${params.drawId}`)).data;
+};
+exports.deleteDraw = deleteDraw;
+const updateDraw = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`draw/${params.drawId}`, body)).data;
+};
+exports.updateDraw = updateDraw;
+const createDraw = async (body) => {
+    return (await __1.AbyssCore.axios.post(`draw`, body)).data;
+};
+exports.createDraw = createDraw;
+const createForProjectDraw = async (params, body) => {
+    return (await __1.AbyssCore.axios.post(`draw/project/${params.projectId}`, body))
+        .data;
+};
+exports.createForProjectDraw = createForProjectDraw;

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

@@ -0,0 +1,5 @@
+import { ICreateDrawPublicBody, ICreateDrawPublicResponse, IDeleteDrawPublicParams, IDeleteDrawPublicResponse, IGetDrawPublicParams, IGetDrawPublicResponse, IUpdateDrawPublicBody, IUpdateDrawPublicParams, IUpdateDrawPublicResponse } from '../types';
+export declare const getDrawPublic: (params: IGetDrawPublicParams) => Promise<IGetDrawPublicResponse>;
+export declare const deleteDrawPublic: (params: IDeleteDrawPublicParams) => Promise<IDeleteDrawPublicResponse>;
+export declare const updateDrawPublic: (params: IUpdateDrawPublicParams, body: IUpdateDrawPublicBody) => Promise<IUpdateDrawPublicResponse>;
+export declare const createDrawPublic: (body: ICreateDrawPublicBody) => Promise<ICreateDrawPublicResponse>;

package/dist/api/draw.public.api.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDrawPublic = exports.updateDrawPublic = exports.deleteDrawPublic = exports.getDrawPublic = void 0;
+const __1 = require("..");
+const getDrawPublic = async (params) => {
+    return (await __1.AbyssCore.axios.get(`draw/public/${params.publicAccessToken}`)).data;
+};
+exports.getDrawPublic = getDrawPublic;
+const deleteDrawPublic = async (params) => {
+    return (await __1.AbyssCore.axios.delete(`draw/public/${params.publicAccessToken}`)).data;
+};
+exports.deleteDrawPublic = deleteDrawPublic;
+const updateDrawPublic = async (params, body) => {
+    return (await __1.AbyssCore.axios.put(`draw/public/${params.publicAccessToken}`, body)).data;
+};
+exports.updateDrawPublic = updateDrawPublic;
+const createDrawPublic = async (body) => {
+    return (await __1.AbyssCore.axios.post(`draw/public`, body)).data;
+};
+exports.createDrawPublic = createDrawPublic;

package/dist/api/index.d.ts

@@ -29,3 +29,10 @@ export * from './board-label.api';
 export * from './board-card-comment.api';
 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';

package/dist/api/index.js

@@ -45,3 +45,10 @@ __exportStar(require("./board-label.api"), exports);
 __exportStar(require("./board-card-comment.api"), exports);
 __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);

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/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,6 @@ 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"
 }

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

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

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

@@ -2,6 +2,7 @@ import { ValueOf } from '../..';
 export * from './user-notification';
 export * from './board';
 export * from './board-card';
+export * from './retrospective';
 export declare enum SYSTEM_PROTOCOL_EVENTS {
     PING = "PING"
 }

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

@@ -18,6 +18,7 @@ exports.SystemSSEEventPayload = exports.SYSTEM_PROTOCOL_EVENTS = void 0;
 __exportStar(require("./user-notification"), exports);
 __exportStar(require("./board"), exports);
 __exportStar(require("./board-card"), exports);
+__exportStar(require("./retrospective"), exports);
 var SYSTEM_PROTOCOL_EVENTS;
 (function (SYSTEM_PROTOCOL_EVENTS) {
     SYSTEM_PROTOCOL_EVENTS["PING"] = "PING";

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

@@ -0,0 +1 @@
+export * from './retrospective.sse-protocol';

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./retrospective.sse-protocol"), exports);

package/dist/server-sent-events/protocols/retrospective/retrospective.sse-protocol.d.ts

@@ -0,0 +1,73 @@
+import { SystemSSEMessageContent } from '..';
+import { ValueOf } from '../../../types';
+import { IRetrospective, IRetrospectiveCard, IRetrospectiveSection, IRetrospectiveMember } from '../../../types/interface';
+export declare enum RetrospectiveSSEEvent {
+    USER_NOTIFICATION_CREATED = "USER_NOTIFICATION_CREATED",
+    RETROSPECTIVE_UPDATED = "RETROSPECTIVE_UPDATED",
+    RETROSPECTIVE_DELETED = "RETROSPECTIVE_DELETED",
+    CARD_CREATED = "CARD_CREATED",
+    CARD_UPDATED = "CARD_UPDATED",
+    CARD_DELETED = "CARD_DELETED",
+    SECTION_CREATED = "SECTION_CREATED",
+    SECTION_UPDATED = "SECTION_UPDATED",
+    SECTION_DELETED = "SECTION_DELETED",
+    MEMBER_JOINED = "MEMBER_JOINED",
+    MEMBER_UPDATED = "MEMBER_UPDATED",
+    MEMBER_LEFT = "MEMBER_LEFT"
+}
+export type RetrospectiveSSEMessageContent = ValueOf<{
+    [K in RetrospectiveSSEEvent]: {
+        type: K;
+        payload: SourceRetrospectiveSSEEventPayload[K];
+    };
+}>;
+export declare class SourceRetrospectiveSSEEventPayload implements Record<RetrospectiveSSEEvent, Record<string, any>> {
+    [RetrospectiveSSEEvent.USER_NOTIFICATION_CREATED]: {
+        retrospectiveId: string;
+    };
+    [RetrospectiveSSEEvent.RETROSPECTIVE_UPDATED]: {
+        retrospectiveId: string;
+        retrospective: IRetrospective;
+    };
+    [RetrospectiveSSEEvent.RETROSPECTIVE_DELETED]: {
+        retrospectiveId: string;
+        userId?: string;
+    };
+    [RetrospectiveSSEEvent.CARD_CREATED]: {
+        retrospectiveId: string;
+        card: IRetrospectiveCard;
+    };
+    [RetrospectiveSSEEvent.CARD_UPDATED]: {
+        retrospectiveId: string;
+        card: IRetrospectiveCard;
+    };
+    [RetrospectiveSSEEvent.CARD_DELETED]: {
+        retrospectiveId: string;
+        cardId: string;
+    };
+    [RetrospectiveSSEEvent.SECTION_CREATED]: {
+        retrospectiveId: string;
+        section: IRetrospectiveSection;
+    };
+    [RetrospectiveSSEEvent.SECTION_UPDATED]: {
+        retrospectiveId: string;
+        section: IRetrospectiveSection;
+    };
+    [RetrospectiveSSEEvent.SECTION_DELETED]: {
+        retrospectiveId: string;
+        sectionId: string;
+    };
+    [RetrospectiveSSEEvent.MEMBER_JOINED]: {
+        retrospectiveId: string;
+        member: IRetrospectiveMember;
+    };
+    [RetrospectiveSSEEvent.MEMBER_UPDATED]: {
+        retrospectiveId: string;
+        member: IRetrospectiveMember;
+    };
+    [RetrospectiveSSEEvent.MEMBER_LEFT]: {
+        retrospectiveId: string;
+        memberId: string;
+    };
+}
+export type RetrospectiveSSEEventContent = RetrospectiveSSEMessageContent | SystemSSEMessageContent;

package/dist/server-sent-events/protocols/retrospective/retrospective.sse-protocol.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceRetrospectiveSSEEventPayload = exports.RetrospectiveSSEEvent = void 0;
+var RetrospectiveSSEEvent;
+(function (RetrospectiveSSEEvent) {
+    RetrospectiveSSEEvent["USER_NOTIFICATION_CREATED"] = "USER_NOTIFICATION_CREATED";
+    RetrospectiveSSEEvent["RETROSPECTIVE_UPDATED"] = "RETROSPECTIVE_UPDATED";
+    RetrospectiveSSEEvent["RETROSPECTIVE_DELETED"] = "RETROSPECTIVE_DELETED";
+    RetrospectiveSSEEvent["CARD_CREATED"] = "CARD_CREATED";
+    RetrospectiveSSEEvent["CARD_UPDATED"] = "CARD_UPDATED";
+    RetrospectiveSSEEvent["CARD_DELETED"] = "CARD_DELETED";
+    RetrospectiveSSEEvent["SECTION_CREATED"] = "SECTION_CREATED";
+    RetrospectiveSSEEvent["SECTION_UPDATED"] = "SECTION_UPDATED";
+    RetrospectiveSSEEvent["SECTION_DELETED"] = "SECTION_DELETED";
+    RetrospectiveSSEEvent["MEMBER_JOINED"] = "MEMBER_JOINED";
+    RetrospectiveSSEEvent["MEMBER_UPDATED"] = "MEMBER_UPDATED";
+    RetrospectiveSSEEvent["MEMBER_LEFT"] = "MEMBER_LEFT";
+})(RetrospectiveSSEEvent || (exports.RetrospectiveSSEEvent = RetrospectiveSSEEvent = {}));
+class SourceRetrospectiveSSEEventPayload {
+}
+exports.SourceRetrospectiveSSEEventPayload = SourceRetrospectiveSSEEventPayload;
+RetrospectiveSSEEvent.USER_NOTIFICATION_CREATED, RetrospectiveSSEEvent.RETROSPECTIVE_UPDATED, RetrospectiveSSEEvent.RETROSPECTIVE_DELETED, RetrospectiveSSEEvent.CARD_CREATED, RetrospectiveSSEEvent.CARD_UPDATED, RetrospectiveSSEEvent.CARD_DELETED, RetrospectiveSSEEvent.SECTION_CREATED, RetrospectiveSSEEvent.SECTION_UPDATED, RetrospectiveSSEEvent.SECTION_DELETED, RetrospectiveSSEEvent.MEMBER_JOINED, RetrospectiveSSEEvent.MEMBER_UPDATED, RetrospectiveSSEEvent.MEMBER_LEFT;

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

@@ -16,7 +16,7 @@ export declare class ServerSentEventsManager<T extends ServerSentEventBaseContex
     private channel;
     private contexts;
     constructor(channelName: string);
-    add(key: string, context: T): void;
+    add(key: string, context: T, onClose: () => void): void;
     sendToContext(key: string, data: P, { senderId }?: {
         senderId?: string;
     }): void;

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

@@ -15,7 +15,7 @@ class ServerSentEventsManager {
         this.channel = channelName;
         this.contexts = new Map();
     }
-    add(key, context) {
+    add(key, context, onClose) {
         var _a, _b;
         context.res.setHeader('Content-Type', 'text/event-stream');
         context.res.setHeader('Cache-Control', 'no-cache');
@@ -40,6 +40,7 @@ class ServerSentEventsManager {
         }, 10000);
         context.res.on('close', () => {
             clearInterval(pingTimeout);
+            onClose();
             const row = this.contexts.get(key);
             row === null || row === void 0 ? void 0 : row.delete(context);
         });