feat(admin-sdk,admin-bundler,admin-shared,medusa): Restructure admin packages (#8988)

**What**
- Renames /admin-next -> /admin
- Renames @medusajs/admin-sdk -> @medusajs/admin-bundler
- Creates a new package called @medusajs/admin-sdk that will hold all tooling relevant to creating admin extensions. This is currently `defineRouteConfig` and `defineWidgetConfig`, but will eventually also export methods for adding custom fields, register translation, etc. 
  - cc: @shahednasser we should update the examples in the docs so these functions are imported from `@medusajs/admin-sdk`. People will also need to install the package in their project, as it's no longer a transient dependency.
  - cc: @olivermrbl we might want to publish a changelog when this is merged, as it is a breaking change, and will require people to import the `defineXConfig` from the new package instead of `@medusajs/admin-shared`.
- Updates CODEOWNERS so /admin packages does not require a review from the UI team.

packages/admin/dashboard/src/hooks/api/api-keys.tsx

@@ -0,0 +1,179 @@
+import { HttpTypes } from "@medusajs/types"
+import { FetchError } from "@medusajs/js-sdk"
+import {
+  MutationOptions,
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { salesChannelsQueryKeys } from "./sales-channels"
+
+const API_KEYS_QUERY_KEY = "api_keys" as const
+export const apiKeysQueryKeys = queryKeysFactory(API_KEYS_QUERY_KEY)
+
+export const useApiKey = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminApiKeyResponse,
+      FetchError,
+      HttpTypes.AdminApiKeyResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.apiKey.retrieve(id),
+    queryKey: apiKeysQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useApiKeys = (
+  query?: HttpTypes.AdminGetApiKeysParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminGetApiKeysParams,
+      FetchError,
+      HttpTypes.AdminApiKeyListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.apiKey.list(query),
+    queryKey: apiKeysQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateApiKey = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminApiKeyResponse,
+    FetchError,
+    HttpTypes.AdminCreateApiKey
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.apiKey.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateApiKey = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminApiKeyResponse,
+    FetchError,
+    HttpTypes.AdminUpdateApiKey
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.apiKey.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRevokeApiKey = (
+  id: string,
+  options?: UseMutationOptions<HttpTypes.AdminApiKeyResponse, FetchError, void>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.apiKey.revoke(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+  })
+}
+
+export const useDeleteApiKey = (
+  id: string,
+  options?: MutationOptions<
+    HttpTypes.AdminApiKeyDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.apiKey.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+  })
+}
+
+export const useBatchRemoveSalesChannelsFromApiKey = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminApiKeyResponse,
+    FetchError,
+    HttpTypes.AdminBatchLink["remove"]
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.apiKey.batchSalesChannels(id, { remove: payload }),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.detail(id) })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useBatchAddSalesChannelsToApiKey = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminApiKeyResponse,
+    FetchError,
+    HttpTypes.AdminBatchLink["add"]
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.apiKey.batchSalesChannels(id, { add: payload }),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.detail(id) })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/auth.tsx

@@ -0,0 +1,43 @@
+import { UseMutationOptions, useMutation } from "@tanstack/react-query"
+import { FetchError } from "@medusajs/js-sdk"
+import { sdk } from "../../lib/client"
+import { HttpTypes } from "@medusajs/types"
+
+export const useSignInWithEmailPassword = (
+  options?: UseMutationOptions<
+    string,
+    FetchError,
+    HttpTypes.AdminSignUpWithEmailPassword
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.auth.login("user", "emailpass", payload),
+    onSuccess: async (data, variables, context) => {
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useSignUpWithEmailPass = (
+  options?: UseMutationOptions<
+    string,
+    FetchError,
+    HttpTypes.AdminSignInWithEmailPassword
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.auth.register("user", "emailpass", payload),
+    onSuccess: async (data, variables, context) => {
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useLogout = (options?: UseMutationOptions<void, FetchError>) => {
+  return useMutation({
+    mutationFn: () => sdk.auth.logout(),
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/campaigns.tsx

@@ -0,0 +1,135 @@
+import { HttpTypes, LinkMethodRequest } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { promotionsQueryKeys } from "./promotions"
+import { FetchError } from "@medusajs/js-sdk"
+
+const REGIONS_QUERY_KEY = "campaigns" as const
+export const campaignsQueryKeys = queryKeysFactory(REGIONS_QUERY_KEY)
+
+export const useCampaign = (
+  id: string,
+  query?: HttpTypes.AdminGetCampaignParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminCampaignResponse,
+      FetchError,
+      HttpTypes.AdminCampaignResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: campaignsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.campaign.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCampaigns = (
+  query?: HttpTypes.AdminGetCampaignsParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminCampaignListResponse,
+      FetchError,
+      HttpTypes.AdminCampaignListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.campaign.list(query),
+    queryKey: campaignsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateCampaign = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminCampaignResponse,
+    FetchError,
+    HttpTypes.AdminCreateCampaign
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.campaign.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: campaignsQueryKeys.lists() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateCampaign = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminCampaignResponse,
+    FetchError,
+    HttpTypes.AdminUpdateCampaign
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.campaign.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: campaignsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: campaignsQueryKeys.details() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteCampaign = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.DeleteResponse<"campaign">,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.campaign.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: campaignsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: campaignsQueryKeys.details() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddOrRemoveCampaignPromotions = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminCampaignResponse,
+    FetchError,
+    LinkMethodRequest
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.campaign.batchPromotions(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: campaignsQueryKeys.details() })
+      queryClient.invalidateQueries({ queryKey: promotionsQueryKeys.lists() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/categories.tsx

@@ -0,0 +1,150 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { productsQueryKeys } from "./products"
+
+const CATEGORIES_QUERY_KEY = "categories" as const
+export const categoriesQueryKeys = queryKeysFactory(CATEGORIES_QUERY_KEY)
+
+export const useProductCategory = (
+  id: string,
+  query?: HttpTypes.AdminProductCategoryParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductCategoryResponse,
+      FetchError,
+      HttpTypes.AdminProductCategoryResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: categoriesQueryKeys.detail(id, query),
+    queryFn: () => sdk.admin.productCategory.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useProductCategories = (
+  query?: HttpTypes.AdminProductCategoryListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductCategoryListResponse,
+      FetchError,
+      HttpTypes.AdminProductCategoryListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: categoriesQueryKeys.list(query),
+    queryFn: () => sdk.admin.productCategory.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateProductCategory = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductCategoryResponse,
+    FetchError,
+    HttpTypes.AdminCreateProductCategory
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.productCategory.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: categoriesQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProductCategory = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductCategoryResponse,
+    FetchError,
+    HttpTypes.AdminUpdateProductCategory
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.productCategory.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: categoriesQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: categoriesQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteProductCategory = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductCategoryDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.productCategory.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: categoriesQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({ queryKey: categoriesQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProductCategoryProducts = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductCategoryResponse,
+    FetchError,
+    HttpTypes.AdminUpdateProductCategoryProducts
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.productCategory.updateProducts(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: categoriesQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: categoriesQueryKeys.detail(id),
+      })
+      /**
+       * Invalidate products list query to ensure that the products collections are updated.
+       */
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/claims.tsx

@@ -0,0 +1,618 @@
+import { HttpTypes } from "@medusajs/types"
+import { FetchError } from "@medusajs/js-sdk"
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { ordersQueryKeys } from "./orders"
+import { returnsQueryKeys } from "./returns"
+
+const CLAIMS_QUERY_KEY = "claims" as const
+export const claimsQueryKeys = queryKeysFactory(CLAIMS_QUERY_KEY)
+
+export const useClaim = (
+  id: string,
+  query?: HttpTypes.AdminClaimListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminClaimResponse,
+      FetchError,
+      HttpTypes.AdminClaimResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.claim.retrieve(id, query),
+    queryKey: claimsQueryKeys.detail(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useClaims = (
+  query?: HttpTypes.AdminClaimListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminClaimListParams,
+      FetchError,
+      HttpTypes.AdminClaimListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.claim.list(query),
+    queryKey: claimsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateClaim = (
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminCreateClaim
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateClaim) =>
+      sdk.admin.claim.create(payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: claimsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelClaim = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminClaimResponse, FetchError>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.claim.cancel(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: claimsQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: claimsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteClaim = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminClaimDeleteResponse, FetchError>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.claim.delete(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: claimsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: claimsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddClaimItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminAddClaimItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddClaimItems) =>
+      sdk.admin.claim.addItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateClaimItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminUpdateClaimItem & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateClaimItem & { actionId: string }) => {
+      return sdk.admin.claim.updateItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveClaimItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.return.removeReturnItem(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddClaimInboundItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminAddClaimInboundItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddClaimInboundItems) =>
+      sdk.admin.claim.addInboundItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateClaimInboundItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminUpdateClaimInboundItem & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateClaimInboundItem & { actionId: string }) => {
+      return sdk.admin.claim.updateInboundItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveClaimInboundItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminClaimResponse, FetchError, string>
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.claim.removeInboundItem(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddClaimInboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminClaimAddInboundShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminClaimAddInboundShipping) =>
+      sdk.admin.claim.addInboundShipping(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateClaimInboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminClaimUpdateInboundShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminClaimUpdateInboundShipping & { actionId: string }) =>
+      sdk.admin.claim.updateInboundShipping(id, actionId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteClaimInboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminClaimResponse, FetchError, string>
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.claim.deleteInboundShipping(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddClaimOutboundItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminAddClaimOutboundItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddClaimOutboundItems) =>
+      sdk.admin.claim.addOutboundItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateClaimOutboundItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminUpdateClaimOutboundItem & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateClaimOutboundItem & { actionId: string }) => {
+      return sdk.admin.claim.updateOutboundItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveClaimOutboundItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminClaimResponse, FetchError, string>
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.claim.removeOutboundItem(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddClaimOutboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminClaimAddOutboundShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminClaimAddOutboundShipping) =>
+      sdk.admin.claim.addOutboundShipping(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateClaimOutboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminClaimUpdateOutboundShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminClaimUpdateOutboundShipping & { actionId: string }) =>
+      sdk.admin.claim.updateOutboundShipping(id, actionId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteClaimOutboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminClaimResponse, FetchError, string>
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.claim.deleteOutboundShipping(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useClaimConfirmRequest = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminClaimResponse,
+    FetchError,
+    HttpTypes.AdminRequestClaim
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminRequestClaim) =>
+      sdk.admin.claim.request(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.all,
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: claimsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelClaimRequest = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminClaimResponse, FetchError>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.claim.cancelRequest(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: claimsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: claimsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/collections.tsx

@@ -0,0 +1,149 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { FindParams, HttpTypes, PaginatedResponse } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { productsQueryKeys } from "./products"
+
+const COLLECTION_QUERY_KEY = "collections" as const
+export const collectionsQueryKeys = queryKeysFactory(COLLECTION_QUERY_KEY)
+
+export const useCollection = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<
+      { collection: HttpTypes.AdminCollection },
+      FetchError,
+      { collection: HttpTypes.AdminCollection },
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: collectionsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.productCollection.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCollections = (
+  query?: FindParams & HttpTypes.AdminCollectionFilters,
+  options?: Omit<
+    UseQueryOptions<
+      PaginatedResponse<{ collections: HttpTypes.AdminCollection[] }>,
+      FetchError,
+      PaginatedResponse<{ collections: HttpTypes.AdminCollection[] }>,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: collectionsQueryKeys.list(query),
+    queryFn: async () => sdk.admin.productCollection.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUpdateCollection = (
+  id: string,
+  options?: UseMutationOptions<
+    { collection: HttpTypes.AdminCollection },
+    FetchError,
+    HttpTypes.AdminUpdateCollection
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.productCollection.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: collectionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: collectionsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateCollectionProducts = (
+  id: string,
+  options?: UseMutationOptions<
+    { collection: HttpTypes.AdminCollection },
+    FetchError,
+    HttpTypes.AdminUpdateCollectionProducts
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.productCollection.updateProducts(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: collectionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: collectionsQueryKeys.detail(id),
+      })
+      /**
+       * Invalidate products list query to ensure that the products collections are updated.
+       */
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCreateCollection = (
+  options?: UseMutationOptions<
+    { collection: HttpTypes.AdminCollection },
+    FetchError,
+    HttpTypes.AdminCreateCollection
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.productCollection.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: collectionsQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteCollection = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminCollectionDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.productCollection.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: collectionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: collectionsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/currencies.tsx

@@ -0,0 +1,52 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { QueryKey, UseQueryOptions, useQuery } from "@tanstack/react-query"
+
+import { sdk } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const CURRENCIES_QUERY_KEY = "currencies" as const
+const currenciesQueryKeys = queryKeysFactory(CURRENCIES_QUERY_KEY)
+
+export const useCurrencies = (
+  query?: HttpTypes.AdminCurrencyListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminCurrencyListResponse,
+      FetchError,
+      HttpTypes.AdminCurrencyListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.currency.list(query),
+    queryKey: currenciesQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCurrency = (
+  id: string,
+  query?: HttpTypes.AdminCurrencyParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminCurrencyResponse,
+      FetchError,
+      HttpTypes.AdminCurrencyResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: currenciesQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.currency.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin/dashboard/src/hooks/api/customer-groups.tsx

@@ -0,0 +1,183 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { customersQueryKeys } from "./customers"
+
+const CUSTOMER_GROUPS_QUERY_KEY = "customer_groups" as const
+export const customerGroupsQueryKeys = queryKeysFactory(
+  CUSTOMER_GROUPS_QUERY_KEY
+)
+
+export const useCustomerGroup = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminCustomerGroupResponse,
+      FetchError,
+      HttpTypes.AdminCustomerGroupResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: customerGroupsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.customerGroup.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCustomerGroups = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminGetCustomerGroupsParams,
+      FetchError,
+      HttpTypes.AdminCustomerGroupListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.customerGroup.list(query),
+    queryKey: customerGroupsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateCustomerGroup = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminCustomerGroupResponse,
+    FetchError,
+    HttpTypes.AdminCreateCustomerGroup
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.customerGroup.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateCustomerGroup = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminCustomerGroupResponse,
+    FetchError,
+    HttpTypes.AdminUpdateCustomerGroup
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.customerGroup.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteCustomerGroup = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminCustomerGroupDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.customerGroup.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddCustomersToGroup = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminCustomerGroupResponse,
+    FetchError,
+    HttpTypes.AdminBatchLink["add"]
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.customerGroup.batchCustomers(id, { add: payload }),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({
+        queryKey: customersQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveCustomersFromGroup = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminCustomerGroupResponse,
+    FetchError,
+    HttpTypes.AdminBatchLink["remove"]
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.customerGroup.batchCustomers(id, { remove: payload }),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: customerGroupsQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({
+        queryKey: customersQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/customers.tsx

@@ -0,0 +1,117 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes, PaginatedResponse } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const CUSTOMERS_QUERY_KEY = "customers" as const
+export const customersQueryKeys = queryKeysFactory(CUSTOMERS_QUERY_KEY)
+
+export const useCustomer = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      { customer: HttpTypes.AdminCustomer },
+      FetchError,
+      { customer: HttpTypes.AdminCustomer },
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: customersQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.customer.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCustomers = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      PaginatedResponse<{ customers: HttpTypes.AdminCustomer[] }>,
+      FetchError,
+      PaginatedResponse<{ customers: HttpTypes.AdminCustomer[] }>,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.customer.list(query),
+    queryKey: customersQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateCustomer = (
+  options?: UseMutationOptions<
+    { customer: HttpTypes.AdminCustomer },
+    FetchError,
+    HttpTypes.AdminCreateCustomer
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.customer.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: customersQueryKeys.lists() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateCustomer = (
+  id: string,
+  options?: UseMutationOptions<
+    { customer: HttpTypes.AdminCustomer },
+    FetchError,
+    HttpTypes.AdminUpdateCustomer
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.customer.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: customersQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: customersQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteCustomer = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminCustomerDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.customer.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: customersQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: customersQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/exchanges.tsx

@@ -0,0 +1,565 @@
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+import { FetchError } from "@medusajs/js-sdk"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { ordersQueryKeys } from "./orders"
+import { returnsQueryKeys } from "./returns"
+
+const EXCHANGES_QUERY_KEY = "exchanges" as const
+export const exchangesQueryKeys = queryKeysFactory(EXCHANGES_QUERY_KEY)
+
+export const useExchange = (
+  id: string,
+  query?: HttpTypes.AdminExchangeListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminExchangeResponse,
+      FetchError,
+      HttpTypes.AdminExchangeResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.exchange.retrieve(id, query),
+    queryKey: exchangesQueryKeys.detail(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useExchanges = (
+  query?: HttpTypes.AdminExchangeListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminExchangeListParams,
+      FetchError,
+      HttpTypes.AdminExchangeListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.exchange.list(query),
+    queryKey: exchangesQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateExchange = (
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminCreateExchange
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateExchange) =>
+      sdk.admin.exchange.create(payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: exchangesQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelExchange = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminExchangeResponse, FetchError>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.exchange.cancel(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: exchangesQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: exchangesQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteExchange = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeDeleteResponse,
+    FetchError
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.exchange.delete(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: exchangesQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: exchangesQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddExchangeItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminAddExchangeItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddExchangeItems) =>
+      sdk.admin.exchange.addItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateExchangeItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminUpdateExchangeItem & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateExchangeItem & { actionId: string }) => {
+      return sdk.admin.exchange.updateItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveExchangeItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.return.removeReturnItem(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddExchangeInboundItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminAddExchangeInboundItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddExchangeInboundItems) =>
+      sdk.admin.exchange.addInboundItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateExchangeInboundItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminUpdateExchangeInboundItem & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateExchangeInboundItem & { actionId: string }) => {
+      return sdk.admin.exchange.updateInboundItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveExchangeInboundItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.exchange.removeInboundItem(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddExchangeInboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminExchangeAddInboundShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminExchangeAddInboundShipping) =>
+      sdk.admin.exchange.addInboundShipping(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateExchangeInboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminExchangeUpdateInboundShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminExchangeUpdateInboundShipping & { actionId: string }) =>
+      sdk.admin.exchange.updateInboundShipping(id, actionId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteExchangeInboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.exchange.deleteInboundShipping(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddExchangeOutboundItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminAddExchangeOutboundItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddExchangeOutboundItems) =>
+      sdk.admin.exchange.addOutboundItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateExchangeOutboundItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminUpdateExchangeOutboundItem & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateExchangeOutboundItem & { actionId: string }) => {
+      return sdk.admin.exchange.updateOutboundItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveExchangeOutboundItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.exchange.removeOutboundItem(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddExchangeOutboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminExchangeAddOutboundShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminExchangeAddOutboundShipping) =>
+      sdk.admin.exchange.addOutboundShipping(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateExchangeOutboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminExchangeUpdateOutboundShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminExchangeUpdateOutboundShipping & { actionId: string }) =>
+      sdk.admin.exchange.updateOutboundShipping(id, actionId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteExchangeOutboundShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.exchange.deleteOutboundShipping(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useExchangeConfirmRequest = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExchangeResponse,
+    FetchError,
+    HttpTypes.AdminRequestExchange
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminRequestExchange) =>
+      sdk.admin.exchange.request(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.all,
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: exchangesQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelExchangeRequest = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminExchangeResponse, FetchError>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.exchange.cancelRequest(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: exchangesQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: exchangesQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/fulfillment-providers.tsx

@@ -0,0 +1,31 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { QueryKey, useQuery, UseQueryOptions } from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const FULFILLMENT_PROVIDERS_QUERY_KEY = "fulfillment_providers" as const
+export const fulfillmentProvidersQueryKeys = queryKeysFactory(
+  FULFILLMENT_PROVIDERS_QUERY_KEY
+)
+
+export const useFulfillmentProviders = (
+  query?: HttpTypes.AdminFulfillmentProviderListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminFulfillmentProviderListResponse,
+      FetchError,
+      HttpTypes.AdminFulfillmentProviderListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.fulfillmentProvider.list(query),
+    queryKey: fulfillmentProvidersQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin/dashboard/src/hooks/api/fulfillment-sets.tsx

@@ -0,0 +1,181 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { shippingOptionsQueryKeys } from "./shipping-options"
+import { stockLocationsQueryKeys } from "./stock-locations"
+
+const FULFILLMENT_SETS_QUERY_KEY = "fulfillment_sets" as const
+export const fulfillmentSetsQueryKeys = queryKeysFactory(
+  FULFILLMENT_SETS_QUERY_KEY
+)
+
+export const useDeleteFulfillmentSet = (
+  id: string,
+  options?: Omit<
+    UseMutationOptions<
+      HttpTypes.AdminFulfillmentSetDeleteResponse,
+      FetchError,
+      void
+    >,
+    "mutationFn"
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.fulfillmentSet.delete(id),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: fulfillmentSetsQueryKeys.detail(id),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: fulfillmentSetsQueryKeys.lists(),
+      })
+
+      // We need to invalidate all related entities. We invalidate using `all` keys to ensure that all relevant entities are invalidated.
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.all,
+        refetchType: "all",
+      })
+      await queryClient.invalidateQueries({
+        queryKey: shippingOptionsQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useFulfillmentSetServiceZone = (
+  fulfillmentSetId: string,
+  serviceZoneId: string,
+  query?: HttpTypes.SelectParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminServiceZoneResponse,
+      FetchError,
+      HttpTypes.AdminServiceZoneResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () =>
+      sdk.admin.fulfillmentSet.retrieveServiceZone(
+        fulfillmentSetId,
+        serviceZoneId,
+        query
+      ),
+    queryKey: fulfillmentSetsQueryKeys.detail(fulfillmentSetId, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateFulfillmentSetServiceZone = (
+  fulfillmentSetId: string,
+  options?: Omit<
+    UseMutationOptions<
+      HttpTypes.AdminFulfillmentSetResponse,
+      FetchError,
+      HttpTypes.AdminCreateFulfillmentSetServiceZone,
+      QueryKey
+    >,
+    "mutationFn"
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.fulfillmentSet.createServiceZone(fulfillmentSetId, payload),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: fulfillmentSetsQueryKeys.lists(),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateFulfillmentSetServiceZone = (
+  fulfillmentSetId: string,
+  serviceZoneId: string,
+  options?: Omit<
+    UseMutationOptions<
+      HttpTypes.AdminFulfillmentSetResponse,
+      FetchError,
+      HttpTypes.AdminUpdateFulfillmentSetServiceZone,
+      QueryKey
+    >,
+    "mutationFn"
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.fulfillmentSet.updateServiceZone(
+        fulfillmentSetId,
+        serviceZoneId,
+        payload
+      ),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: fulfillmentSetsQueryKeys.lists(),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteFulfillmentServiceZone = (
+  fulfillmentSetId: string,
+  serviceZoneId: string,
+  options?: Omit<
+    UseMutationOptions<
+      HttpTypes.AdminServiceZoneDeleteResponse,
+      FetchError,
+      void
+    >,
+    "mutationFn"
+  >
+) => {
+  return useMutation({
+    mutationFn: () =>
+      sdk.admin.fulfillmentSet.deleteServiceZone(
+        fulfillmentSetId,
+        serviceZoneId
+      ),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: fulfillmentSetsQueryKeys.lists(),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: shippingOptionsQueryKeys.lists(),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/fulfillment.tsx

@@ -0,0 +1,66 @@
+import { useMutation, UseMutationOptions } from "@tanstack/react-query"
+
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+import { HttpTypes } from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { ordersQueryKeys } from "./orders"
+import { FetchError } from "@medusajs/js-sdk"
+
+const FULFILLMENTS_QUERY_KEY = "fulfillments" as const
+export const fulfillmentsQueryKeys = queryKeysFactory(FULFILLMENTS_QUERY_KEY)
+
+export const useCreateFulfillment = (
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (payload: any) => sdk.admin.fulfillment.create(payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: fulfillmentsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelFulfillment = (
+  id: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.fulfillment.cancel(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: fulfillmentsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCreateFulfillmentShipment = (
+  fulfillmentId: string,
+  options?: UseMutationOptions<
+    { fulfillment: HttpTypes.AdminFulfillment },
+    FetchError,
+    HttpTypes.AdminCreateFulfillmentShipment
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateFulfillmentShipment) =>
+      sdk.admin.fulfillment.createShipment(fulfillmentId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/index.ts

@@ -0,0 +1,35 @@
+export * from "./api-keys"
+export * from "./auth"
+export * from "./campaigns"
+export * from "./categories"
+export * from "./collections"
+export * from "./currencies"
+export * from "./customer-groups"
+export * from "./customers"
+export * from "./fulfillment"
+export * from "./fulfillment-providers"
+export * from "./fulfillment-sets"
+export * from "./inventory"
+export * from "./invites"
+export * from "./notification"
+export * from "./orders"
+export * from "./payment-collections"
+export * from "./payments"
+export * from "./price-lists"
+export * from "./product-types"
+export * from "./product-variants"
+export * from "./products"
+export * from "./promotions"
+export * from "./refund-reasons"
+export * from "./regions"
+export * from "./reservations"
+export * from "./sales-channels"
+export * from "./shipping-options"
+export * from "./shipping-profiles"
+export * from "./stock-locations"
+export * from "./store"
+export * from "./tags"
+export * from "./tax-rates"
+export * from "./tax-regions"
+export * from "./users"
+export * from "./workflow-executions"

packages/admin/dashboard/src/hooks/api/inventory.tsx

@@ -0,0 +1,238 @@
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { FetchError } from "@medusajs/js-sdk"
+
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const INVENTORY_ITEMS_QUERY_KEY = "inventory_items" as const
+export const inventoryItemsQueryKeys = queryKeysFactory(
+  INVENTORY_ITEMS_QUERY_KEY
+)
+
+const INVENTORY_ITEM_LEVELS_QUERY_KEY = "inventory_item_levels" as const
+export const inventoryItemLevelsQueryKeys = queryKeysFactory(
+  INVENTORY_ITEM_LEVELS_QUERY_KEY
+)
+
+export const useInventoryItems = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminInventoryItemListResponse,
+      FetchError,
+      HttpTypes.AdminInventoryItemListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.inventoryItem.list(query),
+    queryKey: inventoryItemsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useInventoryItem = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminInventoryItemResponse,
+      FetchError,
+      HttpTypes.AdminInventoryItemResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.inventoryItem.retrieve(id, query),
+    queryKey: inventoryItemsQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateInventoryItem = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminInventoryItemResponse,
+    FetchError,
+    HttpTypes.AdminCreateInventoryItem
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateInventoryItem) =>
+      sdk.admin.inventoryItem.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateInventoryItem = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminInventoryItemResponse,
+    FetchError,
+    HttpTypes.AdminUpdateInventoryItem
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminUpdateInventoryItem) =>
+      sdk.admin.inventoryItem.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.detail(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteInventoryItem = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminInventoryItemDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.inventoryItem.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.detail(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteInventoryItemLevel = (
+  inventoryItemId: string,
+  locationId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminInventoryItemDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () =>
+      sdk.admin.inventoryItem.deleteLevel(inventoryItemId, locationId),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.detail(inventoryItemId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemLevelsQueryKeys.detail(inventoryItemId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useInventoryItemLevels = (
+  inventoryItemId: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminInventoryLevelListResponse,
+      FetchError,
+      HttpTypes.AdminInventoryLevelListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.inventoryItem.listLevels(inventoryItemId, query),
+    queryKey: inventoryItemLevelsQueryKeys.detail(inventoryItemId),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUpdateInventoryLevel = (
+  inventoryItemId: string,
+  locationId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminInventoryItemResponse,
+    FetchError,
+    HttpTypes.AdminUpdateInventoryLevel
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminUpdateInventoryLevel) =>
+      sdk.admin.inventoryItem.updateLevel(inventoryItemId, locationId, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.detail(inventoryItemId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemLevelsQueryKeys.detail(inventoryItemId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useBatchUpdateInventoryLevels = (
+  inventoryItemId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminInventoryItemResponse,
+    FetchError,
+    HttpTypes.AdminBatchUpdateInventoryLevelLocation
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminBatchUpdateInventoryLevelLocation) =>
+      sdk.admin.inventoryItem.batchUpdateLevels(inventoryItemId, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.detail(inventoryItemId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemLevelsQueryKeys.detail(inventoryItemId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/invites.tsx

@@ -0,0 +1,143 @@
+import {
+  AdminInviteResponse,
+  HttpTypes,
+  PaginatedResponse,
+} from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { FetchError } from "@medusajs/js-sdk"
+
+const INVITES_QUERY_KEY = "invites" as const
+const invitesQueryKeys = queryKeysFactory(INVITES_QUERY_KEY)
+
+export const useInvite = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<
+      { invite: HttpTypes.AdminInviteResponse },
+      FetchError,
+      { invite: HttpTypes.AdminInviteResponse },
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: invitesQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.invite.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useInvites = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      PaginatedResponse<{ invites: HttpTypes.AdminInviteResponse[] }>,
+      FetchError,
+      PaginatedResponse<{ invites: HttpTypes.AdminInviteResponse[] }>,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.invite.list(query),
+    queryKey: invitesQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateInvite = (
+  options?: UseMutationOptions<
+    { invite: AdminInviteResponse },
+    FetchError,
+    HttpTypes.AdminCreateInvite
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.invite.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.lists() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useResendInvite = (
+  id: string,
+  options?: UseMutationOptions<
+    { invite: AdminInviteResponse },
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.invite.resend(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.detail(id) })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteInvite = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminInviteDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.invite.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.detail(id) })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAcceptInvite = (
+  inviteToken: string,
+  options?: UseMutationOptions<
+    { user: HttpTypes.AdminUserResponse },
+    FetchError,
+    HttpTypes.AdminAcceptInvite & { auth_token: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => {
+      const { auth_token, ...rest } = payload
+
+      return sdk.admin.invite.accept(
+        { invite_token: inviteToken, ...rest },
+        {},
+        {
+          Authorization: `Bearer ${auth_token}`,
+        }
+      )
+    },
+    onSuccess: (data, variables, context) => {
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/notification.tsx

@@ -0,0 +1,52 @@
+import { QueryKey, UseQueryOptions, useQuery } from "@tanstack/react-query"
+
+import { HttpTypes } from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { FetchError } from "@medusajs/js-sdk"
+
+const NOTIFICATION_QUERY_KEY = "notification" as const
+export const notificationQueryKeys = queryKeysFactory(NOTIFICATION_QUERY_KEY)
+
+export const useNotification = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminNotificationResponse,
+      FetchError,
+      HttpTypes.AdminNotificationResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: notificationQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.notification.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useNotifications = (
+  query?: HttpTypes.AdminNotificationListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminNotificationListResponse,
+      FetchError,
+      HttpTypes.AdminNotificationListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.notification.list(query),
+    queryKey: notificationQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin/dashboard/src/hooks/api/order-edits.tsx

@@ -0,0 +1,215 @@
+import { useMutation, UseMutationOptions } from "@tanstack/react-query"
+
+import { HttpTypes } from "@medusajs/types"
+
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { ordersQueryKeys } from "./orders"
+import { FetchError } from "@medusajs/js-sdk"
+
+export const useCreateOrderEdit = (
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminOrderEditPreviewResponse,
+    FetchError,
+    HttpTypes.AdminInitiateOrderEditRequest
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminInitiateOrderEditRequest) =>
+      sdk.admin.orderEdit.initiateRequest(payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRequestOrderEdit = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminOrderEditPreviewResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.orderEdit.request(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(id),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.changes(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useConfirmOrderEdit = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminOrderEditPreviewResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.orderEdit.confirm(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(id),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.changes(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelOrderEdit = (
+  orderId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.orderEdit.cancelRequest(orderId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.changes(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddOrderEditItems = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminOrderEditPreviewResponse,
+    FetchError,
+    HttpTypes.AdminAddOrderEditItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddOrderEditItems) =>
+      sdk.admin.orderEdit.addItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+/**
+ * Update (quantity) of an item that was originally on the order.
+ */
+export const useUpdateOrderEditOriginalItem = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminOrderEditPreviewResponse,
+    FetchError,
+    HttpTypes.AdminUpdateOrderEditItem & { itemId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      itemId,
+      ...payload
+    }: HttpTypes.AdminUpdateOrderEditItem & { itemId: string }) => {
+      return sdk.admin.orderEdit.updateOriginalItem(id, itemId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+/**
+ * Update (quantity) of an item that was added to the order edit.
+ */
+export const useUpdateOrderEditAddedItem = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminOrderEditPreviewResponse,
+    FetchError,
+    HttpTypes.AdminUpdateOrderEditItem & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateOrderEditItem & { actionId: string }) => {
+      return sdk.admin.orderEdit.updateAddedItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+/**
+ * Remove item that was added to the edit.
+ * To remove an original item on the order, set quantity to 0.
+ */
+export const useRemoveOrderEditItem = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminOrderEditPreviewResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.orderEdit.removeAddedItem(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(id),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/orders.tsx

@@ -0,0 +1,210 @@
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory, TQueryKey } from "../../lib/query-key-factory"
+
+const ORDERS_QUERY_KEY = "orders" as const
+const _orderKeys = queryKeysFactory(ORDERS_QUERY_KEY) as TQueryKey<
+  "orders",
+  any,
+  string
+> & {
+  preview: (orderId: string) => any
+  changes: (orderId: string) => any
+}
+
+_orderKeys.preview = function (id: string) {
+  return [this.detail(id), "preview"]
+}
+
+_orderKeys.changes = function (id: string) {
+  return [this.detail(id), "changes"]
+}
+
+export const ordersQueryKeys = _orderKeys
+
+export const useOrder = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<any, FetchError, any, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.order.retrieve(id, query),
+    queryKey: ordersQueryKeys.detail(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useOrderPreview = (
+  id: string,
+  query?: HttpTypes.AdminOrderFilters,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminOrderPreviewResponse,
+      FetchError,
+      HttpTypes.AdminOrderPreviewResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.order.retrievePreview(id, query),
+    queryKey: ordersQueryKeys.preview(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useOrders = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<any, FetchError, any, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.order.list(query),
+    queryKey: ordersQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useOrderChanges = (
+  id: string,
+  query?: HttpTypes.AdminOrderChangesFilters,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminOrderChangesResponse,
+      Error,
+      HttpTypes.AdminOrderChangesResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.order.listChanges(id, query),
+    queryKey: ordersQueryKeys.changes(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateOrderFulfillment = (
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminOrderResponse,
+    FetchError,
+    HttpTypes.AdminCreateOrderFulfillment
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateOrderFulfillment) =>
+      sdk.admin.order.createFulfillment(orderId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelOrderFulfillment = (
+  orderId: string,
+  fulfillmentId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (payload: { no_notification?: boolean }) =>
+      sdk.admin.order.cancelFulfillment(orderId, fulfillmentId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCreateOrderShipment = (
+  orderId: string,
+  fulfillmentId: string,
+  options?: UseMutationOptions<
+    { order: HttpTypes.AdminOrder },
+    FetchError,
+    HttpTypes.AdminCreateOrderShipment
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateOrderShipment) =>
+      sdk.admin.order.createShipment(orderId, fulfillmentId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelOrder = (
+  orderId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (id) => sdk.admin.order.cancel(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/payment-collections.tsx

@@ -0,0 +1,104 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { useMutation, UseMutationOptions } from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { ordersQueryKeys } from "./orders"
+
+const PAYMENT_COLLECTION_QUERY_KEY = "payment-collection" as const
+export const paymentCollectionQueryKeys = queryKeysFactory(
+  PAYMENT_COLLECTION_QUERY_KEY
+)
+
+export const useCreatePaymentCollection = (
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPaymentCollectionResponse,
+    FetchError,
+    HttpTypes.AdminCreatePaymentCollection
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.paymentCollection.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: paymentCollectionQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useMarkPaymentCollectionAsPaid = (
+  orderId: string,
+  paymentCollectionId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPaymentCollectionResponse,
+    FetchError,
+    HttpTypes.AdminMarkPaymentCollectionAsPaid
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.paymentCollection.markAsPaid(paymentCollectionId, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: paymentCollectionQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeletePaymentCollection = (
+  orderId: string,
+  options?: Omit<
+    UseMutationOptions<
+      HttpTypes.AdminDeletePaymentCollectionResponse,
+      FetchError,
+      string
+    >,
+    "mutationFn"
+  >
+) => {
+  return useMutation({
+    mutationFn: (id: string) => sdk.admin.paymentCollection.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: paymentCollectionQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/payments.tsx

@@ -0,0 +1,111 @@
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { ordersQueryKeys } from "./orders"
+import { FetchError } from "@medusajs/js-sdk"
+
+const PAYMENT_QUERY_KEY = "payment" as const
+export const paymentQueryKeys = queryKeysFactory(PAYMENT_QUERY_KEY)
+
+export const usePaymentProviders = (
+  query?: HttpTypes.AdminGetPaymentProvidersParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminGetPaymentProvidersParams,
+      FetchError,
+      HttpTypes.AdminPaymentProviderListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.payment.listPaymentProviders(query),
+    queryKey: [],
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const usePayment = (
+  id: string,
+  query?: HttpTypes.AdminPaymentFilters,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminPaymentResponse,
+      FetchError,
+      HttpTypes.AdminPaymentResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.payment.retrieve(id, query),
+    queryKey: paymentQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCapturePayment = (
+  orderId: string,
+  paymentId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPaymentResponse,
+    FetchError,
+    HttpTypes.AdminCapturePayment
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.payment.capture(paymentId, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRefundPayment = (
+  orderId: string,
+  paymentId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPaymentResponse,
+    FetchError,
+    HttpTypes.AdminRefundPayment
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.payment.refund(paymentId, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/price-lists.tsx

@@ -0,0 +1,172 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { customerGroupsQueryKeys } from "./customer-groups"
+import { productsQueryKeys } from "./products"
+
+const PRICE_LISTS_QUERY_KEY = "price-lists" as const
+export const priceListsQueryKeys = queryKeysFactory(PRICE_LISTS_QUERY_KEY)
+
+export const usePriceList = (
+  id: string,
+  query?: HttpTypes.AdminPriceListListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminPriceListResponse,
+      FetchError,
+      HttpTypes.AdminPriceListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.priceList.retrieve(id, query),
+    queryKey: priceListsQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const usePriceLists = (
+  query?: HttpTypes.AdminPriceListListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminPriceListListResponse,
+      FetchError,
+      HttpTypes.AdminPriceListListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.priceList.list(query),
+    queryKey: priceListsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreatePriceList = (
+  query?: HttpTypes.AdminPriceListParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPriceListResponse,
+    FetchError,
+    HttpTypes.AdminCreatePriceList
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.priceList.create(payload, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: priceListsQueryKeys.lists() })
+
+      queryClient.invalidateQueries({ queryKey: customerGroupsQueryKeys.all })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdatePriceList = (
+  id: string,
+  query?: HttpTypes.AdminPriceListParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPriceListResponse,
+    FetchError,
+    HttpTypes.AdminUpdatePriceList
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.priceList.update(id, payload, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: priceListsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: priceListsQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({ queryKey: customerGroupsQueryKeys.all })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeletePriceList = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPriceListDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.priceList.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: priceListsQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useBatchPriceListPrices = (
+  id: string,
+  query?: HttpTypes.AdminPriceListParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPriceListResponse,
+    FetchError,
+    HttpTypes.AdminBatchPriceListPrice
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.priceList.batchPrices(id, payload, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: priceListsQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const usePriceListLinkProducts = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPriceListResponse,
+    FetchError,
+    HttpTypes.AdminLinkPriceListProducts
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.priceList.linkProducts(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: priceListsQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({ queryKey: priceListsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/price-preferences.tsx

@@ -0,0 +1,113 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const PRICE_PREFERENCES_QUERY_KEY = "price-preferences" as const
+export const pricePreferencesQueryKeys = queryKeysFactory(
+  PRICE_PREFERENCES_QUERY_KEY
+)
+
+export const usePricePreference = (
+  id: string,
+  query?: HttpTypes.AdminPricePreferenceParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminPricePreferenceResponse,
+      FetchError,
+      HttpTypes.AdminPricePreferenceResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.pricePreference.retrieve(id, query),
+    queryKey: pricePreferencesQueryKeys.detail(),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const usePricePreferences = (
+  query?: HttpTypes.AdminPricePreferenceListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminPricePreferenceListResponse,
+      FetchError,
+      HttpTypes.AdminPricePreferenceListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.pricePreference.list(query),
+    queryKey: pricePreferencesQueryKeys.list(),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUpsertPricePreference = (
+  id?: string | undefined,
+  query?: HttpTypes.AdminPricePreferenceParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPricePreferenceResponse,
+    FetchError,
+    HttpTypes.AdminUpdatePricePreference | HttpTypes.AdminCreatePricePreference
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => {
+      if (id) {
+        return sdk.admin.pricePreference.update(id, payload, query)
+      }
+      return sdk.admin.pricePreference.create(payload, query)
+    },
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: pricePreferencesQueryKeys.list(),
+      })
+      if (id) {
+        queryClient.invalidateQueries({
+          queryKey: pricePreferencesQueryKeys.detail(id),
+        })
+      }
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeletePricePreference = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPricePreferenceDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.pricePreference.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: pricePreferencesQueryKeys.list(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/product-types.tsx

@@ -0,0 +1,120 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const PRODUCT_TYPES_QUERY_KEY = "product_types" as const
+export const productTypesQueryKeys = queryKeysFactory(PRODUCT_TYPES_QUERY_KEY)
+
+export const useProductType = (
+  id: string,
+  query?: HttpTypes.AdminProductTypeParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductTypeResponse,
+      FetchError,
+      HttpTypes.AdminProductTypeResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.productType.retrieve(id, query),
+    queryKey: productTypesQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useProductTypes = (
+  query?: HttpTypes.AdminProductTypeListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductTypeListResponse,
+      FetchError,
+      HttpTypes.AdminProductTypeListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.productType.list(query),
+    queryKey: productTypesQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateProductType = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductTypeResponse,
+    FetchError,
+    HttpTypes.AdminCreateProductType
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.productType.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: productTypesQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProductType = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductTypeResponse,
+    FetchError,
+    HttpTypes.AdminUpdateProductType
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.productType.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productTypesQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({ queryKey: productTypesQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteProductType = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductTypeDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.productType.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productTypesQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({ queryKey: productTypesQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/product-variants.tsx

@@ -0,0 +1,25 @@
+import { QueryKey, useQuery, UseQueryOptions } from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { FetchError } from "@medusajs/js-sdk"
+
+const PRODUCT_VARIANT_QUERY_KEY = "product_variant" as const
+export const productVariantQueryKeys = queryKeysFactory(
+  PRODUCT_VARIANT_QUERY_KEY
+)
+
+export const useVariants = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<any, FetchError, any, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.productVariant.list(query),
+    queryKey: productVariantQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin/dashboard/src/hooks/api/products.tsx

@@ -0,0 +1,373 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { inventoryItemsQueryKeys } from "./inventory.tsx"
+
+const PRODUCTS_QUERY_KEY = "products" as const
+export const productsQueryKeys = queryKeysFactory(PRODUCTS_QUERY_KEY)
+
+const VARIANTS_QUERY_KEY = "product_variants" as const
+export const variantsQueryKeys = queryKeysFactory(VARIANTS_QUERY_KEY)
+
+const OPTIONS_QUERY_KEY = "product_options" as const
+export const optionsQueryKeys = queryKeysFactory(OPTIONS_QUERY_KEY)
+
+export const useCreateProductOption = (
+  productId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateProductOption) =>
+      sdk.admin.product.createOption(productId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: optionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProductOption = (
+  productId: string,
+  optionId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminUpdateProductOption) =>
+      sdk.admin.product.updateOption(productId, optionId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: optionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: optionsQueryKeys.detail(optionId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteProductOption = (
+  productId: string,
+  optionId: string,
+  options?: UseMutationOptions<any, FetchError, void>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.product.deleteOption(productId, optionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: optionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: optionsQueryKeys.detail(optionId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useProductVariant = (
+  productId: string,
+  variantId: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<any, FetchError, any, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () =>
+      sdk.admin.product.retrieveVariant(productId, variantId, query),
+    queryKey: variantsQueryKeys.detail(variantId),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useProductVariants = (
+  productId: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<any, FetchError, any, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.product.listVariants(productId, query),
+    queryKey: variantsQueryKeys.list({ productId, ...query }),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateProductVariant = (
+  productId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateProductVariant) =>
+      sdk.admin.product.createVariant(productId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProductVariant = (
+  productId: string,
+  variantId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminUpdateProductVariant) =>
+      sdk.admin.product.updateVariant(productId, variantId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: variantsQueryKeys.detail(variantId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProductVariantsBatch = (
+  productId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (
+      payload: HttpTypes.AdminBatchProductVariantRequest["update"]
+    ) =>
+      sdk.admin.product.batchVariants(productId, {
+        update: payload,
+      }),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.details() })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useProductVariantsInventoryItemsBatch = (
+  productId: string,
+  options?: UseMutationOptions<any, FetchError, any>
+) => {
+  return useMutation({
+    mutationFn: (
+      payload: HttpTypes.AdminBatchProductVariantInventoryItemRequest
+    ) => sdk.admin.product.batchVariantInventoryItems(productId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.details() })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteVariant = (
+  productId: string,
+  variantId: string,
+  options?: UseMutationOptions<any, FetchError, void>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.product.deleteVariant(productId, variantId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: variantsQueryKeys.detail(variantId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useProduct = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<any, FetchError, any, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.product.retrieve(id, query),
+    queryKey: productsQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useProducts = (
+  query?: HttpTypes.AdminProductListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductListResponse,
+      FetchError,
+      HttpTypes.AdminProductListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.product.list(query),
+    queryKey: productsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateProduct = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductResponse,
+    FetchError,
+    HttpTypes.AdminCreateProduct
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.lists() })
+      // if `manage_inventory` is true on created variants that will create inventory items automatically
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProduct = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductResponse,
+    FetchError,
+    HttpTypes.AdminUpdateProduct
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteProduct = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.product.delete(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useExportProducts = (
+  query?: HttpTypes.AdminProductListParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminExportProductResponse,
+    FetchError,
+    HttpTypes.AdminExportProductRequest
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.export(payload, query),
+    onSuccess: (data, variables, context) => {
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useImportProducts = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminImportProductResponse,
+    FetchError,
+    HttpTypes.AdminImportProductRequest
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.import(payload),
+    onSuccess: (data, variables, context) => {
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useConfirmImportProducts = (
+  options?: UseMutationOptions<{}, FetchError, string>
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.confirmImport(payload),
+    onSuccess: (data, variables, context) => {
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/promotions.tsx

@@ -0,0 +1,272 @@
+import { HttpTypes } from "@medusajs/types"
+import { FetchError } from "@medusajs/js-sdk"
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { campaignsQueryKeys } from "./campaigns"
+
+const PROMOTIONS_QUERY_KEY = "promotions" as const
+export const promotionsQueryKeys = {
+  ...queryKeysFactory(PROMOTIONS_QUERY_KEY),
+  // TODO: handle invalidations properly
+  listRules: (
+    id: string | null,
+    ruleType: string,
+    query?: HttpTypes.AdminGetPromotionRuleParams
+  ) => [PROMOTIONS_QUERY_KEY, id, ruleType, query],
+  listRuleAttributes: (ruleType: string, promotionType?: string) => [
+    PROMOTIONS_QUERY_KEY,
+    ruleType,
+    promotionType,
+  ],
+  listRuleValues: (
+    ruleType: string,
+    ruleValue: string,
+    query: HttpTypes.AdminGetPromotionsRuleValueParams
+  ) => [PROMOTIONS_QUERY_KEY, ruleType, ruleValue, query],
+}
+
+export const usePromotion = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminPromotionResponse,
+      FetchError,
+      HttpTypes.AdminPromotionResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: promotionsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.promotion.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const usePromotionRules = (
+  id: string | null,
+  ruleType: string,
+  query?: HttpTypes.AdminGetPromotionRuleParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminGetPromotionRuleParams,
+      FetchError,
+      HttpTypes.AdminPromotionRuleListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: promotionsQueryKeys.listRules(id, ruleType, query),
+    queryFn: async () => sdk.admin.promotion.listRules(id, ruleType, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const usePromotions = (
+  query?: HttpTypes.AdminGetPromotionsParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminPromotionListResponse,
+      FetchError,
+      HttpTypes.AdminPromotionListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: promotionsQueryKeys.list(query),
+    queryFn: async () => sdk.admin.promotion.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const usePromotionRuleAttributes = (
+  ruleType: string,
+  promotionType?: string,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminRuleAttributeOptionsListResponse,
+      FetchError,
+      HttpTypes.AdminRuleAttributeOptionsListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: promotionsQueryKeys.listRuleAttributes(ruleType, promotionType),
+    queryFn: async () =>
+      sdk.admin.promotion.listRuleAttributes(ruleType, promotionType),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const usePromotionRuleValues = (
+  ruleType: string,
+  ruleValue: string,
+  query?: HttpTypes.AdminGetPromotionsRuleValueParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminRuleValueOptionsListResponse,
+      FetchError,
+      HttpTypes.AdminRuleValueOptionsListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: promotionsQueryKeys.listRuleValues(
+      ruleType,
+      ruleValue,
+      query || {}
+    ),
+    queryFn: async () =>
+      sdk.admin.promotion.listRuleValues(ruleType, ruleValue, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useDeletePromotion = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.DeleteResponse<"promotion">,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.promotion.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: promotionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: promotionsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCreatePromotion = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminPromotionResponse,
+    FetchError,
+    HttpTypes.AdminCreatePromotion
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.promotion.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: promotionsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: campaignsQueryKeys.lists() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdatePromotion = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPromotionResponse,
+    FetchError,
+    HttpTypes.AdminUpdatePromotion
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.promotion.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: promotionsQueryKeys.all })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const usePromotionAddRules = (
+  id: string,
+  ruleType: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPromotionResponse,
+    FetchError,
+    HttpTypes.BatchAddPromotionRulesReq
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.promotion.addRules(id, ruleType, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: promotionsQueryKeys.all })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const usePromotionRemoveRules = (
+  id: string,
+  ruleType: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPromotionResponse,
+    FetchError,
+    HttpTypes.BatchRemovePromotionRulesReq
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.promotion.removeRules(id, ruleType, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: promotionsQueryKeys.all })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const usePromotionUpdateRules = (
+  id: string,
+  ruleType: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminPromotionResponse,
+    FetchError,
+    HttpTypes.BatchUpdatePromotionRulesReq
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.promotion.updateRules(id, ruleType, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: promotionsQueryKeys.all })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/refund-reasons.tsx

@@ -0,0 +1,29 @@
+import { HttpTypes } from "@medusajs/types"
+import { QueryKey, useQuery, UseQueryOptions } from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { FetchError } from "@medusajs/js-sdk"
+
+const REFUND_REASON_QUERY_KEY = "refund-reason" as const
+export const refundReasonQueryKeys = queryKeysFactory(REFUND_REASON_QUERY_KEY)
+
+export const useRefundReasons = (
+  query?: HttpTypes.RefundReasonFilters,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.RefundReasonsResponse,
+      FetchError,
+      HttpTypes.RefundReasonsResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.refundReason.list(query),
+    queryKey: [],
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin/dashboard/src/hooks/api/regions.tsx

@@ -0,0 +1,131 @@
+import { HttpTypes, PaginatedResponse } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { pricePreferencesQueryKeys } from "./price-preferences"
+import { FetchError } from "@medusajs/js-sdk"
+
+const REGIONS_QUERY_KEY = "regions" as const
+export const regionsQueryKeys = queryKeysFactory(REGIONS_QUERY_KEY)
+
+export const useRegion = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      { region: HttpTypes.AdminRegion },
+      FetchError,
+      { region: HttpTypes.AdminRegion },
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: regionsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.region.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useRegions = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      PaginatedResponse<{ regions: HttpTypes.AdminRegion[] }>,
+      FetchError,
+      PaginatedResponse<{ regions: HttpTypes.AdminRegion[] }>,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.region.list(query),
+    queryKey: regionsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateRegion = (
+  options?: UseMutationOptions<
+    { region: HttpTypes.AdminRegion },
+    FetchError,
+    HttpTypes.AdminCreateRegion
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.region.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.lists() })
+
+      queryClient.invalidateQueries({
+        queryKey: pricePreferencesQueryKeys.list(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: pricePreferencesQueryKeys.details(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateRegion = (
+  id: string,
+  options?: UseMutationOptions<
+    { region: HttpTypes.AdminRegion },
+    FetchError,
+    HttpTypes.AdminUpdateRegion
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.region.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.detail(id) })
+
+      queryClient.invalidateQueries({
+        queryKey: pricePreferencesQueryKeys.list(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: pricePreferencesQueryKeys.details(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteRegion = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminRegionDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.region.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/reservations.tsx

@@ -0,0 +1,149 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { HttpTypes } from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import {
+  inventoryItemLevelsQueryKeys,
+  inventoryItemsQueryKeys,
+} from "./inventory.tsx"
+import { FetchError } from "@medusajs/js-sdk"
+
+const RESERVATION_ITEMS_QUERY_KEY = "reservation_items" as const
+export const reservationItemsQueryKeys = queryKeysFactory(
+  RESERVATION_ITEMS_QUERY_KEY
+)
+
+export const useReservationItem = (
+  id: string,
+  query?: HttpTypes.AdminReservationParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminReservationResponse,
+      FetchError,
+      HttpTypes.AdminReservationResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: reservationItemsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.reservation.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useReservationItems = (
+  query?: HttpTypes.AdminGetReservationsParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminGetReservationsParams,
+      FetchError,
+      HttpTypes.AdminReservationListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.reservation.list(query),
+    queryKey: reservationItemsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUpdateReservationItem = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReservationResponse,
+    FetchError,
+    HttpTypes.AdminUpdateReservation
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminUpdateReservation) =>
+      sdk.admin.reservation.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: reservationItemsQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({
+        queryKey: reservationItemsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemLevelsQueryKeys.details(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCreateReservationItem = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminReservationResponse,
+    FetchError,
+    HttpTypes.AdminCreateReservation
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminCreateReservation) =>
+      sdk.admin.reservation.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: reservationItemsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemLevelsQueryKeys.details(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteReservationItem = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReservationDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.reservation.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: reservationItemsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: reservationItemsQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: inventoryItemLevelsQueryKeys.details(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/return-reasons.tsx

@@ -0,0 +1,132 @@
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+
+import { FetchError } from "@medusajs/js-sdk"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const RETURN_REASONS_QUERY_KEY = "return_reasons" as const
+export const returnReasonsQueryKeys = queryKeysFactory(RETURN_REASONS_QUERY_KEY)
+
+export const useReturnReasons = (
+  query?: HttpTypes.AdminReturnReasonListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminReturnReasonListResponse,
+      FetchError,
+      HttpTypes.AdminReturnReasonListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.returnReason.list(query),
+    queryKey: returnReasonsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useReturnReason = (
+  id: string,
+  query?: HttpTypes.AdminReturnReasonParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminReturnReasonResponse,
+      FetchError,
+      HttpTypes.AdminReturnReasonResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.returnReason.retrieve(id, query),
+    queryKey: returnReasonsQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateReturnReason = (
+  query?: HttpTypes.AdminReturnReasonParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnReasonResponse,
+    FetchError,
+    HttpTypes.AdminCreateReturnReason
+  >
+) => {
+  return useMutation({
+    mutationFn: async (data) => sdk.admin.returnReason.create(data, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: returnReasonsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+export const useUpdateReturnReason = (
+  id: string,
+  query?: HttpTypes.AdminReturnReasonParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnReasonResponse,
+    FetchError,
+    HttpTypes.AdminUpdateReturnReason
+  >
+) => {
+  return useMutation({
+    mutationFn: async (data) => sdk.admin.returnReason.update(id, data, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: returnReasonsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: returnReasonsQueryKeys.detail(data.return_reason.id, query),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteReturnReason = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnReasonDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.returnReason.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: returnReasonsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: returnReasonsQueryKeys.detail(id),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: returnReasonsQueryKeys.details(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/returns.tsx

@@ -0,0 +1,641 @@
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { ordersQueryKeys } from "./orders"
+import { FetchError } from "@medusajs/js-sdk"
+
+const RETURNS_QUERY_KEY = "returns" as const
+export const returnsQueryKeys = queryKeysFactory(RETURNS_QUERY_KEY)
+
+export const useReturn = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<any, FetchError, any, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.return.retrieve(id, query),
+    queryKey: returnsQueryKeys.detail(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useReturns = (
+  query?: HttpTypes.AdminReturnFilters,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminReturnFilters,
+      FetchError,
+      HttpTypes.AdminReturnsResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.return.list(query),
+    queryKey: returnsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useInitiateReturn = (
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminInitiateReturnRequest
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminInitiateReturnRequest) =>
+      sdk.admin.return.initiateRequest(payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelReturn = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminReturnResponse, FetchError>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.return.cancel(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+        refetchType: "all",
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+/**
+ * REQUEST RETURN
+ */
+
+export const useConfirmReturnRequest = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminConfirmReturnRequest
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminConfirmReturnRequest) =>
+      sdk.admin.return.confirmRequest(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelReturnRequest = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminReturnResponse, FetchError>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.return.cancelRequest(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+        refetchType: "all",
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddReturnItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminAddReturnItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddReturnItems) =>
+      sdk.admin.return.addReturnItem(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateReturnItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminUpdateReturnItems & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateReturnItems & { actionId: string }) => {
+      return sdk.admin.return.updateReturnItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveReturnItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.return.removeReturnItem(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateReturn = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminUpdateReturnRequest
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminUpdateReturnRequest) => {
+      return sdk.admin.return.updateRequest(id, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddReturnShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminAddReturnShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminAddReturnShipping) =>
+      sdk.admin.return.addReturnShipping(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateReturnShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminAddReturnShipping
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminAddReturnShipping & { actionId: string }) =>
+      sdk.admin.return.updateReturnShipping(id, actionId, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteReturnShipping = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) =>
+      sdk.admin.return.deleteReturnShipping(id, actionId),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+/**
+ * RECEIVE RETURN
+ */
+
+export const useInitiateReceiveReturn = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminInitiateReceiveReturn
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminInitiateReceiveReturn) =>
+      sdk.admin.return.initiateReceive(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddReceiveItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminReceiveItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminReceiveItems) =>
+      sdk.admin.return.receiveItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateReceiveItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminUpdateReceiveItems & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateReceiveItems & { actionId: string }) => {
+      return sdk.admin.return.updateReceiveItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveReceiveItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) => {
+      return sdk.admin.return.removeReceiveItem(id, actionId)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useAddDismissItems = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminDismissItems
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminDismissItems) =>
+      sdk.admin.return.dismissItems(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateDismissItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminUpdateDismissItems & { actionId: string }
+  >
+) => {
+  return useMutation({
+    mutationFn: ({
+      actionId,
+      ...payload
+    }: HttpTypes.AdminUpdateReceiveItems & { actionId: string }) => {
+      return sdk.admin.return.updateDismissItem(id, actionId, payload)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRemoveDismissItem = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (actionId: string) => {
+      return sdk.admin.return.removeDismissItem(id, actionId)
+    },
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useConfirmReturnReceive = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminReturnResponse,
+    FetchError,
+    HttpTypes.AdminConfirmReceiveReturn
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: HttpTypes.AdminConfirmReceiveReturn) =>
+      sdk.admin.return.confirmReceive(id, payload),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCancelReceiveReturn = (
+  id: string,
+  orderId: string,
+  options?: UseMutationOptions<HttpTypes.AdminReturnResponse, FetchError>
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.return.cancelReceive(id),
+    onSuccess: (data: any, variables: any, context: any) => {
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.details(),
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: ordersQueryKeys.preview(orderId),
+        refetchType: "all", // For some reason RQ will refetch this but will return stale record from the cache
+      })
+
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: returnsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/sales-channels.tsx

@@ -0,0 +1,208 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import {
+  AdminSalesChannelListResponse,
+  AdminSalesChannelResponse,
+  HttpTypes,
+} from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { productsQueryKeys } from "./products"
+import { FetchError } from "@medusajs/js-sdk"
+
+const SALES_CHANNELS_QUERY_KEY = "sales-channels" as const
+export const salesChannelsQueryKeys = queryKeysFactory(SALES_CHANNELS_QUERY_KEY)
+
+export const useSalesChannel = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<
+      AdminSalesChannelResponse,
+      FetchError,
+      AdminSalesChannelResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: salesChannelsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.salesChannel.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useSalesChannels = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      AdminSalesChannelListResponse,
+      FetchError,
+      AdminSalesChannelListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.salesChannel.list(query),
+    queryKey: salesChannelsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateSalesChannel = (
+  options?: UseMutationOptions<
+    AdminSalesChannelResponse,
+    FetchError,
+    HttpTypes.AdminCreateSalesChannel
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.salesChannel.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateSalesChannel = (
+  id: string,
+  options?: UseMutationOptions<
+    AdminSalesChannelResponse,
+    FetchError,
+    HttpTypes.AdminUpdateSalesChannel
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.salesChannel.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteSalesChannel = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminSalesChannelDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.salesChannel.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.detail(id),
+      })
+
+      // Invalidate all products to ensure they are updated if they were linked to the sales channel
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useSalesChannelRemoveProducts = (
+  id: string,
+  options?: UseMutationOptions<
+    AdminSalesChannelResponse,
+    FetchError,
+    HttpTypes.AdminBatchLink["remove"]
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.salesChannel.batchProducts(id, { remove: payload }),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.detail(id),
+      })
+
+      // Invalidate the products that were removed
+      for (const product of variables || []) {
+        queryClient.invalidateQueries({
+          queryKey: productsQueryKeys.detail(product),
+        })
+      }
+
+      // Invalidate the products list query
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useSalesChannelAddProducts = (
+  id: string,
+  options?: UseMutationOptions<
+    AdminSalesChannelResponse,
+    FetchError,
+    HttpTypes.AdminBatchLink["add"]
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.salesChannel.batchProducts(id, { add: payload }),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.detail(id),
+      })
+
+      // Invalidate the products that were removed
+      for (const product of variables || []) {
+        queryClient.invalidateQueries({
+          queryKey: productsQueryKeys.detail(product),
+        })
+      }
+
+      // Invalidate the products list query
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/shipping-options.tsx

@@ -0,0 +1,128 @@
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { stockLocationsQueryKeys } from "./stock-locations"
+
+const SHIPPING_OPTIONS_QUERY_KEY = "shipping_options" as const
+export const shippingOptionsQueryKeys = queryKeysFactory(
+  SHIPPING_OPTIONS_QUERY_KEY
+)
+
+// TODO: Endpoint is not implemented yet
+// export const useShippingOption = (
+//   id: string,
+//   options?: UseQueryOptions<
+//     HttpTypes.AdminShippingOptionResponse,
+//     Error,
+//     HttpTypes.AdminShippingOptionResponse,
+//     QueryKey
+//   >
+// ) => {
+//   const { data, ...rest } = useQuery({
+//     queryFn: () => sdk.admin.shippingOption.retrieve(id),
+//     queryKey: shippingOptionsQueryKeys.retrieve(id),
+//     ...options,
+//   })
+
+//   return { ...data, ...rest }
+// }
+
+export const useShippingOptions = (
+  query?: HttpTypes.AdminShippingOptionListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminShippingOptionListResponse,
+      FetchError,
+      HttpTypes.AdminShippingOptionListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.shippingOption.list(query),
+    queryKey: shippingOptionsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateShippingOptions = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminShippingOptionResponse,
+    FetchError,
+    HttpTypes.AdminCreateShippingOption
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.shippingOption.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.all,
+      })
+      queryClient.invalidateQueries({
+        queryKey: shippingOptionsQueryKeys.all,
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateShippingOptions = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminShippingOptionResponse,
+    FetchError,
+    HttpTypes.AdminUpdateShippingOption
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.shippingOption.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.all,
+      })
+      queryClient.invalidateQueries({
+        queryKey: shippingOptionsQueryKeys.all,
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteShippingOption = (
+  optionId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminShippingOptionDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.shippingOption.delete(optionId),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.all,
+      })
+      queryClient.invalidateQueries({
+        queryKey: shippingOptionsQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/shipping-profiles.tsx

@@ -0,0 +1,102 @@
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const SHIPPING_PROFILE_QUERY_KEY = "shipping_profile" as const
+export const shippingProfileQueryKeys = queryKeysFactory(
+  SHIPPING_PROFILE_QUERY_KEY
+)
+
+export const useCreateShippingProfile = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminShippingProfileResponse,
+    FetchError,
+    HttpTypes.AdminCreateShippingProfile
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.shippingProfile.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: shippingProfileQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useShippingProfile = (
+  id: string,
+  query?: Record<string, any>,
+  options?: UseQueryOptions<
+    HttpTypes.AdminShippingProfileResponse,
+    FetchError,
+    HttpTypes.AdminShippingProfileResponse,
+    QueryKey
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.shippingProfile.retrieve(id, query),
+    queryKey: shippingProfileQueryKeys.detail(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useShippingProfiles = (
+  query?: HttpTypes.AdminShippingProfileListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminShippingProfileListResponse,
+      FetchError,
+      HttpTypes.AdminShippingProfileListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.shippingProfile.list(query),
+    queryKey: shippingProfileQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useDeleteShippingProfile = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminShippingProfileDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.shippingProfile.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: shippingProfileQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({
+        queryKey: shippingProfileQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/stock-locations.tsx

@@ -0,0 +1,203 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { fulfillmentProvidersQueryKeys } from "./fulfillment-providers"
+
+const STOCK_LOCATIONS_QUERY_KEY = "stock_locations" as const
+export const stockLocationsQueryKeys = queryKeysFactory(
+  STOCK_LOCATIONS_QUERY_KEY
+)
+
+export const useStockLocation = (
+  id: string,
+  query?: HttpTypes.SelectParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminStockLocationResponse,
+      FetchError,
+      HttpTypes.AdminStockLocationResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.stockLocation.retrieve(id, query),
+    queryKey: stockLocationsQueryKeys.detail(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useStockLocations = (
+  query?: HttpTypes.AdminStockLocationListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminStockLocationListResponse,
+      FetchError,
+      HttpTypes.AdminStockLocationListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.stockLocation.list(query),
+    queryKey: stockLocationsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateStockLocation = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminStockLocationResponse,
+    FetchError,
+    HttpTypes.AdminCreateStockLocation
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.stockLocation.create(payload),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateStockLocation = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminStockLocationResponse,
+    FetchError,
+    HttpTypes.AdminUpdateStockLocation
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.stockLocation.update(id, payload),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.details(),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateStockLocationSalesChannels = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminStockLocationResponse,
+    FetchError,
+    HttpTypes.AdminUpdateStockLocationSalesChannels
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.stockLocation.updateSalesChannels(id, payload),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.details(),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteStockLocation = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminStockLocationDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.stockLocation.delete(id),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.lists(),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCreateStockLocationFulfillmentSet = (
+  locationId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminStockLocationResponse,
+    FetchError,
+    HttpTypes.AdminCreateStockLocationFulfillmentSet
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.stockLocation.createFulfillmentSet(locationId, payload),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.all,
+        refetchType: "all",
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateStockLocationFulfillmentProviders = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminStockLocationResponse,
+    FetchError,
+    HttpTypes.AdminBatchLink
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) =>
+      sdk.admin.stockLocation.updateFulfillmentProviders(id, payload),
+    onSuccess: async (data, variables, context) => {
+      await queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.details(),
+      })
+      await queryClient.invalidateQueries({
+        queryKey: fulfillmentProvidersQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/store.tsx

@@ -0,0 +1,83 @@
+import {
+  MutationOptions,
+  QueryKey,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { pricePreferencesQueryKeys } from "./price-preferences"
+
+const STORE_QUERY_KEY = "store" as const
+export const storeQueryKeys = queryKeysFactory(STORE_QUERY_KEY)
+
+/**
+ * Workaround to keep the V1 version of retrieving the store.
+ */
+export async function retrieveActiveStore(
+  query?: HttpTypes.AdminStoreParams
+): Promise<HttpTypes.AdminStoreResponse> {
+  const response = await sdk.admin.store.list(query)
+
+  const activeStore = response.stores?.[0]
+
+  if (!activeStore) {
+    throw new FetchError("No active store found", "Not Found", 404)
+  }
+
+  return { store: activeStore }
+}
+
+export const useStore = (
+  query?: HttpTypes.SelectParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminStoreResponse,
+      FetchError,
+      HttpTypes.AdminStoreResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => retrieveActiveStore(query),
+    queryKey: storeQueryKeys.details(),
+    ...options,
+  })
+
+  return {
+    ...data,
+    ...rest,
+  }
+}
+
+export const useUpdateStore = (
+  id: string,
+  options?: MutationOptions<
+    HttpTypes.AdminStoreResponse,
+    FetchError,
+    HttpTypes.AdminUpdateStore
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.store.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: pricePreferencesQueryKeys.list(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: pricePreferencesQueryKeys.details(),
+      })
+      queryClient.invalidateQueries({ queryKey: storeQueryKeys.details() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/tags.tsx

@@ -0,0 +1,128 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const TAGS_QUERY_KEY = "tags" as const
+export const productTagsQueryKeys = queryKeysFactory(TAGS_QUERY_KEY)
+
+export const useProductTag = (
+  id: string,
+  query?: HttpTypes.AdminProductTagParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductTagResponse,
+      FetchError,
+      HttpTypes.AdminProductTagResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: productTagsQueryKeys.detail(id, query),
+    queryFn: async () => sdk.admin.productTag.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useProductTags = (
+  query?: HttpTypes.AdminProductTagListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductTagListResponse,
+      FetchError,
+      HttpTypes.AdminProductTagListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: productTagsQueryKeys.list(query),
+    queryFn: async () => sdk.admin.productTag.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateProductTag = (
+  query?: HttpTypes.AdminProductTagParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductTagResponse,
+    FetchError,
+    HttpTypes.AdminCreateProductTag
+  >
+) => {
+  return useMutation({
+    mutationFn: async (data) => sdk.admin.productTag.create(data, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productTagsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProductTag = (
+  id: string,
+  query?: HttpTypes.AdminProductTagParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductTagResponse,
+    FetchError,
+    HttpTypes.AdminUpdateProductTag
+  >
+) => {
+  return useMutation({
+    mutationFn: async (data) => sdk.admin.productTag.update(id, data, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productTagsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productTagsQueryKeys.detail(data.product_tag.id, query),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteProductTag = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductTagDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: async () => sdk.admin.productTag.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productTagsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productTagsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/tax-rates.tsx

@@ -0,0 +1,127 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { taxRegionsQueryKeys } from "./tax-regions"
+
+const TAX_RATES_QUERY_KEY = "tax_rates" as const
+export const taxRatesQueryKeys = queryKeysFactory(TAX_RATES_QUERY_KEY)
+
+export const useTaxRate = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminTaxRateResponse,
+      FetchError,
+      HttpTypes.AdminTaxRateResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: taxRatesQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.taxRate.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useTaxRates = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminTaxRateListResponse,
+      FetchError,
+      HttpTypes.AdminTaxRateListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.taxRate.list(query),
+    queryKey: taxRatesQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUpdateTaxRate = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminTaxRateResponse,
+    FetchError,
+    HttpTypes.AdminUpdateTaxRate
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.taxRate.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: taxRatesQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: taxRatesQueryKeys.detail(id),
+      })
+
+      queryClient.invalidateQueries({ queryKey: taxRegionsQueryKeys.details() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCreateTaxRate = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminTaxRateResponse,
+    FetchError,
+    HttpTypes.AdminCreateTaxRate
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.taxRate.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: taxRatesQueryKeys.lists() })
+
+      queryClient.invalidateQueries({ queryKey: taxRegionsQueryKeys.details() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteTaxRate = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminTaxRateDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.taxRate.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: taxRatesQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: taxRatesQueryKeys.detail(id),
+      })
+
+      queryClient.invalidateQueries({ queryKey: taxRegionsQueryKeys.details() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/tax-regions.tsx

@@ -0,0 +1,100 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const TAX_REGIONS_QUERY_KEY = "tax_regions" as const
+export const taxRegionsQueryKeys = queryKeysFactory(TAX_REGIONS_QUERY_KEY)
+
+export const useTaxRegion = (
+  id: string,
+  query?: HttpTypes.AdminTaxRegionParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminTaxRegionResponse,
+      FetchError,
+      HttpTypes.AdminTaxRegionResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: taxRegionsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.taxRegion.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useTaxRegions = (
+  query?: HttpTypes.AdminTaxRegionListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminTaxRegionListResponse,
+      FetchError,
+      HttpTypes.AdminTaxRegionListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.taxRegion.list(query),
+    queryKey: taxRegionsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateTaxRegion = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminTaxRegionResponse,
+    FetchError,
+    HttpTypes.AdminCreateTaxRegion
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.taxRegion.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: taxRegionsQueryKeys.all })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteTaxRegion = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminTaxRegionDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.taxRegion.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: taxRegionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: taxRegionsQueryKeys.detail(id),
+      })
+
+      // Invalidate all detail queries, as the deleted tax region may have been a sublevel region
+      queryClient.invalidateQueries({ queryKey: taxRegionsQueryKeys.details() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/users.tsx

@@ -0,0 +1,150 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryClient } from "../../lib/query-client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+
+const USERS_QUERY_KEY = "users" as const
+const usersQueryKeys = {
+  ...queryKeysFactory(USERS_QUERY_KEY),
+  me: () => [USERS_QUERY_KEY, "me"],
+}
+
+export const useMe = (
+  query?: HttpTypes.AdminUserParams,
+  options?: UseQueryOptions<
+    HttpTypes.AdminUserResponse,
+    FetchError,
+    HttpTypes.AdminUserResponse,
+    QueryKey
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.user.me(query),
+    queryKey: usersQueryKeys.me(),
+    ...options,
+  })
+
+  return {
+    ...data,
+    ...rest,
+  }
+}
+
+export const useUser = (
+  id: string,
+  query?: HttpTypes.AdminUserParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminUserResponse,
+      FetchError,
+      HttpTypes.AdminUserResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.user.retrieve(id, query),
+    queryKey: usersQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUsers = (
+  query?: HttpTypes.AdminUserListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminUserListResponse,
+      FetchError,
+      HttpTypes.AdminUserListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.user.list(query),
+    queryKey: usersQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateUser = (
+  query?: HttpTypes.AdminUserParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminUserResponse,
+    FetchError,
+    HttpTypes.AdminCreateUser,
+    QueryKey
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.user.create(payload, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateUser = (
+  id: string,
+  query?: HttpTypes.AdminUserParams,
+  options?: UseMutationOptions<
+    HttpTypes.AdminUserResponse,
+    FetchError,
+    HttpTypes.AdminUpdateUser,
+    QueryKey
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.user.update(id, payload, query),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.detail(id) })
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.lists() })
+
+      // We invalidate the me query in case the user updates their own profile
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.me() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteUser = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminUserDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.user.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.detail(id) })
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.lists() })
+
+      // We invalidate the me query in case the user updates their own profile
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.me() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin/dashboard/src/hooks/api/workflow-executions.tsx

@@ -0,0 +1,52 @@
+import { QueryKey, UseQueryOptions, useQuery } from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { HttpTypes } from "@medusajs/types"
+import { FetchError } from "@medusajs/js-sdk"
+
+const WORKFLOW_EXECUTIONS_QUERY_KEY = "workflow_executions" as const
+export const workflowExecutionsQueryKeys = queryKeysFactory(
+  WORKFLOW_EXECUTIONS_QUERY_KEY
+)
+
+export const useWorkflowExecutions = (
+  query?: HttpTypes.AdminGetWorkflowExecutionsParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminGetWorkflowExecutionsParams,
+      FetchError,
+      HttpTypes.AdminWorkflowExecutionListResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.workflowExecution.list(query),
+    queryKey: workflowExecutionsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useWorkflowExecution = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminWorkflowExecutionResponse,
+      FetchError,
+      HttpTypes.AdminWorkflowExecutionResponse,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.workflowExecution.retrieve(id),
+    queryKey: workflowExecutionsQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}