@newpeak/barista-cli 0.1.4 → 0.1.5

package/src/core/api/client.ts

@@ -20,8 +20,22 @@ import {
   ClientQueryParams,
   ClientApiResponse,
 } from '../../types/client.js';
+import {
+  CreateSupplierRequest,
+  UpdateSupplierRequest,
+  SupplierQueryParams,
+  SupplierApiResponse,
+} from '../../types/supplier.js';
 import { OrgListItem } from '../../types/org.js';
 import { PositionListItem } from '../../types/position.js';
+import {
+  CreateUomRequest,
+  UpdateUomRequest,
+  UomQueryParams,
+  UomApiResponse,
+} from '../../types/uom.js';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { ApiResponse, Material, MaterialApiResponse, MaterialQueryParams, MaterialRequest } from '../../types/material.js';
 
 export interface LoginResponse {
   token: string;
@@ -896,6 +910,460 @@ export const apiClient = {
     }
   },
 
+  async listSuppliers(
+    environment: Environment,
+    tenant: string,
+    params: SupplierQueryParams
+  ): Promise<SupplierApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', params.pageNo.toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.status) queryString.append('status', params.status.toString());
+      if (params.supplierCode) queryString.append('supplierCode', params.supplierCode);
+      if (params.supplierName) queryString.append('supplierName', params.supplierName);
+      const url = `/api/enterprise/purchases/supplier/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<SupplierApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async getSupplier(
+    environment: Environment,
+    tenant: string,
+    supplierId: string
+  ): Promise<SupplierApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<SupplierApiResponse>(
+        `/api/enterprise/purchases/supplier/detail?supplierId=${supplierId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async getMaterial(
+    environment: Environment,
+    tenant: string,
+    materialId: string
+  ): Promise<MaterialApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<MaterialApiResponse>(
+        `/api/enterprise/sales/material/detail?materialId=${materialId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async listMaterials(
+    environment: Environment,
+    tenant: string,
+    params: MaterialQueryParams
+  ): Promise<MaterialApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', params.pageNo.toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.statusFlag) queryString.append('statusFlag', params.statusFlag.toString());
+      if (params.materialClass) queryString.append('materialClass', params.materialClass);
+      if (params.keyword) queryString.append('keyword', params.keyword);
+      const url = `/api/enterprise/sales/material/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<MaterialApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async deleteMaterial(
+    environment: Environment,
+    tenant: string,
+    materialId: string
+  ): Promise<ApiResponse<void>> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<ApiResponse<void>>(
+        '/api/enterprise/sales/material/delete',
+        { materialId: materialId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error) as unknown as ApiResponse<void>;
+    }
+  },
+
+  async createSupplier(
+    environment: Environment,
+    tenant: string,
+    data: CreateSupplierRequest
+  ): Promise<SupplierApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<SupplierApiResponse>('/api/enterprise/purchases/supplier/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async updateSupplier(
+    environment: Environment,
+    tenant: string,
+    data: UpdateSupplierRequest
+  ): Promise<SupplierApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<SupplierApiResponse>('/api/enterprise/purchases/supplier/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async deleteSupplier(
+    environment: Environment,
+    tenant: string,
+    supplierId: string
+  ): Promise<SupplierApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<SupplierApiResponse>(
+        '/api/enterprise/purchases/supplier/delete',
+        { supplierId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async enableSupplier(
+    environment: Environment,
+    tenant: string,
+    supplierId: string
+  ): Promise<SupplierApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<SupplierApiResponse>(
+        '/api/enterprise/purchases/supplier/batchActive',
+        { supplierIdList: [supplierId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async disableSupplier(
+    environment: Environment,
+    tenant: string,
+    supplierId: string
+  ): Promise<SupplierApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<SupplierApiResponse>(
+        '/api/enterprise/purchases/supplier/batchDeActive',
+        { supplierIdList: [supplierId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async createMaterial(
+    environment: Environment,
+    tenant: string,
+    data: MaterialRequest
+  ): Promise<MaterialApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MaterialApiResponse>('/api/enterprise/sales/material/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async updateMaterial(
+    environment: Environment,
+    tenant: string,
+    materialId: string,
+    data: MaterialRequest
+  ): Promise<MaterialApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MaterialApiResponse>('/api/enterprise/sales/material/edit', { materialId, ...data });
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async disableMaterial(
+    environment: Environment,
+    tenant: string,
+    materialId: string
+  ): Promise<MaterialApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MaterialApiResponse>(
+        '/api/enterprise/sales/material/batchDeActive',
+        { materialIdList: [materialId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async enableMaterial(
+    environment: Environment,
+    tenant: string,
+    materialId: string
+  ): Promise<MaterialApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MaterialApiResponse>(
+        '/api/enterprise/sales/material/batchActive',
+        { materialIdList: [materialId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async listUoms(
+    environment: Environment,
+    tenant: string,
+    params: UomQueryParams
+  ): Promise<UomApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', params.pageNo.toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.status) queryString.append('status', params.status.toString());
+      if (params.uomCode) queryString.append('uomCode', params.uomCode);
+      if (params.uomName) queryString.append('uomName', params.uomName);
+      const url = `/api/enterprise/sales/uom/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<UomApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async getUom(
+    environment: Environment,
+    tenant: string,
+    uomId: string
+  ): Promise<UomApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<UomApiResponse>(
+        `/api/enterprise/sales/uom/detail?uomId=${uomId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async createUom(
+    environment: Environment,
+    tenant: string,
+    data: CreateUomRequest
+  ): Promise<UomApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UomApiResponse>('/api/enterprise/sales/uom/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async updateUom(
+    environment: Environment,
+    tenant: string,
+    data: UpdateUomRequest
+  ): Promise<UomApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UomApiResponse>('/api/enterprise/sales/uom/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async deleteUom(
+    environment: Environment,
+    tenant: string,
+    uomId: string
+  ): Promise<UomApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UomApiResponse>(
+        '/api/enterprise/sales/uom/delete',
+        { uomId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async enableUom(
+    environment: Environment,
+    tenant: string,
+    uomId: string
+  ): Promise<UomApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UomApiResponse>(
+        '/api/enterprise/sales/uom/batchActive',
+        { uomIdList: [uomId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async disableUom(
+    environment: Environment,
+    tenant: string,
+    uomId: string
+  ): Promise<UomApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UomApiResponse>(
+        '/api/enterprise/sales/uom/batchDeActive',
+        { uomIdList: [uomId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
 };
 
 function handleApiError(error: unknown): EmployeeApiResponse {
@@ -974,4 +1442,121 @@ function handleApiErrorClient(error: unknown): ClientApiResponse {
       message: error instanceof Error ? error.message : 'Unknown error occurred',
     },
   };
+}
+
+function handleApiErrorSupplier(error: unknown): SupplierApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as SupplierApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
+}
+
+function handleApiErrorMaterial(error: unknown): MaterialApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as MaterialApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
+}
+
+function handleApiErrorUom(error: unknown): UomApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as UomApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
 }

package/src/index.ts

@@ -15,7 +15,7 @@ async function main(): Promise<void> {
     program
       .name('barista')
       .description('Barista CLI - Bridge between AI agents and Liberica/Arabica')
-      .version('0.1.4')
+      .version('0.1.5')
       .option('-e, --env <environment>', 'Target environment (dev|test|prod-cn|prod-jp)')
       .option('-t, --tenant <tenant>', 'Target tenant (for Liberica)')
       .option('--dry-run', 'Execute in dry-run mode')

package/src/types/index.ts

@@ -73,6 +73,9 @@ export interface TokenContext {
 export * from './employee.js';
 export * from './org.js';
 export * from './position.js';
-// Export client types explicitly to avoid conflicts with employee types
-export type { StatusFlag, ClientListResponse, MasterClientCompactResponse, ClientQueryParams, ClientApiResponse } from './client.js';
+export type { Uom, CreateUomRequest, UpdateUomRequest, UomQueryParams, UomListResponse, UomApiResponse, UomStatusFlag } from './uom.js';
+export type { Supplier, SupplierListResponse, SupplierQueryParams, SupplierApiResponse } from './supplier.js';
+export type { CreateSupplierRequest, UpdateSupplierRequest } from './supplier.js';
+export type { ClientListResponse, MasterClientCompactResponse, ClientQueryParams, ClientApiResponse } from './client.js';
 export type { MasterClientResponse, CreateClientRequest, UpdateClientRequest } from './client.js';
+export type { ApiResponse, Material, MaterialRequest, MaterialQueryParams, MaterialListResponse, MaterialApiResponse, MaterialStatusFlag } from './material.js';

package/src/types/material.ts

@@ -0,0 +1,61 @@
+// Material status flag literal type (1=enable, 2=disable)
+export type MaterialStatusFlag = 1 | 2;
+
+// Full Material entity
+export interface Material {
+  materialId: string;
+  materialCode: string;
+  materialNo: string;
+  materialName: string;
+  materialClass?: string;
+  statusFlag: MaterialStatusFlag;
+}
+
+// Request for creating/updating material
+export interface MaterialRequest {
+  materialName: string;
+  materialClass: string;
+  materialType?: string;
+  materialUnit?: string;
+  materialCode?: string;
+  materialNo?: string;
+}
+
+// Query params for list/pagination
+export interface MaterialQueryParams {
+  pageNo?: number;
+  pageSize?: number;
+  statusFlag?: MaterialStatusFlag;
+  materialClass?: string;
+  keyword?: string;
+}
+
+// Paginated response wrapper (PageResult from Roses framework)
+export interface MaterialListResponse {
+  totalRows: number;
+  pageSize: number;
+  pageNo: number;
+  rows: Material[];
+}
+
+// Generic API response wrapper
+export interface ApiResponse<T> {
+  success: boolean;
+  code?: string;
+  message?: string;
+  data?: T;
+  error?: {
+    code: string;
+    message: string;
+  };
+}
+
+// API response wrapper
+export interface MaterialApiResponse {
+  success: boolean;
+  data?: Material | MaterialListResponse;
+  error?: {
+    code: string;
+    message: string;
+  };
+}