@diffsome/react 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,546 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { Diffsome, DiffsomeConfig, Member, LoginCredentials, AuthResponse, RegisterData, UpdateProfileData, ResetPasswordData, SocialProvider, Cart, CartItem, WishlistItem, WishlistToggleResult, WishlistMoveToCartResult, BundlePricing, ProductCategory, Product, PaginationMeta, ProductListParams, ProductType, CreateOrderData, Order, OrderListParams, PaymentStatusResponse, StripeCheckoutResponse, StripeVerifyResponse, TossPaymentReadyResponse, TossPaymentConfirmResponse, Coupon, CouponValidation, MemberSubscription, DigitalDownloadLink, CanReviewResponse, CreateProductReviewData, ProductReview, UpdateProductReviewData, ProductReviewStats, ProductReviewListParams, BlogCategory, BlogListParams, BlogPost, BoardPost, Board, CreateBoardPostData, BoardPostListParams, BoardListParams, Comment, CreateCommentData, Form, FormSubmissionData, FormSubmission, ReservationSlot, CreateReservationData, Reservation, ReservationService, ReservationSettings, ReservationStaff, ReservationListParams, Media, CustomEntity, EntityRecord, EntityListParams } from '@diffsome/sdk';
+export { AddToCartData, AuthResponse, BlogCategory, BlogListParams, BlogPost, Board, BoardListParams, BoardPost, BoardPostListParams, CanReviewResponse, Cart, CartItem, Comment, Coupon, CouponType, CouponValidation, CreateBoardPostData, CreateCommentData, CreateOrderData, CreateProductReviewData, CreateReservationData, CustomEntity, DiffsomeConfig, DigitalDownloadLink, DigitalFile, EntityField, EntityListParams, EntityRecord, EntitySchema, Form, FormSubmission, FormSubmissionData, ListResponse, LoginCredentials, Media, Member, MemberSubscription, Order, OrderItem, OrderListParams, OrderStatus, PaginatedResponse, PaginationMeta, Payment, PaymentMethod, PaymentStatus, PaymentStatusResponse, Product, ProductCategory, ProductListParams, ProductReview, ProductReviewStats, ProductType, ProductVariant, RegisterData, Reservation, ReservationService, ReservationSettings, ReservationSlot, ReservationStaff, ResetPasswordData, SocialAuthUrl, SocialProvider, StripeCheckoutResponse, StripeVerifyResponse, SubscriptionInterval, SubscriptionPlan, SubscriptionStatus, TossPaymentConfirmResponse, TossPaymentReadyResponse, UpdateProfileData, WishlistItem, WishlistMoveToCartResult, WishlistToggleResult } from '@diffsome/sdk';
+
+interface DiffsomeContextValue {
+    client: Diffsome;
+    isReady: boolean;
+}
+declare const DiffsomeContext: react.Context<DiffsomeContextValue | null>;
+interface DiffsomeProviderProps {
+    children: ReactNode;
+    config: DiffsomeConfig;
+}
+declare function DiffsomeProvider({ children, config }: DiffsomeProviderProps): react_jsx_runtime.JSX.Element;
+declare function useDiffsome(): DiffsomeContextValue;
+declare function useClient(): Diffsome;
+
+interface UseAuthReturn {
+    user: Member | null;
+    isAuthenticated: boolean;
+    loading: boolean;
+    error: Error | null;
+    login: (credentials: LoginCredentials) => Promise<AuthResponse>;
+    register: (data: RegisterData) => Promise<AuthResponse>;
+    logout: () => Promise<void>;
+    getProfile: () => Promise<Member>;
+    updateProfile: (data: UpdateProfileData) => Promise<Member>;
+    forgotPassword: (email: string) => Promise<{
+        message: string;
+    }>;
+    resetPassword: (data: ResetPasswordData) => Promise<{
+        message: string;
+    }>;
+    refresh: () => Promise<void>;
+}
+declare function useAuth(): UseAuthReturn;
+
+interface UseSocialAuthReturn {
+    providers: SocialProvider[];
+    loading: boolean;
+    error: Error | null;
+    getAuthUrl: (provider: string) => Promise<string>;
+    handleCallback: (provider: string, code: string) => Promise<AuthResponse>;
+    refresh: () => Promise<void>;
+}
+declare function useSocialAuth(): UseSocialAuthReturn;
+
+interface UseCartReturn {
+    cart: Cart | null;
+    items: CartItem[];
+    itemCount: number;
+    totalQuantity: number;
+    subtotal: number;
+    shippingFee: number;
+    total: number;
+    loading: boolean;
+    error: Error | null;
+    addToCart: (productId: number, quantity?: number, variantId?: number, options?: Record<string, string>) => Promise<Cart>;
+    updateItem: (itemId: number, quantity: number) => Promise<Cart>;
+    removeItem: (itemId: number) => Promise<Cart>;
+    clearCart: () => Promise<void>;
+    refresh: () => Promise<void>;
+    isInCart: (productId: number, variantId?: number) => boolean;
+    getItemQuantity: (productId: number, variantId?: number) => number;
+}
+declare function useCart(): UseCartReturn;
+
+interface UseWishlistReturn {
+    items: WishlistItem[];
+    count: number;
+    loading: boolean;
+    error: Error | null;
+    isInWishlist: (productId: number, variantId?: number) => boolean;
+    toggleWishlist: (productId: number, variantId?: number) => Promise<WishlistToggleResult>;
+    addToWishlist: (productId: number, variantId?: number, note?: string) => Promise<WishlistItem>;
+    removeFromWishlist: (wishlistId: number) => Promise<void>;
+    moveToCart: (wishlistIds?: number[]) => Promise<WishlistMoveToCartResult>;
+    updateNote: (wishlistId: number, note: string) => Promise<WishlistItem>;
+    getProductWishlistCount: (productSlug: string) => Promise<number>;
+    refresh: () => Promise<void>;
+}
+declare function useWishlist(): UseWishlistReturn;
+
+interface UseProductsReturn {
+    products: Product[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    loadMore: () => Promise<void>;
+    refresh: () => Promise<void>;
+    search: (query: string) => Promise<void>;
+}
+interface UseProductsOptions extends ProductListParams {
+    autoFetch?: boolean;
+}
+declare function useProducts(options?: UseProductsOptions): UseProductsReturn;
+interface UseProductReturn {
+    product: Product | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useProduct(idOrSlug: number | string): UseProductReturn;
+interface UseCategoriesReturn {
+    categories: ProductCategory[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useCategories(): UseCategoriesReturn;
+interface UseFeaturedProductsReturn {
+    products: Product[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useFeaturedProducts(limit?: number): UseFeaturedProductsReturn;
+interface UseProductsByTypeReturn {
+    products: Product[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useProductsByType(type: ProductType, params?: ProductListParams): UseProductsByTypeReturn;
+declare function useDigitalProducts(params?: ProductListParams): UseProductsByTypeReturn;
+declare function useSubscriptionProducts(params?: ProductListParams): UseProductsByTypeReturn;
+declare function useBundleProducts(params?: ProductListParams): UseProductsByTypeReturn;
+interface UseBundleItemsReturn {
+    bundle: BundlePricing | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useBundleItems(productSlug: string): UseBundleItemsReturn;
+
+interface UseOrdersReturn {
+    orders: Order[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    loadMore: () => Promise<void>;
+    refresh: () => Promise<void>;
+}
+declare function useOrders(params?: OrderListParams): UseOrdersReturn;
+interface UseOrderReturn {
+    order: Order | null;
+    loading: boolean;
+    error: Error | null;
+    cancel: () => Promise<Order>;
+    refresh: () => Promise<void>;
+}
+declare function useOrder(idOrNumber: number | string): UseOrderReturn;
+interface UseCreateOrderReturn {
+    createOrder: (data: CreateOrderData) => Promise<Order>;
+    loading: boolean;
+    error: Error | null;
+}
+declare function useCreateOrder(): UseCreateOrderReturn;
+
+interface UsePaymentStatusReturn {
+    status: PaymentStatusResponse | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    isTossAvailable: boolean;
+    isStripeAvailable: boolean;
+    stripePublishableKey: string | null;
+}
+declare function usePaymentStatus(): UsePaymentStatusReturn;
+interface UseTossPaymentReturn {
+    preparePayment: (orderNumber: string, successUrl: string, failUrl: string) => Promise<TossPaymentReadyResponse>;
+    confirmPayment: (paymentKey: string, orderId: string, amount: number) => Promise<TossPaymentConfirmResponse>;
+    cancelPayment: (orderNumber: string, reason: string, amount?: number) => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+}
+declare function useTossPayment(): UseTossPaymentReturn;
+interface UseStripePaymentReturn {
+    createCheckout: (orderNumber: string, successUrl: string, cancelUrl: string) => Promise<StripeCheckoutResponse>;
+    verifyPayment: (sessionId: string) => Promise<StripeVerifyResponse>;
+    refund: (orderNumber: string, reason?: string, amount?: number) => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+}
+declare function useStripePayment(): UseStripePaymentReturn;
+
+interface UseCouponsReturn {
+    coupons: Coupon[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useCoupons(): UseCouponsReturn;
+interface UseValidateCouponReturn {
+    validate: (code: string, orderAmount: number) => Promise<CouponValidation>;
+    validation: CouponValidation | null;
+    loading: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+declare function useValidateCoupon(): UseValidateCouponReturn;
+
+interface UseSubscriptionsReturn {
+    subscriptions: MemberSubscription[];
+    loading: boolean;
+    error: Error | null;
+    activeSubscription: MemberSubscription | null;
+    hasActiveSubscription: boolean;
+    refresh: () => Promise<void>;
+}
+declare function useSubscriptions(): UseSubscriptionsReturn;
+interface UseSubscriptionReturn {
+    subscription: MemberSubscription | null;
+    loading: boolean;
+    error: Error | null;
+    cancel: (immediately?: boolean) => Promise<MemberSubscription>;
+    pause: () => Promise<MemberSubscription>;
+    resume: () => Promise<MemberSubscription>;
+    refresh: () => Promise<void>;
+}
+declare function useSubscription(id: number): UseSubscriptionReturn;
+interface UseCreateSubscriptionReturn {
+    createCheckout: (planId: number, successUrl: string, cancelUrl: string) => Promise<{
+        url: string;
+        session_id: string;
+    }>;
+    verifyCheckout: (sessionId: string) => Promise<MemberSubscription>;
+    createSetupIntent: () => Promise<string>;
+    loading: boolean;
+    error: Error | null;
+}
+declare function useCreateSubscription(): UseCreateSubscriptionReturn;
+
+interface UseDownloadsReturn {
+    downloads: DigitalDownloadLink[];
+    loading: boolean;
+    error: Error | null;
+    getDownloadUrl: (token: string) => string;
+    getDownloadInfo: (token: string) => Promise<DigitalDownloadLink>;
+    refresh: () => Promise<void>;
+}
+declare function useDownloads(): UseDownloadsReturn;
+interface UseOrderDownloadsReturn {
+    downloads: DigitalDownloadLink[];
+    loading: boolean;
+    error: Error | null;
+    getDownloadUrl: (token: string) => string;
+    getDownloadInfo: (token: string) => Promise<DigitalDownloadLink>;
+    refresh: () => Promise<void>;
+}
+declare function useOrderDownloads(orderNumber: string): UseOrderDownloadsReturn;
+
+interface UseProductReviewsReturn {
+    reviews: ProductReview[];
+    stats: ProductReviewStats | null;
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useProductReviews(productSlug: string, params?: ProductReviewListParams): UseProductReviewsReturn;
+interface UseCanReviewReturn {
+    canReview: boolean;
+    reason: string | null;
+    loading: boolean;
+    error: Error | null;
+    check: () => Promise<CanReviewResponse>;
+}
+declare function useCanReview(productSlug: string): UseCanReviewReturn;
+interface UseCreateReviewReturn {
+    createReview: (productSlug: string, data: CreateProductReviewData) => Promise<ProductReview>;
+    loading: boolean;
+    error: Error | null;
+}
+declare function useCreateReview(): UseCreateReviewReturn;
+interface UseMyReviewsReturn {
+    reviews: ProductReview[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    deleteReview: (reviewId: number) => Promise<void>;
+    updateReview: (reviewId: number, data: UpdateProductReviewData) => Promise<ProductReview>;
+}
+declare function useMyReviews(params?: {
+    per_page?: number;
+    page?: number;
+}): UseMyReviewsReturn;
+
+interface UseBlogReturn {
+    posts: BlogPost[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    loadMore: () => Promise<void>;
+    refresh: () => Promise<void>;
+}
+interface UseBlogOptions extends BlogListParams {
+    autoFetch?: boolean;
+}
+declare function useBlog(options?: UseBlogOptions): UseBlogReturn;
+interface UseBlogPostReturn {
+    post: BlogPost | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useBlogPost(slug: string): UseBlogPostReturn;
+interface UseBlogCategoriesReturn {
+    categories: BlogCategory[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useBlogCategories(): UseBlogCategoriesReturn;
+interface UseBlogTagsReturn {
+    tags: string[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useBlogTags(): UseBlogTagsReturn;
+interface UseFeaturedBlogReturn {
+    posts: BlogPost[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useFeaturedBlog(limit?: number): UseFeaturedBlogReturn;
+interface UseBlogSearchReturn {
+    posts: BlogPost[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    search: (query: string) => Promise<void>;
+}
+declare function useBlogSearch(): UseBlogSearchReturn;
+
+interface UseBoardsReturn {
+    boards: Board[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useBoards(params?: BoardListParams): UseBoardsReturn;
+interface UseBoardReturn {
+    board: Board | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useBoard(slug: string): UseBoardReturn;
+interface UseBoardPostsReturn {
+    posts: BoardPost[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    loadMore: () => Promise<void>;
+    refresh: () => Promise<void>;
+}
+declare function useBoardPosts(boardSlug: string, params?: BoardPostListParams): UseBoardPostsReturn;
+interface UseBoardPostReturn {
+    post: BoardPost | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useBoardPost(postId: number): UseBoardPostReturn;
+interface UseCreateBoardPostReturn {
+    createPost: (data: CreateBoardPostData) => Promise<BoardPost>;
+    loading: boolean;
+    error: Error | null;
+}
+declare function useCreateBoardPost(): UseCreateBoardPostReturn;
+
+interface UseCommentsReturn {
+    comments: Comment[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    createComment: (data: CreateCommentData) => Promise<Comment>;
+    updateComment: (commentId: number, content: string) => Promise<Comment>;
+    deleteComment: (commentId: number, password?: string) => Promise<void>;
+    likeComment: (commentId: number) => Promise<number>;
+    refresh: () => Promise<void>;
+}
+type CommentType = 'board' | 'blog' | 'standalone';
+interface UseCommentsOptions {
+    type: CommentType;
+    /** Post ID for board comments, slug for blog/standalone */
+    target: number | string;
+    page?: number;
+    per_page?: number;
+}
+declare function useComments(options: UseCommentsOptions): UseCommentsReturn;
+
+interface UseFormReturn {
+    form: Form | null;
+    loading: boolean;
+    error: Error | null;
+    submit: (data: FormSubmissionData) => Promise<FormSubmission>;
+    submitting: boolean;
+    submitted: boolean;
+    reset: () => void;
+}
+declare function useForm(formSlug: string): UseFormReturn;
+
+interface UseReservationServicesReturn {
+    services: ReservationService[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useReservationServices(): UseReservationServicesReturn;
+interface UseReservationStaffsReturn {
+    staffs: ReservationStaff[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useReservationStaffs(): UseReservationStaffsReturn;
+interface UseAvailableSlotsReturn {
+    slots: ReservationSlot[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useAvailableSlots(serviceId: number, date: string, staffId?: number): UseAvailableSlotsReturn;
+interface UseMyReservationsReturn {
+    reservations: Reservation[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useMyReservations(params?: ReservationListParams): UseMyReservationsReturn;
+interface UseCreateReservationReturn {
+    createReservation: (data: CreateReservationData) => Promise<Reservation>;
+    loading: boolean;
+    error: Error | null;
+}
+declare function useCreateReservation(): UseCreateReservationReturn;
+interface UseReservationSettingsReturn {
+    settings: ReservationSettings | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useReservationSettings(): UseReservationSettingsReturn;
+
+interface UseMediaReturn {
+    files: Media[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    upload: (file: File | Blob) => Promise<Media>;
+    uploadMultiple: (files: (File | Blob)[]) => Promise<Media[]>;
+    deleteFile: (mediaId: number) => Promise<void>;
+    refresh: () => Promise<void>;
+    uploading: boolean;
+    uploadProgress: number;
+}
+interface UseMediaOptions {
+    type?: string;
+    page?: number;
+    per_page?: number;
+    autoFetch?: boolean;
+}
+declare function useMedia(options?: UseMediaOptions): UseMediaReturn;
+
+interface UseEntitiesReturn {
+    entities: CustomEntity[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useEntities(): UseEntitiesReturn;
+interface UseEntityReturn {
+    entity: CustomEntity | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+declare function useEntity(slug: string): UseEntityReturn;
+interface UseEntityRecordsReturn {
+    records: EntityRecord[];
+    meta: PaginationMeta | null;
+    loading: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    loadMore: () => Promise<void>;
+    createRecord: (data: Record<string, any>) => Promise<EntityRecord>;
+    updateRecord: (id: number, data: Record<string, any>) => Promise<EntityRecord>;
+    deleteRecord: (id: number) => Promise<void>;
+    refresh: () => Promise<void>;
+}
+declare function useEntityRecords(slug: string, params?: EntityListParams): UseEntityRecordsReturn;
+interface UseEntityRecordReturn {
+    record: EntityRecord | null;
+    loading: boolean;
+    error: Error | null;
+    update: (data: Record<string, any>) => Promise<EntityRecord>;
+    refresh: () => Promise<void>;
+}
+declare function useEntityRecord(slug: string, id: number): UseEntityRecordReturn;
+declare function useTypedEntity<T extends Record<string, any>>(slug: string): {
+    useRecords: (params?: EntityListParams) => {
+        records: Array<Omit<EntityRecord, "data"> & {
+            data: T;
+        }>;
+        meta: PaginationMeta | null;
+        loading: boolean;
+        error: Error | null;
+        hasMore: boolean;
+        loadMore: () => Promise<void>;
+        createRecord: (data: Record<string, any>) => Promise<EntityRecord>;
+        updateRecord: (id: number, data: Record<string, any>) => Promise<EntityRecord>;
+        deleteRecord: (id: number) => Promise<void>;
+        refresh: () => Promise<void>;
+    };
+    useRecord: (id: number) => {
+        record: (Omit<EntityRecord, "data"> & {
+            data: T;
+        }) | null;
+        loading: boolean;
+        error: Error | null;
+        update: (data: Record<string, any>) => Promise<EntityRecord>;
+        refresh: () => Promise<void>;
+    };
+    create: (data: T) => Promise<Omit<EntityRecord, "data"> & {
+        data: T;
+    }>;
+    update: (id: number, data: Partial<T>) => Promise<Omit<EntityRecord, "data"> & {
+        data: T;
+    }>;
+    delete: (id: number) => Promise<void>;
+};
+
+export { type CommentType, DiffsomeContext, type DiffsomeContextValue, DiffsomeProvider, type DiffsomeProviderProps, type UseAuthReturn, type UseAvailableSlotsReturn, type UseBlogCategoriesReturn, type UseBlogOptions, type UseBlogPostReturn, type UseBlogReturn, type UseBlogSearchReturn, type UseBlogTagsReturn, type UseBoardPostReturn, type UseBoardPostsReturn, type UseBoardReturn, type UseBoardsReturn, type UseBundleItemsReturn, type UseCanReviewReturn, type UseCartReturn, type UseCategoriesReturn, type UseCommentsOptions, type UseCommentsReturn, type UseCouponsReturn, type UseCreateBoardPostReturn, type UseCreateOrderReturn, type UseCreateReservationReturn, type UseCreateReviewReturn, type UseCreateSubscriptionReturn, type UseDownloadsReturn, type UseEntitiesReturn, type UseEntityRecordReturn, type UseEntityRecordsReturn, type UseEntityReturn, type UseFeaturedBlogReturn, type UseFeaturedProductsReturn, type UseFormReturn, type UseMediaOptions, type UseMediaReturn, type UseMyReservationsReturn, type UseMyReviewsReturn, type UseOrderDownloadsReturn, type UseOrderReturn, type UseOrdersReturn, type UsePaymentStatusReturn, type UseProductReturn, type UseProductReviewsReturn, type UseProductsByTypeReturn, type UseProductsOptions, type UseProductsReturn, type UseReservationServicesReturn, type UseReservationSettingsReturn, type UseReservationStaffsReturn, type UseSocialAuthReturn, type UseStripePaymentReturn, type UseSubscriptionReturn, type UseSubscriptionsReturn, type UseTossPaymentReturn, type UseValidateCouponReturn, type UseWishlistReturn, useAuth, useAvailableSlots, useBlog, useBlogCategories, useBlogPost, useBlogSearch, useBlogTags, useBoard, useBoardPost, useBoardPosts, useBoards, useBundleItems, useBundleProducts, useCanReview, useCart, useCategories, useClient, useComments, useCoupons, useCreateBoardPost, useCreateOrder, useCreateReservation, useCreateReview, useCreateSubscription, useDiffsome, useDigitalProducts, useDownloads, useEntities, useEntity, useEntityRecord, useEntityRecords, useFeaturedBlog, useFeaturedProducts, useForm, useMedia, useMyReservations, useMyReviews, useOrder, useOrderDownloads, useOrders, usePaymentStatus, useProduct, useProductReviews, useProducts, useProductsByType, useReservationServices, useReservationSettings, useReservationStaffs, useSocialAuth, useStripePayment, useSubscription, useSubscriptionProducts, useSubscriptions, useTossPayment, useTypedEntity, useValidateCoupon, useWishlist };