@ph-cms/client-sdk-admin 0.1.1

package/dist/modules/hierarchy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HierarchyModule = void 0;
+class HierarchyModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        return this.client.get('/api/hierarchy', { params });
+    }
+    async get(uid) {
+        return this.client.get(`/api/hierarchy/${uid}`);
+    }
+    async create(data) {
+        return this.client.post('/api/hierarchy', data);
+    }
+    async update(uid, data) {
+        return this.client.put(`/api/hierarchy/${uid}`, data);
+    }
+    async delete(uid) {
+        return this.client.delete(`/api/hierarchy/${uid}`);
+    }
+    async listItems(setUid) {
+        return this.client.get(`/api/hierarchy/${setUid}/items`);
+    }
+    async addItem(setUid, data) {
+        return this.client.post(`/api/hierarchy/${setUid}/items`, data);
+    }
+    async removeItem(setUid, itemUid) {
+        return this.client.delete(`/api/hierarchy/${setUid}/items/${itemUid}`);
+    }
+}
+exports.HierarchyModule = HierarchyModule;

package/dist/modules/policy.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from "axios";
+import { PermissionPolicySetDto, CreatePermissionPolicySetRequest, UpdatePermissionPolicySetRequest, ListPolicyQuery, PagedPermissionPolicySetListResponse } from "@ph-cms/api-contract-admin";
+export declare class PolicyModule {
+    private client;
+    constructor(client: AxiosInstance);
+    list(params?: ListPolicyQuery): Promise<PagedPermissionPolicySetListResponse>;
+    get(uid: string): Promise<PermissionPolicySetDto>;
+    create(data: CreatePermissionPolicySetRequest): Promise<PermissionPolicySetDto>;
+    update(uid: string, data: UpdatePermissionPolicySetRequest): Promise<PermissionPolicySetDto>;
+    delete(uid: string): Promise<void>;
+}

package/dist/modules/policy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyModule = void 0;
+class PolicyModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        return this.client.get('/api/policies', { params });
+    }
+    async get(uid) {
+        return this.client.get(`/api/policies/${uid}`);
+    }
+    async create(data) {
+        return this.client.post('/api/policies', data);
+    }
+    async update(uid, data) {
+        return this.client.put(`/api/policies/${uid}`, data);
+    }
+    async delete(uid) {
+        return this.client.delete(`/api/policies/${uid}`);
+    }
+}
+exports.PolicyModule = PolicyModule;

package/dist/modules/system.d.ts

@@ -0,0 +1,21 @@
+export declare class SystemModule {
+    private client;
+    constructor(client: any);
+    getDbTables(): Promise<{
+        name: string;
+        columns: string[];
+    }[]>;
+    executeQuery(sql: string): Promise<{
+        rows: any[];
+        fields: string[];
+        rowCount: number;
+    }>;
+    getTableData(tableName: string, page?: number, limit?: number): Promise<{
+        rows: any[];
+        fields: string[];
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    }>;
+}

package/dist/modules/system.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemModule = void 0;
+const api_contract_admin_1 = require("@ph-cms/api-contract-admin");
+class SystemModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async getDbTables() {
+        const response = await this.client.get("/api/system/db/tables");
+        return api_contract_admin_1.DbTablesResponseSchema.parse(response);
+    }
+    async executeQuery(sql) {
+        const response = await this.client.post("/api/system/db/query", { sql });
+        return api_contract_admin_1.ExecuteQueryResponseSchema.parse(response);
+    }
+    async getTableData(tableName, page = 1, limit = 20) {
+        const response = await this.client.get(`/api/system/db-data/${tableName}`, {
+            params: { page, limit }
+        });
+        return api_contract_admin_1.GetTableDataResponseSchema.parse(response);
+    }
+}
+exports.SystemModule = SystemModule;

package/dist/modules/terms.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from "axios";
+import { TermDto, ListTermsQuery, PagedTermListResponse } from "@ph-cms/api-contract";
+import { CreateTermRequest } from "@ph-cms/api-contract-admin";
+export declare class TermsModule {
+    private client;
+    constructor(client: AxiosInstance);
+    list(params?: ListTermsQuery): Promise<PagedTermListResponse>;
+    get(id: number): Promise<TermDto>;
+    create(data: CreateTermRequest): Promise<TermDto>;
+    disable(id: number): Promise<void>;
+}

package/dist/modules/terms.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TermsModule = void 0;
+class TermsModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        return this.client.get('/api/terms', { params });
+    }
+    async get(id) {
+        return this.client.get(`/api/terms/${id}`);
+    }
+    async create(data) {
+        return this.client.post('/api/terms', data);
+    }
+    async disable(id) {
+        return this.client.delete(`/api/terms/${id}`);
+    }
+}
+exports.TermsModule = TermsModule;

package/dist/modules/user.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from "axios";
+import { ListUserQuery, CreateUserRequest, UpdateUserRequest, UserDto, PagedUserListResponse } from "@ph-cms/api-contract-admin";
+export declare class UserModule {
+    private client;
+    constructor(client: AxiosInstance);
+    list(params: ListUserQuery): Promise<PagedUserListResponse>;
+    get(uid: string): Promise<UserDto>;
+    create(data: CreateUserRequest): Promise<UserDto>;
+    update(uid: string, data: UpdateUserRequest): Promise<UserDto>;
+    delete(uid: string): Promise<void>;
+}

package/dist/modules/user.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModule = void 0;
+const api_contract_admin_1 = require("@ph-cms/api-contract-admin");
+const errors_1 = require("../errors");
+class UserModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const validation = api_contract_admin_1.ListUserQuerySchema.safeParse(params);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid list user params", validation.error.errors);
+        }
+        return this.client.get('/api/users', { params });
+    }
+    async get(uid) {
+        if (!uid)
+            throw new errors_1.ValidationError("UID is required", []);
+        return this.client.get(`/api/users/${uid}`);
+    }
+    async create(data) {
+        const validation = api_contract_admin_1.CreateUserSchema.safeParse(data);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid create user data", validation.error.errors);
+        }
+        return this.client.post('/api/users', data);
+    }
+    async update(uid, data) {
+        if (!uid)
+            throw new errors_1.ValidationError("UID is required", []);
+        const validation = api_contract_admin_1.UpdateUserSchema.safeParse(data);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid update user data", validation.error.errors);
+        }
+        return this.client.patch(`/api/users/${uid}`, data);
+    }
+    async delete(uid) {
+        if (!uid)
+            throw new errors_1.ValidationError("UID is required", []);
+        return this.client.delete(`/api/users/${uid}`);
+    }
+}
+exports.UserModule = UserModule;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@ph-cms/client-sdk-admin",
+  "version": "0.1.1",
+  "description": "Admin-only PH-CMS Client SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@tanstack/react-query": "^5.0.0",
+    "axios": "^1.6.0",
+    "zod": "^3.22.4",
+    "@ph-cms/client-sdk": "0.1.1",
+    "@ph-cms/api-contract-admin": "0.1.0",
+    "@ph-cms/api-contract": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "firebase": "^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "firebase": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "@types/react": "^18.3.1",
+    "@types/react-dom": "^18.3.1",
+    "@tanstack/react-query": "^5.0.0",
+    "typescript": "^5.3.3",
+    "firebase": "^10.0.0"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}

package/src/client.ts

@@ -0,0 +1,28 @@
+import { PHCMSClient } from "@ph-cms/client-sdk";
+import { DashboardModule } from "./modules/dashboard";
+import { HierarchyModule } from "./modules/hierarchy";
+import { PolicyModule } from "./modules/policy";
+import { SystemModule } from "./modules/system";
+import { UserModule } from "./modules/user";
+import { TermsModule } from "./modules/terms";
+
+export class PHCMSAdminClient {
+  public readonly base: PHCMSClient;
+  public readonly dashboard: DashboardModule;
+  public readonly hierarchy: HierarchyModule;
+  public readonly policy: PolicyModule;
+  public readonly system: SystemModule;
+  public readonly user: UserModule;
+  public readonly terms: TermsModule;
+
+  constructor(baseClient: PHCMSClient) {
+    this.base = baseClient;
+    const axios = baseClient.axiosInstance;
+    this.dashboard = new DashboardModule(axios);
+    this.hierarchy = new HierarchyModule(axios);
+    this.policy = new PolicyModule(axios);
+    this.system = new SystemModule(axios);
+    this.user = new UserModule(axios);
+    this.terms = new TermsModule(axios);
+  }
+}

package/src/context.tsx

@@ -0,0 +1,35 @@
+import React, { createContext, useContext, ReactNode, useMemo } from 'react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { PHCMSAdminClient } from './client';
+
+interface PHCMSAdminContextType {
+  client: PHCMSAdminClient;
+}
+
+const PHCMSAdminContext = createContext<PHCMSAdminContextType | null>(null);
+
+export interface PHCMSAdminProviderProps {
+  client: PHCMSAdminClient;
+  queryClient?: QueryClient;
+  children: ReactNode;
+}
+
+export const PHCMSAdminProvider: React.FC<PHCMSAdminProviderProps> = ({ client, queryClient, children }) => {
+  const internalQueryClient = useMemo(() => queryClient ?? new QueryClient(), [queryClient]);
+
+  return (
+    <PHCMSAdminContext.Provider value={{ client }}>
+      <QueryClientProvider client={internalQueryClient}>
+        {children}
+      </QueryClientProvider>
+    </PHCMSAdminContext.Provider>
+  );
+};
+
+export const usePHCMSAdmin = (): PHCMSAdminClient => {
+  const context = useContext(PHCMSAdminContext);
+  if (!context) {
+    throw new Error('usePHCMSAdmin must be used within a PHCMSAdminProvider');
+  }
+  return context.client;
+};

package/src/errors.ts

@@ -0,0 +1 @@
+export { PHCMSError, ValidationError, ApiError } from '@ph-cms/client-sdk';

package/src/hooks/useDashboard.ts

@@ -0,0 +1,10 @@
+import { useQuery } from '@tanstack/react-query';
+import { usePHCMSAdmin } from '../context';
+
+export const useDashboard = () => {
+  const client = usePHCMSAdmin();
+  return useQuery({
+    queryKey: ['dashboard', 'stats'],
+    queryFn: () => client.dashboard.getStats(),
+  });
+};

package/src/hooks/useHierarchy.ts

@@ -0,0 +1,30 @@
+import { useQuery } from '@tanstack/react-query';
+import { usePHCMSAdmin } from '../context';
+import { ListHierarchyQuery } from '@ph-cms/api-contract-admin';
+
+export const hierarchyKeys = {
+  all: ['hierarchy'] as const,
+  lists: () => [...hierarchyKeys.all, 'list'] as const,
+  list: (params?: ListHierarchyQuery) => [...hierarchyKeys.lists(), params] as const,
+  items: () => [...hierarchyKeys.all, 'items'] as const,
+  itemList: (setUid: string) => [...hierarchyKeys.items(), setUid] as const,
+};
+
+export const useHierarchyList = (params?: ListHierarchyQuery) => {
+  const client = usePHCMSAdmin();
+  return useQuery({
+    queryKey: hierarchyKeys.list(params),
+    queryFn: () => client.hierarchy.list(params),
+    staleTime: 1000 * 60 * 60, // 1 hour
+  });
+};
+
+export const useHierarchyItems = (setUid?: string, enabled = true) => {
+  const client = usePHCMSAdmin();
+  return useQuery({
+    queryKey: hierarchyKeys.itemList(setUid || ''),
+    queryFn: () => client.hierarchy.listItems(setUid || ''),
+    staleTime: 1000 * 60 * 60, // 1 hour
+    enabled: enabled && !!setUid,
+  });
+};

package/src/hooks/usePolicy.ts

@@ -0,0 +1,18 @@
+import { useQuery } from '@tanstack/react-query';
+import { usePHCMSAdmin } from '../context';
+import { ListPolicyQuery } from '@ph-cms/api-contract-admin';
+
+export const policyKeys = {
+  all: ['policy'] as const,
+  lists: () => [...policyKeys.all, 'list'] as const,
+  list: (params?: ListPolicyQuery) => [...policyKeys.lists(), params] as const,
+};
+
+export const usePolicyList = (params?: ListPolicyQuery) => {
+  const client = usePHCMSAdmin();
+  return useQuery({
+    queryKey: policyKeys.list(params),
+    queryFn: () => client.policy.list(params),
+    staleTime: 1000 * 60 * 60, // 1 hour
+  });
+};

package/src/hooks/useSystem.ts

@@ -0,0 +1,26 @@
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { usePHCMSAdmin } from '../context';
+
+export const useDbTables = () => {
+  const sdk = usePHCMSAdmin();
+  return useQuery({
+    queryKey: ['db-tables'],
+    queryFn: () => sdk.system.getDbTables(),
+  });
+};
+
+export const useExecuteQuery = () => {
+  const sdk = usePHCMSAdmin();
+  return useMutation({
+    mutationFn: (sql: string) => sdk.system.executeQuery(sql),
+  });
+};
+
+export const useTableData = (tableName: string, page: number = 1, limit: number = 20) => {
+  const sdk = usePHCMSAdmin();
+  return useQuery({
+    queryKey: ['table-data', tableName, page, limit],
+    queryFn: () => sdk.system.getTableData(tableName, page, limit),
+    enabled: !!tableName,
+  });
+};

package/src/hooks/useTerms.ts

@@ -0,0 +1,18 @@
+import { useQuery } from '@tanstack/react-query';
+import { usePHCMSAdmin } from '../context';
+import { ListTermsQuery } from '@ph-cms/api-contract';
+
+export const termsKeys = {
+  all: ['terms'] as const,
+  lists: () => [...termsKeys.all, 'list'] as const,
+  list: (params?: ListTermsQuery) => [...termsKeys.lists(), params] as const,
+};
+
+export const useTermsList = (params?: ListTermsQuery) => {
+  const client = usePHCMSAdmin();
+  return useQuery({
+    queryKey: termsKeys.list(params),
+    queryFn: () => client.terms.list(params),
+    staleTime: 1000 * 60 * 60, // 1 hour
+  });
+};

package/src/hooks/useUser.ts

@@ -0,0 +1,69 @@
+import { keepPreviousData, useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { usePHCMSAdmin } from '../context';
+import { CreateUserRequest, ListUserQuery, UpdateUserRequest } from '@ph-cms/api-contract-admin';
+
+export const userKeys = {
+  all: ['users'] as const,
+  lists: () => [...userKeys.all, 'list'] as const,
+  list: (params: ListUserQuery) => [...userKeys.lists(), params] as const,
+  details: () => [...userKeys.all, 'detail'] as const,
+  detail: (uid: string) => [...userKeys.details(), uid] as const,
+};
+
+export const useUserList = (params: ListUserQuery) => {
+  const client = usePHCMSAdmin();
+  return useQuery({
+    queryKey: userKeys.list(params),
+    queryFn: () => client.user.list(params),
+    staleTime: 1000 * 60, // 1 minute
+    placeholderData: keepPreviousData,
+  });
+};
+
+export const useUserDetail = (uid: string) => {
+  const client = usePHCMSAdmin();
+  return useQuery({
+    queryKey: userKeys.detail(uid),
+    queryFn: () => client.user.get(uid),
+    enabled: !!uid,
+  });
+};
+
+export const useUpdateUser = () => {
+    const client = usePHCMSAdmin();
+    const queryClient = useQueryClient();
+
+    return useMutation({
+      mutationFn: ({ uid, data }: { uid: string; data: UpdateUserRequest }) =>
+        client.user.update(uid, data),
+      onSuccess: (data, variables) => {
+        queryClient.invalidateQueries({ queryKey: userKeys.detail(variables.uid) });
+        queryClient.invalidateQueries({ queryKey: userKeys.lists() });
+      },
+    });
+  };
+
+export const useCreateUser = () => {
+    const client = usePHCMSAdmin();
+    const queryClient = useQueryClient();
+
+    return useMutation({
+      mutationFn: (data: CreateUserRequest) => client.user.create(data),
+      onSuccess: (data) => {
+        queryClient.invalidateQueries({ queryKey: userKeys.lists() });
+        queryClient.invalidateQueries({ queryKey: userKeys.detail(data.uid) });
+      },
+    });
+  };
+
+export const useDeleteUser = () => {
+    const client = usePHCMSAdmin();
+    const queryClient = useQueryClient();
+
+    return useMutation({
+      mutationFn: (uid: string) => client.user.delete(uid),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: userKeys.lists() });
+      },
+    });
+};

package/src/index.ts

@@ -0,0 +1,17 @@
+export { PHCMSAdminClient } from './client';
+export { PHCMSAdminProvider, usePHCMSAdmin } from './context';
+export * from './errors';
+
+export * from './modules/system';
+export * from './modules/dashboard';
+export * from './modules/user';
+export * from './modules/policy';
+export * from './modules/hierarchy';
+export * from './modules/terms';
+
+export * from './hooks/useSystem';
+export * from './hooks/useDashboard';
+export * from './hooks/useUser';
+export * from './hooks/usePolicy';
+export * from './hooks/useHierarchy';
+export * from './hooks/useTerms';

package/src/modules/dashboard.ts

@@ -0,0 +1,10 @@
+import { AxiosInstance } from "axios";
+import { DashboardDto } from "@ph-cms/api-contract-admin";
+
+export class DashboardModule {
+  constructor(private client: AxiosInstance) {}
+
+  async getStats(): Promise<DashboardDto> {
+    return this.client.get<any, DashboardDto>('/api/dashboard') as Promise<DashboardDto>;
+  }
+}

package/src/modules/hierarchy.ts

@@ -0,0 +1,38 @@
+import { AxiosInstance } from "axios";
+import { HierarchySetDto, CreateHierarchySetRequest, UpdateHierarchySetRequest, HierarchyItemDto, AddHierarchyItemRequest, ListHierarchyQuery, PagedHierarchySetListResponse } from "@ph-cms/api-contract-admin";
+
+export class HierarchyModule {
+  constructor(private client: AxiosInstance) {}
+
+  async list(params?: ListHierarchyQuery): Promise<PagedHierarchySetListResponse> {
+    return this.client.get<any, PagedHierarchySetListResponse>('/api/hierarchy', { params }) as Promise<PagedHierarchySetListResponse>;
+  }
+
+  async get(uid: string): Promise<HierarchySetDto> {
+    return this.client.get<any, HierarchySetDto>(`/api/hierarchy/${uid}`) as Promise<HierarchySetDto>;
+  }
+
+  async create(data: CreateHierarchySetRequest): Promise<HierarchySetDto> {
+    return this.client.post<any, HierarchySetDto>('/api/hierarchy', data) as Promise<HierarchySetDto>;
+  }
+
+  async update(uid: string, data: UpdateHierarchySetRequest): Promise<HierarchySetDto> {
+    return this.client.put<any, HierarchySetDto>(`/api/hierarchy/${uid}`, data) as Promise<HierarchySetDto>;
+  }
+
+  async delete(uid: string): Promise<void> {
+    return this.client.delete(`/api/hierarchy/${uid}`);
+  }
+
+  async listItems(setUid: string): Promise<HierarchyItemDto[]> {
+    return this.client.get<any, HierarchyItemDto[]>(`/api/hierarchy/${setUid}/items`) as Promise<HierarchyItemDto[]>;
+  }
+
+  async addItem(setUid: string, data: AddHierarchyItemRequest): Promise<HierarchyItemDto> {
+    return this.client.post<any, HierarchyItemDto>(`/api/hierarchy/${setUid}/items`, data) as Promise<HierarchyItemDto>;
+  }
+
+  async removeItem(setUid: string, itemUid: string): Promise<void> {
+    return this.client.delete(`/api/hierarchy/${setUid}/items/${itemUid}`);
+  }
+}

package/src/modules/policy.ts

@@ -0,0 +1,26 @@
+import { AxiosInstance } from "axios";
+import { PermissionPolicySetDto, CreatePermissionPolicySetRequest, UpdatePermissionPolicySetRequest, ListPolicyQuery, PagedPermissionPolicySetListResponse } from "@ph-cms/api-contract-admin";
+
+export class PolicyModule {
+  constructor(private client: AxiosInstance) {}
+
+  async list(params?: ListPolicyQuery): Promise<PagedPermissionPolicySetListResponse> {
+    return this.client.get<any, PagedPermissionPolicySetListResponse>('/api/policies', { params }) as Promise<PagedPermissionPolicySetListResponse>;
+  }
+
+  async get(uid: string): Promise<PermissionPolicySetDto> {
+    return this.client.get<any, PermissionPolicySetDto>(`/api/policies/${uid}`) as Promise<PermissionPolicySetDto>;
+  }
+
+  async create(data: CreatePermissionPolicySetRequest): Promise<PermissionPolicySetDto> {
+    return this.client.post<any, PermissionPolicySetDto>('/api/policies', data) as Promise<PermissionPolicySetDto>;
+  }
+
+  async update(uid: string, data: UpdatePermissionPolicySetRequest): Promise<PermissionPolicySetDto> {
+    return this.client.put<any, PermissionPolicySetDto>(`/api/policies/${uid}`, data) as Promise<PermissionPolicySetDto>;
+  }
+
+  async delete(uid: string): Promise<void> {
+    return this.client.delete(`/api/policies/${uid}`);
+  }
+}

package/src/modules/system.ts

@@ -0,0 +1,23 @@
+import { DbTablesResponseSchema, ExecuteQueryRequestSchema, ExecuteQueryResponseSchema, GetTableDataResponseSchema } from "@ph-cms/api-contract-admin";
+import { z } from "zod";
+
+export class SystemModule {
+  constructor(private client: any) {}
+
+  async getDbTables() {
+    const response = await this.client.get("/api/system/db/tables");
+    return DbTablesResponseSchema.parse(response);
+  }
+
+  async executeQuery(sql: string) {
+    const response = await this.client.post("/api/system/db/query", { sql });
+    return ExecuteQueryResponseSchema.parse(response);
+  }
+
+  async getTableData(tableName: string, page: number = 1, limit: number = 20) {
+    const response = await this.client.get(`/api/system/db-data/${tableName}`, {
+      params: { page, limit }
+    });
+    return GetTableDataResponseSchema.parse(response);
+  }
+}

package/src/modules/terms.ts

@@ -0,0 +1,23 @@
+import { AxiosInstance } from "axios";
+import { TermDto, ListTermsQuery, PagedTermListResponse } from "@ph-cms/api-contract";
+import { CreateTermRequest } from "@ph-cms/api-contract-admin";
+
+export class TermsModule {
+  constructor(private client: AxiosInstance) {}
+
+  async list(params?: ListTermsQuery): Promise<PagedTermListResponse> {
+    return this.client.get<any, PagedTermListResponse>('/api/terms', { params }) as Promise<PagedTermListResponse>;
+  }
+
+  async get(id: number): Promise<TermDto> {
+    return this.client.get<any, TermDto>(`/api/terms/${id}`) as Promise<TermDto>;
+  }
+
+  async create(data: CreateTermRequest): Promise<TermDto> {
+    return this.client.post<any, TermDto>('/api/terms', data) as Promise<TermDto>;
+  }
+
+  async disable(id: number): Promise<void> {
+    return this.client.delete(`/api/terms/${id}`);
+  }
+}