@doswiftly/storefront-sdk 13.1.0 → 15.1.0

package/dist/core/generated/operation-types.d.ts

@@ -0,0 +1,4428 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = T | null | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    /** A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format. */
+    DateTime: {
+        input: string;
+        output: string;
+    };
+    /** Decimal money amount, JSON-serialized as String. Format: "{int}.{dec}" e.g. "10.50". */
+    Decimal: {
+        input: string;
+        output: string;
+    };
+    /** Opaque JSON payload — shape documented per field. Klient parsuje strukturę sam. */
+    JSON: {
+        input: unknown;
+        output: unknown;
+    };
+    /** URL string per RFC 3986 (e.g. "https://shop.example.com/products/foo"). */
+    URL: {
+        input: string;
+        output: string;
+    };
+    /** Unsigned 64-bit integer, JSON-serialized as String (BigInt-safe). Format: "{integer}". */
+    UnsignedInt64: {
+        input: string;
+        output: string;
+    };
+};
+export type Attribute = {
+    /** Attribute key. */
+    key: Scalars['String']['output'];
+    /** Attribute value. Null when the key is set without an associated value. */
+    value?: Maybe<Scalars['String']['output']>;
+};
+export type AttributeBillingMode = 'BUNDLED' | 'SEPARATE_LINE';
+export type AttributeDefinition = {
+    /** Display order */
+    displayOrder: Scalars['Int']['output'];
+    /** Available filter values (for SELECT, CHECKBOX, RADIO, COLOR, BOOLEAN) */
+    filterValues?: Maybe<Array<AttributeFilterValue>>;
+    /** URL-friendly identifier */
+    handle: Scalars['String']['output'];
+    /** Attribute ID */
+    id: Scalars['ID']['output'];
+    /** Whether attribute is filterable (admin toggle). For storefront UI rendering signal use `isUsableAsFilter` (computed). */
+    isFilterable: Scalars['Boolean']['output'];
+    /** Whether attribute is visible on product pages */
+    isVisible: Scalars['Boolean']['output'];
+    /** Attribute name (e.g., "Color", "Size") */
+    name: Scalars['String']['output'];
+    /** Faza 3 Opcja A (2026-05-17): opcjonalne grupowanie atrybutu (np. "inventory", "marketing", "content"). NULL = atrybut bez grupy. Pomaga storefront-devom rozpoznać "te atrybuty są custom dane ERP" vs "te są filtrowalne cechy katalogu". */
+    namespace?: Maybe<Scalars['String']['output']>;
+    /** Range bounds (for NUMBER, CURRENCY) */
+    rangeBounds?: Maybe<AttributeRangeBounds>;
+    /** Attribute data type */
+    type: AttributeType;
+};
+export type AttributeFillingMode = 'BOTH' | 'CUSTOMER' | 'MERCHANT';
+export type AttributeFilterValue = {
+    /** Option ID or value identifier */
+    id: Scalars['ID']['output'];
+    /** Display label (e.g., "Red", "Extra Large") */
+    label: Scalars['String']['output'];
+    /** Price modifier for this option */
+    priceModifier?: Maybe<Money>;
+    /** Number of products with this value */
+    productCount: Scalars['Int']['output'];
+    /** Sort order for display */
+    sortOrder: Scalars['Int']['output'];
+    /** Visual swatch for COLOR type */
+    swatch?: Maybe<AttributeSwatch>;
+    /** Internal value (e.g., "red", "xl") */
+    value: Scalars['String']['output'];
+};
+export type AttributeFilterValueConnection = {
+    /** Paginated edges z cursorami */
+    edges: Array<AttributeFilterValueEdge>;
+    /** Shortcut: edges.map(e => e.node) */
+    nodes: Array<AttributeFilterValue>;
+    /** Relay pagination info (hasNextPage, hasPreviousPage, cursors) */
+    pageInfo: PageInfo;
+    /** Total number of attribute options matching the filter (po zastosowaniu search + context). NIE zmienia się przy paginacji — pokazuje pełną liczbę dla counter UI. */
+    totalCount: Scalars['Int']['output'];
+};
+export type AttributeFilterValueEdge = {
+    /** Opaque pagination cursor (base64-encoded). Echo as `after` for next page. */
+    cursor: Scalars['String']['output'];
+    /** Attribute filter value (option + product count + swatch) */
+    node: AttributeFilterValue;
+};
+export type AttributeInput = {
+    /** Attribute key */
+    key: Scalars['String']['input'];
+    /** Attribute value */
+    value?: InputMaybe<Scalars['String']['input']>;
+};
+export type AttributeOptionSurchargeType = 'FIXED' | 'PERCENT';
+export type AttributeRangeBounds = {
+    /** Currency code for CURRENCY type */
+    currencyCode?: Maybe<Scalars['String']['output']>;
+    /** Maximum value in current product set */
+    max?: Maybe<Scalars['Float']['output']>;
+    /** Minimum value in current product set */
+    min?: Maybe<Scalars['Float']['output']>;
+};
+export type AttributeSelection = {
+    /** ID of the attribute definition this selection refers to. */
+    attributeDefinitionId: Scalars['ID']['output'];
+    /** Display name of the attribute at the moment it was added to the cart. */
+    attributeName: Scalars['String']['output'];
+    /** How the surcharge is charged: BUNDLED (folded into the line unit price) or SEPARATE_LINE (its own line on the order). Null when the selection is informational and has no surcharge. */
+    billingMode?: Maybe<AttributeBillingMode>;
+    /** Who supplies the value: MERCHANT (set on the product), CUSTOMER (filled at add-to-cart) or BOTH. */
+    fillingMode: AttributeFillingMode;
+    /** Linked variant whose stock is decremented when this option is chosen — used by the hidden-product configurator pattern (e.g. finish, accessory). Null when no component stock is tied to the selection. */
+    linkedVariantId?: Maybe<Scalars['ID']['output']>;
+    /** Selected option ID for single-choice types (SELECT, RADIO, single-CHECKBOX). */
+    optionId?: Maybe<Scalars['ID']['output']>;
+    /** Selected option IDs for multi-choice types (MULTI_SELECT, CHECKBOX list). */
+    optionIds?: Maybe<Array<Scalars['ID']['output']>>;
+    /** Display label of the selected option at the moment of selection. */
+    optionLabel?: Maybe<Scalars['String']['output']>;
+    /** Surcharge attached to this selection in minor units of the shop currency when `surchargeType` is FIXED; thousandths of a percent (per mille of a percent) when PERCENT. Already reflected in the line cost. */
+    surchargeAmount: Scalars['Int']['output'];
+    /** How the surcharge is calculated — FIXED (absolute amount) or PERCENT. Null when the selection has no surcharge. */
+    surchargeType?: Maybe<AttributeOptionSurchargeType>;
+    /** Tax class applied to this selection. Null means the line inherits its tax class from the variant. */
+    taxClassId?: Maybe<Scalars['ID']['output']>;
+    /** Free-text value for TEXT, TEXTAREA, NUMBER or DATE attribute types. */
+    textValue?: Maybe<Scalars['String']['output']>;
+    /** Attribute data type (TEXT, SELECT, RADIO, CHECKBOX, NUMBER, DATE, COLOR, etc.). Drives which value field is populated. */
+    type: AttributeType;
+};
+export type AttributeSelectionInput = {
+    /** ID of the attribute definition this selection refers to. */
+    attributeDefinitionId: Scalars['ID']['input'];
+    /** Selected option ID for single-choice attribute types (SELECT, RADIO, single-CHECKBOX). */
+    optionId?: InputMaybe<Scalars['ID']['input']>;
+    /** Selected option IDs for multi-choice attribute types (MULTI_SELECT, CHECKBOX list). */
+    optionIds?: InputMaybe<Array<Scalars['ID']['input']>>;
+    /** Free-text value for TEXT, TEXTAREA, NUMBER or DATE attribute types (max 2000 chars). */
+    textValue?: InputMaybe<Scalars['String']['input']>;
+};
+export type AttributeSwatch = {
+    /** Hex color code (e.g., #FF5733) */
+    colorHex?: Maybe<Scalars['String']['output']>;
+    /** Image URL for pattern swatches */
+    imageUrl?: Maybe<Scalars['String']['output']>;
+};
+export type AttributeType = 'BOOLEAN' | 'CHECKBOX' | 'COLOR' | 'CURRENCY' | 'DATE' | 'FILE' | 'IMAGE' | 'NUMBER' | 'RADIO' | 'SELECT' | 'TEXT' | 'TEXTAREA';
+export type AvailableFilters = {
+    /** Liczba currently applied filters w `currentFilters` (Storefront UI renderuje "Filtry (3)" w sidebar header). */
+    activeCount: Scalars['Int']['output'];
+    /** Filterable attributes with values */
+    attributes: Array<AttributeDefinition>;
+    /** Boolean facet count: liczba produktów w current context spełniających `Product.isAvailable` (przynajmniej jeden aktywny wariant z untracked inventory LUB available>0). Exclude-self: jeśli `available: true` jest w `currentFilters`, count IGNORUJE ten filtr i pokazuje "ile produktów dostępnych w bazowym kontekście" (nie "ile teraz widać"). Spójne semantically z `attributes[].filterValues[].productCount` (per-enum-value facet) i `brands[].productCount` (per-brand facet) — wszystkie używają exclude-self per dimension. Untracked inventory (gift cards, digital, na-zamówienie) zawsze liczy się jako available. */
+    availableCount: Scalars['Int']['output'];
+    /** Faza 3 (2026-05-17): canonical Brand entities z product counts w current context. Storefront UI renderuje checkbox list / dropdown z logo per brand. Klik → `filters: [{brand: {handle}}]`. Tylko brandy z >0 produktów w current product set + isActive=true. */
+    brands?: Maybe<Array<BrandFilterValue>>;
+    /** Categories available for filtering */
+    categories?: Maybe<Array<CategoryFilterOption>>;
+    /** Price range for filtering */
+    priceRange?: Maybe<PriceRange>;
+    /** Total products w current context (categoryId/collectionId/searchQuery) PRZED zaaplikowaniem faceted filters z `currentFilters`. Spójne z `ProductConnection.totalCount` Relay Connection spec — gdy `currentFilters` jest pusty, `AvailableFilters.totalCount` === `products(filters).totalCount`. Użyj do "Wszystkie produkty (N)" w sidebar header. */
+    totalCount: Scalars['Int']['output'];
+};
+export type AvailablePaymentMethods = {
+    /** Method marked as the merchant default — pre-select in the picker. Null when no default is configured. */
+    defaultMethod?: Maybe<PaymentMethod>;
+    /** Payment methods active for the shop, sorted by `position`. */
+    methods: Array<PaymentMethod>;
+};
+export type AvailableShippingMethod = {
+    /** Carrier behind the method. Null when the merchant configured a custom non-carrier method. */
+    carrier?: Maybe<ShippingCarrier>;
+    /** Destination type — HOME (courier to the street address), PICKUP_POINT (staffed counter) or LOCKER (parcel locker). Drives whether the storefront must render a pickup-point picker for the method instead of inferring it from the method name. */
+    deliveryType: DeliveryType;
+    /** Optional method description shown under the name (e.g. "Saturday delivery available"). */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Estimated delivery window. Null when the merchant has not configured an estimate for this method. */
+    estimatedDelivery?: Maybe<DeliveryEstimate>;
+    /** Progress towards the free-shipping threshold for this method, when one is configured. Null otherwise. */
+    freeShippingProgress?: Maybe<FreeShippingProgress>;
+    /** Stable ID of the shipping method. Pass to `cartSelectShippingMethod` to select it. */
+    id: Scalars['ID']['output'];
+    /** True when the price is zero — the method is free for this cart (e.g. free-shipping threshold met). */
+    isFree: Scalars['Boolean']['output'];
+    /** Display name of the method (e.g. "DPD Standard"). */
+    name: Scalars['String']['output'];
+    /** Cost of the method for the current cart (in the buyer preferred currency). */
+    price: Money;
+    /** Merchant-configured display position — lower values come first in the picker. */
+    sortOrder: Scalars['Int']['output'];
+};
+export type AvailableShippingMethodsPayload = {
+    /** Best free-shipping progress across all returned methods. Use to render a single banner above the picker. */
+    freeShippingProgress?: Maybe<FreeShippingProgress>;
+    /** Methods available for the current cart and destination, sorted by `sortOrder`. */
+    methods: Array<AvailableShippingMethod>;
+    /** Validation / availability errors — e.g. `DIGITAL_ONLY_NO_SHIPPING` when the cart contains only non-physical items. Branch on `code`. */
+    userErrors: Array<UserError>;
+};
+export type AvailableShippingRatesPayload = {
+    /** Providers that failed to return rates */
+    errors: Array<CarrierRateError>;
+    /** Whether the result was served from cache */
+    isCached: Scalars['Boolean']['output'];
+    /** Available rates sorted by price */
+    rates: Array<CarrierShippingRate>;
+};
+export type B2BPriceDisplay = {
+    /** Message for guests (e.g., "Log in for wholesale pricing") */
+    guestMessage?: Maybe<Scalars['String']['output']>;
+    /** Whether user is logged in */
+    isAuthenticated: Scalars['Boolean']['output'];
+    /** Primary pricing information */
+    pricing: B2BVariantPricing;
+    /** Volume discount tiers */
+    volumeTiers?: Maybe<Array<PricingTier>>;
+};
+export type B2BVariantPricing = {
+    /** Applied customer group */
+    appliedGroup?: Maybe<CustomerGroup>;
+    /** Whether this is a group-discounted price */
+    hasGroupDiscount: Scalars['Boolean']['output'];
+    /** Regular retail price */
+    retailPrice: Money;
+    /** Amount saved */
+    savings: Money;
+    /** Savings percentage (0-100) */
+    savingsPercent: Scalars['Float']['output'];
+    /** Pricing tier name */
+    tierName?: Maybe<Scalars['String']['output']>;
+    /** Your group price (best available) */
+    yourPrice: Money;
+};
+export type BlogAuthor = {
+    /** Author avatar */
+    avatar?: Maybe<Image>;
+    /** Author bio */
+    bio?: Maybe<Scalars['String']['output']>;
+    /** Author ID */
+    id: Scalars['ID']['output'];
+    /** Author name */
+    name: Scalars['String']['output'];
+};
+export type BlogCategory = {
+    /** Category description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** URL-friendly handle */
+    handle: Scalars['String']['output'];
+    /** Category ID */
+    id: Scalars['ID']['output'];
+    /** Category image */
+    image?: Maybe<Image>;
+    /** Category name */
+    name: Scalars['String']['output'];
+    /** Number of posts in category */
+    postCount: Scalars['Int']['output'];
+    /** SEO metadata */
+    seo?: Maybe<Seo>;
+};
+export type BlogPost = {
+    /** Whether comments are allowed */
+    allowComments: Scalars['Boolean']['output'];
+    /** Post author */
+    author: BlogAuthor;
+    /** Post category */
+    category?: Maybe<BlogCategory>;
+    /** Comment count */
+    commentCount: Scalars['Int']['output'];
+    /** Full content (HTML) */
+    content: Scalars['String']['output'];
+    /** Format of stored content (HTML or MARKDOWN) */
+    contentFormat: ContentFormat;
+    /** Created date (ISO 8601) */
+    createdAt: Scalars['DateTime']['output'];
+    /** Short excerpt/summary */
+    excerpt?: Maybe<Scalars['String']['output']>;
+    /** Featured image */
+    featuredImage?: Maybe<Image>;
+    /** URL-friendly handle */
+    handle: Scalars['String']['output'];
+    /** Post ID */
+    id: Scalars['ID']['output'];
+    /** Whether post is featured */
+    isFeatured: Scalars['Boolean']['output'];
+    /** Published date (ISO 8601) */
+    publishedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Estimated reading time in minutes */
+    readingTimeMinutes: Scalars['Int']['output'];
+    /** SEO metadata */
+    seo?: Maybe<Seo>;
+    /** Post status */
+    status: BlogPostStatus;
+    /** Post tags */
+    tags: Array<BlogTag>;
+    /** Post title */
+    title: Scalars['String']['output'];
+    /** Updated date (ISO 8601) */
+    updatedAt: Scalars['DateTime']['output'];
+    /** View count */
+    viewCount: Scalars['Int']['output'];
+};
+export type BlogPostConnection = {
+    /** Post edges */
+    edges: Array<BlogPostEdge>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of posts */
+    totalCount: Scalars['Int']['output'];
+};
+export type BlogPostEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Blog post node */
+    node: BlogPost;
+};
+export type BlogPostStatus = 'ARCHIVED' | 'DRAFT' | 'PUBLISHED' | 'SCHEDULED';
+export type BlogTag = {
+    /** URL-friendly handle */
+    handle: Scalars['String']['output'];
+    /** Tag ID */
+    id: Scalars['ID']['output'];
+    /** Tag name */
+    name: Scalars['String']['output'];
+    /** Number of posts with this tag */
+    postCount: Scalars['Int']['output'];
+};
+export type BotProtectionInfo = {
+    /** Fallback provider */
+    fallback?: Maybe<BotProtectionProviderInfo>;
+    /** Primary provider */
+    primary: BotProtectionProviderInfo;
+    /** GraphQL operation names requiring verification */
+    protectedOperations: Array<Scalars['String']['output']>;
+};
+export type BotProtectionProviderInfo = {
+    /** Provider identifier: eucaptcha | turnstile | recaptcha */
+    provider: Scalars['String']['output'];
+    /** Script URL (configurable, region/enterprise overrides) */
+    scriptUrl: Scalars['String']['output'];
+    /** Site key for the bot protection widget */
+    siteKey: Scalars['String']['output'];
+};
+export type Brand = {
+    /** URL-friendly handle (e.g. "funko" → /brands/funko). Stable per-shop. */
+    handle: Scalars['String']['output'];
+    /** Brand unique identifier */
+    id: Scalars['ID']['output'];
+    /** Brand logo URL (CDN-served, storefront-rendered) */
+    logo?: Maybe<Scalars['String']['output']>;
+    /** Brand display name (e.g. "Funko", "Nintendo") */
+    name: Scalars['String']['output'];
+};
+export type BrandColorGroup = {
+    /** Background color (hex, e.g. "#0F172A") */
+    background?: Maybe<Scalars['String']['output']>;
+    /** Foreground/text color (hex) */
+    foreground?: Maybe<Scalars['String']['output']>;
+};
+export type BrandColors = {
+    primary?: Maybe<BrandColorGroup>;
+    secondary?: Maybe<BrandColorGroup>;
+};
+export type BrandFilterValue = {
+    /** Brand handle (refetch payload — paste w ProductFilter.brand.handle) */
+    handle: Scalars['String']['output'];
+    /** Brand ID */
+    id: Scalars['ID']['output'];
+    /** Brand logo URL (UI rendering) */
+    logo?: Maybe<Scalars['String']['output']>;
+    /** Brand name */
+    name: Scalars['String']['output'];
+    /** Liczba produktów z tym brandem w current product set */
+    productCount: Scalars['Int']['output'];
+};
+export type BusinessHour = {
+    /** Closing time (HH:MM format) */
+    closeTime?: Maybe<Scalars['String']['output']>;
+    /** Day of week (monday, tuesday, etc.) */
+    day: Scalars['String']['output'];
+    /** Whether the shop is closed this day */
+    isClosed: Scalars['Boolean']['output'];
+    /** Opening time (HH:MM format) */
+    openTime?: Maybe<Scalars['String']['output']>;
+};
+export type BusinessHours = {
+    /** Friday opening windows */
+    friday: Array<BusinessHoursWindow>;
+    /** Monday opening windows */
+    monday: Array<BusinessHoursWindow>;
+    /** Saturday opening windows */
+    saturday: Array<BusinessHoursWindow>;
+    /** Sunday opening windows */
+    sunday: Array<BusinessHoursWindow>;
+    /** Thursday opening windows */
+    thursday: Array<BusinessHoursWindow>;
+    /** Tuesday opening windows */
+    tuesday: Array<BusinessHoursWindow>;
+    /** Wednesday opening windows */
+    wednesday: Array<BusinessHoursWindow>;
+};
+export type BusinessHoursWindow = {
+    /** Closing hour (0-24, 24h format). 24 = midnight close. */
+    closeHour: Scalars['Int']['output'];
+    /** Opening hour (0-23, 24h format) */
+    openHour: Scalars['Int']['output'];
+};
+export type CarrierRateError = {
+    /** Error message */
+    message: Scalars['String']['output'];
+    /** Provider code */
+    provider: Scalars['String']['output'];
+};
+export type CarrierShippingRate = {
+    /** Estimated delivery in business days */
+    estimatedDeliveryDays: Scalars['Int']['output'];
+    /** Whether cash on delivery is available */
+    isCashOnDeliveryAvailable: Scalars['Boolean']['output'];
+    /** Whether pickup is available for this service */
+    isPickupAvailable: Scalars['Boolean']['output'];
+    /** Rate price */
+    price: Money;
+    /** Provider ID (e.g., furgonetka, inpost) */
+    providerId: Scalars['String']['output'];
+    /** Service ID (provider-specific) */
+    serviceId: Scalars['String']['output'];
+    /** Service display name */
+    serviceName: Scalars['String']['output'];
+};
+export type Cart = Node & {
+    /** Gift cards attached to the cart. Each card is debited by its `appliedAmount` when the cart completes. */
+    appliedGiftCards: Array<CartAppliedGiftCard>;
+    /** Cart-level custom attributes (free-form key/value). Use for cart-wide metadata such as B2B PO number or marketing source. Replace (not merge) the list with `cartUpdateAttributes`. */
+    attributes: Array<CartAttribute>;
+    /** Available payment methods dla tego cart (shop-configured providers) */
+    availablePaymentMethods: Array<PaymentMethod>;
+    /** Shipping methods available for this cart at the given destination. Reads the cart subtotal and weight directly — for pre-cart preview (e.g. a product detail page calculator) use the top-level `availableShippingMethods(address, cart)` query instead. Returns an empty `methods` list plus a `DIGITAL_ONLY_NO_SHIPPING` user error when the cart has no shippable items; the storefront can use this to skip the shipping step entirely. */
+    availableShippingMethods: AvailableShippingMethodsPayload;
+    /** Billing address attached to the cart via `cartSetBillingAddress`. Null when the buyer reuses the shipping address as billing (the order will then mirror the shipping address). */
+    billingAddress?: Maybe<MailingAddress>;
+    /** Buyer identity attached to the cart (email, phone, country and language hints). Null on a fresh cart before any identity is captured. */
+    buyerIdentity?: Maybe<CartBuyerIdentity>;
+    /** Hosted checkout URL the storefront may redirect to as a fallback. The recommended flow is to drive checkout through SDK mutations (`cartSetShippingAddress`, `cartSelectShippingMethod`, `cartSelectPaymentMethod`, `cartComplete`). */
+    checkoutUrl?: Maybe<Scalars['URL']['output']>;
+    /** Cost breakdown for the cart (subtotal, tax, shipping, discount, grand total). */
+    cost: CartCost;
+    /** When the cart was created (ISO 8601). */
+    createdAt: Scalars['DateTime']['output'];
+    /** Per-code discount amounts that make up `cost.totalDiscount`. Render line-item discount breakdown from this list. */
+    discountAllocations: Array<CartDiscountAllocation>;
+    /** Discount codes attached to the cart with their applicability flag. */
+    discountCodes: Array<CartDiscountCode>;
+    /** Convenience accessor — buyer email as last set via `cartUpdateBuyerIdentity`. The same value is available on `buyerIdentity.email`. */
+    email?: Maybe<Scalars['String']['output']>;
+    /** Stable cart identifier — persist in a cookie / local store between sessions. */
+    id: Scalars['ID']['output'];
+    /** Lines in the cart (paginated, Relay Connection). */
+    lines: CartLineConnection;
+    /** Buyer-supplied note (e.g. delivery instructions). Free-form, surfaced to the merchant on the order. */
+    note?: Maybe<Scalars['String']['output']>;
+    /** Convenience accessor — buyer phone as last set via `cartUpdateBuyerIdentity`. The same value is available on `buyerIdentity.phone`. */
+    phone?: Maybe<Scalars['String']['output']>;
+    /** Product recommendations based on cart contents */
+    recommendations?: Maybe<CartRecommendations>;
+    /** True when at least one line in the cart requires physical shipping. False when every line is non-physical (digital, gift card, service, subscription). Use as the single signal to render or skip the shipping step in checkout. */
+    requiresShipping: Scalars['Boolean']['output'];
+    /** The payment method currently selected on the cart. Null until the buyer picks a method via `cartSelectPaymentMethod`. */
+    selectedPaymentMethod?: Maybe<PaymentMethod>;
+    /** The shipping method currently selected on the cart (label + cost). Null until the buyer picks a method. */
+    selectedShippingMethod?: Maybe<CartShippingMethod>;
+    /** Shipping address attached to the cart via `cartSetShippingAddress`. Null until set. */
+    shippingAddress?: Maybe<MailingAddress>;
+    /** Sum of `quantity` across all lines — the badge number for the cart icon. */
+    totalQuantity: Scalars['Int']['output'];
+    /** When the cart was last modified (ISO 8601). */
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type CartAddLinesPayload = {
+    /** The updated cart on success; null when `userErrors` is non-empty. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `CART_NOT_FOUND`, `NOT_ENOUGH_IN_STOCK`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartAddressInput = {
+    /** City */
+    city: Scalars['String']['input'];
+    /** Company name */
+    company?: InputMaybe<Scalars['String']['input']>;
+    /** ISO 3166-1 alpha-2 country code */
+    country: CountryCode;
+    /** First name */
+    firstName?: InputMaybe<Scalars['String']['input']>;
+    /** Last name */
+    lastName?: InputMaybe<Scalars['String']['input']>;
+    /** Phone number */
+    phone?: InputMaybe<Scalars['String']['input']>;
+    /** Selected pickup point — required when the chosen shipping method has a deliveryType other than HOME (parcel locker / collection point). */
+    pickupPoint?: InputMaybe<PickupPointInput>;
+    /** Postal / ZIP code */
+    postalCode: Scalars['String']['input'];
+    /** Buyer business registry number for B2B invoicing (Polish REGON). Persisted on the resulting order at checkout completion. */
+    regon?: InputMaybe<Scalars['String']['input']>;
+    /** State / province */
+    state?: InputMaybe<Scalars['String']['input']>;
+    /** First line of street address */
+    streetLine1: Scalars['String']['input'];
+    /** Second line of street address */
+    streetLine2?: InputMaybe<Scalars['String']['input']>;
+    /** Buyer tax ID for B2B invoicing (Polish NIP). Persisted on the resulting order at checkout completion. */
+    taxId?: InputMaybe<Scalars['String']['input']>;
+};
+export type CartAppliedGiftCard = {
+    /** Amount of this gift card that will be applied to the cart total. */
+    appliedAmount: Money;
+    /** Stable identifier of this applied gift card on the cart. Pass it to `cartRemoveGiftCard` so the storefront never has to hold the full gift card code. */
+    id: Scalars['ID']['output'];
+    /** Last 4 characters of the gift card code — useful when several cards are applied. */
+    lastCharacters: Scalars['String']['output'];
+    /** Masked code safe for display (e.g. "****-****-****-ABCD"). */
+    maskedCode: Scalars['String']['output'];
+    /** Remaining balance on the gift card after this cart is completed. */
+    remainingBalance: Money;
+};
+export type CartApplyGiftCardInput = {
+    /** ID of the cart to update. */
+    cartId: Scalars['ID']['input'];
+    /** Full gift card code entered by the buyer (e.g. "ABCD-1234-EFGH-5678"). Max 64 chars. */
+    giftCardCode: Scalars['String']['input'];
+};
+export type CartApplyGiftCardPayload = {
+    /** The updated cart with the gift card included in `appliedGiftCards`. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `GIFT_CARD_NOT_FOUND`, `GIFT_CARD_DEPLETED`, `GIFT_CARD_UNUSABLE`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartAttribute = {
+    /** Attribute key (e.g. "giftWrap", "engraving"). */
+    key: Scalars['String']['output'];
+    /** Attribute value. Null when the key is set without an associated value. */
+    value?: Maybe<Scalars['String']['output']>;
+};
+export type CartAttributeInput = {
+    /** Attribute key (max 255 chars). */
+    key: Scalars['String']['input'];
+    /** Attribute value (max 500 chars). Omit to set the key without a value. */
+    value?: InputMaybe<Scalars['String']['input']>;
+};
+export type CartBuyerIdentity = {
+    /** Buyer country (ISO 3166-1 alpha-2). Hint for pricing, tax and shipping eligibility before an address is provided. */
+    countryCode?: Maybe<CountryCode>;
+    /** Customer record ID when the cart is owned by a signed-in customer. Null for guest carts. */
+    customerId?: Maybe<Scalars['ID']['output']>;
+    /** Buyer email — receives the order confirmation when the cart completes. */
+    email?: Maybe<Scalars['String']['output']>;
+    /** Buyer preferred language (ISO 639-1). Used for the order confirmation email and any localised content. */
+    languageCode?: Maybe<LanguageCode>;
+    /** Buyer phone number, free-form (validated only for length). */
+    phone?: Maybe<Scalars['String']['output']>;
+};
+export type CartBuyerIdentityInput = {
+    /** Buyer country (ISO 3166-1 alpha-2). Hint for currency, tax and shipping eligibility before an address is set. */
+    countryCode?: InputMaybe<CountryCode>;
+    /** ID of a signed-in customer that owns this cart. Pass to bind a guest cart to a customer record. */
+    customerId?: InputMaybe<Scalars['ID']['input']>;
+    /** Buyer email address. Persisted to the order at checkout completion. */
+    email?: InputMaybe<Scalars['String']['input']>;
+    /** Buyer preferred language (ISO 639-1). Used for the order confirmation email and localised content. */
+    languageCode?: InputMaybe<LanguageCode>;
+    /** Buyer phone number. Free-form; max 30 chars. */
+    phone?: InputMaybe<Scalars['String']['input']>;
+};
+export type CartCompleteInput = {
+    /** ID of the cart to complete. */
+    cartId: Scalars['ID']['input'];
+    /** Optional idempotency key — guards against duplicate orders on retry / network issue. When omitted, the server derives one from the cart ID and the current minute, which is sufficient for the typical "user double-clicks the pay button" case. */
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
+};
+export type CartCompletePayload = {
+    /** The order created from the cart. Carries `canCreatePayment` and `paymentMethodType` signals so the storefront can decide whether to render a "Pay now" button or send the buyer straight to the confirmation page (for offline methods). */
+    order?: Maybe<Order>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `NOT_ENOUGH_IN_STOCK`, `SHIPPING_ADDRESS_REQUIRED`, `SHIPPING_METHOD_REQUIRED`, `PAYMENT_METHOD_REQUIRED`, `EMAIL_REQUIRED`, `ALREADY_COMPLETED`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartCost = {
+    /** Additional fixed checkout fee configured by the shop (e.g. small-order surcharge). Null when no such fee applies. */
+    checkoutCharge?: Maybe<Money>;
+    /** Opt-in: checkoutCharge with conversion transparency. */
+    checkoutChargeWithConversion?: Maybe<PriceMoney>;
+    /** Subtotal of items in the cart before taxes, shipping and discounts. */
+    subtotal: Money;
+    /** Opt-in: subtotal with full conversion transparency. */
+    subtotalWithConversion?: Maybe<PriceMoney>;
+    /** Grand total the buyer will pay — includes taxes, discounts and any selected shipping. Use this directly on the checkout summary instead of summing `subtotal` + extras. */
+    total: Money;
+    /** Aggregated discount across the cart — the sum of every entry in `discountAllocations`. Returns an amount of 0 when no discount applies. */
+    totalDiscount: Money;
+    /** Total customs duty on the cart. Null when no duty applies (most domestic orders). */
+    totalDuty?: Maybe<Money>;
+    /** Opt-in: totalDuty with conversion transparency. */
+    totalDutyWithConversion?: Maybe<PriceMoney>;
+    /** Cost of the currently selected shipping method. Null until a shipping method is selected — a selected free-shipping method returns an amount of 0, so null unambiguously means "no method chosen yet". */
+    totalShipping?: Maybe<Money>;
+    /** Total tax across all lines. Null when tax has not yet been calculated for this cart (e.g. before an address is set in tax-inclusive shops). */
+    totalTax?: Maybe<Money>;
+    /** Opt-in: totalTax with conversion transparency. */
+    totalTaxWithConversion?: Maybe<PriceMoney>;
+    /** Opt-in: total with conversion transparency. */
+    totalWithConversion?: Maybe<PriceMoney>;
+};
+export type CartCreateInput = {
+    /** Cart-level custom attributes to set on the new cart (up to 50 entries). */
+    attributes?: InputMaybe<Array<CartAttributeInput>>;
+    /** Buyer identity to attach to the new cart (email, phone, customer ID, country, language). */
+    buyerIdentity?: InputMaybe<CartBuyerIdentityInput>;
+    /** Discount codes to apply at creation (up to 10). Equivalent to calling `cartDiscountCodesUpdate` immediately after creating the cart. */
+    discountCodes?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Buyer email — shortcut for `buyerIdentity.email`. If both are provided, this field wins. */
+    email?: InputMaybe<Scalars['String']['input']>;
+    /** Initial lines to add to the cart (up to 100). */
+    lines?: InputMaybe<Array<CartLineInput>>;
+    /** Buyer-supplied note (max 1000 chars), e.g. delivery instructions. */
+    note?: InputMaybe<Scalars['String']['input']>;
+    /** Shipping address to attach to the new cart — lets the storefront skip a follow-up `cartSetShippingAddress` call. */
+    shippingAddress?: InputMaybe<CartAddressInput>;
+};
+export type CartCreatePayload = {
+    /** The created cart on success; null when `userErrors` is non-empty. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors. Each entry carries a stable `code` (e.g. `CART_NOT_FOUND`, `NOT_ENOUGH_IN_STOCK`, `INVALID_MERCHANDISE_LINE`) — branch on `code`, never on `message`. */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories (informational only; the mutation itself succeeded). */
+    warnings: Array<CartWarning>;
+};
+export type CartDiscountAllocation = {
+    /** Amount discounted by this code on the cart. */
+    amount: Money;
+    /** The discount code that produced this allocation. */
+    discountCode: Scalars['String']['output'];
+};
+export type CartDiscountCode = {
+    /** The code string as entered by the buyer (case is preserved as stored). */
+    code: Scalars['String']['output'];
+    /** Whether this code currently produces a discount on the cart. False when the code is recognised but its conditions are not met (e.g. minimum-order, customer-eligibility, or product-set restrictions) — keep the chip visible and surface the reason. */
+    isApplicable: Scalars['Boolean']['output'];
+};
+export type CartDiscountCodesUpdatePayload = {
+    /** The updated cart on success. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `INVALID_DISCOUNT_CODE`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartLine = {
+    /** Typed configurator selections filled in by the buyer (snapshot from add-to-cart). Validated server-side against the product attribute definition; carries any pricing surcharge. */
+    attributeSelections: Array<AttributeSelection>;
+    /** Free-form custom attributes (line item properties) attached to this line — engraving text, gift wrap, B2B PO line reference, etc. */
+    attributes: Array<Attribute>;
+    /** Per-line cost breakdown (unit price, subtotal, total, optional compare-at). */
+    cost: CartLineCost;
+    /** Stable line identifier. Use it to address the line in `cartUpdateLines` / `cartRemoveLines`. */
+    id: Scalars['ID']['output'];
+    /** URL handle (slug) of the parent product — link target for the cart drawer (denormalised). */
+    productHandle?: Maybe<Scalars['String']['output']>;
+    /** ID of the parent product. Denormalised so a cart drawer renders without an extra round-trip. */
+    productId?: Maybe<Scalars['ID']['output']>;
+    /** Display title of the parent product (denormalised). */
+    productTitle?: Maybe<Scalars['String']['output']>;
+    /** Type of the parent product (PHYSICAL, DIGITAL, SERVICE, SUBSCRIPTION, GIFT_CARD). Drives whether the line requires shipping and which post-purchase flow applies. */
+    productType?: Maybe<ProductTypeEnum>;
+    /** Quantity of the variant in this line (≥ 1; set to 0 with `cartUpdateLines` to remove). */
+    quantity: Scalars['Int']['output'];
+    /** True when this line requires physical shipping (`productType` = PHYSICAL). False for digital, gift card, service and subscription items. Use together with `Cart.requiresShipping` to decide whether to render the shipping step. */
+    requiresShipping: Scalars['Boolean']['output'];
+    /** The variant being purchased — fresh data (current price, image, stock). */
+    variant: ProductVariant;
+};
+export type CartLineConnection = {
+    /** Edges with the line and its cursor — use for cursor-based pagination. */
+    edges: Array<CartLineEdge>;
+    /** Cart line nodes — convenience shortcut for `edges.map(e => e.node)`. */
+    nodes: Array<CartLine>;
+    /** Cursor pagination info (`hasNextPage`, `endCursor`, etc.). */
+    pageInfo: PageInfo;
+    /** Total number of lines in the cart across all pages. */
+    totalCount: Scalars['Int']['output'];
+};
+export type CartLineCost = {
+    /** Strike-through compare-at unit price when the line is on sale. Null when the line is not discounted; show the strike-through only when this is present and greater than `pricePerUnit`. */
+    compareAtPricePerUnit?: Maybe<Money>;
+    /** Opt-in: compareAtPricePerUnit with conversion transparency. */
+    compareAtPricePerUnitWithConversion?: Maybe<PriceMoney>;
+    /** Unit price of the line item in the shop base currency. Use this for per-unit display. */
+    pricePerUnit: Money;
+    /** Opt-in: pricePerUnit with conversion transparency. */
+    pricePerUnitWithConversion?: Maybe<PriceMoney>;
+    /** Line subtotal before line-level discounts (`pricePerUnit` × quantity). */
+    subtotal: Money;
+    /** Opt-in: subtotal with conversion transparency. */
+    subtotalWithConversion?: Maybe<PriceMoney>;
+    /** Line total after any line-level discounts and surcharges. This is what the buyer pays for the line. */
+    total: Money;
+    /** Opt-in: total with conversion transparency. */
+    totalWithConversion?: Maybe<PriceMoney>;
+};
+export type CartLineEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Cart line node */
+    node: CartLine;
+};
+export type CartLineInput = {
+    /** Typed configurator selections to apply to this line — validated against the product attribute definition; pricing surcharges are taken from a snapshot at add-to-cart. */
+    attributeSelections?: InputMaybe<Array<AttributeSelectionInput>>;
+    /** Free-form custom attributes (line item properties) — e.g. engraving text, gift wrap, B2B PO line reference. Up to 50 entries. */
+    attributes?: InputMaybe<Array<AttributeInput>>;
+    /** Quantity to add (1 to 9999). Defaults to 1 when omitted. */
+    quantity?: Scalars['Int']['input'];
+    /** ID of the product variant being purchased. */
+    variantId: Scalars['ID']['input'];
+};
+export type CartLineUpdateInput = {
+    /** Replacement list of configurator selections. Omit (or pass null) to keep the existing selections; pass an empty array to clear them. */
+    attributeSelections?: InputMaybe<Array<AttributeSelectionInput>>;
+    /** Replacement list of custom attributes on the line. Omit (or pass null) to keep the existing list; pass an empty array to clear it. */
+    attributes?: InputMaybe<Array<AttributeInput>>;
+    /** ID of the cart line to update (`CartLine.id`). */
+    id: Scalars['ID']['input'];
+    /** New quantity. Use 0 to remove the line from the cart. */
+    quantity: Scalars['Int']['input'];
+};
+export type CartRecommendations = {
+    /** Products frequently bought together with cart items */
+    frequentlyBoughtTogether: Array<ProductRecommendation>;
+    /** Products to consider adding */
+    youMayAlsoLike: Array<ProductRecommendation>;
+};
+export type CartRemoveGiftCardInput = {
+    /** ID of the cart to update. */
+    cartId: Scalars['ID']['input'];
+    /** ID of the applied gift card to remove — `CartAppliedGiftCard.id` from the cart. */
+    giftCardId: Scalars['ID']['input'];
+};
+export type CartRemoveGiftCardPayload = {
+    /** The updated cart with the gift card removed from `appliedGiftCards`. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code`. */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartRemoveLinesPayload = {
+    /** The updated cart on success; null when `userErrors` is non-empty. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code`. */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartSelectPaymentMethodInput = {
+    /** ID of the cart to update. */
+    cartId: Scalars['ID']['input'];
+    /** ID of the chosen payment method (matches a `PaymentMethod.id` from `availablePaymentMethods`). */
+    paymentMethodId: Scalars['ID']['input'];
+};
+export type CartSelectPaymentMethodPayload = {
+    /** The updated cart with `selectedPaymentMethod` populated. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `PAYMENT_METHOD_REQUIRED`, `INVALID_PAYMENT_METHOD`, `PAYMENT_METHOD_NOT_SUPPORTED`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartSelectShippingMethodInput = {
+    /** ID of the cart to update. */
+    cartId: Scalars['ID']['input'];
+    /** ID of the chosen shipping method (matches an `AvailableShippingMethod.id` from `cart.availableShippingMethods`). */
+    shippingMethodId: Scalars['ID']['input'];
+};
+export type CartSelectShippingMethodPayload = {
+    /** The updated cart with `selectedShippingMethod` populated and `cost.totalShipping` updated. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `SHIPPING_METHOD_REQUIRED`, `FORBIDDEN_SHIPPING_METHOD`, `ZIP_CODE_NOT_SUPPORTED`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartSetBillingAddressInput = {
+    /** New billing address. The shipping address is left unchanged. */
+    address: CartAddressInput;
+    /** ID of the cart to update. */
+    cartId: Scalars['ID']['input'];
+};
+export type CartSetBillingAddressPayload = {
+    /** The updated cart with the new billing address. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code`. */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartSetShippingAddressInput = {
+    /** New shipping address. Replaces any previous shipping address on the cart. */
+    address: CartAddressInput;
+    /** ID of the cart to update. */
+    cartId: Scalars['ID']['input'];
+};
+export type CartSetShippingAddressPayload = {
+    /** The updated cart with the new shipping address. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `INVALID_ADDRESS`, `EMAIL_REQUIRED`, `PICKUP_POINT_REQUIRED`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartShippingMethod = {
+    /** Handle of the selected shipping method — matches the `id` of an `AvailableShippingMethod`. */
+    handle: Scalars['ID']['output'];
+    /** Cost of the selected shipping method. */
+    price: Money;
+    /** Display title for the checkout summary (e.g. "DPD Standard, 2 days"). */
+    title: Scalars['String']['output'];
+};
+export type CartUpdateAttributesPayload = {
+    /** The updated cart on success. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `CART_ATTRIBUTES_UPDATE_FAILED`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartUpdateBuyerIdentityPayload = {
+    /** The updated cart on success. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code`. */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartUpdateGiftCardRecipientInput = {
+    /** ID of the cart to update. */
+    cartId: Scalars['ID']['input'];
+    /** ID of the cart line; the line must be a gift card SKU. */
+    lineItemId: Scalars['ID']['input'];
+    /** Personalised message included with the gift card (max 500 chars). */
+    message?: InputMaybe<Scalars['String']['input']>;
+    /** Recipient email — where the gift card code will be delivered. */
+    recipientEmail?: InputMaybe<Scalars['String']['input']>;
+    /** Recipient display name. */
+    recipientName?: InputMaybe<Scalars['String']['input']>;
+};
+export type CartUpdateGiftCardRecipientPayload = {
+    /** The updated cart with the new gift card recipient info on the target line. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code`. */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartUpdateLinesPayload = {
+    /** The updated cart on success; null when `userErrors` is non-empty. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code` (e.g. `CART_NOT_FOUND`, `NOT_ENOUGH_IN_STOCK`). */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartUpdateNotePayload = {
+    /** The updated cart on success. */
+    cart?: Maybe<Cart>;
+    /** Business / validation errors carrying a stable `CartErrorCode` in `code`. */
+    userErrors: Array<UserError>;
+    /** Non-fatal advisories — the mutation itself succeeded. */
+    warnings: Array<CartWarning>;
+};
+export type CartWarning = {
+    /** Stable machine-readable warning code. Branch on this for UI behaviour — never on `message` (translated, locale-dependent). */
+    code: CartWarningCode;
+    /** Human-readable warning message — informational, the mutation itself succeeded. */
+    message: Scalars['String']['output'];
+    /** What the warning is about — a cart line ID when the warning refers to a specific item, or a field path otherwise. */
+    target: Scalars['String']['output'];
+};
+export type CartWarningCode = 'MERCHANDISE_NOT_AVAILABLE' | 'MERCHANDISE_NOT_ENOUGH_STOCK' | 'PAYMENTS_AMOUNT_REGION_MISMATCH' | 'SHIPPING_METHOD_AUTO_CLEARED';
+export type Category = {
+    /** Child categories */
+    children: Array<Category>;
+    /** Category description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** URL-friendly handle (e.g. "electronics" -> /categories/electronics). Stable per-shop. */
+    handle: Scalars['String']['output'];
+    /** Unique identifier */
+    id: Scalars['ID']['output'];
+    /** Category image */
+    image?: Maybe<Image>;
+    /** Depth level in hierarchy (0 = root) */
+    level: Scalars['Int']['output'];
+    /** Category name */
+    name: Scalars['String']['output'];
+    /** Parent category (null for root) */
+    parent?: Maybe<Category>;
+    /** Full path (e.g., "Electronics/Phones/Smartphones") */
+    path: Scalars['String']['output'];
+    /** Number of products in category */
+    productCount: Scalars['Int']['output'];
+    /** Products in category */
+    products: CategoryConnection;
+    /** SEO metadata */
+    seo?: Maybe<Seo>;
+    /** Sort order within parent */
+    sortOrder: Scalars['Int']['output'];
+};
+export type CategoryConnection = {
+    /** List of category edges (cursor + node pairs) */
+    edges: Array<CategoryEdge>;
+    /** List of category nodes (shortcut without cursor) */
+    nodes: Array<Category>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of categories */
+    totalCount: Scalars['Int']['output'];
+};
+export type CategoryEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Category node */
+    node: Category;
+};
+export type CategoryFilterOption = {
+    /** URL-friendly handle */
+    handle: Scalars['String']['output'];
+    /** Category ID */
+    id: Scalars['ID']['output'];
+    /** Nesting level (0 = root) */
+    level: Scalars['Int']['output'];
+    /** Category name */
+    name: Scalars['String']['output'];
+    /** Parent category ID */
+    parentId?: Maybe<Scalars['ID']['output']>;
+    /** Number of products in this category */
+    productCount: Scalars['Int']['output'];
+};
+export type Collection = Node & {
+    /** Creation timestamp */
+    createdAt: Scalars['DateTime']['output'];
+    /** Plain text description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** HTML description */
+    descriptionHtml?: Maybe<Scalars['String']['output']>;
+    /** URL-friendly handle (slug) */
+    handle: Scalars['String']['output'];
+    /** Unique identifier */
+    id: Scalars['ID']['output'];
+    /** Collection image */
+    image?: Maybe<Image>;
+    /** Products in collection */
+    products: ProductConnection;
+    /** SEO metadata */
+    seo?: Maybe<Seo>;
+    /** Collection title */
+    title: Scalars['String']['output'];
+    /** Last update timestamp */
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type CollectionConnection = {
+    /** Collection edges */
+    edges: Array<CollectionEdge>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of collections */
+    totalCount: Scalars['Int']['output'];
+};
+export type CollectionEdge = {
+    /** Cursor */
+    cursor: Scalars['String']['output'];
+    /** Collection node */
+    node: Collection;
+};
+export type CompensationType = 'REFUND' | 'STORE_CREDIT';
+export type ContentFormat = 'HTML' | 'MARKDOWN';
+export type ConvertedPriceRange = {
+    /** Maximum variant price (converted) */
+    maxVariantPrice: PriceMoney;
+    /** Minimum variant price (converted) */
+    minVariantPrice: PriceMoney;
+};
+export type Country = Node & {
+    /** Języki wspierane przez sklep dostępne w tym kraju */
+    availableLanguages: Array<Language>;
+    /** Primary currency w tym kraju */
+    currency: Currency;
+    /** Globally-unique identifier (np. "country:PL") */
+    id: Scalars['ID']['output'];
+    /** ISO 3166-1 alpha-2 country code */
+    isoCode: CountryCode;
+    /** English name kraju (np. "Poland", "Germany") */
+    name: Scalars['String']['output'];
+    /** System jednostek (metric/imperial) */
+    unitSystem: UnitSystem;
+};
+export type CountryCode = 'AT' | 'AU' | 'BE' | 'BG' | 'CA' | 'CH' | 'CY' | 'CZ' | 'DE' | 'DK' | 'EE' | 'ES' | 'FI' | 'FR' | 'GB' | 'GR' | 'HR' | 'HU' | 'IE' | 'IS' | 'IT' | 'LI' | 'LT' | 'LU' | 'LV' | 'MT' | 'NL' | 'NO' | 'NZ' | 'PL' | 'PT' | 'RO' | 'SE' | 'SI' | 'SK' | 'US' | 'ZZ';
+export type Currency = {
+    /** ISO 4217 currency code */
+    code: CurrencyCode;
+    /** Number of decimal places */
+    decimalPlaces: Scalars['Float']['output'];
+    /** Currency full name */
+    name: Scalars['String']['output'];
+    /** Currency symbol */
+    symbol: Scalars['String']['output'];
+    /** Symbol position relative to amount */
+    symbolPosition: CurrencySymbolPosition;
+};
+export type CurrencyCode = 'AED' | 'AFN' | 'ALL' | 'AMD' | 'ANG' | 'AOA' | 'ARS' | 'AUD' | 'AWG' | 'AZN' | 'BAM' | 'BBD' | 'BDT' | 'BGN' | 'BHD' | 'BIF' | 'BMD' | 'BND' | 'BOB' | 'BOV' | 'BRL' | 'BSD' | 'BTN' | 'BWP' | 'BYN' | 'BZD' | 'CAD' | 'CDF' | 'CHE' | 'CHF' | 'CHW' | 'CLF' | 'CLP' | 'CNY' | 'COP' | 'COU' | 'CRC' | 'CUC' | 'CUP' | 'CVE' | 'CZK' | 'DJF' | 'DKK' | 'DOP' | 'DZD' | 'EGP' | 'ERN' | 'ETB' | 'EUR' | 'FJD' | 'FKP' | 'GBP' | 'GEL' | 'GHS' | 'GIP' | 'GMD' | 'GNF' | 'GTQ' | 'GYD' | 'HKD' | 'HNL' | 'HTG' | 'HUF' | 'IDR' | 'ILS' | 'INR' | 'IQD' | 'IRR' | 'ISK' | 'JMD' | 'JOD' | 'JPY' | 'KES' | 'KGS' | 'KHR' | 'KMF' | 'KPW' | 'KRW' | 'KWD' | 'KYD' | 'KZT' | 'LAK' | 'LBP' | 'LKR' | 'LRD' | 'LSL' | 'LYD' | 'MAD' | 'MDL' | 'MGA' | 'MKD' | 'MMK' | 'MNT' | 'MOP' | 'MRU' | 'MUR' | 'MVR' | 'MWK' | 'MXN' | 'MXV' | 'MYR' | 'MZN' | 'NAD' | 'NGN' | 'NIO' | 'NOK' | 'NPR' | 'NZD' | 'OMR' | 'PAB' | 'PEN' | 'PGK' | 'PHP' | 'PKR' | 'PLN' | 'PYG' | 'QAR' | 'RON' | 'RSD' | 'RUB' | 'RWF' | 'SAR' | 'SBD' | 'SCR' | 'SDG' | 'SEK' | 'SGD' | 'SHP' | 'SLE' | 'SOS' | 'SRD' | 'SSP' | 'STN' | 'SVC' | 'SYP' | 'SZL' | 'THB' | 'TJS' | 'TMT' | 'TND' | 'TOP' | 'TRY' | 'TTD' | 'TWD' | 'TZS' | 'UAH' | 'UGX' | 'USD' | 'USN' | 'UYI' | 'UYU' | 'UYW' | 'UZS' | 'VED' | 'VES' | 'VND' | 'VUV' | 'WST' | 'XAF' | 'XCD' | 'XOF' | 'XPF' | 'XXX' | 'YER' | 'ZAR' | 'ZMW' | 'ZWG';
+export type CurrencyConversion = {
+    /** Converted amount */
+    convertedAmount: Scalars['Float']['output'];
+    /** Target currency code */
+    convertedCurrency: Scalars['String']['output'];
+    /** Margin percentage applied */
+    marginApplied?: Maybe<Scalars['Float']['output']>;
+    /** Original amount */
+    originalAmount: Scalars['Float']['output'];
+    /** Original currency code */
+    originalCurrency: Scalars['String']['output'];
+    /** Exchange rate used */
+    rate: Scalars['Float']['output'];
+    /** Rate data source */
+    rateSource: CurrencyRateSource;
+    /** Rate timestamp */
+    rateTimestamp: Scalars['DateTime']['output'];
+    /** Rate with margin applied */
+    rateWithMargin?: Maybe<Scalars['Float']['output']>;
+};
+export type CurrencyRateSource = 'ECB' | 'FIXER' | 'MANUAL';
+export type CurrencySymbolPosition = 'AFTER' | 'BEFORE';
+export type Customer = Node & {
+    /** Saved address book of the customer (Relay Connection). Use to render an address picker on checkout. */
+    addresses: MailingAddressConnection;
+    /** Customer custom field values (post-Opcja A unified custom fields). */
+    attributes: Array<EntityAttributeField>;
+    /** Company name. Populated when `customerType` is COMPANY; null for INDIVIDUAL profiles. */
+    companyName?: Maybe<Scalars['String']['output']>;
+    /** When the customer account was created (ISO 8601). */
+    createdAt: Scalars['DateTime']['output'];
+    /** Profile type — INDIVIDUAL (B2C) or COMPANY (B2B). When COMPANY, the company fields below are populated. */
+    customerType: CustomerType;
+    /** Default address pre-selected in checkout pickers. Null when the customer has no saved addresses. */
+    defaultAddress?: Maybe<MailingAddress>;
+    /** Display name — typically `firstName lastName`, with sensible fallback to email when neither is set. Render directly in the UI. */
+    displayName: Scalars['String']['output'];
+    /** Customer email address (login identity). */
+    email: Scalars['String']['output'];
+    /** Marketing consent state (NOT_SUBSCRIBED, PENDING, SUBSCRIBED, UNSUBSCRIBED, REDACTED, INVALID). Drive newsletter UI and opt-in / opt-out controls from this value. */
+    emailMarketing: EmailMarketingState;
+    /** Customer first name. */
+    firstName?: Maybe<Scalars['String']['output']>;
+    /** Stable identifier of the customer. */
+    id: Scalars['ID']['output'];
+    /** True when the customer has confirmed ownership of their email address. */
+    isEmailVerified: Scalars['Boolean']['output'];
+    /** Customer last name. */
+    lastName?: Maybe<Scalars['String']['output']>;
+    /** Total number of orders the customer has placed. Stringified for BigInt safety. */
+    orderCount: Scalars['UnsignedInt64']['output'];
+    /** Orders placed by this customer (Relay Connection). Use for the order history page. */
+    orders: OrderConnection;
+    /** Customer phone number (free-form). */
+    phone?: Maybe<Scalars['String']['output']>;
+    /** Customer-wide Polish business registry number (REGON, 9 or 14 digits with checksum). */
+    regon?: Maybe<Scalars['String']['output']>;
+    /** Merchant-assigned segmentation tags (e.g. "vip", "wholesale", "b2b"). Use to customise UI / pricing rules on the storefront. */
+    tags: Array<Scalars['String']['output']>;
+    /** Customer-wide Polish tax ID (NIP, 10 digits with checksum). Default for new addresses; can be overridden per address via `MailingAddress.taxId`. */
+    taxId?: Maybe<Scalars['String']['output']>;
+    /** Lifetime amount the customer has spent (sum of paid orders). */
+    totalSpent: Money;
+    /** When the customer profile was last modified (ISO 8601). */
+    updatedAt: Scalars['DateTime']['output'];
+    /** Customer-wide EU VAT number (e.g. `PL1234567890`). Default for new addresses; can be overridden per address via `MailingAddress.vatNumber`. */
+    vatNumber?: Maybe<Scalars['String']['output']>;
+};
+export type CustomerAccessToken = {
+    /** The access token string (JWT). Treat as sensitive — do not log. */
+    accessToken: Scalars['String']['output'];
+    /** When the token stops being valid (ISO 8601). Call `customerRefreshToken` before this to obtain a fresh one. */
+    expiresAt: Scalars['DateTime']['output'];
+};
+export type CustomerAccessTokenCreateInput = {
+    /** Customer email address. */
+    email: Scalars['String']['input'];
+    /** Customer password. */
+    password: Scalars['String']['input'];
+};
+export type CustomerActivatePayload = {
+    /** Activated customer */
+    customer?: Maybe<Customer>;
+    /** Auto-login access token */
+    customerAccessToken?: Maybe<CustomerAccessToken>;
+    /** User errors (code is namespaced — e.g. CUSTOMER_NOT_FOUND, CUSTOMER_TOKEN_INVALID, CUSTOMER_PASSWORD_TOO_WEAK) */
+    userErrors: Array<UserError>;
+};
+export type CustomerAddAddressPayload = {
+    /** Created address */
+    address?: Maybe<MailingAddress>;
+    /** User errors (code is namespaced — e.g. CUSTOMER_NOT_FOUND, CUSTOMER_TOKEN_INVALID, CUSTOMER_PASSWORD_TOO_WEAK) */
+    userErrors: Array<UserError>;
+};
+export type CustomerCreateInput = {
+    /** Marketing opt-in checkbox. true → consent state SUBSCRIBED (single opt-in) unless `marketingOptInLevel: CONFIRMED_OPT_IN` is also sent (then PENDING and the server sends a double-opt-in confirmation email). false / null → no consent change. */
+    acceptsMarketing?: InputMaybe<Scalars['Boolean']['input']>;
+    /** Email address — must be unique within the shop. Used as the login identity. */
+    email: Scalars['String']['input'];
+    /** First name. */
+    firstName?: InputMaybe<Scalars['String']['input']>;
+    /** Last name. */
+    lastName?: InputMaybe<Scalars['String']['input']>;
+    /** Opt-in level. Defaults to SINGLE_OPT_IN (signup itself is treated as email proof). Pass CONFIRMED_OPT_IN to enforce double opt-in — the server then emails a confirmation link and leaves consent in PENDING until the buyer clicks it. */
+    marketingOptInLevel?: InputMaybe<MarketingOptInLevel>;
+    /** Password (8 to 128 chars). The shop password policy may impose additional strength rules. */
+    password: Scalars['String']['input'];
+    /** Phone number (free-form). */
+    phone?: InputMaybe<Scalars['String']['input']>;
+};
+export type CustomerGroup = {
+    /** Group code */
+    code: Scalars['String']['output'];
+    /** Group description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Default discount percentage (0-100) */
+    discountPercent: Scalars['Float']['output'];
+    /** Group ID */
+    id: Scalars['ID']['output'];
+    /** Group name (e.g., "Wholesale", "VIP") */
+    name: Scalars['String']['output'];
+    /** Whether group is tax exempt */
+    taxExempt: Scalars['Boolean']['output'];
+};
+export type CustomerLoginPayload = {
+    /** Access token on success; null when `userErrors` is non-empty. */
+    customerAccessToken?: Maybe<CustomerAccessToken>;
+    /** Errors carrying a stable `CustomerErrorCode` in `code` (e.g. `INVALID_CREDENTIALS`, `CUSTOMER_DISABLED`, `UNIDENTIFIED_CUSTOMER`). */
+    userErrors: Array<UserError>;
+};
+export type CustomerLogoutPayload = {
+    /** The token string that was invalidated. Useful for client-side cache clearing. */
+    deletedAccessToken?: Maybe<Scalars['String']['output']>;
+    /** ID of the invalidated token record. */
+    deletedCustomerAccessTokenId?: Maybe<Scalars['String']['output']>;
+    /** Errors carrying a stable `CustomerErrorCode` in `code` (e.g. `TOKEN_INVALID`, `TOKEN_EXPIRED`). */
+    userErrors: Array<UserError>;
+};
+export type CustomerRefreshTokenPayload = {
+    /** Fresh access token on success; null when `userErrors` is non-empty. */
+    customerAccessToken?: Maybe<CustomerAccessToken>;
+    /** Errors carrying a stable `CustomerErrorCode` in `code` (e.g. `TOKEN_INVALID`, `TOKEN_EXPIRED`, `TOKEN_RENEWAL_FAILED`). */
+    userErrors: Array<UserError>;
+};
+export type CustomerRemoveAddressPayload = {
+    /** Deleted address ID */
+    deletedAddressId?: Maybe<Scalars['ID']['output']>;
+    /** User errors (code is namespaced — e.g. CUSTOMER_NOT_FOUND, CUSTOMER_TOKEN_INVALID, CUSTOMER_PASSWORD_TOO_WEAK) */
+    userErrors: Array<UserError>;
+};
+export type CustomerRequestPasswordResetPayload = {
+    /** User errors (code is namespaced — e.g. CUSTOMER_NOT_FOUND, CUSTOMER_TOKEN_INVALID, CUSTOMER_PASSWORD_TOO_WEAK) */
+    userErrors: Array<UserError>;
+};
+export type CustomerResetPasswordPayload = {
+    /** Customer with reset password */
+    customer?: Maybe<Customer>;
+    /** Auto-login access token */
+    customerAccessToken?: Maybe<CustomerAccessToken>;
+    /** User errors (code is namespaced — e.g. CUSTOMER_NOT_FOUND, CUSTOMER_TOKEN_INVALID, CUSTOMER_PASSWORD_TOO_WEAK) */
+    userErrors: Array<UserError>;
+};
+export type CustomerSetDefaultAddressPayload = {
+    /** Updated customer */
+    customer?: Maybe<Customer>;
+    /** User errors (code is namespaced — e.g. CUSTOMER_NOT_FOUND, CUSTOMER_TOKEN_INVALID, CUSTOMER_PASSWORD_TOO_WEAK) */
+    userErrors: Array<UserError>;
+};
+export type CustomerSignupPayload = {
+    /** The created customer on success; null when `userErrors` is non-empty. */
+    customer?: Maybe<Customer>;
+    /** Access token for the new customer — saves a follow-up login round-trip. */
+    customerAccessToken?: Maybe<CustomerAccessToken>;
+    /** Validation / business errors carrying a stable `CustomerErrorCode` in `code` (e.g. `TAKEN`, `INVALID`, `PASSWORD_TOO_WEAK`, `BAD_DOMAIN`). */
+    userErrors: Array<UserError>;
+};
+export type CustomerType = 'COMPANY' | 'INDIVIDUAL';
+export type CustomerUpdateAddressPayload = {
+    /** Updated address */
+    address?: Maybe<MailingAddress>;
+    /** User errors (code is namespaced — e.g. CUSTOMER_NOT_FOUND, CUSTOMER_TOKEN_INVALID, CUSTOMER_PASSWORD_TOO_WEAK) */
+    userErrors: Array<UserError>;
+};
+export type CustomerUpdatePayload = {
+    /** Updated customer */
+    customer?: Maybe<Customer>;
+    /** User errors (code is namespaced — e.g. CUSTOMER_NOT_FOUND, CUSTOMER_TOKEN_INVALID, CUSTOMER_PASSWORD_TOO_WEAK) */
+    userErrors: Array<UserError>;
+};
+export type DeliveryEstimate = {
+    /** Pre-formatted human-readable estimate (e.g. "1-2 business days"). Localised; render as-is. */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Maximum expected delivery time in business days. */
+    maxDays?: Maybe<Scalars['Int']['output']>;
+    /** Minimum expected delivery time in business days. */
+    minDays?: Maybe<Scalars['Int']['output']>;
+};
+export type DeliveryType = 
+/** Courier delivery to the street address — no pickup point required. */
+'HOME'
+/** Automated parcel locker — the buyer collects from a 24/7 self-service machine. */
+ | 'LOCKER'
+/** Staffed pickup point / parcel shop — the buyer collects the parcel at a counter. */
+ | 'PICKUP_POINT';
+export type DiscountApplicationType = 'BUY_X_GET_Y' | 'FIXED_AMOUNT' | 'FREE_SHIPPING' | 'PERCENTAGE';
+export type DiscountErrorCode = 'CUSTOMER_GROUP_NOT_ELIGIBLE' | 'CUSTOMER_NOT_ELIGIBLE' | 'CUSTOMER_USAGE_LIMIT_REACHED' | 'DISCOUNT_COMBINATION_NOT_ALLOWED' | 'EXPIRED' | 'INACTIVE' | 'MINIMUM_ORDER_NOT_MET' | 'MINIMUM_QUANTITY_NOT_MET' | 'NOT_FOUND' | 'NOT_STARTED' | 'SHOP_NOT_FOUND' | 'USAGE_LIMIT_REACHED';
+export type DiscountInfo = {
+    /** The discount code as entered. */
+    code: Scalars['String']['output'];
+    /** Calculated savings the discount produces against the current cart. Null when the savings cannot be computed without a cart context. */
+    discountAmount?: Maybe<Money>;
+    /** Merchant-facing title of the discount (e.g. "Summer sale 10%"). */
+    title: Scalars['String']['output'];
+    /** Category of the discount: `PERCENTAGE`, `FIXED_AMOUNT`, `FREE_SHIPPING` or `BUY_X_GET_Y`. Drives how `value` is interpreted. */
+    type: DiscountApplicationType;
+    /** Discount value — percent points for `PERCENTAGE`, amount (in major currency units) for `FIXED_AMOUNT`. Ignored for `FREE_SHIPPING` / `BUY_X_GET_Y`. */
+    value: Scalars['Float']['output'];
+};
+export type DiscountValidationError = {
+    /** Stable reason code (e.g. `EXPIRED`, `USAGE_LIMIT_REACHED`, `MINIMUM_ORDER_NOT_MET`). Branch on this for UI behaviour. */
+    code: DiscountErrorCode;
+    /** Human-readable explanation of the validation failure. */
+    message: Scalars['String']['output'];
+};
+export type DiscountValidationResult = {
+    /** Discount details when `isValid` is true. Null otherwise. */
+    discount?: Maybe<DiscountInfo>;
+    /** Validation failure details when `isValid` is false. Null otherwise. */
+    error?: Maybe<DiscountValidationError>;
+    /** True when the code is currently applicable to the cart. When false, see `error` for the reason. */
+    isValid: Scalars['Boolean']['output'];
+};
+export type Domain = {
+    /** Host name (e.g. "shop.example.com") */
+    host: Scalars['String']['output'];
+    /** Whether HTTPS is enforced */
+    isSslEnabled: Scalars['Boolean']['output'];
+    /** Full URL z protocol */
+    url: Scalars['URL']['output'];
+};
+export type EmailMarketingState = 'INVALID' | 'NOT_SUBSCRIBED' | 'PENDING' | 'REDACTED' | 'SUBSCRIBED' | 'UNSUBSCRIBED';
+export type EntityAttributeField = {
+    /** AttributeDefinition ID */
+    definitionId: Scalars['ID']['output'];
+    /** Attribute handle (URL-friendly identifier) */
+    handle: Scalars['String']['output'];
+    /** EntityAttribute row ID */
+    id: Scalars['ID']['output'];
+    /** Per-entity visibility override (NULL = use AttributeDefinition.isVisible). */
+    isVisibleOverride?: Maybe<Scalars['Boolean']['output']>;
+    /** Attribute display name */
+    name: Scalars['String']['output'];
+    /** Optional grouping namespace (e.g. "inventory", "marketing"). NULL = ungrouped. */
+    namespace?: Maybe<Scalars['String']['output']>;
+    /** Attribute data type */
+    type: AttributeType;
+    /** Value serialized as JSON string. Storefront-dev parses according to `type` (TEXT/NUMBER/BOOLEAN/JSON/etc.). Null values serialize as JSON `null`. */
+    value: Scalars['String']['output'];
+};
+export type ExchangeRate = {
+    /** Source currency code */
+    from: Scalars['String']['output'];
+    /** Exchange rate */
+    rate: Scalars['Float']['output'];
+    /** Rate data source */
+    source: CurrencyRateSource;
+    /** Target currency code */
+    to: Scalars['String']['output'];
+    /** When rate was last updated */
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type Filter = {
+    /** Unique filter identifier (e.g., "filter.v.option.color", "filter.v.price") */
+    id: Scalars['ID']['output'];
+    /** Display label (e.g., "Color", "Price", "Availability") */
+    label: Scalars['String']['output'];
+    /** Display hint (SWATCH for COLOR, IMAGE for pattern, TEXT default) */
+    presentation?: Maybe<FilterPresentation>;
+    /** Filter type (LIST | PRICE_RANGE | BOOLEAN) */
+    type: FilterType;
+    /** Available values for this filter, with product counts */
+    values: Array<FilterValue>;
+};
+export type FilterPresentation = 'IMAGE' | 'SWATCH' | 'TEXT';
+export type FilterType = 'BOOLEAN' | 'LIST' | 'PRICE_RANGE';
+export type FilterValue = {
+    /** Number of products matching this value in current result set */
+    count: Scalars['Int']['output'];
+    /** Unique identifier within filter */
+    id: Scalars['ID']['output'];
+    /** Pre-built ProductFilter input — paste verbatim into `filters` arg to refetch with this value applied. Example: `{"variantOption":{"name":"Color","value":"Red"}}` */
+    input: Scalars['JSON']['output'];
+    /** Display label (e.g., "Red", "Extra Large", "$50 - $200") */
+    label: Scalars['String']['output'];
+    /** DoSwiftly: visual swatch (color hex or pattern image) */
+    swatch?: Maybe<AttributeSwatch>;
+};
+export type FreeShippingProgress = {
+    /** Current qualifying subtotal of the cart. */
+    currentAmount?: Maybe<Money>;
+    /** Pre-formatted, localised banner message (e.g. "Add 15.00 PLN more for free shipping"). Render as-is when present. */
+    message?: Maybe<Scalars['String']['output']>;
+    /** Progress towards the threshold expressed as a percentage between 0 and 100. Use as the value of a progress bar. */
+    progressPercent?: Maybe<Scalars['Float']['output']>;
+    /** True when the cart already qualifies for free shipping. */
+    qualifies: Scalars['Boolean']['output'];
+    /** How much more the buyer needs to add to qualify. Zero when `qualifies` is true. */
+    remaining?: Maybe<Money>;
+    /** Subtotal threshold that unlocks free shipping. */
+    threshold?: Maybe<Money>;
+};
+export type GenerateReferralCodePayload = {
+    /** Generated referral code */
+    referralCode?: Maybe<Scalars['String']['output']>;
+    /** Shareable referral URL */
+    shareUrl?: Maybe<Scalars['String']['output']>;
+    /** Whether generation was successful */
+    success: Scalars['Boolean']['output'];
+    /** Typed user errors */
+    userErrors: Array<UserError>;
+};
+export type GiftCard = {
+    /** Current balance */
+    balance: Money;
+    /** Creation timestamp */
+    createdAt: Scalars['DateTime']['output'];
+    /** Expiration date */
+    expiresAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Gift card ID */
+    id: Scalars['ID']['output'];
+    /** Initial gift card amount */
+    initialAmount: Money;
+    /** Gift card code (masked for security; client may slice last 4 chars for display) */
+    maskedCode: Scalars['String']['output'];
+    /** Personal message */
+    message?: Maybe<Scalars['String']['output']>;
+    /** Recipient name */
+    recipientName?: Maybe<Scalars['String']['output']>;
+    /** Gift card status */
+    status: GiftCardStatus;
+};
+export type GiftCardError = {
+    /** Error code */
+    code: GiftCardErrorCode;
+    /** Human-readable error message */
+    message: Scalars['String']['output'];
+};
+export type GiftCardErrorCode = 'ALREADY_USED' | 'CURRENCY_MISMATCH' | 'DISABLED' | 'EXPIRED' | 'INSUFFICIENT_BALANCE' | 'INVALID_CODE_FORMAT' | 'NOT_FOUND';
+export type GiftCardStatus = 'ACTIVE' | 'DISABLED' | 'EXPIRED' | 'USED';
+export type GiftCardValidatePayload = {
+    /** User errors */
+    userErrors: Array<UserError>;
+    /** Validation result */
+    validation?: Maybe<GiftCardValidation>;
+};
+export type GiftCardValidation = {
+    /** Available balance if valid */
+    availableBalance?: Maybe<Money>;
+    /** Error details if invalid */
+    error?: Maybe<GiftCardError>;
+    /** Gift card details if valid */
+    giftCard?: Maybe<GiftCard>;
+    /** Whether the gift card is valid for use */
+    isValid: Scalars['Boolean']['output'];
+};
+export type Image = {
+    /** Alt text for accessibility / SEO. Null when the merchant has not provided one. */
+    altText?: Maybe<Scalars['String']['output']>;
+    /** Native height of the source image in pixels. */
+    height?: Maybe<Scalars['Int']['output']>;
+    /** Stable image identifier. Null for ad-hoc images that are not stored as media library entries. */
+    id?: Maybe<Scalars['ID']['output']>;
+    /** ThumbHash placeholder for progressive loading (base64-encoded, ~40 chars). Decode with `thumbHashToDataURL()` on the client to render an instant blurry preview while the full image loads. */
+    thumbhash?: Maybe<Scalars['String']['output']>;
+    /** Public image URL. Pass an optional `transform` argument (max width / height, crop region, scale, preferred format) to obtain a resized / reformatted CDN variant — useful for responsive images and modern formats like WebP / AVIF. */
+    url: Scalars['String']['output'];
+    /** Native width of the source image in pixels. */
+    width?: Maybe<Scalars['Int']['output']>;
+};
+export type ImageConnection = {
+    /** Image edges with cursors */
+    edges: Array<ImageEdge>;
+    /** Image nodes (shortcut for edges.map(e => e.node)) */
+    nodes: Array<Image>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of images */
+    totalCount: Scalars['Int']['output'];
+};
+export type ImageEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Image node */
+    node: Image;
+};
+export type Language = {
+    /** Language code (ISO 639-1) */
+    code: Scalars['ID']['output'];
+    /** Text direction */
+    direction: LanguageDirection;
+    /** English language name */
+    englishName: Scalars['String']['output'];
+    /** Whether this is the default language */
+    isDefault: Scalars['Boolean']['output'];
+    /** Locale code (e.g., "pl-PL") */
+    locale?: Maybe<Scalars['String']['output']>;
+    /** Native language name */
+    nativeName: Scalars['String']['output'];
+};
+export type LanguageCode = 'CS' | 'DA' | 'DE' | 'EN' | 'ES' | 'FI' | 'FR' | 'HR' | 'HU' | 'IT' | 'LT' | 'LV' | 'NL' | 'NO' | 'PL' | 'PT' | 'RO' | 'SK' | 'SL' | 'SV' | 'UK';
+export type LanguageDirection = 'LTR' | 'RTL';
+export type LinkedVariantSummary = {
+    /** Available stock (stock − active reservations, zawsze ≥ 0). */
+    availableStock: Scalars['Int']['output'];
+    /** Variant ID (w tenant DB). */
+    id: Scalars['ID']['output'];
+    /** Czy w tej chwili dostępny do zakupu (uwzględnia allowBackorder). */
+    isAvailable: Scalars['Boolean']['output'];
+    /** Parent product ID. */
+    productId: Scalars['ID']['output'];
+    /** SKU jeśli zdefiniowany. */
+    sku?: Maybe<Scalars['String']['output']>;
+    /** Variant name (e.g., "Finiszer Zewnętrzny SD"). */
+    title: Scalars['String']['output'];
+    /** Czy magazyn śledzi stock dla tego wariantu. */
+    trackQuantity: Scalars['Boolean']['output'];
+};
+export type LocaleCurrencyMapping = {
+    /** Currency code (ISO 4217) */
+    currency: CurrencyCode;
+    /** Browser locale (e.g., "pl-PL", "en-US") */
+    locale: Scalars['String']['output'];
+};
+export type Localization = {
+    /** Wszystkie wsparte kraje (z aktywnych shipping zones) */
+    availableCountries: Array<Country>;
+    /** Wszystkie wsparte języki sklepu */
+    availableLanguages: Array<Language>;
+    /** Aktualny kraj klienta (z `@inContext` lub geo-detection) */
+    country: Country;
+    /** Aktualny język klienta (z `Accept-Language` lub `@inContext`) */
+    language: Language;
+};
+export type Location = {
+    /** Physical address and coordinates */
+    address: LocationAddress;
+    /** Per-day business hours. Null when not configured — use pickupLeadTimeHours only. */
+    businessHours?: Maybe<BusinessHours>;
+    /** Location ID */
+    id: Scalars['ID']['output'];
+    /** Location display name */
+    name: Scalars['String']['output'];
+    /** Optional merchant pickup instructions (e.g., "Show ID at counter") */
+    pickupInstructions?: Maybe<Scalars['String']['output']>;
+    /** Whether this location supports BOPIS pickup */
+    supportsPickup: Scalars['Boolean']['output'];
+    /** IANA timezone identifier (e.g., "Europe/Warsaw"). Falls back to shop timezone if null. */
+    timezone?: Maybe<Scalars['String']['output']>;
+    /** Location type (WAREHOUSE, STORE, etc.) */
+    type: LocationType;
+};
+export type LocationAddress = {
+    /** City */
+    city?: Maybe<Scalars['String']['output']>;
+    /** Country name */
+    country?: Maybe<Scalars['String']['output']>;
+    /** Country ISO 3166-1 alpha-2 code (e.g., PL, US) */
+    countryCode?: Maybe<Scalars['String']['output']>;
+    /** Formatted address lines (country-aware ordering) */
+    formatted: Array<Scalars['String']['output']>;
+    /** Latitude (decimal degrees) */
+    latitude?: Maybe<Scalars['Float']['output']>;
+    /** Longitude (decimal degrees) */
+    longitude?: Maybe<Scalars['Float']['output']>;
+    /** Phone number */
+    phone?: Maybe<Scalars['String']['output']>;
+    /** Postal / ZIP code */
+    postalCode?: Maybe<Scalars['String']['output']>;
+    /** State / province name */
+    state?: Maybe<Scalars['String']['output']>;
+    /** State / province code (e.g., CA, MZ) */
+    stateCode?: Maybe<Scalars['String']['output']>;
+    /** First line of street address */
+    streetLine1?: Maybe<Scalars['String']['output']>;
+    /** Second line of street address (apartment, suite) */
+    streetLine2?: Maybe<Scalars['String']['output']>;
+};
+export type LocationConnection = {
+    /** Location edges */
+    edges: Array<LocationEdge>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of locations matching the query */
+    totalCount: Scalars['Int']['output'];
+};
+export type LocationEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** The location node */
+    node: Location;
+};
+export type LocationType = 'DROPSHIPPER' | 'FULFILLMENT_CENTER' | 'STORE' | 'WAREHOUSE';
+export type LoyaltyAction = {
+    /** Whether action is enabled */
+    isEnabled: Scalars['Boolean']['output'];
+    /** Points awarded for this action (if fixed) */
+    points?: Maybe<Scalars['Int']['output']>;
+    /** Action type */
+    type: Scalars['String']['output'];
+};
+export type LoyaltyMember = {
+    /** Annual spend amount */
+    annualSpend: Money;
+    /** Customer ID */
+    customerId: Scalars['ID']['output'];
+    /** Enrollment date */
+    enrolledAt: Scalars['DateTime']['output'];
+    /** Member ID */
+    id: Scalars['ID']['output'];
+    /** Last activity date */
+    lastActivityAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Points summary */
+    points: LoyaltyPointsSummary;
+    /** Current tier */
+    tier?: Maybe<LoyaltyTier>;
+    /** Progress to next tier */
+    tierProgress?: Maybe<TierProgress>;
+};
+export type LoyaltyPageInfo = {
+    /** End cursor */
+    endCursor?: Maybe<Scalars['String']['output']>;
+    /** Has next page */
+    hasNextPage: Scalars['Boolean']['output'];
+    /** Has previous page */
+    hasPreviousPage: Scalars['Boolean']['output'];
+    /** Start cursor */
+    startCursor?: Maybe<Scalars['String']['output']>;
+};
+export type LoyaltyPointsSummary = {
+    /** Currently available points */
+    currentPoints: Scalars['Int']['output'];
+    /** Points expired */
+    expiredPoints: Scalars['Int']['output'];
+    /** Points expiring soon (next 30 days) */
+    expiringPoints?: Maybe<Scalars['Int']['output']>;
+    /** Next expiry date (ISO 8601) */
+    nextExpiryDate?: Maybe<Scalars['DateTime']['output']>;
+    /** Points pending (from incomplete orders) */
+    pendingPoints: Scalars['Int']['output'];
+    /** Points redeemed */
+    redeemedPoints: Scalars['Int']['output'];
+    /** Total points earned all-time */
+    totalPoints: Scalars['Int']['output'];
+};
+export type LoyaltyReward = {
+    /** Description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Discount amount (if discount type) */
+    discountAmount?: Maybe<Money>;
+    /** Discount percentage (if discount type) */
+    discountPercent?: Maybe<Scalars['Float']['output']>;
+    /** URL-friendly handle */
+    handle: Scalars['String']['output'];
+    /** Reward ID */
+    id: Scalars['ID']['output'];
+    /** Reward image */
+    image?: Maybe<Image>;
+    /** Whether reward is available */
+    isAvailable: Scalars['Boolean']['output'];
+    /** Reward name */
+    name: Scalars['String']['output'];
+    /** Points required to redeem */
+    pointsCost: Scalars['Int']['output'];
+    /** Redemptions remaining (null = unlimited) */
+    redemptionsRemaining?: Maybe<Scalars['Int']['output']>;
+    /** Minimum tier required */
+    tierRequired?: Maybe<LoyaltyTier>;
+    /** Reward type (discount, product, shipping, gift_card) */
+    type: Scalars['String']['output'];
+};
+export type LoyaltySettings = {
+    /** Available point earning actions */
+    availableActions: Array<LoyaltyAction>;
+    /** Whether loyalty program is enabled */
+    isEnabled: Scalars['Boolean']['output'];
+    /** Months until points expire (null = no expiry) */
+    pointsExpiryMonths?: Maybe<Scalars['Int']['output']>;
+    /** Custom name for points (e.g., "Points", "Stars", "Coins") */
+    pointsName: Scalars['String']['output'];
+    /** Points earned per 1 unit of currency */
+    pointsPerCurrency: Scalars['Float']['output'];
+    /** Bonus points for referred customer */
+    referralBonusPoints?: Maybe<Scalars['Int']['output']>;
+    /** Whether referral program is enabled */
+    referralEnabled: Scalars['Boolean']['output'];
+    /** Points awarded to referrer */
+    referralPoints?: Maybe<Scalars['Int']['output']>;
+};
+export type LoyaltyTier = {
+    /** Additional custom benefits */
+    customBenefits: Array<TierBenefit>;
+    /** Tier ID */
+    id: Scalars['ID']['output'];
+    /** Minimum annual spend required */
+    minAnnualSpend?: Maybe<Money>;
+    /** Minimum points required for tier */
+    minPoints: Scalars['Int']['output'];
+    /** Tier name */
+    name: Scalars['String']['output'];
+    /** Points earning multiplier (e.g., 1.5 for 50% bonus) */
+    pointsMultiplier: Scalars['Float']['output'];
+    /** Tier type (null for custom tiers) */
+    type?: Maybe<LoyaltyTierType>;
+};
+export type LoyaltyTierType = 'BRONZE' | 'DIAMOND' | 'GOLD' | 'PLATINUM' | 'SILVER';
+export type LoyaltyTransaction = {
+    /** Balance after transaction */
+    balanceAfter: Scalars['Int']['output'];
+    /** Transaction date */
+    createdAt: Scalars['DateTime']['output'];
+    /** Description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Expiry date for earned points */
+    expiresAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Transaction ID */
+    id: Scalars['ID']['output'];
+    /** Related order ID */
+    orderId?: Maybe<Scalars['String']['output']>;
+    /** Points (positive = earn, negative = spend) */
+    points: Scalars['Int']['output'];
+    /** Transaction type */
+    type: LoyaltyTransactionType;
+};
+export type LoyaltyTransactionConnection = {
+    /** Transaction edges */
+    edges: Array<LoyaltyTransactionEdge>;
+    /** Pagination info */
+    pageInfo: LoyaltyPageInfo;
+    /** Total count of transactions */
+    totalCount: Scalars['Int']['output'];
+};
+export type LoyaltyTransactionEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** The transaction */
+    node: LoyaltyTransaction;
+};
+export type LoyaltyTransactionType = 'ADJUST' | 'EARN_BIRTHDAY' | 'EARN_BONUS' | 'EARN_PURCHASE' | 'EARN_REFERRAL' | 'EARN_REVIEW' | 'EARN_SIGNUP' | 'EXPIRE' | 'REDEEM' | 'REFUND_REVERSAL';
+export type MailingAddress = Node & {
+    /** City / town. */
+    city?: Maybe<Scalars['String']['output']>;
+    /** Company name (relevant for B2B addresses). */
+    company?: Maybe<Scalars['String']['output']>;
+    /** Country name in the request locale (e.g. "Poland", "Polska"). For machine logic use `countryCode`. */
+    country?: Maybe<Scalars['String']['output']>;
+    /** ISO 3166-1 alpha-2 country code (e.g. PL, DE, US). */
+    countryCode?: Maybe<CountryCode>;
+    /** Buyer first name. */
+    firstName?: Maybe<Scalars['String']['output']>;
+    /** Country-aware ordered address lines, ready to render line by line in UI without manual formatting. The exact line layout depends on country (e.g. PL puts postal code before city, US after state). */
+    formatted: Array<Scalars['String']['output']>;
+    /** Single-line summary of the area, e.g. "Warszawa, MZ, Poland". Useful for compact display in lists. */
+    formattedArea?: Maybe<Scalars['String']['output']>;
+    /** Stable identifier of the address. */
+    id: Scalars['ID']['output'];
+    /** True when this is the default address for the owning customer. */
+    isDefault: Scalars['Boolean']['output'];
+    /** Buyer last name. */
+    lastName?: Maybe<Scalars['String']['output']>;
+    /** Convenience full name (`firstName` + " " + `lastName`). */
+    name?: Maybe<Scalars['String']['output']>;
+    /** Phone number associated with the address (free-form). */
+    phone?: Maybe<Scalars['String']['output']>;
+    /** Selected pickup point when the shipping method delivers to a parcel locker / collection point instead of the street address. Null for home delivery. */
+    pickupPoint?: Maybe<PickupPoint>;
+    /** Postal / ZIP code. */
+    postalCode?: Maybe<Scalars['String']['output']>;
+    /** State / province / region name. */
+    state?: Maybe<Scalars['String']['output']>;
+    /** State / province code (ISO 3166-2 subdivision, e.g. PL-MZ). */
+    stateCode?: Maybe<Scalars['String']['output']>;
+    /** First line of the street address (street and house / building number). */
+    streetLine1?: Maybe<Scalars['String']['output']>;
+    /** Second line of the street address (apartment, suite, floor — optional). */
+    streetLine2?: Maybe<Scalars['String']['output']>;
+    /** Per-address buyer tax ID for B2B invoicing — Polish NIP, 10 digits with checksum. Lets B2B buyers invoice different addresses to different legal entities. Independent of `Customer.taxId` (which is the customer-wide default). */
+    taxId?: Maybe<Scalars['String']['output']>;
+    /** Per-address EU VAT number (e.g. `PL1234567890`) for cross-border B2B. Independent of `Customer.vatNumber` (which is the customer-wide default). */
+    vatNumber?: Maybe<Scalars['String']['output']>;
+};
+export type MailingAddressConnection = {
+    /** Edges with the address and its cursor — use for cursor-based pagination. */
+    edges: Array<MailingAddressEdge>;
+    /** Address nodes — convenience shortcut for `edges.map(e => e.node)`. */
+    nodes: Array<MailingAddress>;
+    /** Cursor pagination info (`hasNextPage`, `endCursor`, etc.). */
+    pageInfo: PageInfo;
+    /** Total number of saved addresses for the customer across all pages. */
+    totalCount: Scalars['Int']['output'];
+};
+export type MailingAddressEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** MailingAddress node */
+    node: MailingAddress;
+};
+export type MarketingOptInLevel = 'CONFIRMED_OPT_IN' | 'SINGLE_OPT_IN' | 'UNKNOWN';
+export type Menu = {
+    /** URL handle (e.g., main-menu, footer) */
+    handle: Scalars['String']['output'];
+    /** Menu ID */
+    id: Scalars['ID']['output'];
+    /** Top-level menu items */
+    items: Array<MenuItem>;
+    /** Menu title */
+    title: Scalars['String']['output'];
+};
+export type MenuItem = {
+    /** Item ID */
+    id: Scalars['ID']['output'];
+    /** Custom banner image (with url(transform:) support) */
+    image?: Maybe<Image>;
+    /** Child menu items (max 3 levels) */
+    items: Array<MenuItem>;
+    /** Linked resource object resolved server-side via DataLoader (batched per resource type — no N+1). Null when type is HTTP/FRONTPAGE/SEARCH/CATALOG/BLOG, or when resourceId points to a deleted resource. */
+    resource?: Maybe<MenuItemResource>;
+    /** Linked resource ID */
+    resourceId?: Maybe<Scalars['ID']['output']>;
+    /** Display title */
+    title: Scalars['String']['output'];
+    /** Link type */
+    type: MenuItemType;
+    /** Pre-resolved URL path computed server-side using a standard route convention: /categories/<handle>, /collections/<handle>, /pages/<handle>, /products/<handle>, /brands/<handle>. Static types resolve to /, /search, /products, /blog. HTTP returns the manually stored URL. Null when type is a resource link and the underlying resource was deleted. If your storefront uses non-standard routing (e.g. single-segment /<handle>), prefer reading the `resource` field instead and build URLs yourself from `resource.__typename` + `handle`. */
+    url?: Maybe<Scalars['URL']['output']>;
+};
+export type MenuItemResource = Brand | Category | Collection | Product | ShopPage;
+export type MenuItemType = 'BLOG' | 'BRAND' | 'CATALOG' | 'CATEGORY' | 'COLLECTION' | 'FRONTPAGE' | 'HTTP' | 'PAGE' | 'PRODUCT' | 'SEARCH';
+export type Money = {
+    /** Amount as a decimal string in major currency units (e.g. "12.99"). String, not float — preserves precision across locales. */
+    amount: Scalars['Decimal']['output'];
+    /** ISO 4217 currency code (e.g. PLN, EUR, USD). */
+    currencyCode: CurrencyCode;
+};
+export type Mutation = {
+    /** Add one or more lines to the cart. Adding the same variant a second time merges into the existing line (sums the quantity). Returns the full updated cart plus any non-fatal warnings (e.g. stock dropped below requested quantity). */
+    cartAddLines: CartAddLinesPayload;
+    /** Apply a gift card to the cart by full code. The card is debited at `cartComplete`. Rate-limited to 5 requests per minute per IP+shop (gift card codes form a finite enumerable space). */
+    cartApplyGiftCard: CartApplyGiftCardPayload;
+    /** Finalise the cart into an `Order`. The cart is locked and no longer accepts mutations. Payment is initiated separately via `paymentCreate` — check `order.canCreatePayment` to decide whether to render a "Pay now" button or send the buyer directly to the confirmation page (for offline methods such as cash on delivery). Rate-limited to 5 requests per minute per IP+shop; pass an `idempotencyKey` to guard against duplicate orders on retry. */
+    cartComplete: CartCompletePayload;
+    /** Create a new cart. All fields on `input` are optional — call with no input to create an empty cart, or pass initial lines, buyer identity, attributes, discount codes, email and a shipping address to skip the corresponding follow-up calls. */
+    cartCreate: CartCreatePayload;
+    /** Replace (not merge) the list of discount codes on the cart. Pass an empty array to clear all codes. Rate-limited to 10 requests per minute per IP+shop. */
+    cartDiscountCodesUpdate: CartDiscountCodesUpdatePayload;
+    /** Remove a previously applied gift card from the cart by its `CartAppliedGiftCard.id`. The storefront never has to handle the full gift card code on the client. */
+    cartRemoveGiftCard: CartRemoveGiftCardPayload;
+    /** Remove one or more lines from the cart by `CartLine.id`. Equivalent to `cartUpdateLines` with `quantity: 0` but lets the storefront express the intent explicitly. */
+    cartRemoveLines: CartRemoveLinesPayload;
+    /** Select a payment method on the cart. Validates against the active shop payment methods and currency. The selection is finalised at `cartComplete`; payment itself is initiated via a separate `paymentCreate` mutation after the order is created. */
+    cartSelectPaymentMethod: CartSelectPaymentMethodPayload;
+    /** Select a shipping method on the cart. Validates the method against the cart contents and the shipping address (must be eligible for the destination, and a pickup point must be set when the method delivers to a locker / collection point). Updates `cost.totalShipping` and the grand total. */
+    cartSelectShippingMethod: CartSelectShippingMethodPayload;
+    /** Set the billing address on a cart. The shipping address is left unchanged — pass billing only when it differs from shipping (otherwise the order mirrors the shipping address as the billing address). */
+    cartSetBillingAddress: CartSetBillingAddressPayload;
+    /** Set the shipping address on a cart. Pass `address.pickupPoint` when the buyer is delivering to a parcel locker / collection point — required for non-HOME shipping methods. Replaces any previous shipping address; the billing address is left untouched. */
+    cartSetShippingAddress: CartSetShippingAddressPayload;
+    /** Replace (not merge) the cart-level custom attributes — free-form key/value pairs surfaced to the merchant on the order. Use for cart-wide metadata such as a B2B PO number or marketing source. Max 250 pairs / 255-char keys; over the limit returns `CART_ATTRIBUTES_LIMIT_EXCEEDED`. */
+    cartUpdateAttributes: CartUpdateAttributesPayload;
+    /** Update buyer identity on the cart — email, phone, customer ID, country and language hints. Only supplied fields are touched; omit a field to leave it unchanged. */
+    cartUpdateBuyerIdentity: CartUpdateBuyerIdentityPayload;
+    /** Set recipient details (email, display name, personalised message) on a gift card line item — the gift card will be delivered to this recipient on order completion. */
+    cartUpdateGiftCardRecipient: CartUpdateGiftCardRecipientPayload;
+    /** Update existing cart lines — quantity, custom attributes and / or configurator selections. Set `quantity` to 0 to remove a line. Address lines by `CartLine.id`. */
+    cartUpdateLines: CartUpdateLinesPayload;
+    /** Set or replace the buyer note on the cart (free-form, up to 1000 chars). Surfaced to the merchant on the resulting order. */
+    cartUpdateNote: CartUpdateNotePayload;
+    /** Activate customer account using raw activation token (admin-created flow) */
+    customerActivate: CustomerActivatePayload;
+    /** Add customer address */
+    customerAddAddress: CustomerAddAddressPayload;
+    /** Sign a customer in with email and password. Returns an access token to use on subsequent requests (as a Bearer header or via the SDK auth cookie). */
+    customerLogin: CustomerLoginPayload;
+    /** Sign the current customer out. Invalidates the access token on the server; the SDK BFF auth helpers additionally clear the HTTP-only cookie. */
+    customerLogout: CustomerLogoutPayload;
+    /** Exchange a still-valid access token for a fresh one with a later expiry. Call before `expiresAt` to keep the session alive without prompting the buyer to log in again. */
+    customerRefreshToken: CustomerRefreshTokenPayload;
+    /** Remove customer address */
+    customerRemoveAddress: CustomerRemoveAddressPayload;
+    /** Request password reset email */
+    customerRequestPasswordReset: CustomerRequestPasswordResetPayload;
+    /** Reset customer password via signed URL from email */
+    customerResetPassword: CustomerResetPasswordPayload;
+    /** Set default address */
+    customerSetDefaultAddress: CustomerSetDefaultAddressPayload;
+    /** Register a new customer with email and password. Returns the created customer plus an access token so the storefront can sign the buyer in immediately, no follow-up login call needed. */
+    customerSignup: CustomerSignupPayload;
+    /** Subscribe an email to the newsletter (guest-friendly, double opt-in). */
+    customerSubscribeToMarketing: SubscribeToMarketingPayload;
+    /** Unsubscribe an email from the newsletter (guest-friendly, idempotent). */
+    customerUnsubscribeFromMarketing: UnsubscribeFromMarketingPayload;
+    /** Update customer profile */
+    customerUpdate: CustomerUpdatePayload;
+    /** Update customer address */
+    customerUpdateAddress: CustomerUpdateAddressPayload;
+    /** Generate or retrieve referral code */
+    loyaltyGenerateReferralCode: GenerateReferralCodePayload;
+    /** Redeem a loyalty reward */
+    loyaltyRedeemReward: RedeemRewardPayload;
+    /** Initiate a payment session for an order created by `cartComplete`. Call after checking `order.canCreatePayment`. Idempotent on the order — a second call returns the existing still-valid session. Branch on the returned `payment.flow` to launch the payment (redirect / embedded / instant). Rate-limited to 5 requests per minute per IP+shop. */
+    paymentCreate: PaymentCreatePayload;
+    /** Cancel a return request */
+    returnCancel: ReturnCancelPayload;
+    /** Create a return request */
+    returnCreate: ReturnCreatePayload;
+    /** Create a product review */
+    reviewCreate: ReviewPayload;
+    /** Mark review as not helpful (downvote). Replaces any prior vote by same customer. */
+    reviewDownvote: ReviewPayload;
+    /** Mark review as helpful (upvote). Replaces any prior vote by same customer. */
+    reviewUpvote: ReviewPayload;
+    /** Add item to wishlist */
+    wishlistAddItem: WishlistPayload;
+    /** Create a new wishlist */
+    wishlistCreate: WishlistPayload;
+    /** Delete a wishlist */
+    wishlistDelete: WishlistPayload;
+    /** Remove item from wishlist */
+    wishlistRemoveItem: WishlistPayload;
+};
+export type Node = {
+    /** Globally-unique identifier */
+    id: Scalars['ID']['output'];
+};
+export type Order = Node & {
+    /** Opaque access token (UUID v4) that grants read access to the order summary without an authenticated session — pass it to the `orderByToken` query to build a guest confirmation page. Persistent for the lifetime of the order so it can be re-used in forwarded receipts. Store on the storefront in an HTTP-only cookie or `sessionStorage`; never in `localStorage`. As defense-in-depth, `orderByToken` also accepts an optional email guard to limit the blast radius if the token leaks. */
+    accessToken: Scalars['String']['output'];
+    /** Order custom field values (post-Opcja A unified custom fields). */
+    attributes: Array<EntityAttributeField>;
+    /** True when the storefront should initiate an online payment for this order — render a "Pay now" button. False when the order is cancelled, already paid, or uses an offline payment method (cash on delivery, manual bank transfer) where no online flow applies. Retry-friendly: returns true for UNPAID / PENDING / FAILED payment statuses when the method supports online init. */
+    canCreatePayment: Scalars['Boolean']['output'];
+    /** When the order was cancelled. Null when not cancelled. */
+    cancelledAt?: Maybe<Scalars['DateTime']['output']>;
+    /** When the order was confirmed (e.g. payment authorised / approved). Null until confirmation. */
+    confirmedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** When the order expired (e.g. pending payment timed out). Null when not expired. */
+    expiredAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Fulfillment progress (UNFULFILLED, PARTIALLY_FULFILLED, FULFILLED, IN_TRANSIT, DELIVERED, PARTIALLY_RETURNED, RETURNED, LOST). */
+    fulfillmentStatus: OrderFulfillmentStatus;
+    /** Stable identifier of the order. */
+    id: Scalars['ID']['output'];
+    /** Number of line items on the order (sum of distinct lines, not quantities). */
+    itemCount: Scalars['Int']['output'];
+    /** Line items on the order (paginated, Relay Connection). Use to render the order summary on the confirmation or order detail page. */
+    lineItems: OrderLineItemConnection;
+    /** Human-readable order number shown to the buyer and the merchant (e.g. "1042"). Distinct from `id`. */
+    orderNumber: Scalars['String']['output'];
+    /** Category of the payment method on the order (CARD, BLIK, BANK_TRANSFER, CASH_ON_DELIVERY, OTHER). Use to drive iconography and copy on the confirmation page (e.g. show the card icon for CARD, the BLIK logo for BLIK). */
+    paymentMethodType: PaymentMethodType;
+    /** Payment progress (UNPAID, PENDING, AUTHORIZED, PAID, PARTIALLY_PAID, PARTIALLY_REFUNDED, REFUNDED, FAILED, CHARGEBACK, VOIDED, REFUND_PENDING). */
+    paymentStatus: OrderPaymentStatus;
+    /** When the order was placed (ISO 8601). Use as the canonical "order date" in receipts. */
+    processedAt: Scalars['DateTime']['output'];
+    /** Order shipments */
+    shipments: Array<Shipment>;
+    /** Shipping address snapshot at the moment the order was placed. Null for digital-only orders. */
+    shippingAddress?: Maybe<MailingAddress>;
+    /** High-level lifecycle status of the order (DRAFT, PENDING, CONFIRMED, PROCESSING, ON_HOLD, COMPLETED, CANCELLED, EXPIRED). */
+    status: StorefrontOrderStatus;
+    /** Cost breakdown on the order (subtotal, total, tax, shipping). */
+    totals: OrderTotals;
+};
+export type OrderConnection = {
+    /** Order edges with cursors */
+    edges: Array<OrderEdge>;
+    /** Order nodes (shortcut for edges.map(e => e.node)) */
+    nodes: Array<Order>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total orders count */
+    totalCount: Scalars['Int']['output'];
+};
+export type OrderEdge = {
+    /** Cursor */
+    cursor: Scalars['String']['output'];
+    /** Order node */
+    node: Order;
+};
+export type OrderFulfillmentStatus = 'DELIVERED' | 'FULFILLED' | 'IN_TRANSIT' | 'LOST' | 'PARTIALLY_FULFILLED' | 'PARTIALLY_RETURNED' | 'RETURNED' | 'UNFULFILLED';
+export type OrderLineItem = {
+    /** Unique identifier */
+    id: Scalars['ID']['output'];
+    /** Całkowita cena linii z momentu zakupu (unitPrice × quantity, minor units) */
+    originalTotalPrice: Money;
+    /** Cena jednostkowa z momentu zakupu (minor units, include BUNDLED surcharges) */
+    originalUnitPrice: Money;
+    /** Ilość zamówiona (snapshot z checkout) */
+    quantity: Scalars['Int']['output'];
+    /** Ilość już zrealizowana (shipped — per-item fulfillment tracking) */
+    quantityFulfilled: Scalars['Int']['output'];
+    /** Ilość pozostała do zwrotu/refund (quantity - returnedQuantity, clamp ≥ 0). Industry-standard semantyka dla refund tracking. */
+    refundableQuantity: Scalars['Int']['output'];
+    /** Nazwa produktu z momentu zakupu (snapshot). NIE live `Product.name` — preserved nawet po edycji produktu (KSeF/invoice compliance). */
+    title: Scalars['String']['output'];
+    /** Live wariant produktu (fresh image/price). Null jeśli wariant został usunięty po zakupie — consumer powinien użyć `title` jako fallback. */
+    variant?: Maybe<ProductVariant>;
+};
+export type OrderLineItemConnection = {
+    /** Order line item edges with cursors */
+    edges: Array<OrderLineItemEdge>;
+    /** Order line item nodes (shortcut for edges.map(e => e.node)) */
+    nodes: Array<OrderLineItem>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of line items in the order (convention parity z OrderConnection/MailingAddressConnection) */
+    totalCount: Scalars['Int']['output'];
+};
+export type OrderLineItemEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Order line item node */
+    node: OrderLineItem;
+};
+export type OrderPaymentStatus = 'AUTHORIZED' | 'CHARGEBACK' | 'FAILED' | 'PAID' | 'PARTIALLY_PAID' | 'PARTIALLY_REFUNDED' | 'PENDING' | 'REFUNDED' | 'REFUND_PENDING' | 'UNPAID' | 'VOIDED';
+export type OrderTotals = {
+    /** Order subtotal — items only, before tax, shipping and discounts. */
+    subtotal: Money;
+    /** Grand total the buyer was charged — includes taxes, shipping and discounts. */
+    total: Money;
+    /** Total shipping cost on the order. Null for digital-only orders that did not go through shipping. */
+    totalShipping?: Maybe<Money>;
+    /** Total tax across the order. Null when the order has no taxable component. */
+    totalTax?: Maybe<Money>;
+};
+export type PageInfo = {
+    /** Cursor of the last item on the current page — opaque, base64-encoded. Echo as the `after` argument to fetch the next page. */
+    endCursor?: Maybe<Scalars['String']['output']>;
+    /** True when more pages follow this one. Use to decide whether to enable a "load more" / next page action. */
+    hasNextPage: Scalars['Boolean']['output'];
+    /** True when pages exist before this one (relevant for bidirectional pagination). */
+    hasPreviousPage: Scalars['Boolean']['output'];
+    /** Cursor of the first item on the current page — opaque, base64-encoded. Echo as the `before` argument to paginate backwards. */
+    startCursor?: Maybe<Scalars['String']['output']>;
+};
+export type PaymentCreateInput = {
+    /** URL the gateway returns the buyer to after they cancel the payment. Must point to a verified domain of the shop. */
+    cancelUrl?: InputMaybe<Scalars['URL']['input']>;
+    /** ID of the order to pay for — `cartComplete.order.id`. */
+    orderId: Scalars['ID']['input'];
+    /** URL the gateway returns the buyer to after a successful payment. Must point to a verified domain of the shop; rejected with `RETURN_URL_INVALID` otherwise. */
+    returnUrl?: InputMaybe<Scalars['URL']['input']>;
+};
+export type PaymentCreatePayload = {
+    /** The created (or reused) payment session on success; null when `userErrors` is non-empty. */
+    payment?: Maybe<PaymentSession>;
+    /** Business / validation errors carrying a stable `PaymentErrorCode` in `code` (e.g. `ORDER_NOT_FOUND`, `ORDER_ALREADY_PAID`, `ORDER_NOT_PAYABLE`, `PAYMENT_PROVIDER_NOT_CONFIGURED`, `RETURN_URL_INVALID`, `PAYMENT_FAILED`). */
+    userErrors: Array<UserError>;
+};
+export type PaymentInitiationFlow = 'INSTANT_DIRECT' | 'OFFLINE_MANUAL' | 'ONLINE_EMBEDDED' | 'ONLINE_REDIRECT';
+export type PaymentMethod = {
+    /** Optional buyer-facing description shown under the name (e.g. "Pay with your bank app"). */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Optional icon URL configured by the merchant. Use as the method tile artwork. */
+    icon?: Maybe<Scalars['String']['output']>;
+    /** Stable ID of the payment method. Pass to `cartSelectPaymentMethod` to select it. */
+    id: Scalars['ID']['output'];
+    /** True when the merchant has marked this method as the default. Pre-select it in the picker. */
+    isDefault: Scalars['Boolean']['output'];
+    /** Display name configured by the merchant (e.g. "BLIK", "Credit card", "Cash on delivery"). */
+    name: Scalars['String']['output'];
+    /** Merchant-configured display position — lower values come first in the picker. */
+    position: Scalars['Float']['output'];
+    /** Provider code (e.g. "payu", "stripe", "p24", "cash_on_delivery"). Identifies the integration behind the method; do not branch UI on it — use `type` instead. */
+    provider: Scalars['String']['output'];
+    /** ISO 4217 currency codes the method accepts. Null when the method accepts the shop currency without restriction. */
+    supportedCurrencies?: Maybe<Array<Scalars['String']['output']>>;
+    /** Category of the method (CARD, BLIK, BANK_TRANSFER, CASH_ON_DELIVERY, OTHER). Drives iconography and copy. */
+    type: PaymentMethodType;
+};
+export type PaymentMethodType = 'BANK_TRANSFER' | 'BLIK' | 'CARD' | 'CASH_ON_DELIVERY' | 'OTHER';
+export type PaymentSession = {
+    /** Client secret / token for the in-page payment widget. Populated only when `flow` is ONLINE_EMBEDDED. Treat as sensitive — do not log. */
+    clientSecret?: Maybe<Scalars['String']['output']>;
+    /** When the `redirectUrl` / `clientSecret` stops being usable (ISO 8601). The storefront should call `paymentCreate` again to get a fresh session after this time. */
+    expiresAt?: Maybe<Scalars['String']['output']>;
+    /** How the storefront should launch the payment — branch on this with `switch(flow)`. */
+    flow: PaymentInitiationFlow;
+    /** Stable identifier of the payment record. */
+    id: Scalars['ID']['output'];
+    /** ID of the order this payment is for. */
+    orderId: Scalars['ID']['output'];
+    /** Provider code of the integration behind the session (e.g. "PAYU", "STRIPE"). Use for analytics; do not branch UI on it — use `flow` and the order `paymentMethodType` instead. */
+    provider: Scalars['String']['output'];
+    /** Hosted-gateway URL to redirect the buyer to. Populated only when `flow` is ONLINE_REDIRECT. */
+    redirectUrl?: Maybe<Scalars['URL']['output']>;
+    /** Payment status of the order at the time the session was created. For INSTANT_DIRECT, this already reflects the settled outcome. */
+    status: OrderPaymentStatus;
+};
+export type PaymentSettings = {
+    /** Country code sklepu — driver dostępności metod płatności */
+    countryCode: CountryCode;
+    /** Primary currency użyty do procesowania płatności */
+    currencyCode: CurrencyCode;
+    /** Waluty displayable on storefront (Money.currencyCode allowlist) */
+    enabledPresentmentCurrencies: Array<CurrencyCode>;
+    /** Kody aktywnych payment providerów dla tego sklepu (z IntegrationProvider table, type=PAYMENT). Np. ["payu", "cash_on_delivery"]. Storefront-dev używa do warunkowania UI checkout. */
+    paymentProviders: Array<Scalars['String']['output']>;
+};
+export type PickupPoint = {
+    /** Point address as a single human-readable line — show alongside the name on the confirmation page. */
+    address?: Maybe<Scalars['String']['output']>;
+    /** Display name of the point as shown in the carrier widget. */
+    name?: Maybe<Scalars['String']['output']>;
+    /** Identifier of the point within the provider network (e.g. an InPost parcel locker code such as `KRA010`). Pass back to `PickupPointInput.pointId` when attaching the same point to another address. */
+    pointId: Scalars['String']['output'];
+    /** Carrier network code that owns the point (e.g. `inpost`, `orlen`, `dpd`). */
+    provider: Scalars['String']['output'];
+};
+export type PickupPointInput = {
+    /** Point address as a single line */
+    address?: InputMaybe<Scalars['String']['input']>;
+    /** Human-readable point name */
+    name?: InputMaybe<Scalars['String']['input']>;
+    /** Point identifier within the provider network */
+    pointId: Scalars['String']['input'];
+    /** Courier network code (e.g. inpost, orlen, dpd) */
+    provider: Scalars['String']['input'];
+};
+export type PointsEstimate = {
+    /** Base points to earn */
+    basePoints: Scalars['Int']['output'];
+    /** Bonus points from tier multiplier */
+    bonusPoints: Scalars['Int']['output'];
+    /** Tier multiplier applied */
+    multiplier?: Maybe<Scalars['Float']['output']>;
+    /** Total points to earn */
+    totalPoints: Scalars['Int']['output'];
+};
+export type PredictiveSearchResult = {
+    /** Top matching products (FTS-ranked) */
+    products: Array<Product>;
+    /** Top product title suggestions with highlighted query matches */
+    queries: Array<SearchQuerySuggestion>;
+};
+export type PriceMoney = {
+    /** Price amount in display currency */
+    amount: Scalars['String']['output'];
+    /** Original price in shop base currency */
+    baseAmount: Scalars['String']['output'];
+    /** Shop base currency code */
+    baseCurrencyCode: Scalars['String']['output'];
+    /** Display currency code (ISO 4217) */
+    currencyCode: Scalars['String']['output'];
+    /** Exchange rate used (null if same currency) */
+    exchangeRate?: Maybe<Scalars['Float']['output']>;
+    /** Whether price was converted from different currency */
+    isConverted: Scalars['Boolean']['output'];
+    /** Margin applied by shop (e.g., 0.02 = 2%) */
+    marginApplied?: Maybe<Scalars['Float']['output']>;
+    /** When the exchange rate was fetched */
+    rateTimestamp?: Maybe<Scalars['DateTime']['output']>;
+};
+export type PriceRange = {
+    /** Maximum price in current product set */
+    max: Money;
+    /** Minimum price in current product set */
+    min: Money;
+};
+export type PricingTier = {
+    /** Discount percentage from retail */
+    discountPercent: Scalars['Float']['output'];
+    /** Maximum quantity for this tier */
+    maxQuantity?: Maybe<Scalars['Int']['output']>;
+    /** Minimum quantity for this tier */
+    minQuantity: Scalars['Int']['output'];
+    /** Price per unit at this tier */
+    unitPrice: Money;
+};
+export type Product = Node & {
+    /** Assigned AttributeSet ID (shared template fields) */
+    attributeSetId?: Maybe<Scalars['ID']['output']>;
+    /** Customer-facing product attributes (configurator) — set definitions + per-product scoped */
+    attributes: Array<ProductAttributeDefinition>;
+    /** Average rating (1-5) */
+    averageRating?: Maybe<Scalars['Float']['output']>;
+    /** Canonical brand entity (Faza 3, 2026-05-17). Resolved via DataLoader (N+1 safe dla list queries). Null gdy product nie ma przypisanego brand_id. */
+    brand?: Maybe<Brand>;
+    /** Wszystkie kategorie do których produkt należy (M2M przez ProductCategory junction). Posortowane po junction.sortOrder ASC. Empty list gdy produkt nie jest w żadnej kategorii. */
+    categories: Array<Category>;
+    /** Compare-at price range (Money pair). Null gdy żaden variant nie ma compareAtPrice. */
+    compareAtPriceRange?: Maybe<ProductPriceRange>;
+    /** Opt-in: compare-at price range with conversion transparency. */
+    compareAtPriceRangeWithConversion?: Maybe<ConvertedPriceRange>;
+    /** Creation timestamp */
+    createdAt: Scalars['DateTime']['output'];
+    /** Plain text description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** HTML description */
+    descriptionHtml?: Maybe<Scalars['String']['output']>;
+    /** Featured/primary image */
+    featuredImage?: Maybe<Image>;
+    /** URL-friendly handle (slug) */
+    handle: Scalars['String']['output'];
+    /** Unique identifier */
+    id: Scalars['ID']['output'];
+    /** Product images (Relay Connection) */
+    images: ImageConnection;
+    /** Whether product is available for sale (any variant in stock) */
+    isAvailable: Scalars['Boolean']['output'];
+    /** Whether the storefront should offer a direct purchase path (Add to cart / Buy now). Mirrors `visibility === PUBLIC`. BUNDLE_ONLY ("Komponent") products resolve to false — the PDP renders a Komponent banner explaining access is only via configurator. */
+    isPurchasable: Scalars['Boolean']['output'];
+    /** Per-product option definitions (Color, Size, …) with their available values. Use these to build a variant picker without aggregating `selectedOptions` manually. */
+    options: Array<ProductOption>;
+    /** Price range (Money pair). Default field — industry-standard schema. */
+    priceRange: ProductPriceRange;
+    /** Opt-in: price range with full conversion transparency (exchangeRate, baseCurrency, isConverted). Use dla currency-converter UI gdy customer ma preferred currency inną niż shop base. */
+    priceRangeWithConversion?: Maybe<ConvertedPriceRange>;
+    /** Domyślna kategoria dla breadcrumb/nav (= categories[0] po sortOrder). Null gdy produkt nie jest w żadnej kategorii. */
+    primaryCategory?: Maybe<Category>;
+    /** Similar products recommendations */
+    recommendations?: Maybe<ProductRecommendations>;
+    /** Number of reviews */
+    reviewCount?: Maybe<Scalars['Int']['output']>;
+    /** SEO metadata */
+    seo?: Maybe<Seo>;
+    /** Total stock across all variants */
+    stockTotal?: Maybe<Scalars['Int']['output']>;
+    /** Product tags */
+    tags: Array<Scalars['String']['output']>;
+    /** Product title */
+    title: Scalars['String']['output'];
+    /** Product type enum (PHYSICAL, DIGITAL, SERVICE, SUBSCRIPTION, GIFT_CARD) */
+    type: ProductTypeEnum;
+    /** Last update timestamp */
+    updatedAt: Scalars['DateTime']['output'];
+    /** Product variants (Relay Connection) */
+    variants: ProductVariantConnection;
+    /** Legacy vendor/brand name (free-text). Preferred: `brand` field (canonical Brand entity, Faza 3). */
+    vendor?: Maybe<Scalars['String']['output']>;
+    /** Catalog visibility (Faza 1.5) — PUBLIC | HIDDEN | BUNDLE_ONLY */
+    visibility: ProductVisibility;
+};
+export type ProductAttributeDefinition = {
+    /** Billing mode — BUNDLED | SEPARATE_LINE; null = informational only */
+    billingMode?: Maybe<AttributeBillingMode>;
+    /** Customer-facing description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Display order */
+    displayOrder: Scalars['Int']['output'];
+    /** Filling mode — MERCHANT | CUSTOMER | BOTH */
+    fillingMode: AttributeFillingMode;
+    /** URL-friendly handle */
+    handle: Scalars['String']['output'];
+    /** Definition ID */
+    id: Scalars['ID']['output'];
+    /** Required validation flag */
+    isRequired: Scalars['Boolean']['output'];
+    /** Visibility flag */
+    isVisible: Scalars['Boolean']['output'];
+    /** Max value (NUMBER) / max length (TEXT) */
+    maxValue?: Maybe<Scalars['Float']['output']>;
+    /** Min value (NUMBER) / min length (TEXT) */
+    minValue?: Maybe<Scalars['Float']['output']>;
+    /** Field name (e.g. "Finiszer") */
+    name: Scalars['String']['output'];
+    /** Options for SELECT/RADIO/CHECKBOX types */
+    options: Array<ProductAttributeOption>;
+    /** Per-product scope — set to product ID for unique configurator fields, null for shared (in AttributeSet) */
+    scopeProductId?: Maybe<Scalars['ID']['output']>;
+    /** Tax class ID; null = inherit from variant */
+    taxClassId?: Maybe<Scalars['ID']['output']>;
+    /** Field type — TEXT/SELECT/RADIO/CHECKBOX/etc. */
+    type: AttributeType;
+};
+export type ProductAttributeOption = {
+    /** Hex color (for COLOR/SWATCH types) */
+    colorHex?: Maybe<Scalars['String']['output']>;
+    /** Option ID */
+    id: Scalars['ID']['output'];
+    /** Default option marker */
+    isDefault: Scalars['Boolean']['output'];
+    /** Display label shown to customer */
+    label: Scalars['String']['output'];
+    /** Summary powiązanego ProductVariant (Faza 1.5). Null gdy option nie ma linkedVariantId albo wariant został usunięty. */
+    linkedVariant?: Maybe<LinkedVariantSummary>;
+    /** Linked ProductVariant ID for component stock decrement (Faza 1.5 — Hidden Products pattern) */
+    linkedVariantId?: Maybe<Scalars['ID']['output']>;
+    /** Sort order */
+    sortOrder: Scalars['Int']['output'];
+    /** Surcharge amount when selected (FIXED = grosze; PERCENT = thousandths of percent — Faza 2) */
+    surchargeAmount?: Maybe<Scalars['Int']['output']>;
+    /** Surcharge type — FIXED | PERCENT (Faza 2) */
+    surchargeType?: Maybe<AttributeOptionSurchargeType>;
+    /** Internal value (slug-style) */
+    value: Scalars['String']['output'];
+};
+export type ProductConnection = {
+    /** Product edges with cursors */
+    edges: Array<ProductEdge>;
+    /** Faceted filters driven by current result set. Use FilterValue.input to construct refinement queries. */
+    filters: Array<Filter>;
+    /** Product nodes (shortcut for edges.map(e => e.node)) */
+    nodes: Array<Product>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of products */
+    totalCount: Scalars['Int']['output'];
+};
+export type ProductEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Product node */
+    node: Product;
+};
+export type ProductOption = {
+    id: Scalars['ID']['output'];
+    /** Storefront rendering hint */
+    inputType: ProductOptionInputType;
+    /** Option name (e.g. "Color", "Size") */
+    name: Scalars['String']['output'];
+    /** Sort order among the product's options */
+    sortOrder: Scalars['Int']['output'];
+    /** Available values, ordered by sortOrder */
+    values: Array<ProductOptionValue>;
+};
+export type ProductOptionInputType = 'COLOR_SWATCH' | 'SELECT' | 'TEXT';
+export type ProductOptionValue = {
+    /** Hex colour for COLOR_SWATCH rendering (e.g. "#FF0000"). Null for other types. */
+    colorHex?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    /** Display name (e.g. "Red", "XL") */
+    name: Scalars['String']['output'];
+    /** Sort order (0-based) */
+    sortOrder: Scalars['Int']['output'];
+};
+export type ProductPriceRange = {
+    /** Maximum variant price (shop currency) */
+    maxVariantPrice: Money;
+    /** Minimum variant price (shop currency) */
+    minVariantPrice: Money;
+};
+export type ProductRecommendation = {
+    /** The recommended product */
+    product: Product;
+    /** Reason for recommendation */
+    reason?: Maybe<Scalars['String']['output']>;
+    /** Relevance score (0-100, higher is more relevant) */
+    score?: Maybe<Scalars['Int']['output']>;
+    /** Type of recommendation */
+    type: RecommendationType;
+};
+export type ProductRecommendations = {
+    /** List of product recommendations */
+    items: Array<ProductRecommendation>;
+    /** Total available recommendations */
+    totalCount: Scalars['Int']['output'];
+};
+export type ProductReview = {
+    /** Author display name */
+    authorName: Scalars['String']['output'];
+    /** Cons list */
+    cons: Array<Scalars['String']['output']>;
+    /** Review content */
+    content: Scalars['String']['output'];
+    /** Review date */
+    createdAt: Scalars['DateTime']['output'];
+    /** Helpful votes count (upvotes) */
+    helpfulCount: Scalars['Int']['output'];
+    id: Scalars['ID']['output'];
+    /** Review images */
+    images: Array<Scalars['String']['output']>;
+    /** Is verified purchase */
+    isVerifiedPurchase: Scalars['Boolean']['output'];
+    productId: Scalars['ID']['output'];
+    /** Pros list */
+    pros: Array<Scalars['String']['output']>;
+    /** Rating 1-5 */
+    rating: Scalars['Int']['output'];
+    /** Store response */
+    response?: Maybe<Scalars['String']['output']>;
+    /** Response date */
+    responseAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Review title */
+    title?: Maybe<Scalars['String']['output']>;
+    /** Unhelpful votes count (downvotes) */
+    unhelpfulCount: Scalars['Int']['output'];
+};
+export type ProductReviewConnection = {
+    edges: Array<ProductReviewEdge>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ProductReviewEdge = {
+    cursor: Scalars['String']['output'];
+    node: ProductReview;
+};
+export type ProductTypeEnum = 'DIGITAL' | 'GIFT_CARD' | 'PHYSICAL' | 'SERVICE' | 'SUBSCRIPTION';
+export type ProductVariant = {
+    /** Variant custom field values (post-Opcja A unified custom fields). */
+    attributes: Array<EntityAttributeField>;
+    /** Available stock — what the buyer can buy now (on-hand minus active reservations, never below 0). Null when the merchant has disabled stock tracking for this variant (e.g. digital, made-to-order). */
+    availableStock?: Maybe<Scalars['Int']['output']>;
+    /** Barcode (EAN/UPC/etc.) as set by the merchant. Null when not configured. */
+    barcode?: Maybe<Scalars['String']['output']>;
+    /** Strike-through compare-at price when the variant is on sale. Null when the variant is not discounted; show the strike-through only when this is present and greater than `price`. */
+    compareAtPrice?: Maybe<Money>;
+    /** Optional opt-in: `compareAtPrice` with full conversion transparency. */
+    compareAtPriceWithConversion?: Maybe<PriceMoney>;
+    /** Stable identifier of the variant. Pass to `cartAddLines.variantId` to add the variant to a cart. */
+    id: Scalars['ID']['output'];
+    /** Image specific to this variant. Null when the variant inherits the parent product image. */
+    image?: Maybe<Image>;
+    /** True when the variant can be purchased right now (in stock, or backorder allowed by the merchant). */
+    isAvailable: Scalars['Boolean']['output'];
+    /** Current price of the variant in the buyer preferred currency (auto-converted from the shop base currency when multi-currency is enabled). */
+    price: Money;
+    /** Optional opt-in: `price` with full conversion transparency (original shop-currency amount, exchange rate, conversion timestamp). Use when building a currency-converter UI. */
+    priceWithConversion?: Maybe<PriceMoney>;
+    /** Option values that define this variant (e.g. Size = Large, Color = Red). */
+    selectedOptions: Array<SelectedOption>;
+    /** Stock-keeping unit code as set by the merchant. Null when not configured. */
+    sku?: Maybe<Scalars['String']['output']>;
+    /** Display position of this variant within the parent product list. Lower values come first. */
+    sortOrder?: Maybe<Scalars['Int']['output']>;
+    /** Per-location stock availability. Null for single-location shops. Resolved by StoreAvailabilityResolver with `near`, `locationType`, and `@inContext(preferredLocationId)` support. */
+    storeAvailability?: Maybe<StoreAvailabilityConnection>;
+    /** Display title of the variant (e.g. "Large / Red"). Composed from the variant options. */
+    title: Scalars['String']['output'];
+    /** Variant weight with its unit. Stored in grams; pick a display unit on the storefront if needed. Null when the merchant has not set a weight. */
+    weight?: Maybe<Weight>;
+};
+export type ProductVariantConnection = {
+    /** Variant edges with cursors */
+    edges: Array<ProductVariantEdge>;
+    /** Variant nodes (shortcut for edges.map(e => e.node)) */
+    nodes: Array<ProductVariant>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of variants */
+    totalCount: Scalars['Int']['output'];
+};
+export type ProductVariantEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Variant node */
+    node: ProductVariant;
+};
+export type ProductVisibility = 'BUNDLE_ONLY' | 'HIDDEN' | 'PUBLIC';
+export type Query = {
+    /** List of all currencies supported by the system (ECB rates) */
+    allSupportedCurrencies: Array<Currency>;
+    /** Paginated + searchable attribute options dla drill-into filter UI (np. dropdown z 800 licencjami + search input). Honors product context z exclude-self per attribute. Sort: COUNT_DESC default (most popular first), LABEL_ASC dla alfabetycznego z polskim collation. */
+    attributeOptionsSearch: AttributeFilterValueConnection;
+    /** Payment methods active for the current shop, plus the merchant default. Shop-level — independent of cart contents in this iteration. Fetch once for the checkout payment step. */
+    availablePaymentMethods: AvailablePaymentMethods;
+    /** Standalone shipping-method preview for an address — does not require a cart. Pass an optional `cart` summary (subtotal, weight, currency) to evaluate price-based / weight-based rules and free-shipping thresholds. For an already-created cart, prefer `cart.availableShippingMethods(address)` — it reads the cart contents directly. */
+    availableShippingMethods: AvailableShippingMethodsPayload;
+    /** Get live shipping rates from configured carriers */
+    availableShippingRates: AvailableShippingRatesPayload;
+    /** Get B2B pricing for a product variant */
+    b2bPricing?: Maybe<B2BPriceDisplay>;
+    /** List blog categories */
+    blogCategories: Array<BlogCategory>;
+    /** Get single blog post */
+    blogPost?: Maybe<BlogPost>;
+    /** List blog posts */
+    blogPosts: BlogPostConnection;
+    /** List blog tags */
+    blogTags: Array<BlogTag>;
+    /** Fetch a cart by ID — returns null when the cart does not exist or has already been completed (converted to an order). Use to hydrate the cart state on page load or after a recovery flow. */
+    cart?: Maybe<Cart>;
+    /** Preview whether a discount code is currently applicable to a cart — read-only, no cart side effects. Use for inline feedback while the buyer types a code, before calling `cartDiscountCodesUpdate`. Result depends on the cart subtotal (minimum-order rules) so do not cache aggressively: prefer `fetchPolicy: "network-only"` or include `cart.subtotal` in the cache key. */
+    cartValidateDiscountCode: DiscountValidationResult;
+    /** Lista kategorii (Relay Connection) z opcjonalnym filtrem rootsOnly/parentId */
+    categories: CategoryConnection;
+    /** Get category by ID or slug */
+    category?: Maybe<Category>;
+    /** Get single collection */
+    collection?: Maybe<Collection>;
+    /** List collections with pagination */
+    collections: CollectionConnection;
+    /** Convert amount between currencies (applies shop margin) */
+    convertCurrency: CurrencyConversion;
+    /** List of currencies available for this shop */
+    currencies: Array<Currency>;
+    /** Get currency information by ISO 4217 code */
+    currencyInfo?: Maybe<Currency>;
+    /** The authenticated customer for the current request. The request must carry a valid customer access token (in the `Authorization: Bearer ...` header or an HTTP-only auth cookie). Returns null for anonymous requests. */
+    customer?: Maybe<Customer>;
+    /** Get available customer groups */
+    customerGroups?: Maybe<Array<CustomerGroup>>;
+    /** Fetch a single order owned by the authenticated customer. Returns null silently when there is no authenticated customer or the order does not belong to them. For guest order access use `orderByToken` instead. */
+    customerOrder?: Maybe<Order>;
+    /** Estimate points for an order amount */
+    estimatePoints: PointsEstimate;
+    /** Get exchange rate between two currencies */
+    exchangeRate?: Maybe<ExchangeRate>;
+    /** Get gift card by code (null if not found) */
+    giftCard?: Maybe<GiftCard>;
+    /** Validate gift card for use */
+    giftCardValidate: GiftCardValidatePayload;
+    /** Get available languages for this shop */
+    languages: Array<Language>;
+    /** Localization context (kraje, języki, aktualny kraj/język klienta) */
+    localization: Localization;
+    /** Fetch a single active location by ID. Returns null when missing, inactive, or owned by another shop (tenant isolation via StorefrontShopGuard). */
+    location?: Maybe<Location>;
+    /** Paginated locations for the current shop. Supports proximity (`near`), pickup-only filter (`hasPickupEnabled`), and `locationType` filter. */
+    locations: LocationConnection;
+    /** Get loyalty member status */
+    loyaltyMember?: Maybe<LoyaltyMember>;
+    /** List available loyalty rewards */
+    loyaltyRewards: Array<LoyaltyReward>;
+    /** Get public loyalty program settings */
+    loyaltySettings: LoyaltySettings;
+    /** List all loyalty tiers */
+    loyaltyTiers: Array<LoyaltyTier>;
+    /** Get loyalty transaction history */
+    loyaltyTransactions: LoyaltyTransactionConnection;
+    /** Get a navigation menu by handle */
+    menu?: Maybe<Menu>;
+    /** Universal ID-based lookup (Relay Node spec) */
+    node?: Maybe<Node>;
+    /** Batch ID-based lookup; same NodeType dla all IDs. Missing/wrong IDs → null entries (preserved length). */
+    nodes: Array<Maybe<Node>>;
+    /** Fetch a single order by its opaque access token (guest order access without a session). Optional `email` argument enables defense-in-depth: if provided, must match the order buyer email (case-insensitive); on mismatch the query returns null exactly like an invalid token. Rate-limited to 5 requests per minute per IP+shop. Response carries Cache-Control: no-store. */
+    orderByToken?: Maybe<Order>;
+    /** Get a page by handle or ID */
+    page?: Maybe<ShopPage>;
+    /** List pages with pagination */
+    pages: ShopPageConnection;
+    /** Get personalized product recommendations for the current customer */
+    personalizedRecommendations: ProductRecommendations;
+    /** Get single product by ID or handle */
+    product?: Maybe<Product>;
+    /** Get available filters for product listing (renamed from availableFilters in Storefront 5.0) */
+    productFilters: AvailableFilters;
+    /** Get recommended products similar to the given product */
+    productRecommendations: Array<Product>;
+    /** Get product reviews */
+    productReviews: ProductReviewConnection;
+    /** List products with pagination and filtering */
+    products: ProductConnection;
+    /** Get referral program statistics */
+    referralStats?: Maybe<ReferralStats>;
+    /** Get return by ID */
+    return: ReturnPayload;
+    /** Get available return reasons */
+    returnReasons: Array<ReturnReasonOption>;
+    /** Get returns for an order */
+    returnsByOrder: ReturnConnection;
+    /** Get product review statistics */
+    reviewStats: ReviewStats;
+    /** Search products (DoSwiftly alias for products() with required query) */
+    searchProducts: ProductConnection;
+    /** Search suggestions (typeahead) — top-N products + styled query suggestions (Products only). Powered by PostgreSQL FTS with prefix matching for Polish morphology coverage. */
+    searchSuggestions: PredictiveSearchResult;
+    /** Get shipment by ID */
+    shipment: ShipmentPayload;
+    /** Get shipment by tracking number */
+    shipmentByTrackingNumber: ShipmentPayload;
+    /** Get current shop information */
+    shop: Shop;
+    /** Get currency configuration for the current shop */
+    shopCurrencyConfig: ShopCurrencyConfig;
+    /** Get translations for a language */
+    translations: Translations;
+    /** List URL redirects */
+    urlRedirects: UrlRedirectConnection;
+    /** Get wishlist by ID */
+    wishlist?: Maybe<Wishlist>;
+    /** Get customer wishlists (requires customer auth) */
+    wishlists: WishlistConnection;
+};
+export type RecommendationType = 'CROSS_SELL' | 'FREQUENTLY_BOUGHT_TOGETHER' | 'PERSONALIZED' | 'RECENTLY_VIEWED' | 'SIMILAR' | 'TRENDING' | 'UPSELL';
+export type RedeemRewardPayload = {
+    /** Generated discount code for DISCOUNT type rewards */
+    discountCode?: Maybe<Scalars['String']['output']>;
+    /** Generated gift card code for GIFT_CARD type rewards */
+    giftCardCode?: Maybe<Scalars['String']['output']>;
+    /** Generated discount code for PRODUCT type rewards (100% off specific product) */
+    productDiscountCode?: Maybe<Scalars['String']['output']>;
+    /** Whether redemption was successful */
+    success: Scalars['Boolean']['output'];
+    /** Typed user errors */
+    userErrors: Array<UserError>;
+};
+export type ReferralStats = {
+    /** Completed referrals (first order placed) */
+    completedReferrals: Scalars['Int']['output'];
+    /** Pending referrals (signed up, no order yet) */
+    pendingReferrals: Scalars['Int']['output'];
+    /** Customer referral code */
+    referralCode: Scalars['String']['output'];
+    /** Shareable referral URL */
+    shareUrl: Scalars['String']['output'];
+    /** Total points earned from referrals */
+    totalPointsEarned: Scalars['Int']['output'];
+    /** Total customers referred */
+    totalReferred: Scalars['Int']['output'];
+};
+export type Return = {
+    /** When return was approved */
+    approvedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Requested compensation type */
+    compensationType?: Maybe<CompensationType>;
+    /** When return was completed */
+    completedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Creation date */
+    createdAt: Scalars['DateTime']['output'];
+    /** Customer notes/explanation */
+    customerNote?: Maybe<Scalars['String']['output']>;
+    /** Return ID */
+    id: Scalars['ID']['output'];
+    /** Items being returned */
+    items: Array<ReturnItem>;
+    /** Order ID */
+    orderId: Scalars['ID']['output'];
+    /** Order number */
+    orderNumber: Scalars['String']['output'];
+    /** Primary return reason */
+    reason: ReturnReason;
+    /** When return was received */
+    receivedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Total refund amount */
+    refundAmount?: Maybe<Money>;
+    /** When refund was processed */
+    refundedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** When return was requested */
+    requestedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** RMA number (e.g., RMA-2024-0001) */
+    returnNumber: Scalars['String']['output'];
+    /** Return shipping label (if generated) */
+    shippingLabel?: Maybe<ReturnShippingLabel>;
+    /** Current return status */
+    status: ReturnStatus;
+    /** Last update date */
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ReturnCancelPayload = {
+    /** Cancelled return */
+    return?: Maybe<Return>;
+    /** User errors */
+    userErrors: Array<UserError>;
+};
+export type ReturnConnection = {
+    /** Return edges */
+    edges: Array<ReturnEdge>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total returns count */
+    totalCount: Scalars['Int']['output'];
+};
+export type ReturnCreatePayload = {
+    /** Created return */
+    return?: Maybe<Return>;
+    /** User errors */
+    userErrors: Array<UserError>;
+};
+export type ReturnEdge = {
+    /** Cursor */
+    cursor: Scalars['String']['output'];
+    /** Return node */
+    node: Return;
+};
+export type ReturnItem = {
+    /** Approved quantity (may differ from requested) */
+    approvedQuantity?: Maybe<Scalars['Int']['output']>;
+    /** Item condition */
+    condition?: Maybe<Scalars['String']['output']>;
+    /** Item ID */
+    id: Scalars['ID']['output'];
+    /** Product image URL */
+    imageUrl?: Maybe<Scalars['String']['output']>;
+    /** Evidence photos */
+    photos?: Maybe<Array<ReturnItemPhoto>>;
+    /** Product title */
+    productTitle: Scalars['String']['output'];
+    /** Quantity being returned */
+    quantity: Scalars['Int']['output'];
+    /** Reason for returning this item */
+    reason: ReturnReason;
+    /** Product SKU */
+    sku?: Maybe<Scalars['String']['output']>;
+    /** Item-level status */
+    status?: Maybe<Scalars['String']['output']>;
+    /** Unit price of the item */
+    unitPrice?: Maybe<Money>;
+    /** Product variant ID */
+    variantId: Scalars['ID']['output'];
+    /** Variant title */
+    variantTitle?: Maybe<Scalars['String']['output']>;
+};
+export type ReturnItemPhoto = {
+    /** Alt text for accessibility */
+    alt?: Maybe<Scalars['String']['output']>;
+    /** Upload date */
+    createdAt: Scalars['DateTime']['output'];
+    /** Photo description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Photo ID */
+    id: Scalars['ID']['output'];
+    /** Photo URL */
+    url: Scalars['String']['output'];
+};
+export type ReturnPayload = {
+    /** Return data */
+    return?: Maybe<Return>;
+    /** User errors */
+    userErrors: Array<UserError>;
+};
+export type ReturnReason = 'BETTER_PRICE' | 'CHANGED_MIND' | 'DAMAGED_SHIPPING' | 'DEFECTIVE' | 'NOT_AS_DESCRIBED' | 'OTHER' | 'WRONG_ITEM';
+export type ReturnReasonOption = {
+    /** Description/help text */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Human-readable label */
+    label: Scalars['String']['output'];
+    /** Reason enum value */
+    value: ReturnReason;
+};
+export type ReturnShippingLabel = {
+    /** Carrier for the return shipment */
+    carrier?: Maybe<Scalars['String']['output']>;
+    /** When the label expires */
+    expiresAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Tracking number for the return */
+    trackingNumber?: Maybe<Scalars['String']['output']>;
+    /** URL to download the shipping label */
+    url: Scalars['String']['output'];
+};
+export type ReturnStatus = 'APPROVED' | 'CANCELLED' | 'COMPLETED' | 'DRAFT' | 'EXCHANGED' | 'EXPIRED' | 'FAILED' | 'INSPECTING' | 'IN_TRANSIT' | 'LABEL_GENERATED' | 'RECEIVED' | 'REFUNDED' | 'REFUND_PENDING' | 'REJECTED' | 'REPLACED' | 'REQUESTED';
+export type ReviewPayload = {
+    review?: Maybe<ProductReview>;
+    /** User errors */
+    userErrors: Array<UserError>;
+};
+export type ReviewStats = {
+    /** Average rating */
+    averageRating: Scalars['Float']['output'];
+    /** 5-star count */
+    fiveStarCount: Scalars['Int']['output'];
+    /** 4-star count */
+    fourStarCount: Scalars['Int']['output'];
+    /** 1-star count */
+    oneStarCount: Scalars['Int']['output'];
+    /** 3-star count */
+    threeStarCount: Scalars['Int']['output'];
+    /** Total reviews */
+    totalCount: Scalars['Int']['output'];
+    /** 2-star count */
+    twoStarCount: Scalars['Int']['output'];
+};
+export type Seo = {
+    /** SEO description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** SEO title */
+    title?: Maybe<Scalars['String']['output']>;
+};
+export type SearchQuerySuggestion = {
+    /** Suggestion with <mark> highlights matching the query prefix */
+    styledText: Scalars['String']['output'];
+    /** Plain text suggestion (product title) */
+    text: Scalars['String']['output'];
+};
+export type SelectedOption = {
+    /** Option name (e.g. "Size", "Color"). */
+    name: Scalars['String']['output'];
+    /** Stable ID of the option value — useful as a key when rendering variant selectors. Null only for legacy variants not yet migrated to relational option values. */
+    optionValueId?: Maybe<Scalars['ID']['output']>;
+    /** Option value for this variant (e.g. "Large", "Red"). */
+    value: Scalars['String']['output'];
+};
+export type Shipment = {
+    /** Creation date */
+    createdAt: Scalars['DateTime']['output'];
+    /** When the shipment was delivered */
+    deliveredAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Estimated delivery timestamp */
+    estimatedDeliveryAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Tracking events timeline */
+    events?: Maybe<Array<ShipmentEvent>>;
+    /** Unique identifier */
+    id: Scalars['ID']['output'];
+    /** Items included in this shipment */
+    items?: Maybe<Array<ShipmentItem>>;
+    /** Shipping label download URL */
+    labelUrl?: Maybe<Scalars['String']['output']>;
+    /** Order ID this shipment belongs to */
+    orderId: Scalars['ID']['output'];
+    /** Package dimensions */
+    packages?: Maybe<Array<ShipmentPackage>>;
+    /** Shipping provider (e.g., INPOST, DPD, UPS) */
+    provider: Scalars['String']['output'];
+    /** Recipient address */
+    recipientAddress?: Maybe<MailingAddress>;
+    /** Provider service code */
+    serviceCode?: Maybe<Scalars['String']['output']>;
+    /** When the shipment was shipped */
+    shippedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Current shipment status */
+    status: ShipmentStatus;
+    /** Tracking number */
+    trackingNumber?: Maybe<Scalars['String']['output']>;
+    /** External tracking URL */
+    trackingUrl?: Maybe<Scalars['String']['output']>;
+    /** Last update date */
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ShipmentEvent = {
+    /** Human-readable description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Event ID */
+    id: Scalars['ID']['output'];
+    /** Location where event occurred */
+    location?: Maybe<Scalars['String']['output']>;
+    /** When the event occurred */
+    occurredAt: Scalars['DateTime']['output'];
+    /** Provider-specific event code */
+    providerEventCode?: Maybe<Scalars['String']['output']>;
+    /** Status at this event */
+    status: ShipmentStatus;
+};
+export type ShipmentItem = {
+    /** Item ID */
+    id: Scalars['ID']['output'];
+    /** Product image URL */
+    imageUrl?: Maybe<Scalars['String']['output']>;
+    /** Quantity shipped */
+    quantity: Scalars['Int']['output'];
+    /** Product SKU */
+    sku?: Maybe<Scalars['String']['output']>;
+    /** Product title */
+    title: Scalars['String']['output'];
+    /** Variant title */
+    variantTitle?: Maybe<Scalars['String']['output']>;
+};
+export type ShipmentPackage = {
+    /** Package height in cm */
+    height?: Maybe<Scalars['Float']['output']>;
+    /** Package length in cm */
+    length?: Maybe<Scalars['Float']['output']>;
+    /** Package weight in kg */
+    weight?: Maybe<Scalars['Float']['output']>;
+    /** Package width in cm */
+    width?: Maybe<Scalars['Float']['output']>;
+};
+export type ShipmentPayload = {
+    /** Shipment data */
+    shipment?: Maybe<Shipment>;
+    /** User errors */
+    userErrors: Array<UserError>;
+};
+export type ShipmentStatus = 'CANCELLED' | 'CREATED' | 'DELIVERED' | 'EXCEPTION' | 'IN_TRANSIT' | 'LABEL_PRINTED' | 'OUT_FOR_DELIVERY' | 'PICKED_UP' | 'RETURNED';
+export type ShippingAddressInput = {
+    /** City / town. */
+    city?: InputMaybe<Scalars['String']['input']>;
+    /** Destination country (ISO 3166-1 alpha-2). Required — drives carrier eligibility and tax/region rules. */
+    country: CountryCode;
+    /** Buyer email — useful when the shipping carrier needs notification contact details. */
+    email?: InputMaybe<Scalars['String']['input']>;
+    /** Buyer first name. */
+    firstName?: InputMaybe<Scalars['String']['input']>;
+    /** Buyer last name. */
+    lastName?: InputMaybe<Scalars['String']['input']>;
+    /** Buyer phone number (free-form). */
+    phone?: InputMaybe<Scalars['String']['input']>;
+    /** Postal / ZIP code — required by most carriers for accurate rates. */
+    postalCode?: InputMaybe<Scalars['String']['input']>;
+    /** State / province / region. */
+    state?: InputMaybe<Scalars['String']['input']>;
+    /** First line of the street address (street and house / building number). */
+    streetLine1?: InputMaybe<Scalars['String']['input']>;
+};
+export type ShippingCarrier = {
+    /** Stable carrier identifier. Null when the method does not map to a registered carrier (e.g. local pickup configured by the merchant). */
+    id?: Maybe<Scalars['ID']['output']>;
+    /** URL of the carrier logo. Use for the method tile in the shipping picker. */
+    logoUrl?: Maybe<Scalars['String']['output']>;
+    /** Carrier display name (e.g. "InPost", "DPD", "DHL"). */
+    name: Scalars['String']['output'];
+    /** Carrier service code as configured by the merchant (e.g. "inpost_paczkomat"). Useful when integrating carrier widgets. */
+    serviceCode?: Maybe<Scalars['String']['output']>;
+};
+export type Shop = {
+    /** Shop physical address */
+    address?: Maybe<ShopAddress>;
+    /** Bot protection configuration (platform-level) */
+    botProtection?: Maybe<BotProtectionInfo>;
+    /** Shop brand metadata (logo + slogan + colors). Tenant-scoped (vs canonical product `Brand` entity used in `Product.brand`). */
+    brand?: Maybe<ShopBrand>;
+    /** Complete branding configuration */
+    branding?: Maybe<ShopBranding>;
+    /** Business operating hours */
+    businessHours?: Maybe<Array<BusinessHour>>;
+    /** Contact email address */
+    contactEmail?: Maybe<Scalars['String']['output']>;
+    /** Contact information policy */
+    contactInformation?: Maybe<ShopPolicy>;
+    /** Contact phone number */
+    contactPhone?: Maybe<Scalars['String']['output']>;
+    /** Default currency code (ISO 4217) */
+    currencyCode: CurrencyCode;
+    /** Customer account URL (login/orders) — z primaryDomain */
+    customerAccountUrl?: Maybe<Scalars['URL']['output']>;
+    /** Default language code (ISO 639-1) */
+    defaultLanguage?: Maybe<LanguageCode>;
+    /** Shop description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Shop unique identifier */
+    id: Scalars['ID']['output'];
+    /** Legal notice / impressum */
+    legalNotice?: Maybe<ShopPolicy>;
+    /** Locale to currency mapping for auto-detection (SSOT) */
+    localeToCurrencyMap: Array<LocaleCurrencyMapping>;
+    /** Shop logo */
+    logo?: Maybe<Image>;
+    /** Money display format z `{{amount}}` placeholder, np. "{{amount}} zł" */
+    moneyFormat: Scalars['String']['output'];
+    /** Shop name */
+    name: Scalars['String']['output'];
+    /** Supported payment currencies */
+    paymentCurrencies: Array<CurrencyCode>;
+    /** Payment configuration (currency, accepted cards, digital wallets) */
+    paymentSettings: PaymentSettings;
+    /** Primary domain (host + URL + SSL state) */
+    primaryDomain: Domain;
+    /** Privacy policy */
+    privacyPolicy?: Maybe<ShopPolicy>;
+    /** Refund / return policy */
+    refundPolicy?: Maybe<ShopPolicy>;
+    /** Shipping policy */
+    shippingPolicy?: Maybe<ShopPolicy>;
+    /** Countries shop ships to (z shipping zones) */
+    shipsToCountries: Array<CountryCode>;
+    /** Supported currencies for price display */
+    supportedCurrencies: Array<CurrencyCode>;
+    /** Supported languages (ISO 639-1) */
+    supportedLanguages?: Maybe<Array<LanguageCode>>;
+    /** Terms of sale */
+    termsOfSale?: Maybe<ShopPolicy>;
+    /** Terms of service */
+    termsOfService?: Maybe<ShopPolicy>;
+    /** Shop timezone */
+    timezone?: Maybe<Scalars['String']['output']>;
+};
+export type ShopAddress = {
+    /** City */
+    city?: Maybe<Scalars['String']['output']>;
+    /** Country code (ISO 3166-1 alpha-2) */
+    country?: Maybe<Scalars['String']['output']>;
+    /** Postal / ZIP code */
+    postalCode?: Maybe<Scalars['String']['output']>;
+    /** State / province */
+    state?: Maybe<Scalars['String']['output']>;
+    /** First line of street address */
+    streetLine1?: Maybe<Scalars['String']['output']>;
+    /** Second line of street address */
+    streetLine2?: Maybe<Scalars['String']['output']>;
+};
+export type ShopBrand = {
+    /** Primary + secondary brand colors */
+    colors?: Maybe<BrandColors>;
+    /** Cover image / hero banner */
+    coverImage?: Maybe<Image>;
+    /** Primary logo */
+    logo?: Maybe<Image>;
+    /** Short brand description */
+    shortDescription?: Maybe<Scalars['String']['output']>;
+    /** Marketing slogan / tagline */
+    slogan?: Maybe<Scalars['String']['output']>;
+    /** Square logo variant (favicons, app tiles) */
+    squareLogo?: Maybe<Image>;
+};
+export type ShopBranding = {
+    /** Brand colors */
+    colors?: Maybe<ShopColors>;
+    /** Shop favicon */
+    favicon?: Maybe<Image>;
+    /** Typography configuration */
+    fonts?: Maybe<ShopFonts>;
+    /** Shop logo */
+    logo?: Maybe<Image>;
+    /** Social media links */
+    socialLinks?: Maybe<SocialLinks>;
+};
+export type ShopColors = {
+    /** Accent color (hex) */
+    accent?: Maybe<Scalars['String']['output']>;
+    /** Background color (hex) */
+    background?: Maybe<Scalars['String']['output']>;
+    /** Primary brand color (hex) */
+    primary?: Maybe<Scalars['String']['output']>;
+    /** Secondary brand color (hex) */
+    secondary?: Maybe<Scalars['String']['output']>;
+    /** Text color (hex) */
+    text?: Maybe<Scalars['String']['output']>;
+};
+export type ShopCurrencyConfig = {
+    /** Whether prices auto-convert to customer currency */
+    autoConvertPrices: Scalars['Boolean']['output'];
+    /** Primary currency for the shop */
+    primaryCurrency: Scalars['String']['output'];
+    /** List of currencies available in storefront */
+    supportedCurrencies: Array<Scalars['String']['output']>;
+};
+export type ShopFonts = {
+    /** Secondary/heading font family */
+    heading?: Maybe<Scalars['String']['output']>;
+    /** Primary font family */
+    primary?: Maybe<Scalars['String']['output']>;
+};
+export type ShopPage = {
+    /** HTML body content */
+    body: Scalars['String']['output'];
+    /** Created date (ISO 8601) */
+    createdAt: Scalars['DateTime']['output'];
+    /** Auto-generated plain text summary */
+    excerpt: Scalars['String']['output'];
+    /** URL handle */
+    handle: Scalars['String']['output'];
+    /** Page ID */
+    id: Scalars['ID']['output'];
+    /** Publish date (ISO 8601) */
+    publishedAt?: Maybe<Scalars['DateTime']['output']>;
+    /** SEO metadata */
+    seo?: Maybe<Seo>;
+    /** Page title */
+    title: Scalars['String']['output'];
+    /** Updated date (ISO 8601) */
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type ShopPageConnection = {
+    /** Page edges */
+    edges: Array<ShopPageEdge>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of pages */
+    totalCount: Scalars['Int']['output'];
+};
+export type ShopPageEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Page node */
+    node: ShopPage;
+};
+export type ShopPolicy = Node & {
+    /** Policy body (markdown) */
+    body: Scalars['String']['output'];
+    /** URL-friendly handle (slug) */
+    handle: Scalars['String']['output'];
+    /** Globally-unique identifier */
+    id: Scalars['ID']['output'];
+    /** Policy title (e.g. "Privacy Policy") */
+    title: Scalars['String']['output'];
+    /** Canonical URL on storefront */
+    url: Scalars['URL']['output'];
+};
+export type SocialLinks = {
+    /** Facebook page URL */
+    facebook?: Maybe<Scalars['String']['output']>;
+    /** Instagram profile URL */
+    instagram?: Maybe<Scalars['String']['output']>;
+    /** LinkedIn page URL */
+    linkedin?: Maybe<Scalars['String']['output']>;
+    /** Pinterest profile URL */
+    pinterest?: Maybe<Scalars['String']['output']>;
+    /** TikTok profile URL */
+    tiktok?: Maybe<Scalars['String']['output']>;
+    /** Twitter/X profile URL */
+    twitter?: Maybe<Scalars['String']['output']>;
+    /** YouTube channel URL */
+    youtube?: Maybe<Scalars['String']['output']>;
+};
+export type StoreAvailability = {
+    /** Available stock at this location (computed: stock - reserved). Token-gated: null for anonymous requests, Int for authenticated customer context. */
+    availableStock?: Maybe<Scalars['Int']['output']>;
+    /** Whether the variant is in stock at this location */
+    isAvailable: Scalars['Boolean']['output'];
+    /** Location where this stock resides */
+    location: Location;
+    /** Human-readable pickup readiness string, localized (e.g., "Usually ready in 2 hours"). Null if location does not support pickup. */
+    pickupTime?: Maybe<Scalars['String']['output']>;
+};
+export type StoreAvailabilityConnection = {
+    /** Availability edges */
+    edges: Array<StoreAvailabilityEdge>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of locations with stock availability */
+    totalCount: Scalars['Int']['output'];
+};
+export type StoreAvailabilityEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** The availability node */
+    node: StoreAvailability;
+};
+export type StorefrontOrderStatus = 'CANCELLED' | 'COMPLETED' | 'CONFIRMED' | 'DRAFT' | 'EXPIRED' | 'ON_HOLD' | 'PENDING' | 'PROCESSING';
+export type SubscribeToMarketingPayload = {
+    /** Always true (anti-enumeration). Backend may silently skip enqueue if rate-limited or already SUBSCRIBED. */
+    accepted: Scalars['Boolean']['output'];
+    /** User-facing errors */
+    userErrors: Array<UserError>;
+};
+export type TierBenefit = {
+    /** Benefit description */
+    description?: Maybe<Scalars['String']['output']>;
+    /** Benefit icon */
+    icon?: Maybe<Scalars['String']['output']>;
+    /** Benefit name */
+    name: Scalars['String']['output'];
+};
+export type TierProgress = {
+    /** Current tier */
+    currentTier: LoyaltyTier;
+    /** Next tier (null if at max) */
+    nextTier?: Maybe<LoyaltyTier>;
+    /** Points needed for next tier */
+    pointsToNextTier: Scalars['Int']['output'];
+    /** Progress percentage (0-100) */
+    progressPercent: Scalars['Float']['output'];
+    /** Spend needed for next tier */
+    spendToNextTier?: Maybe<Money>;
+};
+export type TranslationEntry = {
+    /** Translation key */
+    key: Scalars['String']['output'];
+    /** Translated value */
+    value: Scalars['String']['output'];
+};
+export type TranslationNamespace = {
+    /** Translations in this namespace */
+    entries: Array<TranslationEntry>;
+    /** Namespace identifier */
+    namespace: Scalars['String']['output'];
+};
+export type Translations = {
+    /** Language code (ISO 639-1) */
+    language: Scalars['String']['output'];
+    /** Namespaces with translations */
+    namespaces: Array<TranslationNamespace>;
+};
+export type UnitSystem = 'IMPERIAL_SYSTEM' | 'METRIC_SYSTEM';
+export type UnsubscribeFromMarketingPayload = {
+    /** Always true (anti-enumeration). */
+    accepted: Scalars['Boolean']['output'];
+    /** User-facing errors */
+    userErrors: Array<UserError>;
+};
+export type UrlRedirect = {
+    /** Source path */
+    path: Scalars['String']['output'];
+    /** Target path or URL */
+    target: Scalars['String']['output'];
+};
+export type UrlRedirectConnection = {
+    /** Redirect nodes */
+    nodes: Array<UrlRedirect>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+};
+export type UserError = {
+    /** Stable machine-readable code (e.g. `CART_NOT_FOUND`, `NOT_ENOUGH_IN_STOCK`, `INVALID_DISCOUNT_CODE`). The list of possible codes is defined per mutation by `CartErrorCode`, `CustomerErrorCode`, `PaymentErrorCode`, etc. */
+    code?: Maybe<Scalars['String']['output']>;
+    /** Path of the input field that caused the error (e.g. `["input", "lines", 0, "quantity"]`). Use to highlight the offending control in a form. */
+    field?: Maybe<Array<Scalars['String']['output']>>;
+    /** Human-readable error message localised to the request locale (e.g. `Accept-Language`). For display only. */
+    message: Scalars['String']['output'];
+};
+export type Weight = {
+    /** Unit of the weight (GRAMS, KILOGRAMS, OUNCES or POUNDS). */
+    unit: WeightUnit;
+    /** Weight magnitude, interpreted according to `unit`. */
+    value: Scalars['Float']['output'];
+};
+export type WeightUnit = 'GRAMS' | 'KILOGRAMS' | 'OUNCES' | 'POUNDS';
+export type Wishlist = {
+    /** Created date */
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    /** Is publicly shareable */
+    isPublic: Scalars['Boolean']['output'];
+    /** Total items count */
+    itemCount: Scalars['Int']['output'];
+    /** Wishlist items */
+    items: Array<WishlistItem>;
+    /** Wishlist name */
+    name: Scalars['String']['output'];
+    /** Share URL token */
+    shareToken?: Maybe<Scalars['String']['output']>;
+    /** Updated date */
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type WishlistConnection = {
+    /** Wishlist edges with cursors */
+    edges: Array<WishlistEdge>;
+    /** Wishlist nodes (shortcut for edges.map(e => e.node)) */
+    nodes: Array<Wishlist>;
+    /** Pagination info */
+    pageInfo: PageInfo;
+    /** Total count of wishlists */
+    totalCount: Scalars['Int']['output'];
+};
+export type WishlistEdge = {
+    /** Cursor for pagination */
+    cursor: Scalars['String']['output'];
+    /** Wishlist node */
+    node: Wishlist;
+};
+export type WishlistItem = {
+    /** Date added */
+    addedAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    /** Notify on restock */
+    notifyOnRestock: Scalars['Boolean']['output'];
+    /** Notify on sale */
+    notifyOnSale: Scalars['Boolean']['output'];
+    /** Price when added to wishlist */
+    priceWhenAdded: Money;
+    /** Product details */
+    product?: Maybe<Product>;
+    productId: Scalars['ID']['output'];
+    /** Variant details */
+    variant?: Maybe<ProductVariant>;
+    variantId?: Maybe<Scalars['ID']['output']>;
+};
+export type WishlistPayload = {
+    /** Typed user errors */
+    userErrors: Array<UserError>;
+    wishlist?: Maybe<Wishlist>;
+};
+export type AvailablePaymentMethodsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type AvailablePaymentMethodsQuery = {
+    availablePaymentMethods: {
+        methods: Array<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+        defaultMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+    };
+};
+export type CartAddLinesMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    lines: Array<CartLineInput> | CartLineInput;
+}>;
+export type CartAddLinesMutation = {
+    cartAddLines: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartApplyGiftCardMutationVariables = Exact<{
+    input: CartApplyGiftCardInput;
+}>;
+export type CartApplyGiftCardMutation = {
+    cartApplyGiftCard: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartAvailableShippingMethodsQueryVariables = Exact<{
+    cartId: Scalars['ID']['input'];
+    address: ShippingAddressInput;
+}>;
+export type CartAvailableShippingMethodsQuery = {
+    cart?: Maybe<(Pick<Cart, 'id' | 'requiresShipping'> & {
+        availableShippingMethods: {
+            methods: Array<(Pick<AvailableShippingMethod, 'id' | 'name' | 'description' | 'deliveryType' | 'isFree' | 'sortOrder'> & {
+                carrier?: Maybe<Pick<ShippingCarrier, 'id' | 'name' | 'logoUrl' | 'serviceCode'>>;
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+                estimatedDelivery?: Maybe<Pick<DeliveryEstimate, 'minDays' | 'maxDays' | 'description'>>;
+                freeShippingProgress?: Maybe<(Pick<FreeShippingProgress, 'qualifies' | 'progressPercent' | 'message'> & {
+                    currentAmount?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    threshold?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    remaining?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                })>;
+            })>;
+            freeShippingProgress?: Maybe<(Pick<FreeShippingProgress, 'qualifies' | 'progressPercent' | 'message'> & {
+                currentAmount?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                threshold?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                remaining?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            })>;
+            userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        };
+    })>;
+};
+export type CartCompleteMutationVariables = Exact<{
+    input: CartCompleteInput;
+}>;
+export type CartCompleteMutation = {
+    cartComplete: {
+        order?: Maybe<(Pick<Order, 'id' | 'orderNumber' | 'accessToken' | 'status' | 'paymentStatus' | 'fulfillmentStatus' | 'processedAt' | 'confirmedAt' | 'cancelledAt' | 'expiredAt' | 'itemCount' | 'canCreatePayment' | 'paymentMethodType'> & {
+            totals: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalShipping?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartCreateMutationVariables = Exact<{
+    input?: InputMaybe<CartCreateInput>;
+}>;
+export type CartCreateMutation = {
+    cartCreate: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartDiscountCodesUpdateMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    discountCodes: Array<Scalars['String']['input']> | Scalars['String']['input'];
+}>;
+export type CartDiscountCodesUpdateMutation = {
+    cartDiscountCodesUpdate: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type CartQuery = {
+    cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+        cost: {
+            total: Pick<Money, 'amount' | 'currencyCode'>;
+            subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+            totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        };
+        lines: (Pick<CartLineConnection, 'totalCount'> & {
+            nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                    price: Pick<Money, 'amount' | 'currencyCode'>;
+                    compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                    selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                    weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                });
+                cost: {
+                    pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                    subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                    total: Pick<Money, 'amount' | 'currencyCode'>;
+                    compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                };
+                attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+            })>;
+            pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+        });
+        buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+        discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+        discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+            amount: Pick<Money, 'amount' | 'currencyCode'>;
+        })>;
+        attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+        shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+            pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+        })>;
+        billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+            pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+        })>;
+        selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+            price: Pick<Money, 'amount' | 'currencyCode'>;
+        })>;
+        selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+        appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+            appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+            remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+        })>;
+    })>;
+};
+export type CartRemoveGiftCardMutationVariables = Exact<{
+    input: CartRemoveGiftCardInput;
+}>;
+export type CartRemoveGiftCardMutation = {
+    cartRemoveGiftCard: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartRemoveLinesMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    lineIds: Array<Scalars['ID']['input']> | Scalars['ID']['input'];
+}>;
+export type CartRemoveLinesMutation = {
+    cartRemoveLines: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartSelectPaymentMethodMutationVariables = Exact<{
+    input: CartSelectPaymentMethodInput;
+}>;
+export type CartSelectPaymentMethodMutation = {
+    cartSelectPaymentMethod: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartSelectShippingMethodMutationVariables = Exact<{
+    input: CartSelectShippingMethodInput;
+}>;
+export type CartSelectShippingMethodMutation = {
+    cartSelectShippingMethod: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartSetBillingAddressMutationVariables = Exact<{
+    input: CartSetBillingAddressInput;
+}>;
+export type CartSetBillingAddressMutation = {
+    cartSetBillingAddress: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartSetShippingAddressMutationVariables = Exact<{
+    input: CartSetShippingAddressInput;
+}>;
+export type CartSetShippingAddressMutation = {
+    cartSetShippingAddress: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartUpdateAttributesMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    attributes: Array<CartAttributeInput> | CartAttributeInput;
+}>;
+export type CartUpdateAttributesMutation = {
+    cartUpdateAttributes: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartUpdateBuyerIdentityMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    buyerIdentity: CartBuyerIdentityInput;
+}>;
+export type CartUpdateBuyerIdentityMutation = {
+    cartUpdateBuyerIdentity: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartUpdateGiftCardRecipientMutationVariables = Exact<{
+    input: CartUpdateGiftCardRecipientInput;
+}>;
+export type CartUpdateGiftCardRecipientMutation = {
+    cartUpdateGiftCardRecipient: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartUpdateLinesMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    lines: Array<CartLineUpdateInput> | CartLineUpdateInput;
+}>;
+export type CartUpdateLinesMutation = {
+    cartUpdateLines: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartUpdateNoteMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    note: Scalars['String']['input'];
+}>;
+export type CartUpdateNoteMutation = {
+    cartUpdateNote: {
+        cart?: Maybe<(Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+            cost: {
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            lines: (Pick<CartLineConnection, 'totalCount'> & {
+                nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+                    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                        price: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+                    });
+                    cost: {
+                        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                        total: Pick<Money, 'amount' | 'currencyCode'>;
+                        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                    };
+                    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+                    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+                })>;
+                pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+            });
+            buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+            discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+            discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+                amount: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+            shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+            selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+            appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+                appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+                remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+            })>;
+        })>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+        warnings: Array<Pick<CartWarning, 'message' | 'code' | 'target'>>;
+    };
+};
+export type CartValidateDiscountCodeQueryVariables = Exact<{
+    cartId: Scalars['ID']['input'];
+    discountCode: Scalars['String']['input'];
+}>;
+export type CartValidateDiscountCodeQuery = {
+    cartValidateDiscountCode: (Pick<DiscountValidationResult, 'isValid'> & {
+        discount?: Maybe<(Pick<DiscountInfo, 'code' | 'title' | 'type' | 'value'> & {
+            discountAmount?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        })>;
+        error?: Maybe<Pick<DiscountValidationError, 'code' | 'message'>>;
+    });
+};
+export type OrderByTokenQueryVariables = Exact<{
+    token: Scalars['String']['input'];
+    email?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type OrderByTokenQuery = {
+    orderByToken?: Maybe<(Pick<Order, 'id' | 'orderNumber' | 'accessToken' | 'status' | 'paymentStatus' | 'fulfillmentStatus' | 'processedAt' | 'confirmedAt' | 'cancelledAt' | 'expiredAt' | 'itemCount' | 'canCreatePayment' | 'paymentMethodType'> & {
+        totals: {
+            total: Pick<Money, 'amount' | 'currencyCode'>;
+            subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+            totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            totalShipping?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        };
+        shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+            pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+        })>;
+    })>;
+};
+export type PaymentCreateMutationVariables = Exact<{
+    input: PaymentCreateInput;
+}>;
+export type PaymentCreateMutation = {
+    paymentCreate: {
+        payment?: Maybe<Pick<PaymentSession, 'id' | 'orderId' | 'flow' | 'provider' | 'redirectUrl' | 'clientSecret' | 'status' | 'expiresAt'>>;
+        userErrors: Array<Pick<UserError, 'message' | 'code' | 'field'>>;
+    };
+};
+export type CustomerAddressesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type CustomerAddressesQuery = {
+    customer?: Maybe<{
+        addresses: (Pick<MailingAddressConnection, 'totalCount'> & {
+            nodes: Array<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+                pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+            })>;
+            pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+        });
+    }>;
+};
+export type CustomerLoginMutationVariables = Exact<{
+    input: CustomerAccessTokenCreateInput;
+}>;
+export type CustomerLoginMutation = {
+    customerLogin: {
+        customerAccessToken?: Maybe<Pick<CustomerAccessToken, 'accessToken' | 'expiresAt'>>;
+        userErrors: Array<Pick<UserError, 'message' | 'field' | 'code'>>;
+    };
+};
+export type CustomerLogoutMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type CustomerLogoutMutation = {
+    customerLogout: (Pick<CustomerLogoutPayload, 'deletedAccessToken' | 'deletedCustomerAccessTokenId'> & {
+        userErrors: Array<Pick<UserError, 'message' | 'field' | 'code'>>;
+    });
+};
+export type CustomerQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type CustomerQuery = {
+    customer?: Maybe<(Pick<Customer, 'id' | 'email' | 'firstName' | 'lastName' | 'displayName' | 'phone' | 'isEmailVerified' | 'emailMarketing' | 'orderCount' | 'createdAt' | 'updatedAt'> & {
+        defaultAddress?: Maybe<Pick<MailingAddress, 'id' | 'streetLine1' | 'streetLine2' | 'city' | 'company' | 'country' | 'countryCode' | 'firstName' | 'lastName' | 'name' | 'phone' | 'state' | 'stateCode' | 'postalCode' | 'isDefault'>>;
+        totalSpent: Pick<Money, 'amount' | 'currencyCode'>;
+    })>;
+};
+export type CustomerRefreshTokenMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type CustomerRefreshTokenMutation = {
+    customerRefreshToken: {
+        customerAccessToken?: Maybe<Pick<CustomerAccessToken, 'accessToken' | 'expiresAt'>>;
+        userErrors: Array<Pick<UserError, 'message' | 'field' | 'code'>>;
+    };
+};
+export type CustomerSignupMutationVariables = Exact<{
+    input: CustomerCreateInput;
+}>;
+export type CustomerSignupMutation = {
+    customerSignup: {
+        customer?: Maybe<(Pick<Customer, 'id' | 'email' | 'firstName' | 'lastName' | 'displayName' | 'phone' | 'isEmailVerified' | 'emailMarketing' | 'orderCount' | 'createdAt' | 'updatedAt'> & {
+            defaultAddress?: Maybe<Pick<MailingAddress, 'id' | 'streetLine1' | 'streetLine2' | 'city' | 'company' | 'country' | 'countryCode' | 'firstName' | 'lastName' | 'name' | 'phone' | 'state' | 'stateCode' | 'postalCode' | 'isDefault'>>;
+            totalSpent: Pick<Money, 'amount' | 'currencyCode'>;
+        })>;
+        customerAccessToken?: Maybe<Pick<CustomerAccessToken, 'accessToken' | 'expiresAt'>>;
+        userErrors: Array<Pick<UserError, 'message' | 'field' | 'code'>>;
+    };
+};
+export type AvailablePaymentMethodsFragment = {
+    methods: Array<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+    defaultMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+};
+export type PaymentMethodFragment = Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>;
+export type CartFragment = (Pick<Cart, 'id' | 'checkoutUrl' | 'totalQuantity' | 'note' | 'email' | 'phone' | 'requiresShipping' | 'createdAt' | 'updatedAt'> & {
+    cost: {
+        total: Pick<Money, 'amount' | 'currencyCode'>;
+        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+        totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    };
+    lines: (Pick<CartLineConnection, 'totalCount'> & {
+        nodes: Array<(Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+            variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+                price: Pick<Money, 'amount' | 'currencyCode'>;
+                compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+                image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+                selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+                weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+            });
+            cost: {
+                pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+                subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+                total: Pick<Money, 'amount' | 'currencyCode'>;
+                compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+            };
+            attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+            attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+        })>;
+        pageInfo: Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+    });
+    buyerIdentity?: Maybe<Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>>;
+    discountCodes: Array<Pick<CartDiscountCode, 'code' | 'isApplicable'>>;
+    discountAllocations: Array<(Pick<CartDiscountAllocation, 'discountCode'> & {
+        amount: Pick<Money, 'amount' | 'currencyCode'>;
+    })>;
+    attributes: Array<Pick<CartAttribute, 'key' | 'value'>>;
+    shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+        pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+    })>;
+    billingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+        pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+    })>;
+    selectedShippingMethod?: Maybe<(Pick<CartShippingMethod, 'handle' | 'title'> & {
+        price: Pick<Money, 'amount' | 'currencyCode'>;
+    })>;
+    selectedPaymentMethod?: Maybe<Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>>;
+    appliedGiftCards: Array<(Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+        appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+        remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+    })>;
+});
+export type CartCostFragment = {
+    total: Pick<Money, 'amount' | 'currencyCode'>;
+    subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+    totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    totalDuty?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    checkoutCharge?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+};
+export type CartLineFragment = (Pick<CartLine, 'id' | 'quantity' | 'productId' | 'productTitle' | 'productHandle' | 'productType' | 'requiresShipping'> & {
+    variant: (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+        price: Pick<Money, 'amount' | 'currencyCode'>;
+        compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+        selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+        weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+    });
+    cost: {
+        pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+        total: Pick<Money, 'amount' | 'currencyCode'>;
+        compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    };
+    attributes: Array<Pick<Attribute, 'key' | 'value'>>;
+    attributeSelections: Array<Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>>;
+});
+export type CartLineCostFragment = {
+    pricePerUnit: Pick<Money, 'amount' | 'currencyCode'>;
+    subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+    total: Pick<Money, 'amount' | 'currencyCode'>;
+    compareAtPricePerUnit?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+};
+export type ProductVariantFragment = (Pick<ProductVariant, 'id' | 'title' | 'sku' | 'isAvailable' | 'availableStock' | 'barcode' | 'sortOrder'> & {
+    price: Pick<Money, 'amount' | 'currencyCode'>;
+    compareAtPrice?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    image?: Maybe<Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>>;
+    selectedOptions: Array<Pick<SelectedOption, 'name' | 'value'>>;
+    weight?: Maybe<Pick<Weight, 'value' | 'unit'>>;
+});
+export type MoneyFragment = Pick<Money, 'amount' | 'currencyCode'>;
+export type ImageThumbnailFragment = Pick<Image, 'id' | 'url' | 'altText' | 'width' | 'height' | 'thumbhash'>;
+export type SelectedOptionFragment = Pick<SelectedOption, 'name' | 'value'>;
+export type AttributeSelectionFragment = Pick<AttributeSelection, 'attributeDefinitionId' | 'attributeName' | 'type' | 'fillingMode' | 'billingMode' | 'optionId' | 'optionLabel' | 'optionIds' | 'textValue' | 'surchargeAmount' | 'surchargeType' | 'taxClassId' | 'linkedVariantId'>;
+export type CartBuyerIdentityFragment = Pick<CartBuyerIdentity, 'email' | 'phone' | 'countryCode'>;
+export type CartDiscountCodeFragment = Pick<CartDiscountCode, 'code' | 'isApplicable'>;
+export type CartDiscountAllocationFragment = (Pick<CartDiscountAllocation, 'discountCode'> & {
+    amount: Pick<Money, 'amount' | 'currencyCode'>;
+});
+export type MailingAddressFragment = (Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+    pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+});
+export type PickupPointFragment = Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>;
+export type CartShippingMethodFragment = (Pick<CartShippingMethod, 'handle' | 'title'> & {
+    price: Pick<Money, 'amount' | 'currencyCode'>;
+});
+export type CartAppliedGiftCardFragment = (Pick<CartAppliedGiftCard, 'id' | 'maskedCode' | 'lastCharacters'> & {
+    appliedAmount: Pick<Money, 'amount' | 'currencyCode'>;
+    remainingBalance: Pick<Money, 'amount' | 'currencyCode'>;
+});
+export type CartSelectedPaymentMethodFragment = Pick<PaymentMethod, 'id' | 'name' | 'provider' | 'type' | 'icon' | 'description' | 'isDefault' | 'supportedCurrencies' | 'position'>;
+export type PageInfoFragment = Pick<PageInfo, 'hasNextPage' | 'hasPreviousPage' | 'startCursor' | 'endCursor'>;
+export type UserErrorFragment = Pick<UserError, 'message' | 'code' | 'field'>;
+export type CartWarningFragment = Pick<CartWarning, 'message' | 'code' | 'target'>;
+export type AvailableShippingMethodFragment = (Pick<AvailableShippingMethod, 'id' | 'name' | 'description' | 'deliveryType' | 'isFree' | 'sortOrder'> & {
+    carrier?: Maybe<Pick<ShippingCarrier, 'id' | 'name' | 'logoUrl' | 'serviceCode'>>;
+    price: Pick<Money, 'amount' | 'currencyCode'>;
+    estimatedDelivery?: Maybe<Pick<DeliveryEstimate, 'minDays' | 'maxDays' | 'description'>>;
+    freeShippingProgress?: Maybe<(Pick<FreeShippingProgress, 'qualifies' | 'progressPercent' | 'message'> & {
+        currentAmount?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        threshold?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        remaining?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    })>;
+});
+export type ShippingCarrierFragment = Pick<ShippingCarrier, 'id' | 'name' | 'logoUrl' | 'serviceCode'>;
+export type DeliveryEstimateFragment = Pick<DeliveryEstimate, 'minDays' | 'maxDays' | 'description'>;
+export type FreeShippingProgressFragment = (Pick<FreeShippingProgress, 'qualifies' | 'progressPercent' | 'message'> & {
+    currentAmount?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    threshold?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    remaining?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+});
+export type OrderFragment = (Pick<Order, 'id' | 'orderNumber' | 'accessToken' | 'status' | 'paymentStatus' | 'fulfillmentStatus' | 'processedAt' | 'confirmedAt' | 'cancelledAt' | 'expiredAt' | 'itemCount' | 'canCreatePayment' | 'paymentMethodType'> & {
+    totals: {
+        total: Pick<Money, 'amount' | 'currencyCode'>;
+        subtotal: Pick<Money, 'amount' | 'currencyCode'>;
+        totalTax?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+        totalShipping?: Maybe<Pick<Money, 'amount' | 'currencyCode'>>;
+    };
+    shippingAddress?: Maybe<(Pick<MailingAddress, 'id' | 'firstName' | 'lastName' | 'name' | 'company' | 'streetLine1' | 'streetLine2' | 'city' | 'state' | 'stateCode' | 'country' | 'countryCode' | 'postalCode' | 'phone' | 'isDefault' | 'taxId' | 'vatNumber'> & {
+        pickupPoint?: Maybe<Pick<PickupPoint, 'provider' | 'pointId' | 'name' | 'address'>>;
+    })>;
+});
+export type PaymentSessionFragment = Pick<PaymentSession, 'id' | 'orderId' | 'flow' | 'provider' | 'redirectUrl' | 'clientSecret' | 'status' | 'expiresAt'>;
+export type CustomerAccessTokenFieldsFragment = Pick<CustomerAccessToken, 'accessToken' | 'expiresAt'>;
+export type UserErrorFieldsFragment = Pick<UserError, 'message' | 'field' | 'code'>;
+export type CustomerFieldsFragment = (Pick<Customer, 'id' | 'email' | 'firstName' | 'lastName' | 'displayName' | 'phone' | 'isEmailVerified' | 'emailMarketing' | 'orderCount' | 'createdAt' | 'updatedAt'> & {
+    defaultAddress?: Maybe<Pick<MailingAddress, 'id' | 'streetLine1' | 'streetLine2' | 'city' | 'company' | 'country' | 'countryCode' | 'firstName' | 'lastName' | 'name' | 'phone' | 'state' | 'stateCode' | 'postalCode' | 'isDefault'>>;
+    totalSpent: Pick<Money, 'amount' | 'currencyCode'>;
+});
+//# sourceMappingURL=operation-types.d.ts.map