@lana-commerce/core 11.0.0

package/types/productFiltering.d.ts

@@ -0,0 +1,58 @@
+import { Event, Store } from "effector";
+import type { Dict } from "./commonTypes.js";
+import type { HierarchicalSearchOption } from "./hierarchicalSearchOption.js";
+import { VariantPriceInfoEnv, VariantPricer } from "./variantPrice.js";
+export type FilterFn<Product> = (p: Product) => Product | undefined;
+export interface Filter<T, Product> {
+    id: string;
+    context: "product" | "variant";
+    filter(state: T, p: Product): Product | undefined;
+    api(state: T): HierarchicalSearchOption | undefined;
+}
+export interface ProductFiltering {
+    pageKey: Store<string>;
+    filtersState: Store<Dict<any>>;
+    filtersStateDebounced: Store<Dict<any>>;
+    setFiltersState: Event<{
+        pageKey: string;
+        state: Dict<any>;
+    }>;
+    setFilterState: Event<{
+        pageKey: string;
+        id: string;
+        data: any;
+    }>;
+}
+export declare function createProductFiltering(): ProductFiltering;
+export interface Filtered<Product> {
+    original: Product;
+    filtered: Product;
+}
+export declare function filterProducts<Product>(state: Dict<any>, filtersMap: Dict<Filter<any, Product>>, products: Product[]): Filtered<Product>[];
+export declare function filtersToSearchOptions(state: Dict<any>, filtersMap: Dict<Filter<any, any>>): HierarchicalSearchOption[];
+export type OptionFilterState = Set<string>;
+export interface ProductForOptionFilter {
+    variants: Array<{
+        options: Array<{
+            option_id: string;
+            option_value_id: string;
+        }>;
+    } | null> | null;
+}
+export declare function makeOptionFilter<Product extends ProductForOptionFilter>(optionID: string): Filter<OptionFilterState | undefined, Product>;
+export interface PriceFilterState {
+    from: number;
+    to: number;
+}
+export interface ProductForPriceFilter {
+    variants: Array<VariantPricer | null> | null;
+}
+export declare function makePriceFilter<Product extends ProductForPriceFilter>(env: VariantPriceInfoEnv): Filter<PriceFilterState | undefined, Product>;
+export interface RatingFilterState {
+    from: number;
+    to: number;
+}
+export interface ProductForRatingFilter {
+    average_score: number;
+}
+export declare function makeRatingFilter<Product extends ProductForRatingFilter>(): Filter<RatingFilterState | undefined, Product>;

package/types/productSEO.d.ts

@@ -0,0 +1,59 @@
+import type { CanonicalVariantURLInfo } from "./canonicalVariantURL.js";
+import type { CurrencyFragment, TieredPricingFragment } from "./graphql/types.js";
+import type { Dict } from "./commonTypes.js";
+import type { SEOMeta } from "./seo.js";
+interface Environment {
+    currency: string;
+    shopCurrency: string;
+    shopCurrencies: Dict<CurrencyFragment>;
+    canonicalVariantURL: ((info: CanonicalVariantURLInfo) => string) | null;
+}
+interface VariantLike {
+    customer_group_price: number;
+    id: string;
+    inventory: {
+        available: number;
+        low_stock: boolean;
+    } | null;
+    is_default: boolean;
+    map_price: number;
+    media_files: Array<{
+        file: {
+            id: string;
+            mime: string;
+            public_url: string;
+        } | null;
+        thumbnail_file: {
+            id: string;
+            mime: string;
+            public_url: string;
+        } | null;
+    }>;
+    price: number;
+    retail_price: number;
+    sale_price: number;
+    sale_price_eligible: boolean;
+    sku: string;
+    currency_prices: {
+        currency: string;
+        map_price: number;
+        price: number;
+        retail_price: number;
+        sale_price: number;
+        tiered_pricing: TieredPricingFragment | null;
+    }[];
+    tiered_pricing: TieredPricingFragment | null;
+}
+interface ProductLike {
+    handle: string;
+    id: string;
+    meta_description: string;
+    meta_title: string;
+    variants: Array<VariantLike | null> | null;
+}
+export interface ProductSEO {
+    canonicalLinkHref?: string;
+    meta: SEOMeta[];
+}
+export declare function productSEO(env: Environment, product: ProductLike): ProductSEO | undefined;
+export {};

package/types/productSorting.d.ts

@@ -0,0 +1,35 @@
+import type { Filtered } from "./productFiltering.js";
+import type { SearchProductsSortBy } from "./graphql/types.js";
+import { VariantPriceInfoEnv, VariantPricer } from "./variantPrice.js";
+export interface ProductInfo {
+    idx: number;
+    title: string;
+    price: number;
+    rating: number | undefined;
+}
+export interface SortOption {
+    id: string;
+    api: () => [SearchProductsSortBy, boolean];
+    func: (a: ProductInfo, b: ProductInfo) => number;
+    apiOnly?: boolean;
+}
+export declare const sortByPriceAsc: SortOption;
+export declare const sortByPriceDesc: SortOption;
+export declare const sortByTitleAsc: SortOption;
+export declare const sortByTitleDesc: SortOption;
+export declare const sortByRatingAsc: SortOption;
+export declare const sortByRatingDesc: SortOption;
+export declare const sortBySalesDesc: SortOption;
+export declare const sortByVisitsDesc: SortOption;
+export declare const defaultSortOptions: SortOption[];
+export interface SortableVariant extends VariantPricer {
+    is_default?: boolean;
+    media_files?: any[] | null;
+}
+export interface SortableProduct {
+    title: string;
+    review_count: number;
+    average_score: number;
+    variants: Array<SortableVariant | null> | null;
+}
+export declare function sortProducts<Product extends SortableProduct>(env: VariantPriceInfoEnv, sortBy: SortOption | undefined, products: Filtered<Product>[]): Filtered<Product>[];

package/types/promiseAll.d.ts

@@ -0,0 +1,5 @@
+type Depromisify<Type> = {
+    [Property in keyof Type]: Awaited<Type[Property]>;
+};
+export declare function promiseAll<T extends Record<string, any>>(obj: T): Promise<Depromisify<T>>;
+export {};

package/types/promiseLimit.d.ts

@@ -0,0 +1,13 @@
+interface QueueItem {
+    pfunc: (idx: number) => Promise<any>;
+    resolve: (v: any) => void;
+    reject: (v: any) => void;
+}
+export declare class PromiseLimiter {
+    slots: number[];
+    queue: QueueItem[];
+    constructor(num: number);
+    dispatch: () => Promise<void>;
+    run<T>(pfunc: (idx: number) => Promise<T>): Promise<T>;
+}
+export {};

package/types/rdsToInitialScores.d.ts

@@ -0,0 +1,26 @@
+import type { Dict } from "./commonTypes.js";
+interface ReviewDimensionSet {
+    overall_review_dimension: {
+        id: string;
+    } | null;
+    review_dimensions: Array<{
+        id: string;
+    } | null> | null;
+}
+interface Score {
+    review_dimension: {
+        id: string;
+    } | null;
+    score: number;
+}
+interface ReviewDimension {
+    id: string;
+    name: string;
+}
+export interface ScoreValue {
+    review_dimension_id: string;
+    score: number;
+    overall: boolean;
+}
+export declare function rdsToInitialScores(rds: ReviewDimensionSet | null | undefined, reviewDimensions: Dict<ReviewDimension>, prevScores?: Score[]): ScoreValue[];
+export {};

package/types/react/components/Portal.d.ts

@@ -0,0 +1,2 @@
+import type { PropsWithChildren } from "react";
+export declare const Portal: (props: PropsWithChildren<{}>) => import("react").ReactPortal | null;

package/types/react/components/RootCloseWrapper.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import { RootCloseTracker } from "../rootClose.js";
+interface RootCloseWrapperProps {
+    onRootClose: () => void;
+    tracker?: RootCloseTracker;
+    tag?: string;
+    disabled?: boolean;
+    ignoreBelowWidth?: number;
+    ignoreAboveWidth?: number;
+}
+export declare class RootCloseWrapper extends React.Component<RootCloseWrapperProps> {
+    added: boolean;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    render(): React.ReactNode;
+}
+export {};

package/types/react/components/SixDigitInput.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+interface SixDigitInputProps {
+    value: string;
+    onChange: (v: string) => void;
+    autoFocus?: boolean;
+    onEnteredSixDigits?: () => void;
+    className?: string;
+    inputClassName?: string;
+}
+interface CursorPositionOverride {
+    idx: number;
+    pos: number;
+}
+export declare class SixDigitInput extends React.Component<SixDigitInputProps> {
+    inputRefs: (HTMLInputElement | null)[];
+    focusedOnce: boolean;
+    cursorOverride: CursorPositionOverride | undefined;
+    cursorKeyDownPos: number;
+    focus(): void;
+    onChangeNth(e: React.ChangeEvent<HTMLInputElement>, idx: number): void;
+    onChange(nextValue: string, idx: number, move: number): void;
+    onKeyDownNth(idx: number, e: React.KeyboardEvent<HTMLInputElement>): void;
+    getValue(idx: number): string;
+    componentDidUpdate(): void;
+    render(): JSX.Element;
+}
+export {};

package/types/react/contains.d.ts

@@ -0,0 +1 @@
+export declare function contains(container: Node | null, elem: Node | null): boolean;

package/types/react/popperBinder.d.ts

@@ -0,0 +1,23 @@
+import Popper, { Placement } from "../vendor/popper/index.js";
+export type { Placement };
+export interface PopperBinderParams {
+    noFlip?: boolean;
+    scrollFlip?: boolean;
+    placement?: Placement;
+    parentWidth?: boolean;
+}
+export declare class PopperBinder {
+    params: PopperBinderParams;
+    popper: Popper | null;
+    triggerRef: any | null;
+    menuRef: any | null;
+    onUpdateCallbacks: (() => void)[];
+    constructor(params: PopperBinderParams);
+    handleUpdateMenuRef: (e: any | null) => void;
+    handleUpdateTriggerRef: (e: any | null) => void;
+    addOnUpdateCallback(newCB: () => void): void;
+    removeOnUpdateCallback(oldCB: () => void): void;
+    handleUpdate: () => void;
+    hookPopper(triggerRef: any | null, menuRef: any | null): void;
+    update(): void;
+}

package/types/react/rootClose.d.ts

@@ -0,0 +1,18 @@
+interface AdditionalOptions {
+    ignoreBelowWidth?: number;
+    ignoreAboveWidth?: number;
+}
+export declare class RootCloseTracker {
+    private hierarchical;
+    private mouseDownStatus;
+    private trackedComponents;
+    constructor(hierarchical: boolean);
+    addTrackedComponent(v: any, tag: string | undefined, onRootClose: () => void, opts?: AdditionalOptions): void;
+    removeTrackedComponent(v: any): void;
+    private handleMouseDownCapture;
+    private handleClickCapture;
+    private handleKeyUp;
+    private addEventListeners;
+    private removeEventListeners;
+}
+export {};

package/types/react/translateLocalStatic.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { Dict } from "../commonTypes.js";
+import { FArgs, FArgsPrimitives } from "../formatToJSX.js";
+export declare function makeT(perLocaleData: Dict<Dict<string>>): <TArgs extends FArgs>(template: string, ...args: TArgs) => TArgs extends FArgsPrimitives ? string : string | JSX.Element;

package/types/react/useAsyncCachedValue.d.ts

@@ -0,0 +1,2 @@
+import type { CachedLoader } from "../cachedLoader.js";
+export declare function useAsyncCachedValue<T>(loader: CachedLoader<T>): T | undefined;

package/types/refreshTimeout.d.ts

@@ -0,0 +1,5 @@
+export interface RefreshTimeout {
+    refresh(): void;
+    clear(): void;
+}
+export declare function refreshTimeout(f: () => void, delayMs: number): RefreshTimeout;

package/types/remoteAuth.d.ts

@@ -0,0 +1,14 @@
+import Postmate from "postmate";
+export type Auth = {
+    kind: "not_authorized";
+} | {
+    kind: "authorized";
+    jwt: string;
+    customerID: string;
+    customerEmail: string;
+};
+export declare function authFromJWT(jwt: string): Auth;
+export declare function getRemote(url: string): Postmate;
+type SetRemoteAuthResult = "success" | "timeout";
+export declare function setRemoteAuth(pm: Postmate, jwt: string, timeout?: number): Promise<SetRemoteAuthResult>;
+export {};

package/types/request.d.ts

@@ -0,0 +1,104 @@
+import { APIError, ErrorCode } from "./generated/codes.js";
+import type { Dict } from "./commonTypes.js";
+import { RequestDetails } from "./requestDetails.js";
+export type BackoffRetryResult<T> = {
+    type: "expected";
+    value: T;
+} | {
+    type: "unexpected";
+    value: T;
+} | {
+    type: "exhausted";
+};
+export interface ResultInfo<T> {
+    result: BackoffRetryResult<T>;
+    nextTryInMS: number;
+    attemptNumber: number;
+    totalAttempts: number;
+}
+export interface BackoffRetryOpts<T> {
+    getNextTryInMS?: (numTries: number) => number;
+    getTimeoutMS?: (numTries: number) => number;
+    numTries?: number;
+    reportResult?: (result: ResultInfo<T>) => void;
+    forceNextTry?: (info: ResultInfo<T>) => Promise<void>;
+}
+export declare const defaultNextTryInMS: (n: number) => 100 | 500 | 1000 | 200 | 2000;
+export declare const defaultTimeoutMS: (n: number) => 3000 | 6000 | 9000;
+export declare const extendedTimeoutMS: (n: number) => number;
+export declare function backoffRetry<T>(cb: (timeoutMS: number) => Promise<BackoffRetryResult<T>>, opts?: BackoffRetryOpts<T>): Promise<T>;
+export interface AbstractOp<T = any, VT = any> {
+    __opType: T;
+    __opVariablesType: VT;
+    __tag: "graphql-operation";
+}
+export interface AbstractOpWithData<T = any, DataT = any> {
+    __opType: T;
+    __opVariablesType: {
+        data: DataT;
+    };
+    __tag: "graphql-operation";
+}
+export interface GenericAPIError {
+    code?: ErrorCode;
+    meta?: Dict<any>;
+    field?: string;
+    message?: string;
+}
+export interface GraphError {
+    message: string;
+    path?: (string | number)[];
+    apiError?: APIError;
+}
+export type SystemErrorType = "fetch_not_defined" | "no_error" | "timeout" | "no_status" | "bad_status" | "unrecognized_data_body" | "unrecognized_error_body" | "more_than_one_operation";
+export type RequestResponseMulti<T> = {
+    kind: "data_or_error";
+    errors?: GraphError[];
+    data?: T;
+    details: RequestDetails;
+} | {
+    kind: "system_error";
+    type: SystemErrorType;
+    details: RequestDetails;
+};
+export type RequestResponseError = {
+    kind: "error";
+    error: GraphError;
+    details: RequestDetails;
+} | {
+    kind: "system_error";
+    type: SystemErrorType;
+    details: RequestDetails;
+} | {
+    kind: "custom_error";
+    text: string;
+};
+export declare function requestErrorPrefix(details: RequestDetails): string;
+export declare function prettyPrintGraphErrors(errors: GraphError[]): string;
+export declare function prettyPrintAPIError(err: APIError): string;
+export declare function prettyPrintGraphError(gerr: GraphError): string;
+export declare function prettyPrintRequestResponseError(err: RequestResponseError, detailed?: boolean): string;
+export type RequestResponseData<T> = {
+    kind: "data";
+    data: T;
+} | RequestResponseError;
+export type RequestResponse<T> = RequestResponseData<NonNullable<T[keyof T]>>;
+export declare function request<T extends AbstractOp>(query: T): (variables?: T["__opVariablesType"], opts?: GraphQLOpts<T["__opType"]>) => Promise<RequestResponse<T["__opType"]>>;
+export declare function requestMulti<T extends AbstractOp>(query: T): (variables?: T["__opVariablesType"], opts?: GraphQLOpts<T["__opType"]>) => Promise<RequestResponseMulti<T["__opType"]>>;
+export type GraphQLOpts<Output> = BackoffRetryOpts<RequestResponseMulti<Output>> & {
+    /** Locale field for API calls. */
+    locale?: string;
+    /** API endpoint URL (omit for default, default is good for most users) */
+    url?: string;
+    /** Optional authorization token. If customer is logged in, customer's JWT should be used here. */
+    authToken?: string;
+    /** Analytics session id. */
+    sessionID?: string;
+    /** Use commerce API endpoint. Only applies if "url" was not specified. */
+    commerce?: boolean;
+    /** Device id. Used in commerce API. */
+    deviceID?: string;
+    /** Sales channel id. Can be defined globally to affect all storefront API calls. */
+    salesChannelID?: string;
+};
+export declare function graphqlBackoffRetry<Variables, Output>(query: string, variables?: Variables, opts?: GraphQLOpts<Output>): Promise<RequestResponseMulti<Output>>;

package/types/requestDetails.d.ts

@@ -0,0 +1,16 @@
+import type { GraphQLOpts } from "./request.js";
+export declare function trimComments(v: string): string;
+export declare function skipToBalanced(v: string, i: number): number;
+export declare function extractGraphQLOperations(v: string): string[];
+export interface RequestDetails {
+    operations: string[];
+    variables: any;
+    url: string;
+    uuid?: string;
+    authToken?: string;
+    locale?: string;
+    sessionID?: string;
+    salesChannelID?: string;
+    deviceID?: string;
+}
+export declare function requestDetails(query: string, variables: any, opts: GraphQLOpts<any> | undefined, uuid: string | undefined): RequestDetails;

package/types/rfc3339Normalize.d.ts

@@ -0,0 +1 @@
+export declare function rfc3339Normalize(s: string): string;

package/types/script.d.ts

@@ -0,0 +1,36 @@
+import type { BrandingFragment, CurrencyFragment, GatewayFragment, ShopFragment } from "./graphql/types.js";
+import type { GraphQLOpts } from "./request.js";
+export interface UIEmbedConfig {
+    readonly shop: ShopFragment;
+    readonly currencies: CurrencyFragment[];
+    readonly gateways: GatewayFragment[];
+    readonly opts?: GraphQLOpts<any>;
+    readonly cdn?: string;
+    readonly tag?: string;
+}
+export interface UIEmbedInfo {
+    fontTagHref: string;
+    styleTagHref: string;
+    scriptTagSrc: string;
+    scriptInitTagContent: string;
+    fontTag: string;
+    styleTag: string;
+    scriptTag: string;
+    scriptInitTag: string;
+    essentialTags: string;
+    scriptThemeEditorTagSrc: string;
+    scriptThemeEditorTag: string;
+}
+export declare function embedUI(config: UIEmbedConfig): Promise<UIEmbedInfo>;
+export interface AnalyticsEmbedConfig {
+    readonly cdn?: string;
+    readonly beacon?: string;
+    readonly shop: ShopFragment;
+    readonly branding: BrandingFragment;
+}
+export interface AnalyticsEmbedInfo {
+    scriptTagContent: string;
+    scriptTag: string;
+    allTags: string;
+}
+export declare function embedAnalytics(config: AnalyticsEmbedConfig): Promise<AnalyticsEmbedInfo>;

package/types/seo.d.ts

@@ -0,0 +1,5 @@
+export interface SEOMeta {
+    name?: string;
+    property?: string;
+    content?: string;
+}

package/types/shopDomain.d.ts

@@ -0,0 +1,7 @@
+export interface ShopLike {
+    primary_domain?: {
+        domain: string;
+    } | null;
+    app_domain: string;
+}
+export declare function shopDomain(shop: ShopLike): string;

package/types/shopLinks.d.ts

@@ -0,0 +1,14 @@
+import { ShopLike } from "./shopDomain.js";
+export declare function shopBuyURL(shop: ShopLike | string, id: string): string;
+export declare function shopCheckoutBaseURL(shop: ShopLike | string): string;
+export declare function shopCheckoutOrderURL(shop: ShopLike | string, orderID: string, orderUUID: string): string;
+export declare function shopCheckoutTrackingURL(shop: ShopLike | string, orderID: string, orderUUID: string): string;
+export declare function shopEmailConfirmationURL(shop: ShopLike | string, token: string): string;
+export declare function shopPasswordResetURL(shop: ShopLike | string): string;
+export declare function shopNewPasswordURL(shop: ShopLike | string, code: string, email: string): string;
+export declare function shopReviewURL(shop: ShopLike | string, productID: string, email?: string): string;
+export declare function shopQuestionURL(shop: ShopLike | string, productID: string, email?: string): string;
+export declare function shopConnectURL(shop: ShopLike | string): string;
+export declare function shopRemoteURL(shop: ShopLike | string): string;
+export declare function shopUnsubscribeURL(shop: ShopLike | string, token: string, email: string): string;
+export declare function shopSubscriptionURL(shop: ShopLike | string, subscriptionID: string, email: string): string;

package/types/slate.d.ts

@@ -0,0 +1,47 @@
+import type { Dict } from "./commonTypes.js";
+interface Mark {
+    object: "mark";
+    type: "bold" | "code" | "italic" | "underlined" | "strikethrough";
+}
+interface Leaf {
+    object: "leaf";
+    text: string;
+    marks?: Mark[];
+}
+interface Node {
+    object: "block" | "inline" | "text";
+    type: "h1" | "h2" | "h3" | "ol" | "ul" | "li" | "codeblock" | "code" | "blockquote" | "paragraph" | "image" | "video" | "link" | "emoji" | "separator";
+    data: Dict<any>;
+    nodes?: Node[];
+    leaves?: Leaf[];
+}
+interface Document {
+    nodes: Node[];
+}
+interface Value {
+    document: Document;
+}
+export interface NamedDocument extends Document {
+    title: string;
+}
+export declare function splitIntoNamed(v: Value): NamedDocument[];
+export declare function split(v: Value): Node[][];
+export declare function isEmpty(v: Value): boolean;
+export declare function extractText(v: Value): string;
+export declare function extractTextFromParagraphs(v: Value): string;
+export interface Header {
+    id: string;
+    text: string;
+    children: {
+        id: string;
+        text: string;
+    }[];
+}
+export declare function extractHeaders(v: Value): Header[];
+interface ImageFile {
+    id: string;
+    public_url: string;
+}
+export declare function nodesToHTML(cdnBaseURL: string, nodes: Node[], contentImageFiles: ImageFile[]): string;
+export declare function toHTML(cdnBaseURL: string, v: Value, contentImageFiles: ImageFile[]): string[];
+export {};

package/types/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<void>;

package/types/splitBy.d.ts

@@ -0,0 +1 @@
+export declare function splitBy<T>(v: T[], isSep: (v: T) => boolean): T[][];

package/types/splitName.d.ts

@@ -0,0 +1,2 @@
+export declare function splitName(name: string): string[];
+export declare function initials(name: string): string;

package/types/stripZeros.d.ts

@@ -0,0 +1 @@
+export declare function stripZeros(v: string): string;

package/types/stripeError.d.ts

@@ -0,0 +1,14 @@
+import type { Dict } from "./commonTypes.js";
+import type { RequestResponseError } from "./request.js";
+export type StripeUnknownError = "unknown";
+export type StripeNumberError = "invalid_number" | "incorrect_number" | "incomplete_number" | "card_declined" | "missing" | "processing_error";
+export type StripeExpiryError = "invalid_expiry_month" | "invalid_expiry_year" | "expired_card" | "incomplete_expiry" | "invalid_expiry_year_past" | "invalid_expiry_month_past";
+export type StripeCVCError = "invalid_cvc" | "incorrect_cvc" | "incomplete_cvc";
+export declare function matchMap<T extends Dict<boolean>>(map: T, code: string): keyof T | undefined;
+export declare function matchNumberError(code: string): StripeNumberError | undefined;
+export declare function matchExpiryError(code: string): StripeExpiryError | undefined;
+export declare function matchCVCError(code: string): StripeCVCError | undefined;
+export declare function matchMapFromRR<T extends Dict<boolean>>(map: T, e: RequestResponseError): keyof T | undefined;
+export declare function matchNumberErrorFromRR(e: RequestResponseError): StripeNumberError | undefined;
+export declare function matchExpiryErrorFromRR(e: RequestResponseError): StripeExpiryError | undefined;
+export declare function matchCVCErrorFromRR(e: RequestResponseError): StripeCVCError | undefined;

package/types/tailSplit.d.ts

@@ -0,0 +1 @@
+export declare function tailSplit(v: string, sep: string, n: number): string[];

package/types/tieredPrice.d.ts

@@ -0,0 +1,2 @@
+import type { TieredPricingFragment } from "./graphql/types.js";
+export declare function tieredPrice(tp: TieredPricingFragment | undefined, price: number, qty: number, tieredQty: number): number;

package/types/timeIt.d.ts

@@ -0,0 +1 @@
+export declare function timeIt<T>(log: (seconds: number) => void, cb: () => Promise<T>): Promise<T>;

package/types/toMajor.d.ts

@@ -0,0 +1,8 @@
+import type { Dict } from "./commonTypes.js";
+interface CurrencyLike {
+    currency: {
+        to_minor: number;
+    };
+}
+export declare function toMajor(shopCurrencies: Dict<CurrencyLike>, currencyCode: string, v: number): number | undefined;
+export {};

package/types/toMinor.d.ts

@@ -0,0 +1,8 @@
+import type { Dict } from "./commonTypes.js";
+interface CurrencyLike {
+    currency: {
+        to_minor: number;
+    };
+}
+export declare function toMinor(shopCurrencies: Dict<CurrencyLike>, currencyCode: string, v: number): number | undefined;
+export {};

package/types/trace.d.ts

@@ -0,0 +1,17 @@
+export declare function enableTrace(): void;
+export declare function disableTrace(): void;
+export declare const traceEvents: TraceEvent[];
+export declare function trace<T>(tid: number, name: string, pfunc: () => Promise<T>): Promise<T>;
+interface TraceEventCommon {
+    id: number;
+    pid: number;
+    tid: number;
+    ts: number;
+}
+export type TraceEvent = TraceEventCommon & ({
+    ph: "B";
+    name: string;
+} | {
+    ph: "E";
+});
+export {};

package/types/translateLocale.d.ts

@@ -0,0 +1,2 @@
+export declare function getLocale(): string;
+export declare function setLocale(locale: string): void;