@abyss-project/tools 1.0.0

package/src/api/draw.public.api.ts

@@ -0,0 +1,48 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICreateDrawPublicBody,
+  ICreateDrawPublicResponse,
+  IDeleteDrawPublicParams,
+  IDeleteDrawPublicResponse,
+  IGetDrawPublicParams,
+  IGetDrawPublicResponse,
+  IUpdateDrawPublicBody,
+  IUpdateDrawPublicParams,
+  IUpdateDrawPublicResponse,
+} from '../types';
+
+export const getDrawPublic = async (
+  params: IGetDrawPublicParams,
+): Promise<IGetDrawPublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetDrawPublicResponse>(`draw/public/${params.publicAccessToken}`)
+  ).data;
+};
+
+export const deleteDrawPublic = async (
+  params: IDeleteDrawPublicParams,
+): Promise<IDeleteDrawPublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteDrawPublicResponse>(
+      `draw/public/${params.publicAccessToken}`,
+    )
+  ).data;
+};
+
+export const updateDrawPublic = async (
+  params: IUpdateDrawPublicParams,
+  body: IUpdateDrawPublicBody,
+): Promise<IUpdateDrawPublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateDrawPublicResponse>(
+      `draw/public/${params.publicAccessToken}`,
+      body,
+    )
+  ).data;
+};
+
+export const createDrawPublic = async (
+  body: ICreateDrawPublicBody,
+): Promise<ICreateDrawPublicResponse> => {
+  return (await AbyssToolsCore.axios.post<ICreateDrawPublicResponse>(`draw/public`, body)).data;
+};

package/src/api/index.ts

@@ -0,0 +1,43 @@
+export * from './abyss.admin.api';
+
+// Atlas
+export * from './atlas.api';
+export * from './atlas.public.api';
+export * from './atlas-document.api';
+export * from './atlas-group.api';
+export * from './atlas-page.api';
+// export * from './atlas-page-content.api'; // TODO: implement atlas page content API
+
+// Board
+export * from './board.api';
+export * from './board-card.api';
+export * from './board-card-checklist.api';
+export * from './board-card-comment.api';
+export * from './board-card-document.api';
+export * from './board-column.api';
+export * from './board-label.api';
+
+// Draw
+export * from './draw.api';
+export * from './draw.public.api';
+
+// Memo
+export * from './memo.api';
+
+// Retrospective
+export * from './retrospective.api';
+export * from './retrospective.public.api';
+export * from './retrospective-card.api';
+export * from './retrospective-member.api';
+export * from './retrospective-section.api';
+
+// Short Link
+export * from './short-link.api';
+export * from './short-link.public.api';
+export * from './short-link.admin.api';
+
+// Metrics
+export * from './metrics.api';
+
+// User Tag
+export * from './user-tag.api';

package/src/api/memo.api.ts

@@ -0,0 +1,59 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICreateMemoBody,
+  ICreateMemoResponse,
+  ICreateForProjectMemoParams,
+  IDeleteMemoParams,
+  IDeleteMemoResponse,
+  IGetMemoParams,
+  IGetMemoResponse,
+  IPaginateMemoQuery,
+  IPaginateMemoResponse,
+  IPaginateProjectMemoParams,
+  IUpdateMemoBody,
+  IUpdateMemoParams,
+  IUpdateMemoResponse,
+} from '../types';
+
+export const paginateMemo = async (query: IPaginateMemoQuery): Promise<IPaginateMemoResponse> => {
+  return (await AbyssToolsCore.axios.get<IPaginateMemoResponse>(`memo/paginate`, { params: query }))
+    .data;
+};
+
+export const paginateProjectMemo = async (
+  params: IPaginateProjectMemoParams,
+  query: IPaginateMemoQuery,
+): Promise<IPaginateMemoResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IPaginateMemoResponse>(`project/${params.projectId}/memo/paginate`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const getMemo = async (params: IGetMemoParams): Promise<IGetMemoResponse> => {
+  return (await AbyssToolsCore.axios.get<IGetMemoResponse>(`memo/${params.memoId}`)).data;
+};
+
+export const deleteMemo = async (params: IDeleteMemoParams): Promise<IDeleteMemoResponse> => {
+  return (await AbyssToolsCore.axios.delete<IDeleteMemoResponse>(`memo/${params.memoId}`)).data;
+};
+
+export const updateMemo = async (
+  params: IUpdateMemoParams,
+  body: IUpdateMemoBody,
+): Promise<IUpdateMemoResponse> => {
+  return (await AbyssToolsCore.axios.put<IUpdateMemoResponse>(`memo/${params.memoId}`, body)).data;
+};
+
+export const createMemo = async (body: ICreateMemoBody): Promise<ICreateMemoResponse> => {
+  return (await AbyssToolsCore.axios.post<ICreateMemoResponse>(`memo`, body)).data;
+};
+
+export const createForProjectMemo = async (
+  params: ICreateForProjectMemoParams,
+  body: ICreateMemoBody,
+): Promise<ICreateMemoResponse> => {
+  return (await AbyssToolsCore.axios.post<ICreateMemoResponse>(`memo/project/${params.projectId}`, body))
+    .data;
+};

package/src/api/metrics.api.ts

@@ -0,0 +1,15 @@
+import { AbyssToolsCore } from '..';
+import {
+  IGetOrganizationToolsMetricsParams,
+  IGetOrganizationToolsMetricsResponse,
+} from '../types';
+
+export const getOrganizationToolsMetrics = async (
+  params: IGetOrganizationToolsMetricsParams,
+): Promise<IGetOrganizationToolsMetricsResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetOrganizationToolsMetricsResponse>(
+      `metrics/organization/${params.organizationId}`,
+    )
+  ).data;
+};

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

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

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

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

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

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

package/src/api/retrospective.api.ts

@@ -0,0 +1,86 @@
+import { AbyssToolsCore } from '..';
+import {
+  IGetRetrospectiveParams,
+  IGetRetrospectiveResponse,
+  IPaginateProjectRetrospectiveParams,
+  IPaginateRetrospectiveQuery,
+  IPaginateRetrospectiveResponse,
+  ICreateForProjectRetrospectiveParams,
+  ICreateRetrospectiveBody,
+  ICreateRetrospectiveResponse,
+  IUpdateRetrospectiveParams,
+  IUpdateRetrospectiveBody,
+  IUpdateRetrospectiveResponse,
+  IDeleteRetrospectiveParams,
+  IDeleteRetrospectiveResponse,
+} from '../types';
+
+export const getRetrospective = async (
+  params: IGetRetrospectiveParams,
+): Promise<IGetRetrospectiveResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetRetrospectiveResponse>(`retrospective/${params.retrospectiveId}`)
+  ).data;
+};
+
+export const paginateProjectRetrospective = async (
+  params: IPaginateProjectRetrospectiveParams,
+  query?: IPaginateRetrospectiveQuery,
+): Promise<IPaginateRetrospectiveResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IPaginateRetrospectiveResponse>(
+      `project/${params.projectId}/retrospective/paginate`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const paginateRetrospective = async (
+  query?: IPaginateRetrospectiveQuery,
+): Promise<IPaginateRetrospectiveResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IPaginateRetrospectiveResponse>(`retrospective/paginate`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const createForProjectRetrospective = async (
+  params: ICreateForProjectRetrospectiveParams,
+  body: ICreateRetrospectiveBody,
+): Promise<ICreateRetrospectiveResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateRetrospectiveResponse>(
+      `retrospective/project/${params.projectId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createRetrospective = async (
+  body: ICreateRetrospectiveBody,
+): Promise<ICreateRetrospectiveResponse> => {
+  return (await AbyssToolsCore.axios.post<ICreateRetrospectiveResponse>(`retrospective`, body)).data;
+};
+
+export const updateRetrospective = async (
+  params: IUpdateRetrospectiveParams,
+  body: IUpdateRetrospectiveBody,
+): Promise<IUpdateRetrospectiveResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateRetrospectiveResponse>(
+      `retrospective/${params.retrospectiveId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteRetrospective = async (
+  params: IDeleteRetrospectiveParams,
+): Promise<IDeleteRetrospectiveResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteRetrospectiveResponse>(
+      `retrospective/${params.retrospectiveId}`,
+    )
+  ).data;
+};

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

@@ -0,0 +1,147 @@
+import { AbyssToolsCore } 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,
+} from '../types';
+
+export const getRetrospectivePublic = async (
+  params: IGetRetrospectivePublicParams,
+): Promise<IGetRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}`,
+    )
+  ).data;
+};
+
+export const updateRetrospectivePublic = async (
+  params: IUpdateRetrospectivePublicParams,
+  body: IUpdateRetrospectivePublicBody,
+): Promise<IUpdateRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}`,
+      body,
+    )
+  ).data;
+};
+
+// Section methods
+export const createSectionRetrospectivePublic = async (
+  params: ICreateSectionRetrospectivePublicParams,
+  body: ICreateSectionRetrospectivePublicBody,
+): Promise<ICreateSectionRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateSectionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/section`,
+      body,
+    )
+  ).data;
+};
+
+export const updateSectionRetrospectivePublic = async (
+  params: IUpdateSectionRetrospectivePublicParams,
+  body: IUpdateSectionRetrospectivePublicBody,
+): Promise<IUpdateSectionRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateSectionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/section/${params.retrospectiveSectionId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteSectionRetrospectivePublic = async (
+  params: IDeleteSectionRetrospectivePublicParams,
+): Promise<IDeleteSectionRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteSectionRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/section/${params.retrospectiveSectionId}`,
+    )
+  ).data;
+};
+
+// Member methods
+export const joinMemberRetrospectivePublic = async (
+  params: IJoinMemberRetrospectivePublicParams,
+): Promise<IJoinMemberRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IJoinMemberRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/member/join`,
+    )
+  ).data;
+};
+
+export const updateMemberRetrospectivePublic = async (
+  params: IUpdateMemberRetrospectivePublicParams,
+  body: IUpdateMemberRetrospectivePublicBody,
+): Promise<IUpdateMemberRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateMemberRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/member`,
+      body,
+    )
+  ).data;
+};
+
+// Card methods
+export const createCardRetrospectivePublic = async (
+  params: ICreateCardRetrospectivePublicParams,
+  body: ICreateCardRetrospectivePublicBody,
+): Promise<ICreateCardRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateCardRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/card`,
+      body,
+    )
+  ).data;
+};
+
+export const updateCardRetrospectivePublic = async (
+  params: IUpdateCardRetrospectivePublicParams,
+  body: IUpdateCardRetrospectivePublicBody,
+): Promise<IUpdateCardRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateCardRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/card/${params.retrospectiveCardId}`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteCardRetrospectivePublic = async (
+  params: IDeleteCardRetrospectivePublicParams,
+): Promise<IDeleteCardRetrospectivePublicResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteCardRetrospectivePublicResponse>(
+      `retrospective/public/${params.accessToken}/card/${params.retrospectiveCardId}`,
+    )
+  ).data;
+};

package/src/api/short-link.admin.api.ts

@@ -0,0 +1,39 @@
+import { AbyssToolsCore } from '..';
+import type {
+  IPaginateShortLinkAdminQuery,
+  IPaginateShortLinkAdminResponse,
+  IGetShortLinkAdminParams,
+  IGetShortLinkAdminResponse,
+  IUpdateShortLinkAdminParams,
+  IUpdateShortLinkAdminBody,
+  IUpdateShortLinkAdminResponse,
+  IDeleteShortLinkAdminParams,
+  IDeleteShortLinkAdminResponse,
+} from '../types';
+
+export const shortLinkAdminApi = {
+  paginate: async (
+    query: IPaginateShortLinkAdminQuery,
+  ): Promise<IPaginateShortLinkAdminResponse> => {
+    const response = await AbyssToolsCore.axios.get<IPaginateShortLinkAdminResponse>('/admin/short-link/paginate', { params: query });
+    return response.data;
+  },
+
+  get: async (params: IGetShortLinkAdminParams): Promise<IGetShortLinkAdminResponse> => {
+    const response = await AbyssToolsCore.axios.get<IGetShortLinkAdminResponse>(`/admin/short-link/${params.shortLinkId}`);
+    return response.data;
+  },
+
+  update: async (
+    params: IUpdateShortLinkAdminParams,
+    body: IUpdateShortLinkAdminBody,
+  ): Promise<IUpdateShortLinkAdminResponse> => {
+    const response = await AbyssToolsCore.axios.put<IUpdateShortLinkAdminResponse>(`/admin/short-link/${params.shortLinkId}`, body);
+    return response.data;
+  },
+
+  delete: async (params: IDeleteShortLinkAdminParams): Promise<IDeleteShortLinkAdminResponse> => {
+    const response = await AbyssToolsCore.axios.delete<IDeleteShortLinkAdminResponse>(`/admin/short-link/${params.shortLinkId}`);
+    return response.data;
+  },
+};