@abyss-project/workspace 0.0.0-stage → 1.0.0

package/src/api/metrics.api.ts

@@ -0,0 +1,27 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IGetOrganizationWorkspaceMetricsParams,
+  IGetOrganizationWorkspaceMetricsResponse,
+  IGetProjectWorkspaceMetricsParams,
+  IGetProjectWorkspaceMetricsResponse,
+} from '../types';
+
+export const getOrganizationWorkspaceMetrics = async (
+  params: IGetOrganizationWorkspaceMetricsParams,
+): Promise<IGetOrganizationWorkspaceMetricsResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetOrganizationWorkspaceMetricsResponse>(
+      `metrics/organization/${params.organizationId}`,
+    )
+  ).data;
+};
+
+export const getProjectWorkspaceMetrics = async (
+  params: IGetProjectWorkspaceMetricsParams,
+): Promise<IGetProjectWorkspaceMetricsResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetProjectWorkspaceMetricsResponse>(
+      `metrics/project/${params.projectId}`,
+    )
+  ).data;
+};

package/src/api/monitor.api.ts

@@ -0,0 +1,6 @@
+import { AbyssWorkspaceCore } from '..';
+import { IUpMonitorResponse } from '../types';
+
+export const upMonitor = async (): Promise<IUpMonitorResponse> => {
+  return (await AbyssWorkspaceCore.axios.get<IUpMonitorResponse>(`monitor/up`)).data;
+};

package/src/api/organization.api.ts

@@ -0,0 +1,14 @@
+import { AbyssWorkspaceCore } from '..';
+import { IRecentOrganizationResponse } from '../types';
+
+export const recentOrganization = async (
+  params: { organizationId: string },
+  query?: { limit?: number },
+): Promise<IRecentOrganizationResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IRecentOrganizationResponse>(
+      `organization/${params.organizationId}/recent`,
+      { params: query },
+    )
+  ).data;
+};

package/src/api/retrospective-action.api.ts

@@ -0,0 +1,45 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICreateRetrospectiveActionParams,
+  ICreateRetrospectiveActionBody,
+  ICreateRetrospectiveActionResponse,
+  IUpdateRetrospectiveActionParams,
+  IUpdateRetrospectiveActionBody,
+  IUpdateRetrospectiveActionResponse,
+  IDeleteRetrospectiveActionParams,
+  IDeleteRetrospectiveActionResponse,
+} from '../types';
+
+export const createRetrospectiveAction = async (
+  params: ICreateRetrospectiveActionParams,
+  body: ICreateRetrospectiveActionBody,
+): Promise<ICreateRetrospectiveActionResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateRetrospectiveActionResponse>(
+      `retrospective/${params.retrospectiveId}/action`,
+      body,
+    )
+  ).data;
+};
+
+export const updateRetrospectiveAction = async (
+  params: IUpdateRetrospectiveActionParams,
+  body: IUpdateRetrospectiveActionBody,
+): Promise<IUpdateRetrospectiveActionResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateRetrospectiveActionResponse>(
+      `retrospective/${params.retrospectiveId}/action/${params.retrospectiveActionId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteRetrospectiveAction = async (
+  params: IDeleteRetrospectiveActionParams,
+): Promise<IDeleteRetrospectiveActionResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteRetrospectiveActionResponse>(
+      `retrospective/${params.retrospectiveId}/action/${params.retrospectiveActionId}`,
+    )
+  ).data;
+};

package/src/api/retrospective-card.api.ts

@@ -0,0 +1,98 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IGetRetrospectiveCardParams,
+  IGetRetrospectiveCardResponse,
+  IPaginateRetrospectiveCardParams,
+  IPaginateRetrospectiveCardQuery,
+  IPaginateRetrospectiveCardResponse,
+  ICreateRetrospectiveCardParams,
+  ICreateRetrospectiveCardBody,
+  ICreateRetrospectiveCardResponse,
+  IUpdateRetrospectiveCardParams,
+  IUpdateRetrospectiveCardBody,
+  IUpdateRetrospectiveCardResponse,
+  IDeleteRetrospectiveCardParams,
+  IDeleteRetrospectiveCardResponse,
+  IAddRetrospectiveCardVoteParams,
+  IAddRetrospectiveCardVoteResponse,
+  IRemoveRetrospectiveCardVoteParams,
+  IRemoveRetrospectiveCardVoteResponse,
+} from '../types';
+
+export const getRetrospectiveCard = async (
+  params: IGetRetrospectiveCardParams,
+): Promise<IGetRetrospectiveCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetRetrospectiveCardResponse>(
+      `retrospective/${params.retrospectiveId}/card/${params.retrospectiveCardId}`,
+    )
+  ).data;
+};
+
+export const paginateRetrospectiveCard = async (
+  params: IPaginateRetrospectiveCardParams,
+  query?: IPaginateRetrospectiveCardQuery,
+): Promise<IPaginateRetrospectiveCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateRetrospectiveCardResponse>(
+      `retrospective/${params.retrospectiveId}/card/paginate`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};
+
+export const createRetrospectiveCard = async (
+  params: ICreateRetrospectiveCardParams,
+  body: ICreateRetrospectiveCardBody,
+): Promise<ICreateRetrospectiveCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateRetrospectiveCardResponse>(
+      `retrospective/${params.retrospectiveId}/card`,
+      body,
+    )
+  ).data;
+};
+
+export const updateRetrospectiveCard = async (
+  params: IUpdateRetrospectiveCardParams,
+  body: IUpdateRetrospectiveCardBody,
+): Promise<IUpdateRetrospectiveCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateRetrospectiveCardResponse>(
+      `retrospective/${params.retrospectiveId}/card/${params.retrospectiveCardId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteRetrospectiveCard = async (
+  params: IDeleteRetrospectiveCardParams,
+): Promise<IDeleteRetrospectiveCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteRetrospectiveCardResponse>(
+      `retrospective/${params.retrospectiveId}/card/${params.retrospectiveCardId}`,
+    )
+  ).data;
+};
+
+export const addRetrospectiveCardVote = async (
+  params: IAddRetrospectiveCardVoteParams,
+): Promise<IAddRetrospectiveCardVoteResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IAddRetrospectiveCardVoteResponse>(
+      `retrospective/${params.retrospectiveId}/card/${params.retrospectiveCardId}/vote`,
+    )
+  ).data;
+};
+
+export const removeRetrospectiveCardVote = async (
+  params: IRemoveRetrospectiveCardVoteParams,
+): Promise<IRemoveRetrospectiveCardVoteResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IRemoveRetrospectiveCardVoteResponse>(
+      `retrospective/${params.retrospectiveId}/card/${params.retrospectiveCardId}/vote`,
+    )
+  ).data;
+};

package/src/api/retrospective-member.api.ts

@@ -0,0 +1,54 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IGetRetrospectiveMemberParams,
+  IGetRetrospectiveMemberResponse,
+  IListRetrospectiveMemberParams,
+  IListRetrospectiveMemberResponse,
+  IJoinRetrospectiveMemberParams,
+  IJoinRetrospectiveMemberResponse,
+  IUpdateRetrospectiveMemberParams,
+  IUpdateRetrospectiveMemberBody,
+  IUpdateRetrospectiveMemberResponse,
+} from '../types';
+
+export const getRetrospectiveMember = async (
+  params: IGetRetrospectiveMemberParams,
+): Promise<IGetRetrospectiveMemberResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetRetrospectiveMemberResponse>(
+      `retrospective/${params.retrospectiveId}/member/${params.retrospectiveMemberId}`,
+    )
+  ).data;
+};
+
+export const listRetrospectiveMember = async (
+  params: IListRetrospectiveMemberParams,
+): Promise<IListRetrospectiveMemberResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IListRetrospectiveMemberResponse>(
+      `retrospective/${params.retrospectiveId}/member/list`,
+    )
+  ).data;
+};
+
+export const joinRetrospectiveMember = async (
+  params: IJoinRetrospectiveMemberParams,
+): Promise<IJoinRetrospectiveMemberResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IJoinRetrospectiveMemberResponse>(
+      `retrospective/${params.retrospectiveId}/member/join`,
+    )
+  ).data;
+};
+
+export const updateRetrospectiveMember = async (
+  params: IUpdateRetrospectiveMemberParams,
+  body: IUpdateRetrospectiveMemberBody,
+): Promise<IUpdateRetrospectiveMemberResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateRetrospectiveMemberResponse>(
+      `retrospective/${params.retrospectiveId}/member`,
+      body,
+    )
+  ).data;
+};

package/src/api/retrospective-section.api.ts

@@ -0,0 +1,74 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IGetRetrospectiveSectionParams,
+  IGetRetrospectiveSectionResponse,
+  IPaginateRetrospectiveSectionParams,
+  IPaginateRetrospectiveSectionQuery,
+  IPaginateRetrospectiveSectionResponse,
+  ICreateRetrospectiveSectionParams,
+  ICreateRetrospectiveSectionBody,
+  ICreateRetrospectiveSectionResponse,
+  IUpdateRetrospectiveSectionParams,
+  IUpdateRetrospectiveSectionBody,
+  IUpdateRetrospectiveSectionResponse,
+  IDeleteRetrospectiveSectionParams,
+  IDeleteRetrospectiveSectionResponse,
+} from '../types';
+
+export const getRetrospectiveSection = async (
+  params: IGetRetrospectiveSectionParams,
+): Promise<IGetRetrospectiveSectionResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetRetrospectiveSectionResponse>(
+      `retrospective/${params.retrospectiveId}/section/${params.retrospectiveSectionId}`,
+    )
+  ).data;
+};
+
+export const paginateRetrospectiveSection = async (
+  params: IPaginateRetrospectiveSectionParams,
+  query?: IPaginateRetrospectiveSectionQuery,
+): Promise<IPaginateRetrospectiveSectionResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateRetrospectiveSectionResponse>(
+      `retrospective/${params.retrospectiveId}/section/paginate`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};
+
+export const createRetrospectiveSection = async (
+  params: ICreateRetrospectiveSectionParams,
+  body: ICreateRetrospectiveSectionBody,
+): Promise<ICreateRetrospectiveSectionResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateRetrospectiveSectionResponse>(
+      `retrospective/${params.retrospectiveId}/section`,
+      body,
+    )
+  ).data;
+};
+
+export const updateRetrospectiveSection = async (
+  params: IUpdateRetrospectiveSectionParams,
+  body: IUpdateRetrospectiveSectionBody,
+): Promise<IUpdateRetrospectiveSectionResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateRetrospectiveSectionResponse>(
+      `retrospective/${params.retrospectiveId}/section/${params.retrospectiveSectionId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteRetrospectiveSection = async (
+  params: IDeleteRetrospectiveSectionParams,
+): Promise<IDeleteRetrospectiveSectionResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteRetrospectiveSectionResponse>(
+      `retrospective/${params.retrospectiveId}/section/${params.retrospectiveSectionId}`,
+    )
+  ).data;
+};

package/src/api/retrospective.api.ts

@@ -0,0 +1,142 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IGetRetrospectiveParams,
+  IGetRetrospectiveResponse,
+  IPaginateProjectRetrospectiveParams,
+  IPaginateRetrospectiveQuery,
+  IPaginateRetrospectiveResponse,
+  ICreateForOrganizationRetrospectiveParams,
+  ICreateRetrospectiveBody,
+  ICreateRetrospectiveResponse,
+  IUpdateRetrospectiveParams,
+  IUpdateRetrospectiveBody,
+  IUpdateRetrospectiveResponse,
+  IUpdateRetrospectivePhaseParams,
+  IUpdateRetrospectivePhaseBody,
+  IUpdateRetrospectivePhaseResponse,
+  IDeleteRetrospectiveParams,
+  IDeleteRetrospectiveResponse,
+  IPaginateOrganizationRetrospectiveParams,
+  ITransferContentBody,
+  ITransferRetrospectiveResponse,
+  ICountOrganizationResponse,
+} from '../types';
+
+export const getRetrospective = async (
+  params: IGetRetrospectiveParams,
+): Promise<IGetRetrospectiveResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetRetrospectiveResponse>(
+      `retrospective/${params.retrospectiveId}`,
+    )
+  ).data;
+};
+
+export const paginateProjectRetrospective = async (
+  params: IPaginateProjectRetrospectiveParams,
+  query?: IPaginateRetrospectiveQuery,
+): Promise<IPaginateRetrospectiveResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateRetrospectiveResponse>(
+      `project/${params.projectId}/retrospective/paginate`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const paginateRetrospective = async (
+  query?: IPaginateRetrospectiveQuery,
+): Promise<IPaginateRetrospectiveResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateRetrospectiveResponse>(`retrospective/paginate`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const createRetrospective = async (
+  body: ICreateRetrospectiveBody,
+): Promise<ICreateRetrospectiveResponse> => {
+  return (await AbyssWorkspaceCore.axios.post<ICreateRetrospectiveResponse>(`retrospective`, body))
+    .data;
+};
+
+export const createForOrganizationRetrospective = async (
+  params: ICreateForOrganizationRetrospectiveParams,
+  body: ICreateRetrospectiveBody,
+): Promise<ICreateRetrospectiveResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateRetrospectiveResponse>(
+      `retrospective/organization/${params.organizationId}`,
+      body,
+    )
+  ).data;
+};
+
+export const updateRetrospective = async (
+  params: IUpdateRetrospectiveParams,
+  body: IUpdateRetrospectiveBody,
+): Promise<IUpdateRetrospectiveResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateRetrospectiveResponse>(
+      `retrospective/${params.retrospectiveId}`,
+      body,
+    )
+  ).data;
+};
+
+export const updateRetrospectivePhase = async (
+  params: IUpdateRetrospectivePhaseParams,
+  body: IUpdateRetrospectivePhaseBody,
+): Promise<IUpdateRetrospectivePhaseResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateRetrospectivePhaseResponse>(
+      `retrospective/${params.retrospectiveId}/phase`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteRetrospective = async (
+  params: IDeleteRetrospectiveParams,
+): Promise<IDeleteRetrospectiveResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteRetrospectiveResponse>(
+      `retrospective/${params.retrospectiveId}`,
+    )
+  ).data;
+};
+
+export const paginateOrganizationRetrospective = async (
+  params: IPaginateOrganizationRetrospectiveParams,
+  query?: IPaginateRetrospectiveQuery,
+): Promise<IPaginateRetrospectiveResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateRetrospectiveResponse>(
+      `organization/${params.organizationId}/retrospective/paginate`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const transferRetrospective = async (
+  params: { retrospectiveId: string },
+  body: ITransferContentBody,
+): Promise<ITransferRetrospectiveResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ITransferRetrospectiveResponse>(
+      `retrospective/${params.retrospectiveId}/transfer`,
+      body,
+    )
+  ).data;
+};
+
+export const countOrganizationRetrospective = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<ICountOrganizationResponse>(
+      `retrospective/organization/${params.organizationId}/count`,
+    )
+  ).data;
+};

package/src/api/retrospective.public.api.ts

@@ -0,0 +1,217 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IGetRetrospectivePublicParams,
+  IGetRetrospectivePublicResponse,
+  IUpdateRetrospectivePublicParams,
+  IUpdateRetrospectivePublicBody,
+  IUpdateRetrospectivePublicResponse,
+  // Section
+  ICreateSectionRetrospectivePublicParams,
+  ICreateSectionRetrospectivePublicBody,
+  ICreateSectionRetrospectivePublicResponse,
+  IUpdateSectionRetrospectivePublicParams,
+  IUpdateSectionRetrospectivePublicBody,
+  IUpdateSectionRetrospectivePublicResponse,
+  IDeleteSectionRetrospectivePublicParams,
+  IDeleteSectionRetrospectivePublicResponse,
+  // Member
+  IJoinMemberRetrospectivePublicParams,
+  IJoinMemberRetrospectivePublicResponse,
+  IUpdateMemberRetrospectivePublicParams,
+  IUpdateMemberRetrospectivePublicBody,
+  IUpdateMemberRetrospectivePublicResponse,
+  // Card
+  ICreateCardRetrospectivePublicParams,
+  ICreateCardRetrospectivePublicBody,
+  ICreateCardRetrospectivePublicResponse,
+  IUpdateCardRetrospectivePublicParams,
+  IUpdateCardRetrospectivePublicBody,
+  IUpdateCardRetrospectivePublicResponse,
+  IDeleteCardRetrospectivePublicParams,
+  IDeleteCardRetrospectivePublicResponse,
+  // Vote
+  IAddCardVoteRetrospectivePublicParams,
+  IAddCardVoteRetrospectivePublicResponse,
+  IRemoveCardVoteRetrospectivePublicParams,
+  IRemoveCardVoteRetrospectivePublicResponse,
+  // Action
+  ICreateActionRetrospectivePublicParams,
+  ICreateActionRetrospectivePublicBody,
+  ICreateActionRetrospectivePublicResponse,
+  IUpdateActionRetrospectivePublicParams,
+  IUpdateActionRetrospectivePublicBody,
+  IUpdateActionRetrospectivePublicResponse,
+  IDeleteActionRetrospectivePublicParams,
+  IDeleteActionRetrospectivePublicResponse,
+} from '../types';
+
+export const getRetrospectivePublic = async (
+  params: IGetRetrospectivePublicParams,
+): Promise<IGetRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}`,
+    )
+  ).data;
+};
+
+export const updateRetrospectivePublic = async (
+  params: IUpdateRetrospectivePublicParams,
+  body: IUpdateRetrospectivePublicBody,
+): Promise<IUpdateRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}`,
+      body,
+    )
+  ).data;
+};
+
+// Section methods
+export const createSectionRetrospectivePublic = async (
+  params: ICreateSectionRetrospectivePublicParams,
+  body: ICreateSectionRetrospectivePublicBody,
+): Promise<ICreateSectionRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateSectionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/section`,
+      body,
+    )
+  ).data;
+};
+
+export const updateSectionRetrospectivePublic = async (
+  params: IUpdateSectionRetrospectivePublicParams,
+  body: IUpdateSectionRetrospectivePublicBody,
+): Promise<IUpdateSectionRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateSectionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/section/${params.retrospectiveSectionId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteSectionRetrospectivePublic = async (
+  params: IDeleteSectionRetrospectivePublicParams,
+): Promise<IDeleteSectionRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteSectionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/section/${params.retrospectiveSectionId}`,
+    )
+  ).data;
+};
+
+// Member methods
+export const joinMemberRetrospectivePublic = async (
+  params: IJoinMemberRetrospectivePublicParams,
+): Promise<IJoinMemberRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IJoinMemberRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/member/join`,
+    )
+  ).data;
+};
+
+export const updateMemberRetrospectivePublic = async (
+  params: IUpdateMemberRetrospectivePublicParams,
+  body: IUpdateMemberRetrospectivePublicBody,
+): Promise<IUpdateMemberRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateMemberRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/member`,
+      body,
+    )
+  ).data;
+};
+
+// Card methods
+export const createCardRetrospectivePublic = async (
+  params: ICreateCardRetrospectivePublicParams,
+  body: ICreateCardRetrospectivePublicBody,
+): Promise<ICreateCardRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateCardRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/card`,
+      body,
+    )
+  ).data;
+};
+
+export const updateCardRetrospectivePublic = async (
+  params: IUpdateCardRetrospectivePublicParams,
+  body: IUpdateCardRetrospectivePublicBody,
+): Promise<IUpdateCardRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateCardRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/card/${params.retrospectiveCardId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteCardRetrospectivePublic = async (
+  params: IDeleteCardRetrospectivePublicParams,
+): Promise<IDeleteCardRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteCardRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/card/${params.retrospectiveCardId}`,
+    )
+  ).data;
+};
+
+// Vote methods
+export const addCardVoteRetrospectivePublic = async (
+  params: IAddCardVoteRetrospectivePublicParams,
+): Promise<IAddCardVoteRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IAddCardVoteRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/card/${params.retrospectiveCardId}/vote`,
+    )
+  ).data;
+};
+
+export const removeCardVoteRetrospectivePublic = async (
+  params: IRemoveCardVoteRetrospectivePublicParams,
+): Promise<IRemoveCardVoteRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IRemoveCardVoteRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/card/${params.retrospectiveCardId}/vote`,
+    )
+  ).data;
+};
+
+// Action methods
+export const createActionRetrospectivePublic = async (
+  params: ICreateActionRetrospectivePublicParams,
+  body: ICreateActionRetrospectivePublicBody,
+): Promise<ICreateActionRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateActionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/action`,
+      body,
+    )
+  ).data;
+};
+
+export const updateActionRetrospectivePublic = async (
+  params: IUpdateActionRetrospectivePublicParams,
+  body: IUpdateActionRetrospectivePublicBody,
+): Promise<IUpdateActionRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateActionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/action/${params.retrospectiveActionId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteActionRetrospectivePublic = async (
+  params: IDeleteActionRetrospectivePublicParams,
+): Promise<IDeleteActionRetrospectivePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteActionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/action/${params.retrospectiveActionId}`,
+    )
+  ).data;
+};