@abyss-project/tools 1.0.0

package/src/api/atlas.public.api.ts

@@ -0,0 +1,42 @@
+import { AbyssToolsCore } from '..';
+import {
+  IGetAtlasPublicParams,
+  IGetAtlasPublicResponse,
+  IGetPageAtlasPublicParams,
+  IGetPageAtlasPublicResponse,
+  ISearchContentAtlasPublicParams,
+  ISearchContentAtlasPublicQuery,
+  ISearchContentAtlasPublicResponse,
+} from '../types';
+
+export const getAtlasPublic = async (
+  params: IGetAtlasPublicParams,
+): Promise<IGetAtlasPublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetAtlasPublicResponse>(`atlas/public/${params.publicAccessToken}`)
+  ).data;
+};
+
+export const getPageAtlasPublic = async (
+  params: IGetPageAtlasPublicParams,
+): Promise<IGetPageAtlasPublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetPageAtlasPublicResponse>(
+      `atlas/public/${params.publicAccessToken}/page/${params.atlasPageId}`,
+    )
+  ).data;
+};
+
+export const searchContentAtlasPublic = async (
+  params: ISearchContentAtlasPublicParams,
+  query: ISearchContentAtlasPublicQuery,
+): Promise<ISearchContentAtlasPublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<ISearchContentAtlasPublicResponse>(
+      `atlas/public/${params.publicAccessToken}/search`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};

package/src/api/board-card-checklist.api.ts

@@ -0,0 +1,99 @@
+import { AbyssToolsCore } from '..';
+import {
+  IAddRowBoardCardChecklistBody,
+  IAddRowBoardCardChecklistParams,
+  IAddRowBoardCardChecklistResponse,
+  ICreateBoardCardChecklistBody,
+  ICreateBoardCardChecklistParams,
+  ICreateBoardCardChecklistResponse,
+  IDeleteBoardCardChecklistParams,
+  IDeleteBoardCardChecklistResponse,
+  IGetBoardCardChecklistParams,
+  IGetBoardCardChecklistResponse,
+  IRemoveRowBoardCardChecklistParams,
+  IRemoveRowBoardCardChecklistResponse,
+  IUpdateBoardCardChecklistBody,
+  IUpdateBoardCardChecklistParams,
+  IUpdateBoardCardChecklistResponse,
+  IUpdateRowBoardCardChecklistBody,
+  IUpdateRowBoardCardChecklistParams,
+  IUpdateRowBoardCardChecklistResponse,
+} from '../types';
+
+export const getBoardCardChecklist = async (
+  params: IGetBoardCardChecklistParams,
+): Promise<IGetBoardCardChecklistResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardCardChecklist = async (
+  params: IDeleteBoardCardChecklistParams,
+): Promise<IDeleteBoardCardChecklistResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}`,
+    )
+  ).data;
+};
+
+export const updateBoardCardChecklist = async (
+  params: IUpdateBoardCardChecklistParams,
+  body: IUpdateBoardCardChecklistBody,
+): Promise<IUpdateBoardCardChecklistResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardCardChecklist = async (
+  params: ICreateBoardCardChecklistParams,
+  body: ICreateBoardCardChecklistBody,
+): Promise<ICreateBoardCardChecklistResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist`,
+      body,
+    )
+  ).data;
+};
+
+export const addRowBoardCardChecklist = async (
+  params: IAddRowBoardCardChecklistParams,
+  body: IAddRowBoardCardChecklistBody,
+): Promise<IAddRowBoardCardChecklistResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IAddRowBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}/row`,
+      body,
+    )
+  ).data;
+};
+
+export const removeRowBoardCardChecklist = async (
+  params: IRemoveRowBoardCardChecklistParams,
+): Promise<IRemoveRowBoardCardChecklistResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IRemoveRowBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}/row/${params.boardCardChecklistRowId}`,
+    )
+  ).data;
+};
+
+export const updateRowBoardCardChecklist = async (
+  params: IUpdateRowBoardCardChecklistParams,
+  body: IUpdateRowBoardCardChecklistBody,
+): Promise<IUpdateRowBoardCardChecklistResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateRowBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}/row/${params.boardCardChecklistRowId}`,
+      body,
+    )
+  ).data;
+};

package/src/api/board-card-comment.api.ts

@@ -0,0 +1,57 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICreateBoardCardCommentBody,
+  ICreateBoardCardCommentParams,
+  ICreateBoardCardCommentResponse,
+  IDeleteBoardCardCommentParams,
+  IDeleteBoardCardCommentResponse,
+  IGetBoardCardCommentParams,
+  IGetBoardCardCommentResponse,
+  IUpdateBoardCardCommentBody,
+  IUpdateBoardCardCommentParams,
+  IUpdateBoardCardCommentResponse,
+} from '../types';
+
+export const getBoardCardComment = async (
+  params: IGetBoardCardCommentParams,
+): Promise<IGetBoardCardCommentResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetBoardCardCommentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/comment/${params.boardCardCommentId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardCardComment = async (
+  params: IDeleteBoardCardCommentParams,
+): Promise<IDeleteBoardCardCommentResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteBoardCardCommentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/comment/${params.boardCardCommentId}`,
+    )
+  ).data;
+};
+
+export const updateBoardCardComment = async (
+  params: IUpdateBoardCardCommentParams,
+  body: IUpdateBoardCardCommentBody,
+): Promise<IUpdateBoardCardCommentResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateBoardCardCommentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/comment/${params.boardCardCommentId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardCardComment = async (
+  params: ICreateBoardCardCommentParams,
+  body: ICreateBoardCardCommentBody,
+): Promise<ICreateBoardCardCommentResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateBoardCardCommentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/comment`,
+      body,
+    )
+  ).data;
+};

package/src/api/board-card-document.api.ts

@@ -0,0 +1,57 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICloudImportBoardCardDocumentBody,
+  ICloudImportBoardCardDocumentParams,
+  ICloudImportBoardCardDocumentResponse,
+  IDeleteBoardCardDocumentParams,
+  IDeleteBoardCardDocumentResponse,
+  IGetBoardCardDocumentParams,
+  IGetBoardCardDocumentResponse,
+  IGetUploadPreSignedUrlBoardCardDocumentBody,
+  IGetUploadPreSignedUrlBoardCardDocumentParams,
+  IGetUploadPreSignedUrlBoardCardDocumentResponse,
+} from '../types';
+
+export const getBoardCardDocument = async (
+  params: IGetBoardCardDocumentParams,
+): Promise<IGetBoardCardDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetBoardCardDocumentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/document/${params.boardCardDocumentId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardCardDocument = async (
+  params: IDeleteBoardCardDocumentParams,
+): Promise<IDeleteBoardCardDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteBoardCardDocumentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/document/${params.boardCardDocumentId}`,
+    )
+  ).data;
+};
+
+export const getUploadPreSignedUrlBoardCardDocument = async (
+  params: IGetUploadPreSignedUrlBoardCardDocumentParams,
+  body: IGetUploadPreSignedUrlBoardCardDocumentBody,
+): Promise<IGetUploadPreSignedUrlBoardCardDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IGetUploadPreSignedUrlBoardCardDocumentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/document`,
+      body,
+    )
+  ).data;
+};
+
+export const cloudImportBoardCardDocument = async (
+  params: ICloudImportBoardCardDocumentParams,
+  body: ICloudImportBoardCardDocumentBody,
+): Promise<ICloudImportBoardCardDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICloudImportBoardCardDocumentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/document/cloud-import`,
+      body,
+    )
+  ).data;
+};

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

@@ -0,0 +1,137 @@
+import { AbyssToolsCore } from '..';
+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 const getBoardCard = async (params: IGetBoardCardParams): Promise<IGetBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}`,
+    )
+  ).data;
+};
+
+export const getAllBoardCard = async (
+  params: IGetAllBoardCardParams,
+  query: IGetAllBoardCardQuery,
+): Promise<IGetAllBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetAllBoardCardResponse>(`board/${params.boardId}/card`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const deleteBoardCard = async (
+  params: IDeleteBoardCardParams,
+): Promise<IDeleteBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}`,
+    )
+  ).data;
+};
+
+export const updateBoardCard = async (
+  params: IUpdateBoardCardParams,
+  body: IUpdateBoardCardBody,
+): Promise<IUpdateBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}`,
+      body,
+    )
+  ).data;
+};
+
+export const restoreBoardCard = async (
+  params: IRestoreBoardCardParams,
+  body: IRestoreBoardCardBody,
+): Promise<IRestoreBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IRestoreBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/restore`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardCard = async (
+  params: ICreateBoardCardParams,
+  body: ICreateBoardCardBody,
+): Promise<ICreateBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardColumnId}`,
+      body,
+    )
+  ).data;
+};
+
+export const addMemberBoardCard = async (
+  params: IAddMemberBoardCardParams,
+): Promise<IAddMemberBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IAddMemberBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/member/${params.userId}`,
+    )
+  ).data;
+};
+
+export const removeMemberBoardCard = async (
+  params: IRemoveMemberBoardCardParams,
+): Promise<IRemoveMemberBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IRemoveMemberBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/member/${params.userId}`,
+    )
+  ).data;
+};
+
+export const moveToBoardBoardCard = async (
+  params: IMoveToBoardBoardCardParams,
+  body: IMoveToBoardBoardCardBody,
+): Promise<IMoveToBoardBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IMoveToBoardBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/move-to-board`,
+      body,
+    )
+  ).data;
+};
+
+export const searchBoardCard = async (
+  params: ISearchBoardCardParams,
+  query: ISearchBoardCardQuery,
+): Promise<ISearchBoardCardResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<ISearchBoardCardResponse>(`board/${params.boardId}/card/search`, {
+      params: query,
+    })
+  ).data;
+};

package/src/api/board-column.api.ts

@@ -0,0 +1,54 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICreateBoardColumnBody,
+  ICreateBoardColumnParams,
+  ICreateBoardColumnResponse,
+  IDeleteBoardColumnParams,
+  IDeleteBoardColumnResponse,
+  IGetBoardColumnParams,
+  IGetBoardColumnResponse,
+  IUpdateBoardColumnBody,
+  IUpdateBoardColumnParams,
+  IUpdateBoardColumnResponse,
+} from '../types';
+
+export const getBoardColumn = async (
+  params: IGetBoardColumnParams,
+): Promise<IGetBoardColumnResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetBoardColumnResponse>(
+      `board/${params.boardId}/column/${params.boardColumnId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardColumn = async (
+  params: IDeleteBoardColumnParams,
+): Promise<IDeleteBoardColumnResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteBoardColumnResponse>(
+      `board/${params.boardId}/column/${params.boardColumnId}`,
+    )
+  ).data;
+};
+
+export const updateBoardColumn = async (
+  params: IUpdateBoardColumnParams,
+  body: IUpdateBoardColumnBody,
+): Promise<IUpdateBoardColumnResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateBoardColumnResponse>(
+      `board/${params.boardId}/column/${params.boardColumnId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardColumn = async (
+  params: ICreateBoardColumnParams,
+  body: ICreateBoardColumnBody,
+): Promise<ICreateBoardColumnResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateBoardColumnResponse>(`board/${params.boardId}/column`, body)
+  ).data;
+};

package/src/api/board-label.api.ts

@@ -0,0 +1,87 @@
+import { AbyssToolsCore } from '..';
+import {
+  IAddBoardLabelParams,
+  IAddBoardLabelResponse,
+  ICreateBoardLabelBody,
+  ICreateBoardLabelParams,
+  ICreateBoardLabelResponse,
+  IDeleteBoardLabelParams,
+  IDeleteBoardLabelResponse,
+  IGetBoardLabelParams,
+  IGetBoardLabelResponse,
+  IListBoardLabelParams,
+  IListBoardLabelResponse,
+  IRemoveBoardLabelParams,
+  IRemoveBoardLabelResponse,
+  IUpdateBoardLabelBody,
+  IUpdateBoardLabelParams,
+  IUpdateBoardLabelResponse,
+} from '../types';
+
+export const getBoardLabel = async (
+  params: IGetBoardLabelParams,
+): Promise<IGetBoardLabelResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardLabel = async (
+  params: IDeleteBoardLabelParams,
+): Promise<IDeleteBoardLabelResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}`,
+    )
+  ).data;
+};
+
+export const updateBoardLabel = async (
+  params: IUpdateBoardLabelParams,
+  body: IUpdateBoardLabelBody,
+): Promise<IUpdateBoardLabelResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardLabel = async (
+  params: ICreateBoardLabelParams,
+  body: ICreateBoardLabelBody,
+): Promise<ICreateBoardLabelResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateBoardLabelResponse>(`board/${params.boardId}/label`, body)
+  ).data;
+};
+
+export const addBoardLabel = async (
+  params: IAddBoardLabelParams,
+): Promise<IAddBoardLabelResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IAddBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}/card/${params.boardCardId}`,
+    )
+  ).data;
+};
+
+export const removeBoardLabel = async (
+  params: IRemoveBoardLabelParams,
+): Promise<IRemoveBoardLabelResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IRemoveBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}/card/${params.boardCardId}`,
+    )
+  ).data;
+};
+
+export const listBoardLabels = async (
+  params: IListBoardLabelParams,
+): Promise<IListBoardLabelResponse> => {
+  return (await AbyssToolsCore.axios.get<IListBoardLabelResponse>(`board/${params.boardId}/label/list`))
+    .data;
+};

package/src/api/board.api.ts

@@ -0,0 +1,67 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICreateBoardBody,
+  ICreateBoardResponse,
+  ICreateForProjectBoardParams,
+  IDeleteBoardParams,
+  IDeleteBoardResponse,
+  IGetBoardParams,
+  IGetBoardResponse,
+  IGetBySlugBoardParams,
+  IGetBySlugBoardResponse,
+  IGetNextCardPreviewBoardResponse,
+  IListBoardUserResponse,
+  IUpdateBoardBody,
+  IUpdateBoardParams,
+  IUpdateBoardResponse,
+} from '../types';
+
+export const getBoard = async (params: IGetBoardParams): Promise<IGetBoardResponse> => {
+  return (await AbyssToolsCore.axios.get<IGetBoardResponse>(`board/${params.boardId}`)).data;
+};
+
+export const getBySlugBoard = async (
+  params: IGetBySlugBoardParams,
+): Promise<IGetBySlugBoardResponse> => {
+  return (await AbyssToolsCore.axios.get<IGetBySlugBoardResponse>(`board/slug/${params.slug}`)).data;
+};
+
+export const deleteBoard = async (params: IDeleteBoardParams): Promise<IDeleteBoardResponse> => {
+  return (await AbyssToolsCore.axios.delete<IDeleteBoardResponse>(`board/${params.boardId}`)).data;
+};
+
+export const updateBoard = async (
+  params: IUpdateBoardParams,
+  body: IUpdateBoardBody,
+): Promise<IUpdateBoardResponse> => {
+  return (await AbyssToolsCore.axios.put<IUpdateBoardResponse>(`board/${params.boardId}`, body)).data;
+};
+
+export const createBoard = async (body: ICreateBoardBody): Promise<ICreateBoardResponse> => {
+  return (await AbyssToolsCore.axios.post<ICreateBoardResponse>(`board`, body)).data;
+};
+export const createForProjectBoard = async (
+  params: ICreateForProjectBoardParams,
+  body: ICreateBoardBody,
+): Promise<ICreateBoardResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateBoardResponse>(`board/project/${params.projectId}`, body)
+  ).data;
+};
+
+export const listBoard = async (): Promise<IListBoardUserResponse> => {
+  return (await AbyssToolsCore.axios.get<IListBoardUserResponse>('board/list')).data;
+};
+
+export const listBoardProject = async (params: {
+  projectId: string;
+}): Promise<IListBoardUserResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IListBoardUserResponse>(`board/project/${params.projectId}/list`)
+  ).data;
+};
+
+export const getNextCardPreviewBoard = async (): Promise<IGetNextCardPreviewBoardResponse> => {
+  return (await AbyssToolsCore.axios.post<IGetNextCardPreviewBoardResponse>(`board/next-card-preview`))
+    .data;
+};

package/src/api/draw.api.ts

@@ -0,0 +1,58 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICreateDrawBody,
+  ICreateDrawResponse,
+  ICreateForProjectDrawParams,
+  IDeleteDrawParams,
+  IDeleteDrawResponse,
+  IGetDrawParams,
+  IGetDrawResponse,
+  IPaginateDrawQuery,
+  IPaginateDrawResponse,
+  IPaginateProjectDrawParams,
+  IUpdateDrawBody,
+  IUpdateDrawParams,
+  IUpdateDrawResponse,
+} from '../types';
+
+export const paginateDraw = async (query: IPaginateDrawQuery): Promise<IPaginateDrawResponse> => {
+  return (await AbyssToolsCore.axios.get<IPaginateDrawResponse>(`draw/paginate`, { params: query }))
+    .data;
+};
+
+export const paginateProjectDraw = async (
+  params: IPaginateProjectDrawParams,
+  query: IPaginateDrawQuery,
+): Promise<IPaginateDrawResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IPaginateDrawResponse>(`project/${params.projectId}/draw/paginate`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const getDraw = async (params: IGetDrawParams): Promise<IGetDrawResponse> => {
+  return (await AbyssToolsCore.axios.get<IGetDrawResponse>(`draw/${params.drawId}`)).data;
+};
+
+export const deleteDraw = async (params: IDeleteDrawParams): Promise<IDeleteDrawResponse> => {
+  return (await AbyssToolsCore.axios.delete<IDeleteDrawResponse>(`draw/${params.drawId}`)).data;
+};
+
+export const updateDraw = async (
+  params: IUpdateDrawParams,
+  body: IUpdateDrawBody,
+): Promise<IUpdateDrawResponse> => {
+  return (await AbyssToolsCore.axios.put<IUpdateDrawResponse>(`draw/${params.drawId}`, body)).data;
+};
+
+export const createDraw = async (body: ICreateDrawBody): Promise<ICreateDrawResponse> => {
+  return (await AbyssToolsCore.axios.post<ICreateDrawResponse>(`draw`, body)).data;
+};
+export const createForProjectDraw = async (
+  params: ICreateForProjectDrawParams,
+  body: ICreateDrawBody,
+): Promise<ICreateDrawResponse> => {
+  return (await AbyssToolsCore.axios.post<ICreateDrawResponse>(`draw/project/${params.projectId}`, body))
+    .data;
+};