@burdenoff/microfe-store 2026.714.7 → 2026.715.1

package/dist/generated/global-operations.d.ts

@@ -0,0 +1,2027 @@
+import * as Types from './global-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type CreateReviewMutationVariables = Types.Exact<{
+    input: Types.CreateReviewInput;
+}>;
+export type CreateReviewMutation = {
+    __typename?: 'Mutation';
+    createReview: {
+        __typename?: 'ProductReview';
+        id: string;
+        rating: number;
+    };
+};
+export type DeleteReviewMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteReviewMutation = {
+    __typename?: 'Mutation';
+    deleteReview: boolean;
+};
+export type MarkReviewHelpfulMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type MarkReviewHelpfulMutation = {
+    __typename?: 'Mutation';
+    markReviewHelpful: {
+        __typename?: 'ProductReview';
+        id: string;
+        helpful: number;
+    };
+};
+export type UpdateReviewMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateReviewInput;
+}>;
+export type UpdateReviewMutation = {
+    __typename?: 'Mutation';
+    updateReview: {
+        __typename?: 'ProductReview';
+        id: string;
+        rating: number;
+    };
+};
+export type AddToCartMutationVariables = Types.Exact<{
+    input: Types.AddToCartInput;
+}>;
+export type AddToCartMutation = {
+    __typename?: 'Mutation';
+    addToCart: {
+        __typename?: 'CartItemPayload';
+        cartItem?: {
+            __typename?: 'CartItem';
+            id: string;
+            productId: string;
+            productName: string;
+            quantity: number;
+            unitPrice: number;
+            subtotal: number;
+        } | null;
+        cart?: {
+            __typename?: 'Cart';
+            id: string;
+            subtotal: number;
+            total: number;
+            itemCount: number;
+            items: Array<{
+                __typename?: 'CartItem';
+                id: string;
+                productId: string;
+                productName: string;
+                productIcon?: string | null;
+                variantId?: string | null;
+                quantity: number;
+                unitPrice: number;
+                subtotal: number;
+                itemType: Types.CartItemType;
+            }>;
+        } | null;
+        errors?: Array<{
+            __typename?: 'CartError';
+            field?: string | null;
+            message: string;
+            code: string;
+        }> | null;
+    };
+};
+export type CheckoutMutationVariables = Types.Exact<{
+    input: Types.CheckoutInput;
+}>;
+export type CheckoutMutation = {
+    __typename?: 'Mutation';
+    checkout: {
+        __typename?: 'CheckoutPayload';
+        success: boolean;
+        order?: {
+            __typename?: 'StoreOrder';
+            id: string;
+            status: Types.OrderStatus;
+            total: number;
+            createdAt: string;
+        } | null;
+        errors?: Array<{
+            __typename?: 'CartError';
+            field?: string | null;
+            message: string;
+            code: string;
+        }> | null;
+    };
+};
+export type ClearCartMutationVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type ClearCartMutation = {
+    __typename?: 'Mutation';
+    clearCart: {
+        __typename?: 'CartPayload';
+        cart?: {
+            __typename?: 'Cart';
+            id: string;
+            subtotal: number;
+            total: number;
+            itemCount: number;
+            items: Array<{
+                __typename?: 'CartItem';
+                id: string;
+            }>;
+        } | null;
+        errors?: Array<{
+            __typename?: 'CartError';
+            field?: string | null;
+            message: string;
+            code: string;
+        }> | null;
+    };
+};
+export type CreateProductForPublisherMutationVariables = Types.Exact<{
+    input: Types.CreateProductInput;
+}>;
+export type CreateProductForPublisherMutation = {
+    __typename?: 'Mutation';
+    createProduct: {
+        __typename?: 'StoreProduct';
+        id: string;
+        name: string;
+        slug: string;
+        status: Types.ProductStatus;
+        manifestVersion?: string | null;
+        subType?: string | null;
+    };
+};
+export type CreateStoreOrderMutationVariables = Types.Exact<{
+    input: Types.CreateStoreOrderInput;
+}>;
+export type CreateStoreOrderMutation = {
+    __typename?: 'Mutation';
+    createStoreOrder: {
+        __typename?: 'StoreOrder';
+        id: string;
+        status: Types.OrderStatus;
+        total: number;
+        lineItems: Record<string, unknown>;
+        createdAt: string;
+    };
+};
+export type RemoveFromCartMutationVariables = Types.Exact<{
+    cartItemId: Types.Scalars['String']['input'];
+}>;
+export type RemoveFromCartMutation = {
+    __typename?: 'Mutation';
+    removeFromCart: {
+        __typename?: 'CartPayload';
+        cart?: {
+            __typename?: 'Cart';
+            id: string;
+            subtotal: number;
+            total: number;
+            itemCount: number;
+            items: Array<{
+                __typename?: 'CartItem';
+                id: string;
+                productId: string;
+                productName: string;
+                productIcon?: string | null;
+                variantId?: string | null;
+                quantity: number;
+                unitPrice: number;
+                subtotal: number;
+                itemType: Types.CartItemType;
+            }>;
+        } | null;
+        errors?: Array<{
+            __typename?: 'CartError';
+            field?: string | null;
+            message: string;
+            code: string;
+        }> | null;
+    };
+};
+export type RecordAppUninstallationMutationVariables = Types.Exact<{
+    workspaceId: Types.Scalars['String']['input'];
+    productId: Types.Scalars['String']['input'];
+}>;
+export type RecordAppUninstallationMutation = {
+    __typename?: 'Mutation';
+    recordAppUninstallation: {
+        __typename?: 'StoreAppInstallation';
+        id: string;
+        status: Types.StoreInstallationStatus;
+        uninstalledAt?: string | null;
+    };
+};
+export type UpdateCartItemMutationVariables = Types.Exact<{
+    input: Types.UpdateCartItemInput;
+}>;
+export type UpdateCartItemMutation = {
+    __typename?: 'Mutation';
+    updateCartItem: {
+        __typename?: 'CartItemPayload';
+        cartItem?: {
+            __typename?: 'CartItem';
+            id: string;
+            productId: string;
+            productName: string;
+            quantity: number;
+            unitPrice: number;
+            subtotal: number;
+        } | null;
+        cart?: {
+            __typename?: 'Cart';
+            id: string;
+            subtotal: number;
+            total: number;
+            itemCount: number;
+            items: Array<{
+                __typename?: 'CartItem';
+                id: string;
+                productId: string;
+                productName: string;
+                productIcon?: string | null;
+                variantId?: string | null;
+                quantity: number;
+                unitPrice: number;
+                subtotal: number;
+                itemType: Types.CartItemType;
+            }>;
+        } | null;
+        errors?: Array<{
+            __typename?: 'CartError';
+            field?: string | null;
+            message: string;
+            code: string;
+        }> | null;
+    };
+};
+export type CategoriesQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type CategoriesQuery = {
+    __typename?: 'Query';
+    categories: Array<{
+        __typename?: 'ProductCategory';
+        id: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+    }>;
+};
+export type CheckEntitlementQueryVariables = Types.Exact<{
+    productId: Types.Scalars['String']['input'];
+}>;
+export type CheckEntitlementQuery = {
+    __typename?: 'Query';
+    checkEntitlement?: {
+        __typename?: 'ProductEntitlement';
+        id: string;
+        productId: string;
+        status: Types.EntitlementStatus;
+        licenseKey?: string | null;
+        expiresAt?: string | null;
+    } | null;
+};
+export type DeveloperEarningsQueryVariables = Types.Exact<{
+    input?: Types.InputMaybe<Types.DeveloperEarningsInput>;
+}>;
+export type DeveloperEarningsQuery = {
+    __typename?: 'Query';
+    developerEarnings: {
+        __typename?: 'DeveloperEarnings';
+        totalEarnings: number;
+        monthlyEarnings: number;
+        totalOrders: number;
+        monthlyOrders: number;
+        currency: string;
+    };
+};
+export type FeaturedProductsQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type FeaturedProductsQuery = {
+    __typename?: 'Query';
+    featuredProducts: Array<{
+        __typename?: 'StoreProduct';
+        id: string;
+        name: string;
+        slug: string;
+    }>;
+};
+export type FilterOptionsQueryVariables = Types.Exact<{
+    type?: Types.InputMaybe<Types.ProductType>;
+}>;
+export type FilterOptionsQuery = {
+    __typename?: 'Query';
+    filterOptions: {
+        __typename?: 'FilterOptionsResult';
+        categories: Array<{
+            __typename?: 'FacetCount';
+            value: string;
+            count: number;
+        }>;
+        subTypes: Array<{
+            __typename?: 'FacetCount';
+            value: string;
+            count: number;
+        }>;
+        tags: Array<{
+            __typename?: 'FacetCount';
+            value: string;
+            count: number;
+        }>;
+        licenses: Array<{
+            __typename?: 'FacetCount';
+            value: string;
+            count: number;
+        }>;
+        compatibleProducts: Array<{
+            __typename?: 'FacetCount';
+            value: string;
+            count: number;
+        }>;
+    };
+};
+export type MyEntitlementsQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type MyEntitlementsQuery = {
+    __typename?: 'Query';
+    myEntitlements: Array<{
+        __typename?: 'ProductEntitlement';
+        id: string;
+        productId: string;
+        status: Types.EntitlementStatus;
+        licenseKey?: string | null;
+        expiresAt?: string | null;
+    }>;
+};
+export type MyPublishedProductsQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type MyPublishedProductsQuery = {
+    __typename?: 'Query';
+    publishedProducts: Array<{
+        __typename?: 'StoreProduct';
+        id: string;
+        name: string;
+        status: Types.ProductStatus;
+        reviewCount: number;
+    }>;
+};
+export type ProductReviewsQueryVariables = Types.Exact<{
+    productId: Types.Scalars['String']['input'];
+    status?: Types.InputMaybe<Types.ReviewStatus>;
+}>;
+export type ProductReviewsQuery = {
+    __typename?: 'Query';
+    productReviews: Array<{
+        __typename?: 'ProductReview';
+        id: string;
+        rating: number;
+        title?: string | null;
+        comment?: string | null;
+        helpful: number;
+        createdAt: string;
+    }>;
+};
+export type SearchSuggestionsQueryVariables = Types.Exact<{
+    query: Types.Scalars['String']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type SearchSuggestionsQuery = {
+    __typename?: 'Query';
+    searchSuggestions: Array<{
+        __typename?: 'SearchSuggestion';
+        term: string;
+        type: string;
+        count: number;
+    }>;
+};
+export type TrendingSearchesQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type TrendingSearchesQuery = {
+    __typename?: 'Query';
+    trendingSearches: Array<string>;
+};
+export type UserReviewForProductQueryVariables = Types.Exact<{
+    productId: Types.Scalars['String']['input'];
+}>;
+export type UserReviewForProductQuery = {
+    __typename?: 'Query';
+    userReviewForProduct?: {
+        __typename?: 'ProductReview';
+        id: string;
+        rating: number;
+        title?: string | null;
+        comment?: string | null;
+    } | null;
+};
+export type WorkspaceStoreOrdersQueryVariables = Types.Exact<{
+    billingAccountId: Types.Scalars['ID']['input'];
+    page: Types.Scalars['Int']['input'];
+    limit: Types.Scalars['Int']['input'];
+}>;
+export type WorkspaceStoreOrdersQuery = {
+    __typename?: 'Query';
+    workspaceStoreOrders: {
+        __typename?: 'StoreOrdersResult';
+        total: number;
+        orders: Array<{
+            __typename?: 'StoreOrder';
+            id: string;
+            status: Types.OrderStatus;
+            createdAt: string;
+        }>;
+    };
+};
+export type BrowseStoreQueryVariables = Types.Exact<{
+    input: Types.BrowseStoreInput;
+}>;
+export type BrowseStoreQuery = {
+    __typename?: 'Query';
+    browseStore: {
+        __typename?: 'BrowseStoreResult';
+        totalCount: number;
+        hasMore: boolean;
+        nextCursor?: string | null;
+        products: Array<{
+            __typename?: 'StoreProduct';
+            id: string;
+            name: string;
+            slug: string;
+            type: Types.ProductType;
+            nature: Types.ProductNature;
+            status: Types.ProductStatus;
+            description?: string | null;
+            pricingModel: Types.PricingModel;
+            price: number;
+            currency: string;
+            icon?: string | null;
+            screenshots: Array<string>;
+            rating?: number | null;
+            reviewCount: number;
+            downloads: number;
+            featured: boolean;
+            category?: string | null;
+            tags: Array<string>;
+            publishedAt?: string | null;
+            publisher?: {
+                __typename?: 'Publisher';
+                id: string;
+                name: string;
+                isVerified: boolean;
+                logoUrl?: string | null;
+            } | null;
+        }>;
+        facets?: {
+            __typename?: 'StoreFacets';
+            types: Array<{
+                __typename?: 'FacetCount';
+                value: string;
+                count: number;
+            }>;
+            subTypes: Array<{
+                __typename?: 'FacetCount';
+                value: string;
+                count: number;
+            }>;
+            categories: Array<{
+                __typename?: 'FacetCount';
+                value: string;
+                count: number;
+            }>;
+            pricingModels: Array<{
+                __typename?: 'FacetCount';
+                value: string;
+                count: number;
+            }>;
+            licenses: Array<{
+                __typename?: 'FacetCount';
+                value: string;
+                count: number;
+            }>;
+            priceRange?: {
+                __typename?: 'PriceRange';
+                min: number;
+                max: number;
+            } | null;
+        } | null;
+    };
+};
+export type GetCartQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetCartQuery = {
+    __typename?: 'Query';
+    myCart?: {
+        __typename?: 'Cart';
+        id: string;
+        userId?: string | null;
+        status: Types.CartStatus;
+        currency: string;
+        subtotal: number;
+        total: number;
+        itemCount: number;
+        createdAt: string;
+        updatedAt: string;
+        items: Array<{
+            __typename?: 'CartItem';
+            id: string;
+            productId: string;
+            productName: string;
+            productIcon?: string | null;
+            variantId?: string | null;
+            variantName?: string | null;
+            quantity: number;
+            unitPrice: number;
+            subtotal: number;
+            itemType: Types.CartItemType;
+            product?: {
+                __typename?: 'StoreProduct';
+                id: string;
+                name: string;
+                slug: string;
+                icon?: string | null;
+                price: number;
+                pricingModel: Types.PricingModel;
+            } | null;
+            variant?: {
+                __typename?: 'ProductVariant';
+                id: string;
+                name: string;
+                price?: number | null;
+            } | null;
+        }>;
+    } | null;
+};
+export type GetMyStoreInstallationsQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    filter?: Types.InputMaybe<Types.InstallationFilterInput>;
+}>;
+export type GetMyStoreInstallationsQuery = {
+    __typename?: 'Query';
+    myStoreAppInstallations: {
+        __typename?: 'StoreAppInstallationConnection';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'StoreAppInstallation';
+            id: string;
+            productId: string;
+            workspaceId: string;
+            organizationId?: string | null;
+            status: Types.StoreInstallationStatus;
+            installedAt: string;
+            version?: string | null;
+            updatedAt: string;
+            workspaceName?: string | null;
+            workspaceType?: string | null;
+            installedById: string;
+            manifest?: Record<string, unknown> | null;
+            metadata?: Record<string, unknown> | null;
+            context?: Record<string, unknown> | null;
+            grantedPermissions?: Record<string, unknown> | null;
+        }>;
+    };
+};
+export type GetMyOrdersQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    status?: Types.InputMaybe<Types.OrderStatus>;
+}>;
+export type GetMyOrdersQuery = {
+    __typename?: 'Query';
+    myOrders: Array<{
+        __typename?: 'StoreOrder';
+        id: string;
+        status: Types.OrderStatus;
+        total: number;
+        currency: string;
+        lineItems: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        fulfillment?: {
+            __typename?: 'OrderFulfillment';
+            status: Types.FulfillmentStatus;
+            trackingNumber?: string | null;
+            trackingUrl?: string | null;
+            carrier?: string | null;
+            estimatedDeliveryDate?: string | null;
+        } | null;
+    }>;
+};
+export type GetProductQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetProductQuery = {
+    __typename?: 'Query';
+    product?: {
+        __typename?: 'StoreProduct';
+        id: string;
+        publisherId: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        longDescription?: string | null;
+        icon?: string | null;
+        screenshots: Array<string>;
+        videoUrls: Array<string>;
+        subType?: string | null;
+        type: Types.ProductType;
+        manifest?: Record<string, unknown> | null;
+        manifestVersion?: string | null;
+        requiredPermissions: Array<string>;
+        compatibleProducts: Array<string>;
+        category?: string | null;
+        tags: Array<string>;
+        pricingModel: Types.PricingModel;
+        price: number;
+        currency: string;
+        status: Types.ProductStatus;
+        featured: boolean;
+        documentationUrl?: string | null;
+        repositoryUrl?: string | null;
+        downloads: number;
+        viewCount: number;
+        rating?: number | null;
+        reviewCount: number;
+        createdAt: string;
+        updatedAt: string;
+        publishedAt?: string | null;
+        variants: Array<{
+            __typename?: 'ProductVariant';
+            id: string;
+            name: string;
+            sku?: string | null;
+            price?: number | null;
+            compareAtPrice?: number | null;
+            isActive: boolean;
+            stockQuantity: number;
+            options: Record<string, unknown>;
+            imageUrls: Array<string>;
+            displayOrder: number;
+            weight?: number | null;
+            weightUnit?: Types.WeightUnit | null;
+        }>;
+        publisher?: {
+            __typename?: 'Publisher';
+            id: string;
+            name: string;
+            websiteUrl?: string | null;
+            isVerified: boolean;
+            email: string;
+            bio?: string | null;
+            logoUrl?: string | null;
+            totalSales: number;
+            totalEarnings: number;
+            products: Array<{
+                __typename?: 'StoreProduct';
+                id: string;
+            }>;
+        } | null;
+        reviews: Array<{
+            __typename?: 'ProductReview';
+            id: string;
+            userId: string;
+            rating: number;
+            comment?: string | null;
+            status: Types.ReviewStatus;
+            helpful: number;
+            createdAt: string;
+        }>;
+    } | null;
+};
+export type GetProductsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.ProductFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetProductsQuery = {
+    __typename?: 'Query';
+    products: Array<{
+        __typename?: 'StoreProduct';
+        id: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        icon?: string | null;
+        screenshots: Array<string>;
+        subType?: string | null;
+        type: Types.ProductType;
+        pricingModel: Types.PricingModel;
+        price: number;
+        currency: string;
+        status: Types.ProductStatus;
+        featured: boolean;
+        downloads: number;
+        viewCount: number;
+        rating?: number | null;
+        reviewCount: number;
+        category?: string | null;
+        tags: Array<string>;
+        createdAt: string;
+        publishedAt?: string | null;
+        publisher?: {
+            __typename?: 'Publisher';
+            id: string;
+            name: string;
+            isVerified: boolean;
+        } | null;
+    }>;
+};
+export type GetStoreAppInstallationQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetStoreAppInstallationQuery = {
+    __typename?: 'Query';
+    storeAppInstallation?: {
+        __typename?: 'StoreAppInstallation';
+        id: string;
+        productId: string;
+        workspaceId: string;
+        workspaceName?: string | null;
+        workspaceType?: string | null;
+        organizationId?: string | null;
+        installedById: string;
+        status: Types.StoreInstallationStatus;
+        version?: string | null;
+        manifest?: Record<string, unknown> | null;
+        metadata?: Record<string, unknown> | null;
+        context?: Record<string, unknown> | null;
+        grantedPermissions?: Record<string, unknown> | null;
+        installedAt: string;
+        updatedAt: string;
+        uninstalledAt?: string | null;
+        uninstalledById?: string | null;
+    } | null;
+};
+export type HomeGroupedProductsQueryVariables = Types.Exact<{
+    compatibleWith?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type HomeGroupedProductsQuery = {
+    __typename?: 'Query';
+    homeGroupedProducts: {
+        __typename?: 'GroupedStoreProducts';
+        featured: Array<{
+            __typename?: 'StoreProduct';
+            id: string;
+            name: string;
+            slug: string;
+            type: Types.ProductType;
+            nature: Types.ProductNature;
+            status: Types.ProductStatus;
+            description?: string | null;
+            pricingModel: Types.PricingModel;
+            price: number;
+            currency: string;
+            icon?: string | null;
+            screenshots: Array<string>;
+            rating?: number | null;
+            reviewCount: number;
+            downloads: number;
+            featured: boolean;
+            category?: string | null;
+            tags: Array<string>;
+            publishedAt?: string | null;
+            publisher?: {
+                __typename?: 'Publisher';
+                id: string;
+                name: string;
+                isVerified: boolean;
+                logoUrl?: string | null;
+            } | null;
+        }>;
+        mostDownloaded: Array<{
+            __typename?: 'StoreProduct';
+            id: string;
+            name: string;
+            slug: string;
+            type: Types.ProductType;
+            nature: Types.ProductNature;
+            status: Types.ProductStatus;
+            description?: string | null;
+            pricingModel: Types.PricingModel;
+            price: number;
+            currency: string;
+            icon?: string | null;
+            screenshots: Array<string>;
+            rating?: number | null;
+            reviewCount: number;
+            downloads: number;
+            featured: boolean;
+            category?: string | null;
+            tags: Array<string>;
+            publishedAt?: string | null;
+            publisher?: {
+                __typename?: 'Publisher';
+                id: string;
+                name: string;
+                isVerified: boolean;
+                logoUrl?: string | null;
+            } | null;
+        }>;
+        recentlyAdded: Array<{
+            __typename?: 'StoreProduct';
+            id: string;
+            name: string;
+            slug: string;
+            type: Types.ProductType;
+            nature: Types.ProductNature;
+            status: Types.ProductStatus;
+            description?: string | null;
+            pricingModel: Types.PricingModel;
+            price: number;
+            currency: string;
+            icon?: string | null;
+            screenshots: Array<string>;
+            rating?: number | null;
+            reviewCount: number;
+            downloads: number;
+            featured: boolean;
+            category?: string | null;
+            tags: Array<string>;
+            publishedAt?: string | null;
+            publisher?: {
+                __typename?: 'Publisher';
+                id: string;
+                name: string;
+                isVerified: boolean;
+                logoUrl?: string | null;
+            } | null;
+        }>;
+        freeItems: Array<{
+            __typename?: 'StoreProduct';
+            id: string;
+            name: string;
+            slug: string;
+            type: Types.ProductType;
+            nature: Types.ProductNature;
+            status: Types.ProductStatus;
+            description?: string | null;
+            pricingModel: Types.PricingModel;
+            price: number;
+            currency: string;
+            icon?: string | null;
+            screenshots: Array<string>;
+            rating?: number | null;
+            reviewCount: number;
+            downloads: number;
+            featured: boolean;
+            category?: string | null;
+            tags: Array<string>;
+            publishedAt?: string | null;
+            publisher?: {
+                __typename?: 'Publisher';
+                id: string;
+                name: string;
+                isVerified: boolean;
+                logoUrl?: string | null;
+            } | null;
+        }>;
+    };
+};
+export type StoreProductDetailsQueryVariables = Types.Exact<{
+    input: Types.StoreProductDetailsInput;
+}>;
+export type StoreProductDetailsQuery = {
+    __typename?: 'Query';
+    storeProductDetails: {
+        __typename?: 'StoreProductDetailsResult';
+        reviewsCount: number;
+        isPurchased: boolean;
+        product: {
+            __typename?: 'StoreProduct';
+            id: string;
+            name: string;
+            slug: string;
+            type: Types.ProductType;
+            nature: Types.ProductNature;
+            status: Types.ProductStatus;
+            description?: string | null;
+            longDescription?: string | null;
+            pricingModel: Types.PricingModel;
+            price: number;
+            currency: string;
+            icon?: string | null;
+            bannerUrl?: string | null;
+            screenshots: Array<string>;
+            videoUrls: Array<string>;
+            documentationUrl?: string | null;
+            repositoryUrl?: string | null;
+            rating?: number | null;
+            reviewCount: number;
+            downloads: number;
+            viewCount: number;
+            featured: boolean;
+            category?: string | null;
+            tags: Array<string>;
+            publishedAt?: string | null;
+            createdAt: string;
+            updatedAt: string;
+            subType?: string | null;
+            manifestVersion?: string | null;
+            authorName?: string | null;
+            productId?: string | null;
+            license?: string | null;
+            minPlatformVersion?: string | null;
+            compatibleProducts: Array<string>;
+            requiredPermissions: Array<string>;
+            integrationDeps: Array<string>;
+            manifest?: Record<string, unknown> | null;
+            publisher?: {
+                __typename?: 'Publisher';
+                id: string;
+                name: string;
+                isVerified: boolean;
+                logoUrl?: string | null;
+                websiteUrl?: string | null;
+                bio?: string | null;
+                email: string;
+            } | null;
+        };
+        publisher?: {
+            __typename?: 'Publisher';
+            id: string;
+            name: string;
+            isVerified: boolean;
+            logoUrl?: string | null;
+            websiteUrl?: string | null;
+            bio?: string | null;
+            email: string;
+        } | null;
+        relatedProducts: Array<{
+            __typename?: 'StoreProduct';
+            id: string;
+            name: string;
+            slug: string;
+            type: Types.ProductType;
+            nature: Types.ProductNature;
+            status: Types.ProductStatus;
+            description?: string | null;
+            icon?: string | null;
+            rating?: number | null;
+            reviewCount: number;
+            downloads: number;
+            price: number;
+            pricingModel: Types.PricingModel;
+            currency: string;
+            screenshots: Array<string>;
+            featured: boolean;
+            category?: string | null;
+            tags: Array<string>;
+            publishedAt?: string | null;
+            publisher?: {
+                __typename?: 'Publisher';
+                id: string;
+                name: string;
+                isVerified: boolean;
+                logoUrl?: string | null;
+            } | null;
+        }>;
+        reviews: Array<{
+            __typename?: 'ProductReview';
+            id: string;
+            userId: string;
+            rating: number;
+            title?: string | null;
+            comment?: string | null;
+            status: Types.ReviewStatus;
+            helpful: number;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+        userReview?: {
+            __typename?: 'ProductReview';
+            id: string;
+            userId: string;
+            rating: number;
+            title?: string | null;
+            comment?: string | null;
+            status: Types.ReviewStatus;
+            helpful: number;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+        userEntitlement?: {
+            __typename?: 'ProductEntitlement';
+            id: string;
+            status: Types.EntitlementStatus;
+            licenseKey?: string | null;
+            expiresAt?: string | null;
+        } | null;
+        ratingDistribution?: {
+            __typename?: 'ProductRatingDistribution';
+            fiveStars: number;
+            fourStars: number;
+            threeStars: number;
+            twoStars: number;
+            oneStar: number;
+        } | null;
+    };
+};
+export type InstallationStatusUpdatedSubscriptionVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+}>;
+export type InstallationStatusUpdatedSubscription = {
+    __typename?: 'Subscription';
+    installationStatusUpdated?: {
+        __typename?: 'InstallationStatusUpdatedEvent';
+        installationId: string;
+        productId: string;
+        workspaceId: string;
+        status: string;
+        updatedAt: string;
+    } | null;
+};
+export type LicenseStatusUpdatedSubscriptionVariables = Types.Exact<{
+    workspaceId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+}>;
+export type LicenseStatusUpdatedSubscription = {
+    __typename?: 'Subscription';
+    licenseStatusUpdated?: {
+        __typename?: 'LicenseStatusUpdatedEvent';
+        entitlementId: string;
+        productId: string;
+        status: string;
+        updatedAt: string;
+    } | null;
+};
+export type OrderStatusUpdatedSubscriptionVariables = Types.Exact<{
+    orderId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+    workspaceId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+}>;
+export type OrderStatusUpdatedSubscription = {
+    __typename?: 'Subscription';
+    orderStatusUpdated?: {
+        __typename?: 'OrderStatusUpdatedEvent';
+        orderId: string;
+        workspaceId?: string | null;
+        status: string;
+        updatedAt: string;
+    } | null;
+};
+export type SubmissionStatusUpdatedSubscriptionVariables = Types.Exact<{
+    publisherId: Types.Scalars['ID']['input'];
+}>;
+export type SubmissionStatusUpdatedSubscription = {
+    __typename?: 'Subscription';
+    submissionStatusUpdated?: {
+        __typename?: 'SubmissionStatusUpdatedEvent';
+        submissionId: string;
+        productId: string;
+        publisherId: string;
+        status: string;
+        updatedAt: string;
+    } | null;
+};
+export declare const CreateReviewDocument: Apollo.DocumentNode;
+export type CreateReviewMutationFn = Apollo.MutationFunction<Types.CreateReviewMutation, Types.CreateReviewMutationVariables>;
+/**
+ * __useCreateReviewMutation__
+ *
+ * To run a mutation, you first call `useCreateReviewMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateReviewMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createReviewMutation, { data, loading, error }] = useCreateReviewMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateReviewMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateReviewMutation, Types.CreateReviewMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateReviewMutation, any, Apollo.ApolloCache, undefined>;
+export type CreateReviewMutationHookResult = ReturnType<typeof useCreateReviewMutation>;
+export type CreateReviewMutationResult = Apollo.MutationResult<Types.CreateReviewMutation>;
+export type CreateReviewMutationOptions = Apollo.BaseMutationOptions<Types.CreateReviewMutation, Types.CreateReviewMutationVariables>;
+export declare const DeleteReviewDocument: Apollo.DocumentNode;
+export type DeleteReviewMutationFn = Apollo.MutationFunction<Types.DeleteReviewMutation, Types.DeleteReviewMutationVariables>;
+/**
+ * __useDeleteReviewMutation__
+ *
+ * To run a mutation, you first call `useDeleteReviewMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteReviewMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteReviewMutation, { data, loading, error }] = useDeleteReviewMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteReviewMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteReviewMutation, Types.DeleteReviewMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteReviewMutation, any, Apollo.ApolloCache, undefined>;
+export type DeleteReviewMutationHookResult = ReturnType<typeof useDeleteReviewMutation>;
+export type DeleteReviewMutationResult = Apollo.MutationResult<Types.DeleteReviewMutation>;
+export type DeleteReviewMutationOptions = Apollo.BaseMutationOptions<Types.DeleteReviewMutation, Types.DeleteReviewMutationVariables>;
+export declare const MarkReviewHelpfulDocument: Apollo.DocumentNode;
+export type MarkReviewHelpfulMutationFn = Apollo.MutationFunction<Types.MarkReviewHelpfulMutation, Types.MarkReviewHelpfulMutationVariables>;
+/**
+ * __useMarkReviewHelpfulMutation__
+ *
+ * To run a mutation, you first call `useMarkReviewHelpfulMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMarkReviewHelpfulMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [markReviewHelpfulMutation, { data, loading, error }] = useMarkReviewHelpfulMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useMarkReviewHelpfulMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.MarkReviewHelpfulMutation, Types.MarkReviewHelpfulMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.MarkReviewHelpfulMutation, any, Apollo.ApolloCache, undefined>;
+export type MarkReviewHelpfulMutationHookResult = ReturnType<typeof useMarkReviewHelpfulMutation>;
+export type MarkReviewHelpfulMutationResult = Apollo.MutationResult<Types.MarkReviewHelpfulMutation>;
+export type MarkReviewHelpfulMutationOptions = Apollo.BaseMutationOptions<Types.MarkReviewHelpfulMutation, Types.MarkReviewHelpfulMutationVariables>;
+export declare const UpdateReviewDocument: Apollo.DocumentNode;
+export type UpdateReviewMutationFn = Apollo.MutationFunction<Types.UpdateReviewMutation, Types.UpdateReviewMutationVariables>;
+/**
+ * __useUpdateReviewMutation__
+ *
+ * To run a mutation, you first call `useUpdateReviewMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateReviewMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateReviewMutation, { data, loading, error }] = useUpdateReviewMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateReviewMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateReviewMutation, Types.UpdateReviewMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateReviewMutation, any, Apollo.ApolloCache, undefined>;
+export type UpdateReviewMutationHookResult = ReturnType<typeof useUpdateReviewMutation>;
+export type UpdateReviewMutationResult = Apollo.MutationResult<Types.UpdateReviewMutation>;
+export type UpdateReviewMutationOptions = Apollo.BaseMutationOptions<Types.UpdateReviewMutation, Types.UpdateReviewMutationVariables>;
+export declare const AddToCartDocument: Apollo.DocumentNode;
+export type AddToCartMutationFn = Apollo.MutationFunction<Types.AddToCartMutation, Types.AddToCartMutationVariables>;
+/**
+ * __useAddToCartMutation__
+ *
+ * To run a mutation, you first call `useAddToCartMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddToCartMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addToCartMutation, { data, loading, error }] = useAddToCartMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAddToCartMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AddToCartMutation, Types.AddToCartMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AddToCartMutation, any, Apollo.ApolloCache, undefined>;
+export type AddToCartMutationHookResult = ReturnType<typeof useAddToCartMutation>;
+export type AddToCartMutationResult = Apollo.MutationResult<Types.AddToCartMutation>;
+export type AddToCartMutationOptions = Apollo.BaseMutationOptions<Types.AddToCartMutation, Types.AddToCartMutationVariables>;
+export declare const CheckoutDocument: Apollo.DocumentNode;
+export type CheckoutMutationFn = Apollo.MutationFunction<Types.CheckoutMutation, Types.CheckoutMutationVariables>;
+/**
+ * __useCheckoutMutation__
+ *
+ * To run a mutation, you first call `useCheckoutMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCheckoutMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [checkoutMutation, { data, loading, error }] = useCheckoutMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCheckoutMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CheckoutMutation, Types.CheckoutMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CheckoutMutation, any, Apollo.ApolloCache, undefined>;
+export type CheckoutMutationHookResult = ReturnType<typeof useCheckoutMutation>;
+export type CheckoutMutationResult = Apollo.MutationResult<Types.CheckoutMutation>;
+export type CheckoutMutationOptions = Apollo.BaseMutationOptions<Types.CheckoutMutation, Types.CheckoutMutationVariables>;
+export declare const ClearCartDocument: Apollo.DocumentNode;
+export type ClearCartMutationFn = Apollo.MutationFunction<Types.ClearCartMutation, Types.ClearCartMutationVariables>;
+/**
+ * __useClearCartMutation__
+ *
+ * To run a mutation, you first call `useClearCartMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useClearCartMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [clearCartMutation, { data, loading, error }] = useClearCartMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useClearCartMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ClearCartMutation, Types.ClearCartMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ClearCartMutation, any, Apollo.ApolloCache, undefined>;
+export type ClearCartMutationHookResult = ReturnType<typeof useClearCartMutation>;
+export type ClearCartMutationResult = Apollo.MutationResult<Types.ClearCartMutation>;
+export type ClearCartMutationOptions = Apollo.BaseMutationOptions<Types.ClearCartMutation, Types.ClearCartMutationVariables>;
+export declare const CreateProductForPublisherDocument: Apollo.DocumentNode;
+export type CreateProductForPublisherMutationFn = Apollo.MutationFunction<Types.CreateProductForPublisherMutation, Types.CreateProductForPublisherMutationVariables>;
+/**
+ * __useCreateProductForPublisherMutation__
+ *
+ * To run a mutation, you first call `useCreateProductForPublisherMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateProductForPublisherMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createProductForPublisherMutation, { data, loading, error }] = useCreateProductForPublisherMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateProductForPublisherMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateProductForPublisherMutation, Types.CreateProductForPublisherMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateProductForPublisherMutation, any, Apollo.ApolloCache, undefined>;
+export type CreateProductForPublisherMutationHookResult = ReturnType<typeof useCreateProductForPublisherMutation>;
+export type CreateProductForPublisherMutationResult = Apollo.MutationResult<Types.CreateProductForPublisherMutation>;
+export type CreateProductForPublisherMutationOptions = Apollo.BaseMutationOptions<Types.CreateProductForPublisherMutation, Types.CreateProductForPublisherMutationVariables>;
+export declare const CreateStoreOrderDocument: Apollo.DocumentNode;
+export type CreateStoreOrderMutationFn = Apollo.MutationFunction<Types.CreateStoreOrderMutation, Types.CreateStoreOrderMutationVariables>;
+/**
+ * __useCreateStoreOrderMutation__
+ *
+ * To run a mutation, you first call `useCreateStoreOrderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateStoreOrderMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createStoreOrderMutation, { data, loading, error }] = useCreateStoreOrderMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateStoreOrderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateStoreOrderMutation, Types.CreateStoreOrderMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateStoreOrderMutation, any, Apollo.ApolloCache, undefined>;
+export type CreateStoreOrderMutationHookResult = ReturnType<typeof useCreateStoreOrderMutation>;
+export type CreateStoreOrderMutationResult = Apollo.MutationResult<Types.CreateStoreOrderMutation>;
+export type CreateStoreOrderMutationOptions = Apollo.BaseMutationOptions<Types.CreateStoreOrderMutation, Types.CreateStoreOrderMutationVariables>;
+export declare const RemoveFromCartDocument: Apollo.DocumentNode;
+export type RemoveFromCartMutationFn = Apollo.MutationFunction<Types.RemoveFromCartMutation, Types.RemoveFromCartMutationVariables>;
+/**
+ * __useRemoveFromCartMutation__
+ *
+ * To run a mutation, you first call `useRemoveFromCartMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveFromCartMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [removeFromCartMutation, { data, loading, error }] = useRemoveFromCartMutation({
+ *   variables: {
+ *      cartItemId: // value for 'cartItemId'
+ *   },
+ * });
+ */
+export declare function useRemoveFromCartMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveFromCartMutation, Types.RemoveFromCartMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveFromCartMutation, any, Apollo.ApolloCache, undefined>;
+export type RemoveFromCartMutationHookResult = ReturnType<typeof useRemoveFromCartMutation>;
+export type RemoveFromCartMutationResult = Apollo.MutationResult<Types.RemoveFromCartMutation>;
+export type RemoveFromCartMutationOptions = Apollo.BaseMutationOptions<Types.RemoveFromCartMutation, Types.RemoveFromCartMutationVariables>;
+export declare const RecordAppUninstallationDocument: Apollo.DocumentNode;
+export type RecordAppUninstallationMutationFn = Apollo.MutationFunction<Types.RecordAppUninstallationMutation, Types.RecordAppUninstallationMutationVariables>;
+/**
+ * __useRecordAppUninstallationMutation__
+ *
+ * To run a mutation, you first call `useRecordAppUninstallationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRecordAppUninstallationMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [recordAppUninstallationMutation, { data, loading, error }] = useRecordAppUninstallationMutation({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      productId: // value for 'productId'
+ *   },
+ * });
+ */
+export declare function useRecordAppUninstallationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RecordAppUninstallationMutation, Types.RecordAppUninstallationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RecordAppUninstallationMutation, any, Apollo.ApolloCache, undefined>;
+export type RecordAppUninstallationMutationHookResult = ReturnType<typeof useRecordAppUninstallationMutation>;
+export type RecordAppUninstallationMutationResult = Apollo.MutationResult<Types.RecordAppUninstallationMutation>;
+export type RecordAppUninstallationMutationOptions = Apollo.BaseMutationOptions<Types.RecordAppUninstallationMutation, Types.RecordAppUninstallationMutationVariables>;
+export declare const UpdateCartItemDocument: Apollo.DocumentNode;
+export type UpdateCartItemMutationFn = Apollo.MutationFunction<Types.UpdateCartItemMutation, Types.UpdateCartItemMutationVariables>;
+/**
+ * __useUpdateCartItemMutation__
+ *
+ * To run a mutation, you first call `useUpdateCartItemMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateCartItemMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateCartItemMutation, { data, loading, error }] = useUpdateCartItemMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateCartItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCartItemMutation, Types.UpdateCartItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateCartItemMutation, any, Apollo.ApolloCache, undefined>;
+export type UpdateCartItemMutationHookResult = ReturnType<typeof useUpdateCartItemMutation>;
+export type UpdateCartItemMutationResult = Apollo.MutationResult<Types.UpdateCartItemMutation>;
+export type UpdateCartItemMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCartItemMutation, Types.UpdateCartItemMutationVariables>;
+export declare const CategoriesDocument: Apollo.DocumentNode;
+/**
+ * __useCategoriesQuery__
+ *
+ * To run a query within a React component, call `useCategoriesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCategoriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCategoriesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useCategoriesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.CategoriesQuery, Types.CategoriesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.CategoriesQuery, Types.CategoriesQueryVariables, "empty" | "complete" | "streaming", Types.CategoriesQueryVariables>;
+export declare function useCategoriesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CategoriesQuery, Types.CategoriesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CategoriesQuery, Types.CategoriesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCategoriesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CategoriesQuery, Types.CategoriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CategoriesQuery, Types.CategoriesQueryVariables>;
+export declare function useCategoriesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CategoriesQuery, Types.CategoriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CategoriesQuery | undefined, Types.CategoriesQueryVariables>;
+export type CategoriesQueryHookResult = ReturnType<typeof useCategoriesQuery>;
+export type CategoriesLazyQueryHookResult = ReturnType<typeof useCategoriesLazyQuery>;
+export type CategoriesSuspenseQueryHookResult = ReturnType<typeof useCategoriesSuspenseQuery>;
+export type CategoriesQueryResult = Apollo.QueryResult<Types.CategoriesQuery, Types.CategoriesQueryVariables>;
+export declare const CheckEntitlementDocument: Apollo.DocumentNode;
+/**
+ * __useCheckEntitlementQuery__
+ *
+ * To run a query within a React component, call `useCheckEntitlementQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCheckEntitlementQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCheckEntitlementQuery({
+ *   variables: {
+ *      productId: // value for 'productId'
+ *   },
+ * });
+ */
+export declare function useCheckEntitlementQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.CheckEntitlementQuery, Types.CheckEntitlementQueryVariables> & ({
+    variables: Types.CheckEntitlementQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.CheckEntitlementQuery, Types.CheckEntitlementQueryVariables, "empty" | "complete" | "streaming", Types.CheckEntitlementQueryVariables>;
+export declare function useCheckEntitlementLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CheckEntitlementQuery, Types.CheckEntitlementQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CheckEntitlementQuery, Types.CheckEntitlementQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCheckEntitlementSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CheckEntitlementQuery, Types.CheckEntitlementQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CheckEntitlementQuery, Types.CheckEntitlementQueryVariables>;
+export declare function useCheckEntitlementSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CheckEntitlementQuery, Types.CheckEntitlementQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CheckEntitlementQuery | undefined, Types.CheckEntitlementQueryVariables>;
+export type CheckEntitlementQueryHookResult = ReturnType<typeof useCheckEntitlementQuery>;
+export type CheckEntitlementLazyQueryHookResult = ReturnType<typeof useCheckEntitlementLazyQuery>;
+export type CheckEntitlementSuspenseQueryHookResult = ReturnType<typeof useCheckEntitlementSuspenseQuery>;
+export type CheckEntitlementQueryResult = Apollo.QueryResult<Types.CheckEntitlementQuery, Types.CheckEntitlementQueryVariables>;
+export declare const DeveloperEarningsDocument: Apollo.DocumentNode;
+/**
+ * __useDeveloperEarningsQuery__
+ *
+ * To run a query within a React component, call `useDeveloperEarningsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useDeveloperEarningsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useDeveloperEarningsQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useDeveloperEarningsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.DeveloperEarningsQuery, Types.DeveloperEarningsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.DeveloperEarningsQuery, Types.DeveloperEarningsQueryVariables, "empty" | "complete" | "streaming", Types.DeveloperEarningsQueryVariables>;
+export declare function useDeveloperEarningsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.DeveloperEarningsQuery, Types.DeveloperEarningsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.DeveloperEarningsQuery, Types.DeveloperEarningsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useDeveloperEarningsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.DeveloperEarningsQuery, Types.DeveloperEarningsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DeveloperEarningsQuery, Types.DeveloperEarningsQueryVariables>;
+export declare function useDeveloperEarningsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.DeveloperEarningsQuery, Types.DeveloperEarningsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DeveloperEarningsQuery | undefined, Types.DeveloperEarningsQueryVariables>;
+export type DeveloperEarningsQueryHookResult = ReturnType<typeof useDeveloperEarningsQuery>;
+export type DeveloperEarningsLazyQueryHookResult = ReturnType<typeof useDeveloperEarningsLazyQuery>;
+export type DeveloperEarningsSuspenseQueryHookResult = ReturnType<typeof useDeveloperEarningsSuspenseQuery>;
+export type DeveloperEarningsQueryResult = Apollo.QueryResult<Types.DeveloperEarningsQuery, Types.DeveloperEarningsQueryVariables>;
+export declare const FeaturedProductsDocument: Apollo.DocumentNode;
+/**
+ * __useFeaturedProductsQuery__
+ *
+ * To run a query within a React component, call `useFeaturedProductsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFeaturedProductsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFeaturedProductsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export declare function useFeaturedProductsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.FeaturedProductsQuery, Types.FeaturedProductsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.FeaturedProductsQuery, Types.FeaturedProductsQueryVariables, "empty" | "complete" | "streaming", Types.FeaturedProductsQueryVariables>;
+export declare function useFeaturedProductsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.FeaturedProductsQuery, Types.FeaturedProductsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.FeaturedProductsQuery, Types.FeaturedProductsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useFeaturedProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.FeaturedProductsQuery, Types.FeaturedProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.FeaturedProductsQuery, Types.FeaturedProductsQueryVariables>;
+export declare function useFeaturedProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.FeaturedProductsQuery, Types.FeaturedProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.FeaturedProductsQuery | undefined, Types.FeaturedProductsQueryVariables>;
+export type FeaturedProductsQueryHookResult = ReturnType<typeof useFeaturedProductsQuery>;
+export type FeaturedProductsLazyQueryHookResult = ReturnType<typeof useFeaturedProductsLazyQuery>;
+export type FeaturedProductsSuspenseQueryHookResult = ReturnType<typeof useFeaturedProductsSuspenseQuery>;
+export type FeaturedProductsQueryResult = Apollo.QueryResult<Types.FeaturedProductsQuery, Types.FeaturedProductsQueryVariables>;
+export declare const FilterOptionsDocument: Apollo.DocumentNode;
+/**
+ * __useFilterOptionsQuery__
+ *
+ * To run a query within a React component, call `useFilterOptionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFilterOptionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFilterOptionsQuery({
+ *   variables: {
+ *      type: // value for 'type'
+ *   },
+ * });
+ */
+export declare function useFilterOptionsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.FilterOptionsQuery, Types.FilterOptionsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.FilterOptionsQuery, Types.FilterOptionsQueryVariables, "empty" | "complete" | "streaming", Types.FilterOptionsQueryVariables>;
+export declare function useFilterOptionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.FilterOptionsQuery, Types.FilterOptionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.FilterOptionsQuery, Types.FilterOptionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useFilterOptionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.FilterOptionsQuery, Types.FilterOptionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.FilterOptionsQuery, Types.FilterOptionsQueryVariables>;
+export declare function useFilterOptionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.FilterOptionsQuery, Types.FilterOptionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.FilterOptionsQuery | undefined, Types.FilterOptionsQueryVariables>;
+export type FilterOptionsQueryHookResult = ReturnType<typeof useFilterOptionsQuery>;
+export type FilterOptionsLazyQueryHookResult = ReturnType<typeof useFilterOptionsLazyQuery>;
+export type FilterOptionsSuspenseQueryHookResult = ReturnType<typeof useFilterOptionsSuspenseQuery>;
+export type FilterOptionsQueryResult = Apollo.QueryResult<Types.FilterOptionsQuery, Types.FilterOptionsQueryVariables>;
+export declare const MyEntitlementsDocument: Apollo.DocumentNode;
+/**
+ * __useMyEntitlementsQuery__
+ *
+ * To run a query within a React component, call `useMyEntitlementsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useMyEntitlementsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useMyEntitlementsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useMyEntitlementsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.MyEntitlementsQuery, Types.MyEntitlementsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.MyEntitlementsQuery, Types.MyEntitlementsQueryVariables, "empty" | "complete" | "streaming", Types.MyEntitlementsQueryVariables>;
+export declare function useMyEntitlementsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.MyEntitlementsQuery, Types.MyEntitlementsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.MyEntitlementsQuery, Types.MyEntitlementsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useMyEntitlementsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.MyEntitlementsQuery, Types.MyEntitlementsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.MyEntitlementsQuery, Types.MyEntitlementsQueryVariables>;
+export declare function useMyEntitlementsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.MyEntitlementsQuery, Types.MyEntitlementsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.MyEntitlementsQuery | undefined, Types.MyEntitlementsQueryVariables>;
+export type MyEntitlementsQueryHookResult = ReturnType<typeof useMyEntitlementsQuery>;
+export type MyEntitlementsLazyQueryHookResult = ReturnType<typeof useMyEntitlementsLazyQuery>;
+export type MyEntitlementsSuspenseQueryHookResult = ReturnType<typeof useMyEntitlementsSuspenseQuery>;
+export type MyEntitlementsQueryResult = Apollo.QueryResult<Types.MyEntitlementsQuery, Types.MyEntitlementsQueryVariables>;
+export declare const MyPublishedProductsDocument: Apollo.DocumentNode;
+/**
+ * __useMyPublishedProductsQuery__
+ *
+ * To run a query within a React component, call `useMyPublishedProductsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useMyPublishedProductsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useMyPublishedProductsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useMyPublishedProductsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.MyPublishedProductsQuery, Types.MyPublishedProductsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.MyPublishedProductsQuery, Types.MyPublishedProductsQueryVariables, "empty" | "complete" | "streaming", Types.MyPublishedProductsQueryVariables>;
+export declare function useMyPublishedProductsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.MyPublishedProductsQuery, Types.MyPublishedProductsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.MyPublishedProductsQuery, Types.MyPublishedProductsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useMyPublishedProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.MyPublishedProductsQuery, Types.MyPublishedProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.MyPublishedProductsQuery, Types.MyPublishedProductsQueryVariables>;
+export declare function useMyPublishedProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.MyPublishedProductsQuery, Types.MyPublishedProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.MyPublishedProductsQuery | undefined, Types.MyPublishedProductsQueryVariables>;
+export type MyPublishedProductsQueryHookResult = ReturnType<typeof useMyPublishedProductsQuery>;
+export type MyPublishedProductsLazyQueryHookResult = ReturnType<typeof useMyPublishedProductsLazyQuery>;
+export type MyPublishedProductsSuspenseQueryHookResult = ReturnType<typeof useMyPublishedProductsSuspenseQuery>;
+export type MyPublishedProductsQueryResult = Apollo.QueryResult<Types.MyPublishedProductsQuery, Types.MyPublishedProductsQueryVariables>;
+export declare const ProductReviewsDocument: Apollo.DocumentNode;
+/**
+ * __useProductReviewsQuery__
+ *
+ * To run a query within a React component, call `useProductReviewsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductReviewsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useProductReviewsQuery({
+ *   variables: {
+ *      productId: // value for 'productId'
+ *      status: // value for 'status'
+ *   },
+ * });
+ */
+export declare function useProductReviewsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductReviewsQuery, Types.ProductReviewsQueryVariables> & ({
+    variables: Types.ProductReviewsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductReviewsQuery, Types.ProductReviewsQueryVariables, "empty" | "complete" | "streaming", Types.ProductReviewsQueryVariables>;
+export declare function useProductReviewsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductReviewsQuery, Types.ProductReviewsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductReviewsQuery, Types.ProductReviewsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductReviewsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductReviewsQuery, Types.ProductReviewsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductReviewsQuery, Types.ProductReviewsQueryVariables>;
+export declare function useProductReviewsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductReviewsQuery, Types.ProductReviewsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductReviewsQuery | undefined, Types.ProductReviewsQueryVariables>;
+export type ProductReviewsQueryHookResult = ReturnType<typeof useProductReviewsQuery>;
+export type ProductReviewsLazyQueryHookResult = ReturnType<typeof useProductReviewsLazyQuery>;
+export type ProductReviewsSuspenseQueryHookResult = ReturnType<typeof useProductReviewsSuspenseQuery>;
+export type ProductReviewsQueryResult = Apollo.QueryResult<Types.ProductReviewsQuery, Types.ProductReviewsQueryVariables>;
+export declare const SearchSuggestionsDocument: Apollo.DocumentNode;
+/**
+ * __useSearchSuggestionsQuery__
+ *
+ * To run a query within a React component, call `useSearchSuggestionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSearchSuggestionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useSearchSuggestionsQuery({
+ *   variables: {
+ *      query: // value for 'query'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export declare function useSearchSuggestionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.SearchSuggestionsQuery, Types.SearchSuggestionsQueryVariables> & ({
+    variables: Types.SearchSuggestionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.SearchSuggestionsQuery, Types.SearchSuggestionsQueryVariables, "empty" | "complete" | "streaming", Types.SearchSuggestionsQueryVariables>;
+export declare function useSearchSuggestionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.SearchSuggestionsQuery, Types.SearchSuggestionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.SearchSuggestionsQuery, Types.SearchSuggestionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useSearchSuggestionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchSuggestionsQuery, Types.SearchSuggestionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchSuggestionsQuery, Types.SearchSuggestionsQueryVariables>;
+export declare function useSearchSuggestionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchSuggestionsQuery, Types.SearchSuggestionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchSuggestionsQuery | undefined, Types.SearchSuggestionsQueryVariables>;
+export type SearchSuggestionsQueryHookResult = ReturnType<typeof useSearchSuggestionsQuery>;
+export type SearchSuggestionsLazyQueryHookResult = ReturnType<typeof useSearchSuggestionsLazyQuery>;
+export type SearchSuggestionsSuspenseQueryHookResult = ReturnType<typeof useSearchSuggestionsSuspenseQuery>;
+export type SearchSuggestionsQueryResult = Apollo.QueryResult<Types.SearchSuggestionsQuery, Types.SearchSuggestionsQueryVariables>;
+export declare const TrendingSearchesDocument: Apollo.DocumentNode;
+/**
+ * __useTrendingSearchesQuery__
+ *
+ * To run a query within a React component, call `useTrendingSearchesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTrendingSearchesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTrendingSearchesQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export declare function useTrendingSearchesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.TrendingSearchesQuery, Types.TrendingSearchesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.TrendingSearchesQuery, Types.TrendingSearchesQueryVariables, "empty" | "complete" | "streaming", Types.TrendingSearchesQueryVariables>;
+export declare function useTrendingSearchesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.TrendingSearchesQuery, Types.TrendingSearchesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.TrendingSearchesQuery, Types.TrendingSearchesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useTrendingSearchesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.TrendingSearchesQuery, Types.TrendingSearchesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.TrendingSearchesQuery, Types.TrendingSearchesQueryVariables>;
+export declare function useTrendingSearchesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.TrendingSearchesQuery, Types.TrendingSearchesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.TrendingSearchesQuery | undefined, Types.TrendingSearchesQueryVariables>;
+export type TrendingSearchesQueryHookResult = ReturnType<typeof useTrendingSearchesQuery>;
+export type TrendingSearchesLazyQueryHookResult = ReturnType<typeof useTrendingSearchesLazyQuery>;
+export type TrendingSearchesSuspenseQueryHookResult = ReturnType<typeof useTrendingSearchesSuspenseQuery>;
+export type TrendingSearchesQueryResult = Apollo.QueryResult<Types.TrendingSearchesQuery, Types.TrendingSearchesQueryVariables>;
+export declare const UserReviewForProductDocument: Apollo.DocumentNode;
+/**
+ * __useUserReviewForProductQuery__
+ *
+ * To run a query within a React component, call `useUserReviewForProductQuery` and pass it any options that fit your needs.
+ * When your component renders, `useUserReviewForProductQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useUserReviewForProductQuery({
+ *   variables: {
+ *      productId: // value for 'productId'
+ *   },
+ * });
+ */
+export declare function useUserReviewForProductQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.UserReviewForProductQuery, Types.UserReviewForProductQueryVariables> & ({
+    variables: Types.UserReviewForProductQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.UserReviewForProductQuery, Types.UserReviewForProductQueryVariables, "empty" | "complete" | "streaming", Types.UserReviewForProductQueryVariables>;
+export declare function useUserReviewForProductLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.UserReviewForProductQuery, Types.UserReviewForProductQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.UserReviewForProductQuery, Types.UserReviewForProductQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useUserReviewForProductSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.UserReviewForProductQuery, Types.UserReviewForProductQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.UserReviewForProductQuery, Types.UserReviewForProductQueryVariables>;
+export declare function useUserReviewForProductSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.UserReviewForProductQuery, Types.UserReviewForProductQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.UserReviewForProductQuery | undefined, Types.UserReviewForProductQueryVariables>;
+export type UserReviewForProductQueryHookResult = ReturnType<typeof useUserReviewForProductQuery>;
+export type UserReviewForProductLazyQueryHookResult = ReturnType<typeof useUserReviewForProductLazyQuery>;
+export type UserReviewForProductSuspenseQueryHookResult = ReturnType<typeof useUserReviewForProductSuspenseQuery>;
+export type UserReviewForProductQueryResult = Apollo.QueryResult<Types.UserReviewForProductQuery, Types.UserReviewForProductQueryVariables>;
+export declare const WorkspaceStoreOrdersDocument: Apollo.DocumentNode;
+/**
+ * __useWorkspaceStoreOrdersQuery__
+ *
+ * To run a query within a React component, call `useWorkspaceStoreOrdersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useWorkspaceStoreOrdersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useWorkspaceStoreOrdersQuery({
+ *   variables: {
+ *      billingAccountId: // value for 'billingAccountId'
+ *      page: // value for 'page'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export declare function useWorkspaceStoreOrdersQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.WorkspaceStoreOrdersQuery, Types.WorkspaceStoreOrdersQueryVariables> & ({
+    variables: Types.WorkspaceStoreOrdersQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.WorkspaceStoreOrdersQuery, Types.WorkspaceStoreOrdersQueryVariables, "empty" | "complete" | "streaming", Types.WorkspaceStoreOrdersQueryVariables>;
+export declare function useWorkspaceStoreOrdersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.WorkspaceStoreOrdersQuery, Types.WorkspaceStoreOrdersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.WorkspaceStoreOrdersQuery, Types.WorkspaceStoreOrdersQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useWorkspaceStoreOrdersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkspaceStoreOrdersQuery, Types.WorkspaceStoreOrdersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkspaceStoreOrdersQuery, Types.WorkspaceStoreOrdersQueryVariables>;
+export declare function useWorkspaceStoreOrdersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkspaceStoreOrdersQuery, Types.WorkspaceStoreOrdersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkspaceStoreOrdersQuery | undefined, Types.WorkspaceStoreOrdersQueryVariables>;
+export type WorkspaceStoreOrdersQueryHookResult = ReturnType<typeof useWorkspaceStoreOrdersQuery>;
+export type WorkspaceStoreOrdersLazyQueryHookResult = ReturnType<typeof useWorkspaceStoreOrdersLazyQuery>;
+export type WorkspaceStoreOrdersSuspenseQueryHookResult = ReturnType<typeof useWorkspaceStoreOrdersSuspenseQuery>;
+export type WorkspaceStoreOrdersQueryResult = Apollo.QueryResult<Types.WorkspaceStoreOrdersQuery, Types.WorkspaceStoreOrdersQueryVariables>;
+export declare const BrowseStoreDocument: Apollo.DocumentNode;
+/**
+ * __useBrowseStoreQuery__
+ *
+ * To run a query within a React component, call `useBrowseStoreQuery` and pass it any options that fit your needs.
+ * When your component renders, `useBrowseStoreQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useBrowseStoreQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useBrowseStoreQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.BrowseStoreQuery, Types.BrowseStoreQueryVariables> & ({
+    variables: Types.BrowseStoreQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.BrowseStoreQuery, Types.BrowseStoreQueryVariables, "empty" | "complete" | "streaming", Types.BrowseStoreQueryVariables>;
+export declare function useBrowseStoreLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.BrowseStoreQuery, Types.BrowseStoreQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.BrowseStoreQuery, Types.BrowseStoreQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useBrowseStoreSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.BrowseStoreQuery, Types.BrowseStoreQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BrowseStoreQuery, Types.BrowseStoreQueryVariables>;
+export declare function useBrowseStoreSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.BrowseStoreQuery, Types.BrowseStoreQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BrowseStoreQuery | undefined, Types.BrowseStoreQueryVariables>;
+export type BrowseStoreQueryHookResult = ReturnType<typeof useBrowseStoreQuery>;
+export type BrowseStoreLazyQueryHookResult = ReturnType<typeof useBrowseStoreLazyQuery>;
+export type BrowseStoreSuspenseQueryHookResult = ReturnType<typeof useBrowseStoreSuspenseQuery>;
+export type BrowseStoreQueryResult = Apollo.QueryResult<Types.BrowseStoreQuery, Types.BrowseStoreQueryVariables>;
+export declare const GetCartDocument: Apollo.DocumentNode;
+/**
+ * __useGetCartQuery__
+ *
+ * To run a query within a React component, call `useGetCartQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetCartQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetCartQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetCartQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetCartQuery, Types.GetCartQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetCartQuery, Types.GetCartQueryVariables, "empty" | "complete" | "streaming", Types.GetCartQueryVariables>;
+export declare function useGetCartLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetCartQuery, Types.GetCartQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetCartQuery, Types.GetCartQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetCartSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCartQuery, Types.GetCartQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCartQuery, Types.GetCartQueryVariables>;
+export declare function useGetCartSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCartQuery, Types.GetCartQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCartQuery | undefined, Types.GetCartQueryVariables>;
+export type GetCartQueryHookResult = ReturnType<typeof useGetCartQuery>;
+export type GetCartLazyQueryHookResult = ReturnType<typeof useGetCartLazyQuery>;
+export type GetCartSuspenseQueryHookResult = ReturnType<typeof useGetCartSuspenseQuery>;
+export type GetCartQueryResult = Apollo.QueryResult<Types.GetCartQuery, Types.GetCartQueryVariables>;
+export declare const GetMyStoreInstallationsDocument: Apollo.DocumentNode;
+/**
+ * __useGetMyStoreInstallationsQuery__
+ *
+ * To run a query within a React component, call `useGetMyStoreInstallationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyStoreInstallationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetMyStoreInstallationsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *      filter: // value for 'filter'
+ *   },
+ * });
+ */
+export declare function useGetMyStoreInstallationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyStoreInstallationsQuery, Types.GetMyStoreInstallationsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetMyStoreInstallationsQuery, Types.GetMyStoreInstallationsQueryVariables, "empty" | "complete" | "streaming", Types.GetMyStoreInstallationsQueryVariables>;
+export declare function useGetMyStoreInstallationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyStoreInstallationsQuery, Types.GetMyStoreInstallationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetMyStoreInstallationsQuery, Types.GetMyStoreInstallationsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetMyStoreInstallationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyStoreInstallationsQuery, Types.GetMyStoreInstallationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyStoreInstallationsQuery, Types.GetMyStoreInstallationsQueryVariables>;
+export declare function useGetMyStoreInstallationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyStoreInstallationsQuery, Types.GetMyStoreInstallationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyStoreInstallationsQuery | undefined, Types.GetMyStoreInstallationsQueryVariables>;
+export type GetMyStoreInstallationsQueryHookResult = ReturnType<typeof useGetMyStoreInstallationsQuery>;
+export type GetMyStoreInstallationsLazyQueryHookResult = ReturnType<typeof useGetMyStoreInstallationsLazyQuery>;
+export type GetMyStoreInstallationsSuspenseQueryHookResult = ReturnType<typeof useGetMyStoreInstallationsSuspenseQuery>;
+export type GetMyStoreInstallationsQueryResult = Apollo.QueryResult<Types.GetMyStoreInstallationsQuery, Types.GetMyStoreInstallationsQueryVariables>;
+export declare const GetMyOrdersDocument: Apollo.DocumentNode;
+/**
+ * __useGetMyOrdersQuery__
+ *
+ * To run a query within a React component, call `useGetMyOrdersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyOrdersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetMyOrdersQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *      status: // value for 'status'
+ *   },
+ * });
+ */
+export declare function useGetMyOrdersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyOrdersQuery, Types.GetMyOrdersQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetMyOrdersQuery, Types.GetMyOrdersQueryVariables, "empty" | "complete" | "streaming", Types.GetMyOrdersQueryVariables>;
+export declare function useGetMyOrdersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyOrdersQuery, Types.GetMyOrdersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetMyOrdersQuery, Types.GetMyOrdersQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetMyOrdersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyOrdersQuery, Types.GetMyOrdersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyOrdersQuery, Types.GetMyOrdersQueryVariables>;
+export declare function useGetMyOrdersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyOrdersQuery, Types.GetMyOrdersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyOrdersQuery | undefined, Types.GetMyOrdersQueryVariables>;
+export type GetMyOrdersQueryHookResult = ReturnType<typeof useGetMyOrdersQuery>;
+export type GetMyOrdersLazyQueryHookResult = ReturnType<typeof useGetMyOrdersLazyQuery>;
+export type GetMyOrdersSuspenseQueryHookResult = ReturnType<typeof useGetMyOrdersSuspenseQuery>;
+export type GetMyOrdersQueryResult = Apollo.QueryResult<Types.GetMyOrdersQuery, Types.GetMyOrdersQueryVariables>;
+export declare const GetProductDocument: Apollo.DocumentNode;
+/**
+ * __useGetProductQuery__
+ *
+ * To run a query within a React component, call `useGetProductQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetProductQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetProductQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetProductQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables> & ({
+    variables: Types.GetProductQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetProductQuery, Types.GetProductQueryVariables, "empty" | "complete" | "streaming", Types.GetProductQueryVariables>;
+export declare function useGetProductLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProductQuery, Types.GetProductQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetProductSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProductQuery, Types.GetProductQueryVariables>;
+export declare function useGetProductSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProductQuery | undefined, Types.GetProductQueryVariables>;
+export type GetProductQueryHookResult = ReturnType<typeof useGetProductQuery>;
+export type GetProductLazyQueryHookResult = ReturnType<typeof useGetProductLazyQuery>;
+export type GetProductSuspenseQueryHookResult = ReturnType<typeof useGetProductSuspenseQuery>;
+export type GetProductQueryResult = Apollo.QueryResult<Types.GetProductQuery, Types.GetProductQueryVariables>;
+export declare const GetProductsDocument: Apollo.DocumentNode;
+/**
+ * __useGetProductsQuery__
+ *
+ * To run a query within a React component, call `useGetProductsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetProductsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetProductsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetProductsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetProductsQuery, Types.GetProductsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetProductsQuery, Types.GetProductsQueryVariables, "empty" | "complete" | "streaming", Types.GetProductsQueryVariables>;
+export declare function useGetProductsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProductsQuery, Types.GetProductsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProductsQuery, Types.GetProductsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductsQuery, Types.GetProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProductsQuery, Types.GetProductsQueryVariables>;
+export declare function useGetProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductsQuery, Types.GetProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProductsQuery | undefined, Types.GetProductsQueryVariables>;
+export type GetProductsQueryHookResult = ReturnType<typeof useGetProductsQuery>;
+export type GetProductsLazyQueryHookResult = ReturnType<typeof useGetProductsLazyQuery>;
+export type GetProductsSuspenseQueryHookResult = ReturnType<typeof useGetProductsSuspenseQuery>;
+export type GetProductsQueryResult = Apollo.QueryResult<Types.GetProductsQuery, Types.GetProductsQueryVariables>;
+export declare const GetStoreAppInstallationDocument: Apollo.DocumentNode;
+/**
+ * __useGetStoreAppInstallationQuery__
+ *
+ * To run a query within a React component, call `useGetStoreAppInstallationQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetStoreAppInstallationQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetStoreAppInstallationQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetStoreAppInstallationQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetStoreAppInstallationQuery, Types.GetStoreAppInstallationQueryVariables> & ({
+    variables: Types.GetStoreAppInstallationQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetStoreAppInstallationQuery, Types.GetStoreAppInstallationQueryVariables, "empty" | "complete" | "streaming", Types.GetStoreAppInstallationQueryVariables>;
+export declare function useGetStoreAppInstallationLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetStoreAppInstallationQuery, Types.GetStoreAppInstallationQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetStoreAppInstallationQuery, Types.GetStoreAppInstallationQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetStoreAppInstallationSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetStoreAppInstallationQuery, Types.GetStoreAppInstallationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetStoreAppInstallationQuery, Types.GetStoreAppInstallationQueryVariables>;
+export declare function useGetStoreAppInstallationSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetStoreAppInstallationQuery, Types.GetStoreAppInstallationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetStoreAppInstallationQuery | undefined, Types.GetStoreAppInstallationQueryVariables>;
+export type GetStoreAppInstallationQueryHookResult = ReturnType<typeof useGetStoreAppInstallationQuery>;
+export type GetStoreAppInstallationLazyQueryHookResult = ReturnType<typeof useGetStoreAppInstallationLazyQuery>;
+export type GetStoreAppInstallationSuspenseQueryHookResult = ReturnType<typeof useGetStoreAppInstallationSuspenseQuery>;
+export type GetStoreAppInstallationQueryResult = Apollo.QueryResult<Types.GetStoreAppInstallationQuery, Types.GetStoreAppInstallationQueryVariables>;
+export declare const HomeGroupedProductsDocument: Apollo.DocumentNode;
+/**
+ * __useHomeGroupedProductsQuery__
+ *
+ * To run a query within a React component, call `useHomeGroupedProductsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useHomeGroupedProductsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useHomeGroupedProductsQuery({
+ *   variables: {
+ *      compatibleWith: // value for 'compatibleWith'
+ *   },
+ * });
+ */
+export declare function useHomeGroupedProductsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.HomeGroupedProductsQuery, Types.HomeGroupedProductsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.HomeGroupedProductsQuery, Types.HomeGroupedProductsQueryVariables, "empty" | "complete" | "streaming", Types.HomeGroupedProductsQueryVariables>;
+export declare function useHomeGroupedProductsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.HomeGroupedProductsQuery, Types.HomeGroupedProductsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.HomeGroupedProductsQuery, Types.HomeGroupedProductsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useHomeGroupedProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.HomeGroupedProductsQuery, Types.HomeGroupedProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.HomeGroupedProductsQuery, Types.HomeGroupedProductsQueryVariables>;
+export declare function useHomeGroupedProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.HomeGroupedProductsQuery, Types.HomeGroupedProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.HomeGroupedProductsQuery | undefined, Types.HomeGroupedProductsQueryVariables>;
+export type HomeGroupedProductsQueryHookResult = ReturnType<typeof useHomeGroupedProductsQuery>;
+export type HomeGroupedProductsLazyQueryHookResult = ReturnType<typeof useHomeGroupedProductsLazyQuery>;
+export type HomeGroupedProductsSuspenseQueryHookResult = ReturnType<typeof useHomeGroupedProductsSuspenseQuery>;
+export type HomeGroupedProductsQueryResult = Apollo.QueryResult<Types.HomeGroupedProductsQuery, Types.HomeGroupedProductsQueryVariables>;
+export declare const StoreProductDetailsDocument: Apollo.DocumentNode;
+/**
+ * __useStoreProductDetailsQuery__
+ *
+ * To run a query within a React component, call `useStoreProductDetailsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useStoreProductDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useStoreProductDetailsQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useStoreProductDetailsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.StoreProductDetailsQuery, Types.StoreProductDetailsQueryVariables> & ({
+    variables: Types.StoreProductDetailsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.StoreProductDetailsQuery, Types.StoreProductDetailsQueryVariables, "empty" | "complete" | "streaming", Types.StoreProductDetailsQueryVariables>;
+export declare function useStoreProductDetailsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.StoreProductDetailsQuery, Types.StoreProductDetailsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.StoreProductDetailsQuery, Types.StoreProductDetailsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useStoreProductDetailsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.StoreProductDetailsQuery, Types.StoreProductDetailsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.StoreProductDetailsQuery, Types.StoreProductDetailsQueryVariables>;
+export declare function useStoreProductDetailsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.StoreProductDetailsQuery, Types.StoreProductDetailsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.StoreProductDetailsQuery | undefined, Types.StoreProductDetailsQueryVariables>;
+export type StoreProductDetailsQueryHookResult = ReturnType<typeof useStoreProductDetailsQuery>;
+export type StoreProductDetailsLazyQueryHookResult = ReturnType<typeof useStoreProductDetailsLazyQuery>;
+export type StoreProductDetailsSuspenseQueryHookResult = ReturnType<typeof useStoreProductDetailsSuspenseQuery>;
+export type StoreProductDetailsQueryResult = Apollo.QueryResult<Types.StoreProductDetailsQuery, Types.StoreProductDetailsQueryVariables>;
+export declare const InstallationStatusUpdatedDocument: Apollo.DocumentNode;
+/**
+ * __useInstallationStatusUpdatedSubscription__
+ *
+ * To run a query within a React component, call `useInstallationStatusUpdatedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useInstallationStatusUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useInstallationStatusUpdatedSubscription({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *   },
+ * });
+ */
+export declare function useInstallationStatusUpdatedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.InstallationStatusUpdatedSubscription, Types.InstallationStatusUpdatedSubscriptionVariables> & ({
+    variables: Types.InstallationStatusUpdatedSubscriptionVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useSubscription.Result<Types.InstallationStatusUpdatedSubscription>;
+export type InstallationStatusUpdatedSubscriptionHookResult = ReturnType<typeof useInstallationStatusUpdatedSubscription>;
+export type InstallationStatusUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.InstallationStatusUpdatedSubscription>;
+export declare const LicenseStatusUpdatedDocument: Apollo.DocumentNode;
+/**
+ * __useLicenseStatusUpdatedSubscription__
+ *
+ * To run a query within a React component, call `useLicenseStatusUpdatedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useLicenseStatusUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useLicenseStatusUpdatedSubscription({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *   },
+ * });
+ */
+export declare function useLicenseStatusUpdatedSubscription(baseOptions?: ApolloReactHooks.SubscriptionHookOptions<Types.LicenseStatusUpdatedSubscription, Types.LicenseStatusUpdatedSubscriptionVariables>): ApolloReactHooks.useSubscription.Result<Types.LicenseStatusUpdatedSubscription>;
+export type LicenseStatusUpdatedSubscriptionHookResult = ReturnType<typeof useLicenseStatusUpdatedSubscription>;
+export type LicenseStatusUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.LicenseStatusUpdatedSubscription>;
+export declare const OrderStatusUpdatedDocument: Apollo.DocumentNode;
+/**
+ * __useOrderStatusUpdatedSubscription__
+ *
+ * To run a query within a React component, call `useOrderStatusUpdatedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useOrderStatusUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useOrderStatusUpdatedSubscription({
+ *   variables: {
+ *      orderId: // value for 'orderId'
+ *      workspaceId: // value for 'workspaceId'
+ *   },
+ * });
+ */
+export declare function useOrderStatusUpdatedSubscription(baseOptions?: ApolloReactHooks.SubscriptionHookOptions<Types.OrderStatusUpdatedSubscription, Types.OrderStatusUpdatedSubscriptionVariables>): ApolloReactHooks.useSubscription.Result<Types.OrderStatusUpdatedSubscription>;
+export type OrderStatusUpdatedSubscriptionHookResult = ReturnType<typeof useOrderStatusUpdatedSubscription>;
+export type OrderStatusUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.OrderStatusUpdatedSubscription>;
+export declare const SubmissionStatusUpdatedDocument: Apollo.DocumentNode;
+/**
+ * __useSubmissionStatusUpdatedSubscription__
+ *
+ * To run a query within a React component, call `useSubmissionStatusUpdatedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useSubmissionStatusUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useSubmissionStatusUpdatedSubscription({
+ *   variables: {
+ *      publisherId: // value for 'publisherId'
+ *   },
+ * });
+ */
+export declare function useSubmissionStatusUpdatedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.SubmissionStatusUpdatedSubscription, Types.SubmissionStatusUpdatedSubscriptionVariables> & ({
+    variables: Types.SubmissionStatusUpdatedSubscriptionVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useSubscription.Result<Types.SubmissionStatusUpdatedSubscription>;
+export type SubmissionStatusUpdatedSubscriptionHookResult = ReturnType<typeof useSubmissionStatusUpdatedSubscription>;
+export type SubmissionStatusUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.SubmissionStatusUpdatedSubscription>;