@occluze/tether 0.6.8 → 0.7.0

package/dist/types/src/account/order-page.d.ts

@@ -0,0 +1,6 @@
+type OrderState = 'loading' | 'ready' | 'not-found' | 'error';
+/** Every state but `ready`, which shows with the order. */
+export declare function showOrderState(el: HTMLElement, state: Exclude<OrderState, 'ready'>): void;
+/** Loads and renders the order `el` names. A failure is reported and shows the error state. */
+export declare function renderOrder(el: HTMLElement): Promise<void>;
+export {};

package/dist/types/src/account/page-answers.d.ts

@@ -0,0 +1,182 @@
+import type { AccountImage, AccountOrderLine } from '../../server/src/shared/account-orders.js';
+import type { Money } from '../shopify-values.js';
+/** An address as the documents select it. */
+export interface MailingAddress {
+    id: string | null;
+    firstName: string | null;
+    lastName: string | null;
+    company: string | null;
+    address1: string | null;
+    address2: string | null;
+    city: string | null;
+    province: string | null;
+    zoneCode: string | null;
+    zip: string | null;
+    country: string | null;
+    countryCode: string | null;
+    phoneNumber: string | null;
+    /** One line per entry. */
+    formatted: string[];
+}
+/** One of the customer's saved addresses. */
+export type AccountAddress = MailingAddress & {
+    id: string;
+};
+export type CustomerAddress = AccountAddress & {
+    isDefault: boolean;
+};
+interface ReturnReason {
+    id: string;
+    name: string | null;
+    handle: string | null;
+}
+/** A line of the order page's document. */
+export type OrderDetailLine = AccountOrderLine & {
+    id: string;
+    name: string | null;
+    sku: string | null;
+    price: Money | null;
+    totalPrice: Money | null;
+    suggestedReturnReasonDefinitions: {
+        nodes: ReturnReason[];
+    };
+};
+interface Tracking {
+    company: string | null;
+    number: string | null;
+    url: string | null;
+}
+export interface Fulfillment {
+    id: string | null;
+    status: string | null;
+    createdAt: string | null;
+    estimatedDeliveryAt: string | null;
+    latestShipmentStatus: string | null;
+    trackingInformation: Tracking[];
+}
+interface ReturnableLine {
+    quantity: number;
+    lineItem: {
+        id: string;
+    } | null;
+}
+/** A return Shopify opened. */
+export interface OpenedReturn {
+    id: string;
+    status: string | null;
+}
+/** The order page's document. */
+export interface OrderDetail {
+    id: string;
+    name: string | null;
+    number: number | null;
+    processedAt: string | null;
+    cancelledAt: string | null;
+    financialStatus: string | null;
+    fulfillmentStatus: string | null;
+    statusPageUrl: string | null;
+    requiresShipping: boolean | null;
+    totalPrice: Money | null;
+    subtotal: Money | null;
+    totalShipping: Money | null;
+    totalTax: Money | null;
+    shippingAddress: MailingAddress | null;
+    billingAddress: MailingAddress | null;
+    lineItems: {
+        nodes: OrderDetailLine[];
+    };
+    fulfillments: {
+        nodes: Fulfillment[];
+    };
+    returnInformation: {
+        returnableLineItems: {
+            nodes: ReturnableLine[];
+        };
+    } | null;
+    returns: {
+        nodes: OpenedReturn[];
+    };
+}
+export interface SubscriptionLine {
+    id: string | null;
+    name: string | null;
+    title: string | null;
+    variantTitle: string | null;
+    quantity: number;
+    sku: string | null;
+    currentPrice: Money | null;
+    lineDiscountedPrice: Money | null;
+    image: AccountImage | null;
+}
+interface BillingCycle {
+    cycleIndex: number | null;
+    skipped: boolean;
+    billingAttemptExpectedDate: string | null;
+}
+/** The subscriptions document. */
+export interface SubscriptionContract {
+    id: string;
+    /** `ACTIVE`, `PAUSED`, `CANCELLED`, `EXPIRED` or `FAILED`. */
+    status: string | null;
+    nextBillingDate: string | null;
+    currencyCode: string | null;
+    deliveryPrice: Money | null;
+    deliveryPolicy: {
+        interval: string | null;
+        intervalCount: {
+            count: number;
+        } | null;
+    } | null;
+    lines: {
+        nodes: SubscriptionLine[];
+    };
+    upcomingBillingCycles: {
+        nodes: BillingCycle[];
+    };
+}
+export interface Profile {
+    firstName: string | null;
+    lastName: string | null;
+}
+/** What a subscription action changed: the contract (pause, resume, cancel) or its next billing cycle (skip, unskip). */
+export type SubscriptionChange = {
+    contract: {
+        id: string | null;
+        status: string | null;
+    };
+} | {
+    billingCycle: {
+        cycleIndex: number | null;
+        skipped: boolean;
+    };
+};
+/** @throws {TetherError} Without an id. */
+export declare const toAccountAddress: (value: unknown) => AccountAddress;
+/**
+ * @param value The addresses operation's list, each address with the `isDefault` it adds.
+ * @throws {TetherError} For an address without an id.
+ */
+export declare const toCustomerAddresses: (value: unknown) => CustomerAddress[];
+/**
+ * @param value The order operation's `order`.
+ * @returns `null` when the customer has no such order.
+ * @throws {TetherError} For an order, line, reason or return without an id.
+ */
+export declare function toOrderDetail(value: unknown): OrderDetail | null;
+/**
+ * @param value The subscriptions operation's list.
+ * @throws {TetherError} For a contract without an id.
+ */
+export declare const toSubscriptionContracts: (value: unknown) => SubscriptionContract[];
+/**
+ * @param result The subscription operation's result.
+ * @throws {TetherError} With neither a contract nor a billing cycle.
+ */
+export declare function toSubscriptionChange(result: Record<string, unknown>): SubscriptionChange;
+/** @throws {TetherError} Without an id. */
+export declare function toReturn(value: unknown): OpenedReturn;
+/** @throws {TetherError} Without an id. */
+export declare const toDeletedId: (value: unknown) => string;
+/** @param value The profile operation's `customer`. */
+export declare const toProfile: (value: unknown) => Profile;
+export {};

package/dist/types/src/account/page-events.d.ts

@@ -0,0 +1,2 @@
+/** Listens on the document once, for every account page rendered into it. */
+export declare function listenToPages(): void;

package/dist/types/src/account/server-client.d.ts

@@ -0,0 +1,60 @@
+import type { AccountCustomer } from './answers.js';
+/** The Worker's answer, or a 401: the session cookie is missing, has expired, or Shopify ended the login. */
+export type ServerAnswer = {
+    kind: 'answer';
+    data: Record<string, unknown>;
+} | {
+    kind: 'logged-out';
+};
+type ServerLogin = {
+    loggedIn: true;
+    customer: AccountCustomer;
+} | {
+    loggedIn: false;
+};
+export interface ServerRequest {
+    method?: 'GET' | 'POST';
+    body?: Record<string, unknown>;
+}
+/**
+ * One request to the Worker, with the session cookie. A POST carries the header the Worker requires against
+ * cross-site forms.
+ *
+ * @throws {TetherError} `NOT_CONFIGURED` without `account.server`, `INVALID` for refused input, `HTTP_<status>` for
+ *   any other failure but a 401, with the Worker's `userErrors`; `NETWORK` when the Worker can't be reached.
+ */
+export declare function serverFetch(path: string, { method, body }?: ServerRequest): Promise<ServerAnswer>;
+/**
+ * Who is logged in, asked once and then kept; the "may be logged in" hint follows the answer.
+ *
+ * @throws {TetherError} When the Worker can't be reached or fails: that says nothing about the login.
+ */
+export declare function serverLogin(): Promise<ServerLogin>;
+/** @returns True when the Worker last said a customer is logged in. */
+export declare const isServerLoggedIn: () => boolean;
+/** Asks the Worker again on the next `serverLogin()`, after a change of the customer's data. */
+export declare function forgetServerLogin(): void;
+/**
+ * To the Worker's login, which comes back to `returnTo` with `?account=<outcome>`. The cart is linked later, at
+ * checkout, through the Worker's protected `POST /cart`.
+ *
+ * @throws {TetherError} `NOT_CONFIGURED` without `account.server`.
+ */
+export declare function serverLoginRedirect({ returnTo, locale }: {
+    returnTo: string;
+    locale?: string | undefined;
+}): void;
+/**
+ * The logged-in customer's checkout, for `Cart.setCheckoutResolver`: the Worker links the cart to the customer and
+ * answers with its checkout URL.
+ *
+ * @returns `null` when nobody is logged in or the Worker linked no cart, so the cart's own checkout URL is used.
+ * @throws {TetherError} When the Worker fails; the cart reports it and checks out without the login.
+ */
+export declare function serverCheckoutUrl(): Promise<string | null>;
+/**
+ * Ends the session at the Worker, which also unlinks the cart, then goes on to Shopify's logout when the Worker says
+ * where. Sends `tether:account-logout`.
+ */
+export declare function serverLogout(returnTo: string): Promise<'redirected' | 'stayed'>;
+export {};

package/dist/types/src/account/subscriptions-view.d.ts

@@ -0,0 +1,2 @@
+/** Loads and renders the subscriptions. A failure is reported and shows `subscriptions-error`. */
+export declare function renderSubscriptions(root: ParentNode): Promise<void>;

package/dist/types/src/account-api.d.ts

@@ -0,0 +1,18 @@
+import type { Parts } from './lazy.js';
+type AccountPart = Parts['account'];
+type AccountResult<Name extends keyof AccountPart> = Awaited<ReturnType<AccountPart[Name]>>;
+type AccountFunction<Name extends keyof AccountPart> = (...args: Parameters<AccountPart[Name]>) => Promise<AccountResult<Name>>;
+type AccountApi = {
+    [Name in keyof AccountPart]: AccountFunction<Name>;
+};
+/**
+ * Loads the account part and mounts it on `root`, when accounts are configured and the page needs them: account
+ * markup in `root`, a login coming back from the Worker (`?account=`), or the "may be logged in" hint.
+ */
+export declare function mountAccountIfUsed(root: ParentNode): void;
+/**
+ * `Tether.account`: the account part's functions, each loading the part on first call. A plain object, so `await
+ * Tether.account` and `Object.keys(Tether.account)` behave as for any object.
+ */
+export declare const accountApi: AccountApi;
+export {};

package/dist/types/src/account-marks.d.ts

@@ -0,0 +1,15 @@
+/**
+ * What the Worker's login redirect says in `?account=`: `in` after a login, `expired` when the login took too long,
+ * `error` when it failed.
+ */
+type LoginOutcome = 'in' | 'expired' | 'error';
+/** The "may be logged in" hint's key: it makes the core load the part on the next page, and holds no secret. */
+export declare const hintKey: () => string;
+/**
+ * Removes the customer tokens and pending login that Tether 0.6's browser-mode accounts kept in this browser. The
+ * session held a refresh token with the customer's full scope, so it must not stay behind once accounts run through
+ * the Worker. TODO: remove in 0.8.0, when no visitor's browser still holds a 0.6 session.
+ */
+export declare function forgetBrowserModeTokens(): void;
+export declare const isLoginOutcome: (value: string | null) => value is LoginOutcome;
+export {};

package/dist/types/src/account-pages.d.ts

@@ -0,0 +1,8 @@
+export { setup, order, updateProfile, addresses, saveAddress, deleteAddress, subscriptions, subscriptionAction, requestReturn, } from './account/operations.js';
+/** Renders the order page, profile form, addresses and subscriptions in `root`: only what it has. */
+export declare function renderPages(root?: ParentNode): Promise<void>;
+/**
+ * The error state of every account page in `root`, for when nobody can say whether a customer is logged in (the
+ * Worker or Shopify can't be reached).
+ */
+export declare function showUnavailable(root: ParentNode): void;

package/dist/types/src/account.d.ts

@@ -0,0 +1,64 @@
+import type { AccountCustomer } from './account/answers.js';
+import type { AccountOrder } from '../server/src/shared/account-orders.js';
+import type { AddressFields, ReturnLine } from './account/operations.js';
+import type { AccountAddress, CustomerAddress, OpenedReturn, OrderDetail, Profile, SubscriptionChange, SubscriptionContract } from './account/page-answers.js';
+import type { SubscriptionAction } from '../server/src/shared/account-routes.js';
+/** @returns True when the Worker last said a customer is logged in; false before it has been asked. */
+export declare const isLoggedIn: () => boolean;
+/**
+ * Through the Worker to Shopify's login page; the visitor comes back to `returnTo`.
+ *
+ * @throws {TetherError} `NOT_CONFIGURED` without `account.server`.
+ */
+export declare function login({ returnTo, locale, }?: {
+    returnTo?: string;
+    locale?: string;
+}): Promise<void>;
+/**
+ * @returns The logged-in customer, `null` when nobody is.
+ * @throws {TetherError} When the Worker can't be reached or fails.
+ */
+export declare function customer(): Promise<AccountCustomer | null>;
+/**
+ * @param options `first`: a whole number from 1 to `MAX_ORDER_COUNT`.
+ * @returns The customer's most recent orders, newest first; none when nobody is logged in.
+ * @throws {TetherError} `INVALID` for another `first`, which is refused before any request; else when the Worker or
+ *   Shopify can't answer.
+ */
+export declare function orders({ first }?: {
+    first?: number;
+}): Promise<AccountOrder[]>;
+/**
+ * Logs out here and at Shopify, and unlinks the cart. Sends `tether:account-logout`.
+ *
+ * @param options `returnTo`: where Shopify sends the visitor afterwards.
+ */
+export declare function logout({ returnTo, }?: {
+    returnTo?: string;
+}): Promise<void>;
+/**
+ * Fills the account markup in `root`: what shows when logged in or out, the customer, their orders, and the account
+ * pages.
+ */
+export declare function render(root?: ParentNode): Promise<void>;
+/** One of the customer's orders, in full (lines, totals, addresses, fulfillments, returns). */
+export declare const order: (id: string | number) => Promise<OrderDetail | null>;
+export declare const updateProfile: (fields?: {
+    firstName?: string;
+    lastName?: string;
+}) => Promise<Profile>;
+export declare const addresses: () => Promise<CustomerAddress[]>;
+/** Creates an address, or updates the one with `id`. */
+export declare const saveAddress: (address: AddressFields | null, options?: {
+    id?: string;
+    isDefault?: boolean;
+}) => Promise<AccountAddress>;
+export declare const deleteAddress: (id: string) => Promise<string>;
+export declare const subscriptions: () => Promise<SubscriptionContract[]>;
+export declare const subscriptionAction: (id: string | number, action: SubscriptionAction) => Promise<SubscriptionChange>;
+export declare const requestReturn: (orderId: string | number, lines: ReturnLine[]) => Promise<OpenedReturn>;
+/**
+ * Called by the core on mount: on the first one, finishes a login that's coming back and lets the Worker link the
+ * cart at checkout; then fills the page.
+ */
+export declare function mountAccount(root?: ParentNode): Promise<void>;

package/dist/types/src/amounts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Arithmetic on Shopify's money amounts, which are decimal strings (`'27.50'`). Comparisons go digit by digit, as
+ * integers of the smallest unit present, so two amounts that differ only past float precision aren't misjudged. Sums
+ * and differences are taken in the currency's own smallest unit, so JPY stays whole and KWD keeps its three digits.
+ */
+import type { Money } from './shopify-values.js';
+/** @returns True when both are decimal numbers and `amount` is the larger one. */
+export declare function isGreaterAmount(amount: string | null | undefined, other: string | null | undefined): boolean;
+/** @returns The amount in the currency's smallest unit (cents, yen, fils), rounded to a whole one. */
+export declare function toMinorUnits(money: Money): number;
+/** @returns The amount written with the currency's own number of digits. */
+export declare function fromMinorUnits(minorUnits: number, currencyCode: string): Money;

package/dist/types/src/analytics-shopify.d.ts

@@ -0,0 +1,41 @@
+export type EventPayload = Record<string, unknown>;
+interface TrackingValues {
+    uniqueToken: string;
+    visitToken: string;
+}
+interface DestinationContext {
+    getTrackingValues: () => TrackingValues;
+}
+type Subscriber = (payload: EventPayload, context: DestinationContext) => void;
+type Subscribe = (event: string, subscriber: Subscriber) => () => void;
+interface BusConfig {
+    shop: {
+        shopId: string;
+        channel: 'headless';
+    };
+    consent: {
+        mode: string;
+    };
+}
+/** What shopify.js registers. */
+interface DestinationSpec {
+    name: string;
+    setup?: (api: {
+        subscribe: Subscribe;
+        getConfig: () => BusConfig;
+    }) => unknown;
+}
+/** Hydrogen's `window.Shopify.analytics`. */
+export interface AnalyticsBus {
+    getConfig: () => BusConfig;
+    publish: (event: string, payload?: EventPayload) => void;
+    addDestination: (destination: DestinationSpec) => () => void;
+}
+/**
+ * Sets up `window.Shopify` for Shopify's scripts and loads them.
+ *
+ * @param isProductPage Asked by Shopify's script for the page template.
+ * @returns The bus, the page's own when a theme already set one up.
+ */
+export declare function startShopifyAnalytics(isProductPage: () => boolean): Promise<AnalyticsBus>;
+export {};

package/dist/types/src/analytics.d.ts

@@ -0,0 +1,2 @@
+/** Called by the core with the events it buffered while this part loaded; the queue then handles events as they come. */
+export declare function startAnalytics(queue: Event[]): Promise<void>;

package/dist/types/src/api-version.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shopify API versions are quarterly (YYYY-01, -04, -07, -10) and supported for 12 months. Tether pins a dated version
+ * and never targets `unstable` (it changes without notice). Used by the config, the diagnose part and the release
+ * scripts.
+ */
+import type { ApiVersion } from '../server/src/shared/api-versions.js';
+export interface ApiVersionStatus {
+    version: string;
+    /** Released and still supported. */
+    ok: boolean;
+    /** What to do about it, for people. */
+    note: string;
+    /** Months of support left, rounded; negative once support ended. */
+    monthsLeft?: number;
+    /** The version after this one. */
+    next?: string;
+}
+/** @returns True for a dated version such as `2026-07`. */
+export declare const isQuarterlyVersion: (version: unknown) => version is ApiVersion;
+/**
+ * `'2026-07'` → `'2026-10'`, `'2026-10'` → `'2027-01'`.
+ *
+ * @param steps Quarters ahead.
+ * @throws {Error} When `version` isn't a quarterly version.
+ */
+export declare function nextApiVersion(version: string, steps?: number): string;
+/** The support window of `version`, relative to `now`. */
+export declare function apiVersionStatus(version: string, now?: Date): ApiVersionStatus;

package/dist/types/src/astro.d.ts

@@ -0,0 +1,42 @@
+import type { TetherOptions } from './config.js';
+import type { StorefrontOptions } from './server.js';
+interface AstroLogger {
+    warn: (message: string) => void;
+}
+/** The argument of Astro's `astro:config:setup` hook. */
+interface AstroConfigSetup {
+    injectScript: (stage: 'head-inline' | 'page', content: string) => void;
+    /** `dev`, `build`, `preview` or `sync`. */
+    command: string;
+    config: {
+        root?: URL;
+    };
+    logger: AstroLogger;
+    addWatchFile?: (path: string) => void;
+    /** Takes a partial Astro config. A method, so that Astro's own `DeepPartial<AstroConfig>` parameter fits. */
+    updateConfig?(config: {
+        env?: {
+            schema?: Record<string, unknown>;
+        };
+    }): unknown;
+}
+/** The config options a page can be handed as JSON: all but the functions. */
+type SerializableOptions = {
+    [Key in keyof TetherOptions as Exclude<TetherOptions[Key], null | undefined> extends (...args: never[]) => unknown ? never : Key]?: TetherOptions[Key];
+};
+/** `createStorefront()`'s own options that a config shared with it may hold, which the page leaves out. */
+type ServerOnlyOptions = Pick<StorefrontOptions, 'siteUrl' | 'pageSize'>;
+/** Tether's serializable config and the storefront's own options, plus the integration's own options. */
+interface TetherAstroOptions extends SerializableOptions, ServerOnlyOptions {
+    /** Add the Tether script to every page (default true). */
+    inject?: boolean;
+    /** Files that restart the dev server when they change. */
+    watch?: string[] | null;
+}
+export type { TetherAstroOptions, AstroConfigSetup };
+export default function tether(options?: TetherAstroOptions): {
+    name: string;
+    hooks: {
+        'astro:config:setup': (setup: AstroConfigSetup) => Promise<void>;
+    };
+};

package/dist/types/src/cart/cart-shape.d.ts

@@ -0,0 +1,43 @@
+export declare const CART: {
+    readonly id: "string";
+    readonly checkoutUrl: "string";
+    readonly totalQuantity: "number";
+    readonly attributes: readonly ["object"];
+    readonly discountCodes: readonly ["object"];
+    readonly cost: {
+        readonly totalAmount: {
+            readonly amount: "string";
+            readonly currencyCode: "string";
+        };
+        readonly subtotalAmount: {
+            readonly amount: "string";
+            readonly currencyCode: "string";
+        };
+    };
+    readonly lines: {
+        readonly nodes: readonly [{
+            readonly id: "string";
+            readonly quantity: "number";
+            readonly attributes: readonly ["object"];
+            readonly cost: {
+                readonly totalAmount: {
+                    readonly amount: "string";
+                    readonly currencyCode: "string";
+                };
+                readonly subtotalAmount: {
+                    readonly amount: "string";
+                    readonly currencyCode: "string";
+                };
+                readonly amountPerQuantity: {
+                    readonly amount: "string";
+                    readonly currencyCode: "string";
+                };
+            };
+            readonly merchandise: {
+                readonly id: "string";
+                readonly selectedOptions: readonly ["object"];
+                readonly product: "object";
+            };
+        }];
+    };
+};

package/dist/types/src/cart/checkout.d.ts

@@ -0,0 +1,16 @@
+import type { CheckoutTarget } from '../config.js';
+/**
+ * The logged-in customer's checkout URL for the cart; `null` when nobody is logged in, so the cart's own checkout URL
+ * is used.
+ */
+type CheckoutResolver = () => Promise<string | null>;
+/** Sets the account part's checkout URL, or clears it with `null`. A URL it answers opens checkout logged in. */
+export declare function setCheckoutResolver(resolver: CheckoutResolver | null): void;
+/**
+ * Goes to Shopify's checkout. With `_blank` the tab opens inside the click (Safari blocks `window.open` after an
+ * await) and gets its URL once there is one.
+ *
+ * @returns The checkout URL, `null` with nothing to check out or after a reported failure.
+ */
+export declare function checkout(target?: CheckoutTarget): Promise<string | null>;
+export {};

package/dist/types/src/cart/drawer.d.ts

@@ -0,0 +1,18 @@
+/** Every cart drawer on the page. */
+export declare const drawers: () => HTMLElement[];
+/** True while a drawer, or the drawer-less cart, is open. */
+export declare function isOpen(): boolean;
+/**
+ * `aria-expanded` on the open buttons, and dialog semantics on the drawers unless their markup has its own. A closed
+ * drawer is hidden from screen readers and, with `cartFocus`, out of the Tab order (inert), like a closed dialog.
+ */
+export declare function syncDrawerAria(open: boolean): void;
+/** Opens every drawer except `tether-cart-drawer="manual"` ones, which the site opens itself. */
+export declare function openCart(): void;
+export declare function closeCart(): void;
+export declare function toggleCart(): void;
+/**
+ * Keeps Tab inside the open drawer (`cartFocus`): from the last focusable element it wraps to the first, with Shift
+ * from the first to the last, and from outside the drawer it goes in. For a document `keydown` listener.
+ */
+export declare function trapFocus(event: KeyboardEvent): void;

package/dist/types/src/cart/mutations.d.ts

@@ -0,0 +1,79 @@
+import type { AttributeValue } from '../dom.js';
+import type { ShopifyCart, Attribute } from './store.js';
+export type Attributes = Record<string, AttributeValue> | {
+    key: string | number;
+    value?: AttributeValue;
+}[];
+/** A line to add, in any of the shapes `Cart.add` takes. */
+export interface LineSpec {
+    variantId?: string | number;
+    merchandiseId?: string | number;
+    id?: string | number;
+    quantity?: number | string;
+    sellingPlanId?: string | number | null;
+    sellingPlan?: string | number | null;
+    attributes?: Attributes | null;
+}
+/** Shopify's `CartLineInput`. */
+export interface CartLineInput {
+    merchandiseId: string;
+    quantity: number;
+    sellingPlanId?: string;
+    attributes?: Attribute[];
+}
+/**
+ * @returns True when `error` says Shopify doesn't have the cart, false for any other failure (the network, the token,
+ *   a line it refused), after which the saved cart is still good.
+ */
+export declare function isCartGone(error: unknown): boolean;
+/**
+ * @param input A variant id, or a line.
+ * @param quantity For a variant id.
+ * @param options For a variant id.
+ * @throws {TetherError} `ERROR` without a variant id.
+ */
+export declare function toLineInput(input: string | number | LineSpec | null | undefined, quantity?: number, options?: Omit<LineSpec, 'variantId' | 'quantity'>): CartLineInput;
+/** A mutation on the saved cart. */
+interface CartMutation {
+    /** The mutation, e.g. `cartLinesAdd`. */
+    name: string;
+    /** Its variable definitions besides `$cartId`. */
+    args: string;
+    /** Its arguments besides `cartId`. */
+    inner: string;
+    variables: Record<string, unknown>;
+    /**
+     * The `CartInput` of a new cart that does what the mutation asks, when there is no cart (or Shopify no longer has
+     * it); `null` leaves the visitor without a cart instead.
+     */
+    createInput: Record<string, unknown> | null;
+}
+/**
+ * Runs a mutation on the saved cart, or creates a cart from `createInput` when there is none to change.
+ *
+ * @returns The changed cart; `null` without a cart and without a `createInput`.
+ * @throws {TetherError} For a failed request or Shopify's user errors; also when the cart is gone and there is no
+ *   `createInput` (the saved cart is forgotten first).
+ */
+export declare function mutateCart({ name, args, inner, variables, createInput, }: CartMutation): Promise<ShopifyCart | null>;
+/** @returns The cart, `null` when Shopify doesn't have it (expired or checked out). */
+export declare function fetchCart(id: string): Promise<ShopifyCart | null>;
+/** @returns The cart's current checkout URL, `null` when Shopify doesn't have the cart. */
+export declare function fetchCheckoutUrl(id: string): Promise<string | null>;
+/** A change to one line, for `updateLine`. */
+export interface LinePatch {
+    /** 0 or less removes the line. */
+    quantity?: number;
+    /** `null` switches the line back to one-time purchase. */
+    sellingPlanId?: string | number | null;
+    attributes?: Attributes;
+    merchandiseId?: string | number;
+    variantId?: string | number;
+}
+/** @returns Shopify's `CartLineUpdateInput`. */
+export declare function toLineUpdate(lineId: string, patch: number | LinePatch): Record<string, unknown>;
+export declare const updateLines: (lines: Record<string, unknown>[]) => Promise<ShopifyCart | null>;
+export declare const removeLines: (lineIds: string[]) => Promise<ShopifyCart | null>;
+/** @returns The cart once `lineId` has `target` (0 removes it). */
+export declare const setLineQuantity: (lineId: string, target: number) => Promise<ShopifyCart | null>;
+export {};