fix: api type

hooks/data/use-activities.ts

@@ -2,39 +2,14 @@ import { ApiError } from "@/lib/types"
 import { useState } from "react"
 import { OWNER_ID } from "@/hooks/constants"
 import { root } from '@repo/core';
-import { ActivityController } from "@repo/sdk";
+import { ActivityController, ListActivitiesResult, ListActivitiesInput } from "@repo/sdk";
 import { useError } from "./use-error";
 export const useActivities = () => {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<ApiError | null>(null)
-  const [data, setData] = useState<{
+  const [data, setData] = useState<ListActivitiesResult>()
-    activities: {
-      title: string
-      titleEn: string
-      desc: string
-      descEn: string
-      coverUrl: string
-      link: string
-      createdAt: Date
-      updatedAt: Date
-      id: string
-      videoUrl?: string | null
-      ownerId?: string | null
-      isActive?: boolean | null
-      sortOrder?: number | null
-    }[]
-    total: number
-    page: number
-    limit: number
-    totalPages: number
-  }>()
 
-  const load = async (params: {
+  const load = async (params: ListActivitiesInput = { page: 1, limit: 10, orderBy: 'createdAt', order: 'desc' }) => {
-    page: number;
-    limit: number;
-    orderBy: string;
-    order: string;
-  } = { page: 1, limit: 10, orderBy: 'createdAt', order: 'desc' }) => {
     try {
       setLoading(true)
       const activity = root.get(ActivityController)

hooks/data/use-categories.ts

@@ -2,7 +2,7 @@ import { ApiError } from "@/lib/types"
 import { useState } from "react"
 import { OWNER_ID } from "@/hooks/constants"
 import { root } from '@repo/core'
-import { CategoryController, ListCategoriesResult } from "@repo/sdk"
+import { CategoryController, ListCategoriesResult, ListCategoriesInput } from "@repo/sdk"
 import { useError } from "./use-error"
 
 export const useCategories = () => {
@@ -10,15 +10,7 @@ export const useCategories = () => {
   const [error, setError] = useState<ApiError | null>(null)
   const [data, setData] = useState<ListCategoriesResult>()
 
-  const load = async (params?: {
+  const load = async (params?: ListCategoriesInput) => {
-    page?: number
-    limit?: number
-    isActive?: boolean
-    search?: string
-    categoryIds?: string[]
-    withChildren?: boolean
-    ownerId?: string
-  }) => {
     try {
       setLoading(true)
       const category = root.get(CategoryController)

hooks/data/use-favorite-templates.ts

@@ -1,20 +1,15 @@
 import { ApiError } from "@/lib/types"
 import { useState, useCallback } from "react"
 import { root } from '@repo/core'
-import { TemplateSocialController, GetUserFavoritesResponse } from "@repo/sdk"
+import { TemplateSocialController, GetUserFavoritesInput, GetUserFavoritesResponse } from "@repo/sdk"
 import { useError } from "./use-error"
 
-interface UseFavoriteTemplatesParams {
-  page?: number
-  limit?: number
-}
-
 export const useFavoriteTemplates = () => {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<ApiError | null>(null)
   const [data, setData] = useState<GetUserFavoritesResponse | undefined>()
 
-  const execute = useCallback(async (params?: UseFavoriteTemplatesParams) => {
+  const execute = useCallback(async (params?: GetUserFavoritesInput) => {
     setLoading(true)
     setError(null)
 
@@ -35,7 +30,7 @@ export const useFavoriteTemplates = () => {
     return { data, error: null }
   }, [])
 
-  const refetch = useCallback((params?: UseFavoriteTemplatesParams) => {
+  const refetch = useCallback((params?: GetUserFavoritesInput) => {
     return execute(params)
   }, [execute])
 

hooks/data/use-public-templates.ts

@@ -1,24 +1,15 @@
 import { ApiError } from "@/lib/types"
 import { useState, useCallback } from "react"
 import { root } from '@repo/core'
-import { RecommendedTemplateController } from "@repo/sdk"
+import { RecommendedTemplateController, ListPublicRecommendedTemplatesInput, ListPublicRecommendedTemplatesResult } from "@repo/sdk"
 import { useError } from "./use-error"
 
-type ApiListResult = Awaited<ReturnType<RecommendedTemplateController['listPublic']>>
-type ListPublicRecommendedTemplatesResult = NonNullable<ApiListResult>
-
-interface UsePublicTemplatesParams {
-  limit?: number
-  sortBy?: 'sortOrder' | 'likeCount' | 'viewCount' | 'createdAt' | 'updatedAt'
-  sortOrder?: 'asc' | 'desc'
-}
-
 export const usePublicTemplates = () => {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<ApiError | null>(null)
   const [data, setData] = useState<ListPublicRecommendedTemplatesResult | undefined>()
 
-  const execute = useCallback(async (params?: UsePublicTemplatesParams) => {
+  const execute = useCallback(async (params?: ListPublicRecommendedTemplatesInput) => {
     setLoading(true)
     setError(null)
 
@@ -40,7 +31,7 @@ export const usePublicTemplates = () => {
     return { data, error: null }
   }, [])
 
-  const refetch = useCallback((params?: UsePublicTemplatesParams) => {
+  const refetch = useCallback((params?: ListPublicRecommendedTemplatesInput) => {
     return execute(params)
   }, [execute])
 

hooks/data/use-recommended-templates.ts

@@ -1,25 +1,15 @@
-import { ApiError, PaginationParams } from "@/lib/types"
+import { ApiError } from "@/lib/types"
 import { useState, useCallback } from "react"
 import { root } from '@repo/core'
-import { RecommendedTemplateController } from "@repo/sdk"
+import { RecommendedTemplateController, ListPublicRecommendedTemplatesInput, ListPublicRecommendedTemplatesResult } from "@repo/sdk"
 import { useError } from "./use-error"
 
-interface UseRecommendedTemplatesParams extends PaginationParams {
-  isActive?: boolean
-}
-
-type ApiListResult = Awaited<ReturnType<RecommendedTemplateController['listPublic']>>
-type ApiData = NonNullable<ApiListResult>
-
-export type RecommendedTemplate = ApiData['templates'][number]
-type UseRecommendedTemplatesResponse = ApiData
-
 export const useRecommendedTemplates = () => {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<ApiError | null>(null)
-  const [data, setData] = useState<UseRecommendedTemplatesResponse | undefined>()
+  const [data, setData] = useState<ListPublicRecommendedTemplatesResult | undefined>()
 
-  const execute = useCallback(async (params?: UseRecommendedTemplatesParams) => {
+  const execute = useCallback(async (params?: ListPublicRecommendedTemplatesInput) => {
     setLoading(true)
     setError(null)
 
@@ -41,7 +31,7 @@ export const useRecommendedTemplates = () => {
     return { data, error: null }
   }, [])
 
-  const refetch = useCallback((params?: UseRecommendedTemplatesParams) => {
+  const refetch = useCallback((params?: ListPublicRecommendedTemplatesInput) => {
     return execute(params)
   }, [execute])
 

hooks/data/use-tags.ts

@@ -2,20 +2,14 @@ import { ApiError } from "@/lib/types"
 import { useState } from "react"
 import { OWNER_ID } from '@/hooks/constants'
 import { root } from '@repo/core'
-import { TagController, ListTagsResult } from "@repo/sdk"
+import { TagController, ListTagsResult, ListTagsInput } from "@repo/sdk"
 import { useError } from "./use-error"
 export const useTags = () => {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<ApiError | null>(null)
   const [data, setData] = useState<ListTagsResult>()
 
-  const load = async (params?: {
+  const load = async (params?: ListTagsInput) => {
-    page?: number
-    limit?: number
-    search?: string
-    ownerId?: string
-    categoryIds?: string[]
-  }) => {
     try {
       setLoading(true)
       const tag = root.get(TagController)

hooks/data/use-template-generation-detail.ts

@@ -1,8 +1,7 @@
 import { ApiError } from "@/lib/types"
 import { useState, useCallback } from "react"
-import type { TemplateGeneration } from "./use-template-generations"
 import { root } from '@repo/core'
-import { TemplateGenerationController } from "@repo/sdk"
+import { TemplateGenerationController, TemplateGeneration } from "@repo/sdk"
 import { useError } from "./use-error"
 
 interface GetParams {

hooks/data/use-template-generations.ts

@@ -1,28 +1,15 @@
-import { ApiError, PaginationParams } from "@/lib/types"
+import { ApiError } from "@/lib/types"
 import { useState, useCallback } from "react"
 import { root } from '@repo/core'
-import { TemplateGenerationController } from "@repo/sdk"
+import { TemplateGenerationController, ListTemplateGenerationsInput, ListTemplateGenerationsResult } from "@repo/sdk"
 import { useError } from "./use-error"
 
-type ApiListResult = Awaited<ReturnType<TemplateGenerationController['list']>>
-type ApiData = NonNullable<ApiListResult>
-
-export type TemplateGeneration = ApiData['data'][number]
-type ListResponse = ApiData
-
-interface ListParams extends PaginationParams {
-  userId?: string
-  templateId?: string
-  status?: "pending" | "processing" | "completed" | "failed"
-  search?: string
-}
-
 export const useTemplateGenerations = () => {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<ApiError | null>(null)
-  const [data, setData] = useState<ListResponse | undefined>()
+  const [data, setData] = useState<ListTemplateGenerationsResult | undefined>()
 
-  const load = useCallback(async (params?: ListParams) => {
+  const load = useCallback(async (params?: ListTemplateGenerationsInput) => {
     setLoading(true)
     setError(null)
 
@@ -44,7 +31,7 @@ export const useTemplateGenerations = () => {
     return { data, error: null }
   }, [])
 
-  const refetch = useCallback((params?: ListParams) => {
+  const refetch = useCallback((params?: ListTemplateGenerationsInput) => {
     return load(params)
   }, [load])
 

hooks/data/use-templates.ts

@@ -1,26 +1,16 @@
-import { ApiError, PaginationParams } from "@/lib/types"
+import { ApiError } from "@/lib/types"
 import { useState, useCallback } from "react"
 import { OWNER_ID } from "@/hooks/constants"
 import { root } from '@repo/core'
 import { TemplateController, ListTemplatesInput, ListTemplatesResult } from "@repo/sdk"
 import { useError } from "./use-error"
 
-interface UseTemplatesParams extends PaginationParams {
-  search?: string
-  categoryId?: string
-  isActive?: boolean
-  status?: string
-  ownerId?: string
-  sortBy?: 'sortOrder' | 'likeCount' | 'viewCount' | 'createdAt' | 'updatedAt'
-  sortOrder?: 'asc' | 'desc'
-}
-
 export const useTemplates = () => {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<ApiError | null>(null)
   const [data, setData] = useState<ListTemplatesResult | undefined>()
 
-  const execute = useCallback(async (params?: UseTemplatesParams) => {
+  const execute = useCallback(async (params?: ListTemplatesInput) => {
     setLoading(true)
     setError(null)
 
@@ -44,7 +34,7 @@ export const useTemplates = () => {
     return { data, error: null }
   }, [])
 
-  const refetch = useCallback((params?: UseTemplatesParams) => {
+  const refetch = useCallback((params?: ListTemplatesInput) => {
     return execute(params)
   }, [execute])