@occluze/tether 0.6.7 → 0.7.0

package/dist/types/server/src/shared/json.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reading JSON that arrives from outside (Shopify's answers, a Worker request body) field by field, for the browser
+ * script and the Worker alike. Every reader takes `unknown`, so a missing or mistyped field is `undefined`, never a
+ * crash.
+ */
+/** A plain object, as parsed JSON holds it. */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** The field `key` of `value`, or `undefined` when `value` is not a plain object. */
+export declare function field(value: unknown, key: string): unknown;
+/** The value when it is an array, else an empty list. */
+export declare function asList(value: unknown): unknown[];
+/** A non-empty string, or `null`: Shopify sends `""` and `null` alike for an unset text field. */
+export declare function textOrNull(value: unknown): string | null;
+export declare const numberOrNull: (value: unknown) => number | null;
+/** A count Shopify always sends; 0 for an answer without it. */
+export declare const countOrZero: (value: unknown) => number;
+export declare const listOf: <T>(value: unknown, read: (item: unknown) => T) => T[];
+/**
+ * @param connection A GraphQL connection: `{ nodes: [...] }`.
+ */
+export declare const nodesOf: <T>(connection: unknown, read: (item: unknown) => T) => {
+    nodes: T[];
+};
+/** The non-empty strings of a list. */
+export declare const textList: (value: unknown) => string[];

package/dist/types/server/src/shared/market-codes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Country and language codes as Shopify takes them, parsed the same way in the browser and the Worker: anything that
+ * isn't a code is dropped rather than repaired.
+ */
+/** An ISO 3166-1 alpha-2 code, upper case. */
+export type CountryCode = string & {
+    readonly __brand: 'CountryCode';
+};
+/** A Shopify `LanguageCode` value. */
+export type LanguageCode = string & {
+    readonly __brand: 'LanguageCode';
+};
+/** @returns `'de'` → `'DE'`; `null` for anything that is not a country code. */
+export declare function toCountry(value: unknown): CountryCode | null;
+/** @returns `'de-DE'` → `'DE'`, `'pt-BR'` → `'PT_BR'`, `'en'` → `'EN'`; `null` otherwise. */
+export declare function toLanguage(value: unknown): LanguageCode | null;

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

@@ -0,0 +1,5 @@
+import type { CustomerAddress } from './page-answers.js';
+/** @returns The address with this id in the list shown last. */
+export declare const shownAddress: (id: string) => CustomerAddress | undefined;
+/** Loads and renders the addresses. A failure is reported and shows `addresses-error`, never "no addresses yet". */
+export declare function renderAddresses(root: ParentNode): Promise<void>;

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

@@ -0,0 +1,40 @@
+/**
+ * The Worker's account answers as typed values. The Worker passes on what Shopify answers to its fixed documents, and
+ * each answer is read once, field by field. Every field a document selects is kept. One that is missing or of another
+ * type reads as `null` (a list as empty, a count as 0): a page with one blank field is better than no page. The ids
+ * the pages act on are required, and an answer without one is an error. This module reads what the account part
+ * shows (the customer, their orders through the reader the Worker shares, Shopify's `userErrors`); page-answers.ts
+ * reads the account pages' answers.
+ */
+import { TetherError } from '../client.js';
+import type { UserError } from '../client.js';
+import type { AccountOrder } from '../../server/src/shared/account-orders.js';
+/** The logged-in customer. */
+export interface AccountCustomer {
+    /** The customer's gid; left out when the Worker's `/me` doesn't send it. */
+    id?: string;
+    firstName: string | null;
+    lastName: string | null;
+    displayName: string | null;
+    emailAddress: {
+        emailAddress: string;
+    } | null;
+    defaultAddress: {
+        formatted: string[];
+    } | null;
+}
+export declare const unexpected: (what: string) => TetherError;
+/**
+ * @param what Named in the error.
+ * @throws {TetherError} Without an id.
+ */
+export declare function requiredId(value: unknown, what: string): string;
+/** @param value The `customer` of the Worker's `/me`, which flattens the email and the default address. */
+export declare function toAccountCustomer(value: unknown): AccountCustomer;
+/**
+ * @param value The `orders` of the Worker's `/orders`.
+ * @throws {TetherError} For an order without an id.
+ */
+export declare function toAccountOrders(value: unknown): AccountOrder[];
+/** @param value Shopify's `userErrors`, as Shopify or the Worker sends them. */
+export declare const toUserErrors: (value: unknown) => UserError[];

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

@@ -0,0 +1,19 @@
+/**
+ * Shows or hides each `name` element whose value is one of `conditions`' keys; other values are left alone.
+ *
+ * @param name `show`, `order-show`, `address-show`…
+ */
+export declare function showIn(root: ParentNode, name: string, conditions: Readonly<Record<string, boolean>>): void;
+/**
+ * @param row A copy of a repeater's template.
+ * @returns The `name` elements in `row`, and `row` itself when it carries `name`.
+ */
+export declare const bindsIn: (row: HTMLElement, name: string) => HTMLElement[];
+/** @returns A Shopify enum as text: `PARTIALLY_FULFILLED` → `partially fulfilled`. */
+export declare const enumText: (value: string | null | undefined) => string;
+/** @returns Shopify's formatted address on one line. */
+export declare const addressText: (address: {
+    formatted?: string[] | null;
+} | null | undefined) => string;
+/** A bind's value, looked up by the attribute's text: only the table's own keys, never `constructor` and the like. */
+export declare const ownValue: <T>(values: Readonly<Record<string, T>>, key: string) => T | undefined;

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

@@ -0,0 +1,41 @@
+import type { AddressFields, ReturnLine, SubscriptionAction } from '../../server/src/shared/account-routes.js';
+export type { AddressFields, ReturnLine };
+import type { AccountAddress, CustomerAddress, OpenedReturn, OrderDetail, Profile, SubscriptionChange, SubscriptionContract } from './page-answers.js';
+import type { ServerAnswer, ServerRequest } from './server-client.js';
+import type { AccountCustomer } from './answers.js';
+/** The account part's session, shared so both parts act as one customer. */
+interface PagesContext {
+    serverFetch: (path: string, request?: ServerRequest) => Promise<ServerAnswer>;
+    customer: () => Promise<AccountCustomer | null>;
+    bindCustomer: (root: ParentNode) => Promise<void>;
+    /** Forgets the cached customer after a change of their data. */
+    reset: () => void;
+}
+/** Called by the account part once, when it loads this part. */
+export declare function setup(shared: PagesContext): void;
+/** @throws {Error} Before `setup`: this part is only ever loaded by the account part, which calls it first. */
+export declare function pagesContext(): PagesContext;
+/**
+ * One of the customer's orders, in full (lines, totals, addresses, fulfillments, returns).
+ *
+ * @param id A gid or the numeric order id.
+ * @returns `null` when the customer has no such order.
+ */
+export declare function order(id: string | number): Promise<OrderDetail | null>;
+export declare function updateProfile({ firstName, lastName, }?: {
+    firstName?: string;
+    lastName?: string;
+}): Promise<Profile>;
+/** @returns The customer's addresses, the default one marked `isDefault`. */
+export declare function addresses(): Promise<CustomerAddress[]>;
+/** Creates an address, or updates the one with `id`; without fields, only makes it the default. */
+export declare function saveAddress(address: AddressFields | null, { id, isDefault }?: {
+    id?: string | undefined;
+    isDefault?: boolean;
+}): Promise<AccountAddress>;
+/** @returns The deleted address's id. */
+export declare function deleteAddress(id: string): Promise<string>;
+export declare function subscriptions(): Promise<SubscriptionContract[]>;
+/** @returns The changed contract or billing cycle. */
+export declare function subscriptionAction(id: string | number, action: SubscriptionAction): Promise<SubscriptionChange>;
+export declare function requestReturn(orderId: string | number, lines: ReturnLine[]): Promise<OpenedReturn>;

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

@@ -0,0 +1,13 @@
+import type { AccountOrderLine } from '../../server/src/shared/account-orders.js';
+import type { OrderDetailLine } from './page-answers.js';
+/** A line of the order list, or of the order page, which has the fields after `image` too. */
+type OrderLine = AccountOrderLine & Partial<Pick<OrderDetailLine, 'id' | 'name' | 'sku' | 'price' | 'totalPrice' | 'suggestedReturnReasonDefinitions'>>;
+/** Line id → how many of it can still be returned. */
+type Returnable = ReadonlyMap<string, number>;
+/**
+ * Renders `lines` into a `tether-order-lines` repeater.
+ *
+ * @param returns `null` for the order list.
+ */
+export declare function fillLines(box: HTMLElement, lines: readonly OrderLine[], returns: Returnable | null): void;
+export {};

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

@@ -0,0 +1,12 @@
+import type { AccountOrder } from '../../server/src/shared/account-orders.js';
+/** How many orders `orders()` answers, and a `tether-orders` list shows, without being told. */
+export declare const DEFAULT_ORDER_COUNT = 10;
+/** The most orders one request asks for: the Worker answers no more. */
+export declare const MAX_ORDER_COUNT = 50;
+/** @returns True for a number of orders one request can ask for: a whole number from 1 to `MAX_ORDER_COUNT`. */
+export declare const isOrderCount: (value: unknown) => value is number;
+/**
+ * Fills every `tether-orders` list in `root`. A failure is reported and leaves the lists empty, without claiming the
+ * customer has no orders.
+ */
+export declare function renderOrderList(root: ParentNode, loadOrders: (first: number) => Promise<AccountOrder[]>): Promise<void>;

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;