@techsio/storefront-data/dist/medusa/server-read.d.ts

Medusa-first storefront data layer built on TanStack Query.

import type Medusa from "@medusajs/js-sdk";
import type { HttpTypes } from "@medusajs/types";
import type { CreateCatalogHooksConfig } from "../catalog/hooks";
import { createMedusaCatalogService, type MedusaCatalogListInput, type MedusaCatalogServiceConfig } from "../catalog/medusa-service";
import { type CatalogQueryOptionsFactory } from "../catalog/query-options";
import type { CatalogFacets, CatalogQueryKeys } from "../catalog/types";
import type { CreateCategoryHooksConfig } from "../categories/hooks";
import { createMedusaCategoryService, type MedusaCategoryDetailInput, type MedusaCategoryListInput, type MedusaCategoryServiceConfig } from "../categories/medusa-service";
import { type CategoryQueryOptionsFactory } from "../categories/query-options";
import type { CategoryQueryKeys } from "../categories/types";
import type { CreateCollectionHooksConfig } from "../collections/hooks";
import { createMedusaCollectionService, type MedusaCollectionDetailInput, type MedusaCollectionListInput, type MedusaCollectionServiceConfig } from "../collections/medusa-service";
import { type CollectionQueryOptionsFactory } from "../collections/query-options";
import type { CollectionQueryKeys } from "../collections/types";
import type { CreateOrderHooksConfig } from "../orders/hooks";
import { type MedusaOrderDetailHookInput, type MedusaOrderDetailInput, type MedusaOrderListHookInput, type MedusaOrderListInput, type MedusaOrderServiceConfig } from "../orders/medusa-service";
import { type OrderQueryOptionsFactory } from "../orders/query-options";
import type { OrderQueryKeys, OrderService } from "../orders/types";
import { type MedusaProductAttributeServiceConfig, type MedusaProductAttributesInput } from "../product-attributes/medusa-service";
import { type CreateProductAttributeQueryOptionsFactoryConfig, type ProductAttributeQueryOptionsFactory } from "../product-attributes/query-options";
import type { ProductAttribute, ProductAttributeQueryKeys, ProductAttributeService } from "../product-attributes/types";
import { type MedusaProductListDetailHookInput, type MedusaProductListDetailInput, type MedusaProductListDetailKeyInput, type MedusaProductListListHookInput, type MedusaProductListListInput, type MedusaProductListListKeyInput, type MedusaProductListServiceConfig } from "../product-lists/medusa-service";
import { type CreateProductListQueryOptionsFactoryConfig, type ProductListQueryOptionsFactory } from "../product-lists/query-options";
import type { ProductListBase, ProductListItemBase, ProductListQueryKeys, ProductListService } from "../product-lists/types";
import { type MedusaProductLocationAvailabilityInput, type MedusaProductLocationAvailabilityServiceConfig } from "../product-location-availability/medusa-service";
import { type ProductLocationAvailabilityQueryOptionsFactory } from "../product-location-availability/query-options";
import type { ProductLocationAvailabilityQueryKeys, ProductLocationAvailabilityResponse, ProductLocationAvailabilityService } from "../product-location-availability/types";
import type { CreateProductHooksConfig } from "../products/hooks";
import { createMedusaProductService, type MedusaProductDetailInput, type MedusaProductListInput, type MedusaProductServiceConfig } from "../products/medusa-service";
import { type ProductQueryOptionsFactory } from "../products/query-options";
import type { ProductQueryKeys } from "../products/types";
import type { CreateRegionHooksConfig } from "../regions/hooks";
import { createMedusaRegionService, type MedusaRegionDetailInput, type MedusaRegionListInput } from "../regions/medusa-service";
import { type RegionQueryOptionsFactory } from "../regions/query-options";
import type { RegionQueryKeys } from "../regions/types";
import { type MedusaProductReviewListInput, type MedusaProductReviewServiceConfig } from "../reviews/medusa-service";
import { type CreateProductReviewQueryOptionsFactoryConfig, type ProductReviewQueryOptionsFactory } from "../reviews/query-options";
import type { ProductReviewQueryKeys, ProductReviewService, ReviewBase } from "../reviews/types";
import type { CacheConfig } from "../shared/cache-config";
import type { QueryNamespace } from "../shared/query-keys";
import { createMedusaStorefrontQueryKeys as createMedusaStorefrontQueryKeysFromFoundation } from "./foundation";
type OmitFactoryConfig<TConfig> = Omit<TConfig, "service" | "queryKeys" | "queryKeyNamespace" | "cacheConfig">;
type MedusaProductServerReadHooksConfig<TProduct> = Pick<OmitFactoryConfig<CreateProductHooksConfig<TProduct, MedusaProductListInput, MedusaProductListInput, MedusaProductDetailInput, MedusaProductDetailInput>>, "buildListParams" | "buildDetailParams">;
type MedusaOrderServerReadHooksConfig = Pick<OmitFactoryConfig<CreateOrderHooksConfig<HttpTypes.StoreOrder, MedusaOrderListHookInput, MedusaOrderListInput, MedusaOrderDetailHookInput, MedusaOrderDetailInput>>, "buildListParams" | "buildDetailParams">;
type MedusaProductListServerReadHooksConfig = Pick<OmitFactoryConfig<CreateProductListQueryOptionsFactoryConfig<ProductListBase<ProductListItemBase>, ProductListItemBase, HttpTypes.StoreCart, MedusaProductListListHookInput, MedusaProductListListInput, MedusaProductListDetailHookInput, MedusaProductListDetailInput, MedusaProductListListKeyInput, MedusaProductListDetailKeyInput>>, "buildListParams" | "buildDetailParams" | "buildListKeyParams" | "buildDetailKeyParams" | "defaultPageSize">;
type MedusaProductReviewServerReadHooksConfig = Pick<OmitFactoryConfig<CreateProductReviewQueryOptionsFactoryConfig<ReviewBase, MedusaProductReviewListInput, MedusaProductReviewListInput>>, "buildListParams" | "defaultPageSize">;
type MedusaProductAttributeServerReadHooksConfig = Pick<OmitFactoryConfig<CreateProductAttributeQueryOptionsFactoryConfig<ProductAttribute, MedusaProductAttributesInput, MedusaProductAttributesInput>>, "buildDetailParams">;
type MedusaRegionServerReadHooksConfig = Pick<OmitFactoryConfig<CreateRegionHooksConfig<HttpTypes.StoreRegion, MedusaRegionListInput, MedusaRegionListInput, MedusaRegionDetailInput, MedusaRegionDetailInput>>, "buildListParams" | "buildDetailParams">;
type MedusaCategoryServerReadHooksConfig<TCategory> = Pick<OmitFactoryConfig<CreateCategoryHooksConfig<TCategory, MedusaCategoryListInput, MedusaCategoryListInput, MedusaCategoryDetailInput, MedusaCategoryDetailInput>>, "buildListParams" | "buildDetailParams">;
type MedusaCollectionServerReadHooksConfig<TCollection> = Pick<OmitFactoryConfig<CreateCollectionHooksConfig<TCollection, MedusaCollectionListInput, MedusaCollectionListInput, MedusaCollectionDetailInput, MedusaCollectionDetailInput>>, "buildListParams" | "buildDetailParams">;
type MedusaCatalogServerReadHooksConfig<TProduct, TFacets> = Pick<Omit<CreateCatalogHooksConfig<TProduct, MedusaCatalogListInput, MedusaCatalogListInput, TFacets>, "service" | "queryKeys" | "queryKeyNamespace" | "cacheConfig" | "fallbackFacets">, "buildListParams">;
type MedusaStorefrontReadQueryKeys = {
    products: ProductQueryKeys<MedusaProductListInput, MedusaProductDetailInput>;
    productLists: ProductListQueryKeys<MedusaProductListListKeyInput, MedusaProductListDetailKeyInput>;
    productAttributes: ProductAttributeQueryKeys<MedusaProductAttributesInput>;
    productLocationAvailability: ProductLocationAvailabilityQueryKeys<MedusaProductLocationAvailabilityInput>;
    orders: OrderQueryKeys<MedusaOrderListInput, MedusaOrderDetailInput>;
    regions: RegionQueryKeys<MedusaRegionListInput, MedusaRegionDetailInput>;
    categories: CategoryQueryKeys<MedusaCategoryListInput, MedusaCategoryDetailInput>;
    collections: CollectionQueryKeys<MedusaCollectionListInput, MedusaCollectionDetailInput>;
    catalog: CatalogQueryKeys<MedusaCatalogListInput>;
    reviews: ProductReviewQueryKeys<MedusaProductReviewListInput>;
};
type MedusaOrderReadService = OrderService<HttpTypes.StoreOrder, MedusaOrderListInput, MedusaOrderDetailInput>;
type MedusaProductListReadService = ProductListService<ProductListBase<ProductListItemBase>, ProductListItemBase, HttpTypes.StoreCart, MedusaProductListListInput, MedusaProductListDetailInput>;
type MedusaProductReviewReadService = ProductReviewService<ReviewBase, MedusaProductReviewListInput>;
type MedusaProductAttributeReadService = ProductAttributeService<ProductAttribute, MedusaProductAttributesInput>;
type MedusaProductLocationAvailabilityReadService = ProductLocationAvailabilityService<ProductLocationAvailabilityResponse, MedusaProductLocationAvailabilityInput>;
export type CreateMedusaStorefrontServerReadPresetConfig<TProduct = HttpTypes.StoreProduct, TCategory = HttpTypes.StoreProductCategory, TCollection = HttpTypes.StoreCollection, TCatalogProduct = HttpTypes.StoreProduct, TCatalogFacets = CatalogFacets> = {
    sdk: Medusa;
    queryKeyNamespace?: QueryNamespace;
    cacheConfig?: CacheConfig;
    products?: {
        serviceConfig?: MedusaProductServiceConfig<TProduct, MedusaProductListInput, MedusaProductDetailInput>;
        hooks?: MedusaProductServerReadHooksConfig<TProduct>;
        queryKeys?: ProductQueryKeys<MedusaProductListInput, MedusaProductDetailInput>;
    };
    productLists?: {
        service?: MedusaProductListReadService;
        serviceConfig?: MedusaProductListServiceConfig<ProductListBase<ProductListItemBase>, ProductListItemBase, HttpTypes.StoreCart>;
        hooks?: MedusaProductListServerReadHooksConfig;
        queryKeys?: ProductListQueryKeys<MedusaProductListListKeyInput, MedusaProductListDetailKeyInput>;
    };
    productAttributes?: {
        service?: MedusaProductAttributeReadService;
        serviceConfig?: MedusaProductAttributeServiceConfig;
        hooks?: MedusaProductAttributeServerReadHooksConfig;
        queryKeys?: ProductAttributeQueryKeys<MedusaProductAttributesInput>;
    };
    productLocationAvailability?: {
        service?: MedusaProductLocationAvailabilityReadService;
        serviceConfig?: MedusaProductLocationAvailabilityServiceConfig;
        queryKeys?: ProductLocationAvailabilityQueryKeys<MedusaProductLocationAvailabilityInput>;
    };
    orders?: {
        service?: MedusaOrderReadService;
        serviceConfig?: MedusaOrderServiceConfig;
        hooks?: MedusaOrderServerReadHooksConfig;
        queryKeys?: OrderQueryKeys<MedusaOrderListInput, MedusaOrderDetailInput>;
    };
    regions?: {
        hooks?: MedusaRegionServerReadHooksConfig;
        queryKeys?: RegionQueryKeys<MedusaRegionListInput, MedusaRegionDetailInput>;
    };
    categories?: {
        serviceConfig?: MedusaCategoryServiceConfig<TCategory, MedusaCategoryListInput, MedusaCategoryDetailInput>;
        hooks?: MedusaCategoryServerReadHooksConfig<TCategory>;
        queryKeys?: CategoryQueryKeys<MedusaCategoryListInput, MedusaCategoryDetailInput>;
    };
    collections?: {
        serviceConfig?: MedusaCollectionServiceConfig<TCollection, MedusaCollectionListInput, MedusaCollectionDetailInput>;
        hooks?: MedusaCollectionServerReadHooksConfig<TCollection>;
        queryKeys?: CollectionQueryKeys<MedusaCollectionListInput, MedusaCollectionDetailInput>;
    };
    catalog?: {
        serviceConfig?: MedusaCatalogServiceConfig<TCatalogProduct, MedusaCatalogListInput, TCatalogFacets>;
        hooks?: MedusaCatalogServerReadHooksConfig<TCatalogProduct, TCatalogFacets>;
        queryKeys?: CatalogQueryKeys<MedusaCatalogListInput>;
    };
    reviews?: {
        service?: MedusaProductReviewReadService;
        serviceConfig?: MedusaProductReviewServiceConfig<ReviewBase>;
        hooks?: MedusaProductReviewServerReadHooksConfig;
        queryKeys?: ProductReviewQueryKeys<MedusaProductReviewListInput>;
    };
};
type MedusaStorefrontReadServices<TProduct, TCategory, TCollection, TCatalogProduct, TCatalogFacets> = {
    products: ReturnType<typeof createMedusaProductService<TProduct, MedusaProductListInput, MedusaProductDetailInput>>;
    productLists: MedusaProductListReadService;
    productAttributes: MedusaProductAttributeReadService;
    productLocationAvailability: MedusaProductLocationAvailabilityReadService;
    orders: MedusaOrderReadService;
    regions: ReturnType<typeof createMedusaRegionService>;
    categories: ReturnType<typeof createMedusaCategoryService<TCategory, MedusaCategoryListInput, MedusaCategoryDetailInput>>;
    collections: ReturnType<typeof createMedusaCollectionService<TCollection, MedusaCollectionListInput, MedusaCollectionDetailInput>>;
    catalog: ReturnType<typeof createMedusaCatalogService<TCatalogProduct, MedusaCatalogListInput, TCatalogFacets>>;
    reviews: MedusaProductReviewReadService;
};
type MedusaStorefrontReadQueries<TProduct, TCategory, TCollection, TCatalogProduct, TCatalogFacets> = {
    products: ProductQueryOptionsFactory<TProduct, MedusaProductListInput, MedusaProductDetailInput>;
    productLists: ProductListQueryOptionsFactory<ProductListBase<ProductListItemBase>, MedusaProductListListHookInput, MedusaProductListDetailHookInput>;
    productAttributes: ProductAttributeQueryOptionsFactory<ProductAttribute, MedusaProductAttributesInput>;
    productLocationAvailability: ProductLocationAvailabilityQueryOptionsFactory<ProductLocationAvailabilityResponse, MedusaProductLocationAvailabilityInput>;
    orders: OrderQueryOptionsFactory<HttpTypes.StoreOrder, MedusaOrderListHookInput, MedusaOrderDetailHookInput>;
    regions: RegionQueryOptionsFactory<HttpTypes.StoreRegion, MedusaRegionListInput, MedusaRegionDetailInput>;
    categories: CategoryQueryOptionsFactory<TCategory, MedusaCategoryListInput, MedusaCategoryDetailInput>;
    collections: CollectionQueryOptionsFactory<TCollection, MedusaCollectionListInput, MedusaCollectionDetailInput>;
    catalog: CatalogQueryOptionsFactory<TCatalogProduct, MedusaCatalogListInput, TCatalogFacets>;
    reviews: ProductReviewQueryOptionsFactory<ReviewBase, MedusaProductReviewListInput>;
};
export type MedusaStorefrontServerReadPresetResult<TProduct, TCategory, TCollection, TCatalogProduct, TCatalogFacets> = {
    namespace: QueryNamespace;
    cacheConfig: CacheConfig;
    queryKeys: MedusaStorefrontReadQueryKeys;
    services: MedusaStorefrontReadServices<TProduct, TCategory, TCollection, TCatalogProduct, TCatalogFacets>;
    queries: MedusaStorefrontReadQueries<TProduct, TCategory, TCollection, TCatalogProduct, TCatalogFacets>;
};
export declare const createMedusaStorefrontQueryKeys: typeof createMedusaStorefrontQueryKeysFromFoundation;
export declare function createMedusaStorefrontServerReadPreset<TProduct = HttpTypes.StoreProduct, TCategory = HttpTypes.StoreProductCategory, TCollection = HttpTypes.StoreCollection, TCatalogProduct = HttpTypes.StoreProduct, TCatalogFacets = CatalogFacets>(config: CreateMedusaStorefrontServerReadPresetConfig<TProduct, TCategory, TCollection, TCatalogProduct, TCatalogFacets>): MedusaStorefrontServerReadPresetResult<TProduct, TCategory, TCollection, TCatalogProduct, TCatalogFacets>;
export {};
//# sourceMappingURL=server-read.d.ts.map