@replohq/sdk 0.1.0

package/_vendor/schemas/errors.d.ts

@@ -0,0 +1,459 @@
+import type { ErrorUserFacingDetails, ErrorUserFacingDetailsWithMessage } from "./generated/errors";
+import { z, ZodError } from "zod";
+/**
+ * Config to use for any standard error we throw in Replo
+ */
+export type ReploErrorConfig = {
+    /**
+     * Message of the error, used only internally. If not provided, defaults to
+     * the error's class name
+     */
+    message?: string;
+    /**
+     * Any additional data about the error, e.g. ids of content that was trying
+     * to be accessed, contextual variables, etc. This is included when the error
+     * is logged to Sentry, etc
+     */
+    additionalData?: Record<string, unknown>;
+    /** Meta details for error reporting */
+    errorReportingDetails?: {
+        /**
+         * If true, tells Sentry that it should group this error differently when
+         * it happens on different endpoints ("transactions" in Sentry are endpoints)
+         */
+        includeTransactionInFingerprint?: boolean;
+        /**
+         * If provided, these get added to the Sentry fingerprint for this error. Useful
+         * for when you want to modify the grouping of an error, especially for reusing
+         * errors in different places.
+         */
+        customFingerprint?: string[];
+    };
+    /**
+     * Original cause of the error (useful for if you need to catch and re-throw errors
+     * with more context). Will be reported in stacktraces, sentry, etc.
+     */
+    cause?: unknown;
+};
+/**
+ * Base error that all errors in Replo inherit from
+ */
+export declare abstract class ReploError extends Error {
+    config: ReploErrorConfig;
+    id: string;
+    constructor(config: ReploErrorConfig);
+}
+/**
+ * Wraps an error so `async-retry` stops immediately instead of scheduling
+ * another attempt: the library rejects with any thrown error carrying a truthy
+ * `bail` property. Preserves the underlying error's message and keeps it as the
+ * cause so callers still surface the real failure.
+ */
+export declare class AsyncRetryBailError extends ReploError {
+    readonly bail = true;
+    constructor(cause: unknown);
+}
+export type AuthErrorType = "unauthenticated" | "unauthorized" | "notFound";
+export type ReploAuthenticationErrorConfig = {
+    message: string;
+    type: AuthErrorType;
+    userFacingDetails?: ErrorUserFacingDetailsWithMessage;
+    additionalData?: ReploErrorConfig["additionalData"];
+};
+export declare class ReploAuthenticationError extends ReploError {
+    type: AuthErrorType;
+    userFacingDetails?: ErrorUserFacingDetailsWithMessage;
+    constructor(config: ReploAuthenticationErrorConfig);
+    getHttpStatusCode(): 401 | 403 | 404;
+    getTRPCErrorCode(): "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND";
+}
+/**
+ * Error which automatically makes all Replo services respond with a specific
+ * HTTP status code when caught. Should only be thrown from routes, makes it
+ * easier to provide a standardized way of implementing user-facing messages
+ */
+export declare class ReploHTTPError extends ReploError {
+    userFacingDetails: ErrorUserFacingDetails;
+    statusCode: number;
+    details?: object;
+    constructor(config: ReploErrorConfig & {
+        statusCode: number;
+        userFacingDetails: ErrorUserFacingDetails;
+        details?: object;
+    });
+}
+/**
+ * Error used to represent an HTTP error that should be surfaced as such. This
+ * should be thrown when we want to pass the error through without changing the
+ * status code and without providing any user facing details (because this route
+ * is not serving the client e.g. when we're calling Mirror through the
+ * Publisher)
+ */
+export declare class ReploRawHTTPError extends ReploError {
+    statusCode: number;
+    errorType: string;
+    data?: object;
+    constructor(config: {
+        statusCode: number;
+        message: string;
+        errorType: string;
+        data?: object;
+    });
+}
+/**
+ * Error which is automatically mapped to a status code response wherever it's
+ * thrown. Errors which are thrown from many different places where we want to
+ * always respond in the same way should inherit this, e.g. an error thrown for
+ * any Shopify call when the user has uninstalled the app.
+ *
+ * Inheriting from this should be uncommon, for most errors we want to inherit
+ * from ReploError and catch/map them to ReploHTTPErrors in our routes. For the
+ * uncommon cases where we want to globally map errors this reduces boilerplate.
+ *
+ * Globally mapped errors are never reported to Sentry or logged.
+ */
+export declare class Uncommon_GloballyMappedError extends ReploError {
+    userFacingDetails: ErrorUserFacingDetails;
+    statusCode: number;
+    constructor(config: ReploErrorConfig & {
+        statusCode: number;
+        userFacingDetails: ErrorUserFacingDetails;
+    });
+}
+export declare class ReploValidationError extends ReploError {
+    constructor(message: string);
+}
+export declare class UnexpectedMutationError extends ReploError {
+    constructor();
+}
+export declare class UnexpectedRawGraphqlClientError extends ReploError {
+    originalError: unknown;
+    errors: unknown[];
+    data: unknown;
+    constructor(opts: {
+        originalError: unknown;
+        errors: unknown[];
+        data: unknown;
+    });
+}
+export declare const DEFAULT_ERROR_MESSAGE_CONFIG: {
+    header: string;
+    message: string;
+    isFullPage: boolean;
+};
+export type ErrorDetails = {
+    header: string;
+    subheader?: string;
+    message?: string | string[] | React.ReactNode;
+    messageDetail?: string;
+    isRecoverable?: boolean;
+    isFullPage?: boolean;
+    usage?: {
+        current: number;
+        maximum: number;
+    };
+    callToAction?: {
+        type: "installApp";
+    } | {
+        type: "callback";
+        name: string;
+        onClick(): void;
+    } | {
+        type: "link";
+        name: string;
+        to: string;
+        target?: string;
+    } | {
+        type: "closeModal";
+        name: string;
+    } | {
+        type: "navigate";
+        location: {
+            type: "integrationHub";
+        } | {
+            type: "home";
+        } | {
+            type: "workspace";
+            workspaceId: string;
+            workspaceName: string;
+        };
+    } | {
+        type: "custom";
+        callToActionType: ErrorUserFacingDetailsWithMessage["callToAction"];
+    };
+};
+/**
+ * Map of error keys to custom user-facing details. Should ONLY be used
+ * in cases where we want to override the default behavior of ErrorUserFacingDetails
+ * from the backend.
+ *
+ * TODO (Noah, 2024-01-15): Clean up these custom configs, all of them
+ * are only used by Django (and 'base' can be moved directly into the reducer function)
+ */
+export declare const CUSTOM_ERROR_KEY_TO_PROPS: {
+    "shopifyArticle.failedToPublish": () => {
+        header: string;
+        message: string;
+    };
+    "shopifySection.failedToPublish": () => {
+        header: string;
+        message: string;
+    };
+    "page.failedToPublish": () => {
+        header: string;
+        message: string;
+    };
+    "shopifyProductTemplate.failedToPublish": () => {
+        header: string;
+        message: string;
+    };
+    "element.failedToPublish": () => {
+        header: string;
+        message: string;
+    };
+    "element.failedToUpdate": () => {
+        header: string;
+        message: string;
+    };
+    "store.billingPlan.alreadyExist": () => {
+        header: string;
+        message: string;
+    };
+    "error.assets.unsupportedFileType": ({ serverMessage }: {
+        type: string;
+        serverMessage?: string;
+        endpoint: string | null;
+    }) => {
+        header: string;
+        message: string;
+    };
+    "error.assets.fileTooLarge": () => {
+        header: string;
+        message: string;
+    };
+    "error.files.fileTooLarge": () => {
+        header: string;
+        message: string;
+    };
+    base: () => {
+        header: string;
+        message: string;
+        isFullPage: boolean;
+    };
+};
+export declare function extractErrorId(error: unknown): string | undefined;
+export declare function addErrorIdIfNeeded(error: unknown): void;
+export declare const errorUserFacingDetailsMessageSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        toast: "toast";
+        fullPageModal: "fullPageModal";
+        shopifyStorePassword: "shopifyStorePassword";
+        "billing.addPublishedElements": "billing.addPublishedElements";
+        "billing.addShopifyThemeProject": "billing.addShopifyThemeProject";
+        "billing.addReploSite": "billing.addReploSite";
+        "agentBilling.shopifyThemeBuilder.publishedElements.exceeded": "agentBilling.shopifyThemeBuilder.publishedElements.exceeded";
+        "agentBilling.shopifyThemeBuilder.projects.exceeded": "agentBilling.shopifyThemeBuilder.projects.exceeded";
+        "agentBilling.sites.exceeded": "agentBilling.sites.exceeded";
+        "agentBilling.credits.exceeded": "agentBilling.credits.exceeded";
+        "agentBilling.upgradeRequired": "agentBilling.upgradeRequired";
+    }>;
+    message: z.ZodString;
+    isRecoverable: z.ZodOptional<z.ZodBoolean>;
+    detail: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodString]>>;
+    key: z.ZodString;
+    usage: z.ZodOptional<z.ZodObject<{
+        current: z.ZodNumber;
+        maximum: z.ZodNumber;
+    }, z.core.$strip>>;
+    plan: z.ZodOptional<z.ZodString>;
+    callToAction: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"reload">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"installApp">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"goToHomepage">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"navigateToProjectEditor">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"closeModal">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"navigateToLink">;
+        link: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"errors.wrongJsonExtension">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.chunkingError">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.indexBackupError">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.shopifyIntegrationAlreadyAssigned">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.shopifyIntegrationMissingAccessScopes">;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"customLink">;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.projectConnectedToBillingIntegrationForShopifyWorkspace">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.themeAssetSizeLimitExceeded">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.themeTotalSizeLimitExceeded">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.pageMetafieldDefinitionsChanged">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"settings.billing">;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+/**
+ * Schema for user-facing details which the frontend uses to show toasts, modals, etc
+ * when an error is thrown from the backend
+ */
+export declare const errorUserFacingDetailsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodEnum<{
+        toast: "toast";
+        fullPageModal: "fullPageModal";
+        shopifyStorePassword: "shopifyStorePassword";
+        "billing.addPublishedElements": "billing.addPublishedElements";
+        "billing.addShopifyThemeProject": "billing.addShopifyThemeProject";
+        "billing.addReploSite": "billing.addReploSite";
+        "agentBilling.shopifyThemeBuilder.publishedElements.exceeded": "agentBilling.shopifyThemeBuilder.publishedElements.exceeded";
+        "agentBilling.shopifyThemeBuilder.projects.exceeded": "agentBilling.shopifyThemeBuilder.projects.exceeded";
+        "agentBilling.sites.exceeded": "agentBilling.sites.exceeded";
+        "agentBilling.credits.exceeded": "agentBilling.credits.exceeded";
+        "agentBilling.upgradeRequired": "agentBilling.upgradeRequired";
+    }>;
+    message: z.ZodString;
+    isRecoverable: z.ZodOptional<z.ZodBoolean>;
+    detail: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodString]>>;
+    key: z.ZodString;
+    usage: z.ZodOptional<z.ZodObject<{
+        current: z.ZodNumber;
+        maximum: z.ZodNumber;
+    }, z.core.$strip>>;
+    plan: z.ZodOptional<z.ZodString>;
+    callToAction: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"reload">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"installApp">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"goToHomepage">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"navigateToProjectEditor">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"closeModal">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"navigateToLink">;
+        link: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"errors.wrongJsonExtension">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.chunkingError">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.indexBackupError">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.shopifyIntegrationAlreadyAssigned">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.shopifyIntegrationMissingAccessScopes">;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"customLink">;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.projectConnectedToBillingIntegrationForShopifyWorkspace">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.themeAssetSizeLimitExceeded">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.themeTotalSizeLimitExceeded">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"errors.pageMetafieldDefinitionsChanged">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"settings.billing">;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"uncommon_none">;
+    key: z.ZodString;
+    usage: z.ZodOptional<z.ZodObject<{
+        current: z.ZodNumber;
+        maximum: z.ZodNumber;
+    }, z.core.$strip>>;
+    message: z.ZodOptional<z.ZodString>;
+    isRecoverable: z.ZodOptional<z.ZodBoolean>;
+    detail: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodString]>>;
+}, z.core.$strip>], "type">;
+export declare const extractErrorTrackingEventDetails: (error: unknown, transaction: string | undefined, tags?: Record<string, string>) => {
+    fingerprint: string[];
+    extra: {
+        zodIssues: z.core.$ZodIssue[];
+        cause?: undefined;
+    };
+    tags: {
+        errorId?: string | undefined;
+    };
+} | {
+    fingerprint: string[];
+    extra: Record<string, unknown> | undefined;
+    tags: {
+        errorId: string;
+    };
+} | {
+    extra: {
+        cause: unknown;
+        zodIssues?: undefined;
+    };
+    tags: {
+        errorId?: string | undefined;
+    };
+    fingerprint?: undefined;
+} | {
+    tags: {
+        errorId?: string | undefined;
+    };
+    fingerprint?: undefined;
+    extra?: undefined;
+} | null;
+export declare const shouldReportErrorToSentry: (error: Error) => boolean;
+export declare class CloudflareAgentCoordinatorRpcError extends ReploError {
+    constructor(error: unknown);
+}
+/**
+ * Failures on the shared iframe RPC channel (miniapp ↔ parent, canopy ↔ WB).
+ * Live next to other domain errors so callers get ReploError reporting without
+ * a `replo-utils → schemas` workspace cycle (schemas already depends on
+ * replo-utils; the channel implementation lives in `schemas/iframeRpcChannel`).
+ */
+export declare abstract class IframeRpcChannelError extends ReploError {
+}
+export declare class IframeRpcChannelTimeoutError extends IframeRpcChannelError {
+    constructor({ method, timeoutMs }: {
+        method: string;
+        timeoutMs: number;
+    });
+}
+export declare class IframeRpcChannelRemoteError extends IframeRpcChannelError {
+    constructor({ method, message }: {
+        method: string;
+        message: string;
+    });
+}
+export declare class IframeRpcChannelUnsubscribedError extends IframeRpcChannelError {
+    constructor({ method }: {
+        method: string;
+    });
+}
+export declare class IframeRpcChannelUnknownMethodError extends IframeRpcChannelError {
+    constructor({ method }: {
+        method: string;
+    });
+}
+export declare class IframeRpcChannelConfigurationError extends IframeRpcChannelError {
+    constructor({ message }: {
+        message: string;
+    });
+}
+export declare class IframeRpcChannelInvalidInputError extends IframeRpcChannelError {
+    constructor({ method, cause }: {
+        method: string;
+        cause: ZodError;
+    });
+}

package/_vendor/schemas/generated/consent.d.ts

@@ -0,0 +1,55 @@
+export type ReploScriptType = "GA4" | "GoogleTagManager" | "Meta" | "TikTok" | "Pinterest" | "Reddit" | "Snapchat" | "Hotjar" | "MicrosoftClarity" | "Segment" | "Northbeam" | "snippet" | "custom";
+export type ConsentCategory = "necessary" | "analytics" | "marketing" | "preferences" | "sale_of_data";
+export type ConsentMode = "off" | "simple" | "per-category";
+export type ScriptTagDescriptor = {
+    kind: "external";
+    src: string;
+    attributes?: {
+        [x: string]: string;
+    };
+} | {
+    kind: "inline";
+    body: string;
+};
+export type ReploScriptEntry = {
+    type: "GA4" | "GoogleTagManager" | "Meta" | "TikTok" | "Pinterest" | "Reddit" | "Snapchat" | "Hotjar" | "MicrosoftClarity" | "Segment" | "Northbeam";
+    identifier: string;
+    requiredConsent?: ConsentCategory[];
+} | {
+    type: "snippet";
+    id: string;
+    body: string;
+    requiredConsent: ConsentCategory[];
+} | {
+    type: "custom";
+    id: string;
+    requiredConsent: ConsentCategory[];
+    src?: string;
+    body?: string;
+};
+export type ConsentAction = "accept" | "reject" | "update" | "withdraw";
+export type ConsentRecordRequest = {
+    consentId: string;
+    projectId: string;
+    decidedAt: number;
+    action: ConsentAction;
+    categories: {
+        [x: string]: boolean;
+    };
+    consentMode: ConsentMode;
+    policyVersion: number;
+};
+export type ConsentEventMessage = {
+    consentId: string;
+    projectId: string;
+    decidedAt: number;
+    action: ConsentAction;
+    categories: {
+        [x: string]: boolean;
+    };
+    consentMode: ConsentMode;
+    policyVersion: number;
+    useragent: string;
+    referrer: string;
+    ipCountry: string;
+};

package/_vendor/schemas/generated/errors.d.ts

@@ -0,0 +1,61 @@
+export type ErrorUserFacingDetailsWithMessage = {
+    type: "toast" | "fullPageModal" | "shopifyStorePassword" | "billing.addPublishedElements" | "billing.addShopifyThemeProject" | "billing.addReploSite" | "agentBilling.shopifyThemeBuilder.publishedElements.exceeded" | "agentBilling.shopifyThemeBuilder.projects.exceeded" | "agentBilling.sites.exceeded" | "agentBilling.credits.exceeded" | "agentBilling.upgradeRequired";
+    message: string;
+    isRecoverable?: boolean;
+    detail?: string[] | string;
+    key: string;
+    usage?: {
+        current: number;
+        maximum: number;
+    };
+    plan?: string;
+    callToAction?: {
+        type: "reload";
+    } | {
+        type: "installApp";
+    } | {
+        type: "goToHomepage";
+    } | {
+        type: "navigateToProjectEditor";
+    } | {
+        type: "closeModal";
+    } | {
+        type: "navigateToLink";
+        link: {
+            type: "errors.wrongJsonExtension";
+        } | {
+            type: "errors.chunkingError";
+        } | {
+            type: "errors.indexBackupError";
+        } | {
+            type: "errors.shopifyIntegrationAlreadyAssigned";
+        } | {
+            type: "errors.shopifyIntegrationMissingAccessScopes";
+            url: string;
+        } | {
+            type: "customLink";
+            url: string;
+        } | {
+            type: "errors.projectConnectedToBillingIntegrationForShopifyWorkspace";
+        } | {
+            type: "errors.themeAssetSizeLimitExceeded";
+        } | {
+            type: "errors.themeTotalSizeLimitExceeded";
+        } | {
+            type: "errors.pageMetafieldDefinitionsChanged";
+        } | {
+            type: "settings.billing";
+        };
+    };
+};
+export type ErrorUserFacingDetails = ErrorUserFacingDetailsWithMessage | {
+    type: "uncommon_none";
+    key: string;
+    usage?: {
+        current: number;
+        maximum: number;
+    };
+    message?: string;
+    isRecoverable?: boolean;
+    detail?: string[] | string;
+};

package/_vendor/schemas/loaderKeys.d.ts

@@ -0,0 +1 @@
+export * from "../../loaders/loader-keys";

package/_vendor/schemas/loaderKeys.mjs

@@ -0,0 +1,27 @@
+import '../../chunk-UJCSKKID.mjs';
+
+// loaders/loader-keys.ts
+var DATA_LOADER_KEYS = {
+  SHOPIFY_PRODUCT: "shopify_storefront.product",
+  SHOPIFY_COLLECTION: "shopify_storefront.collection",
+  SHOPIFY_COLLECTION_PRODUCTS: "shopify_storefront.collection_products",
+  SHOPIFY_METAOBJECT: "shopify_storefront.metaobject",
+  SHOPIFY_METAOBJECTS: "shopify_storefront.metaobjects",
+  REPLO_PRODUCT: "replo_products.product",
+  OKENDO_PRODUCT_REVIEWS: "okendo.product_reviews",
+  OKENDO_PRODUCT_REVIEW_AGGREGATE: "okendo.product_review_aggregate",
+  REBUY_RECOMMENDATIONS: "rebuy.recommendations",
+  LEVANTA_PRODUCT: "levanta_products.product",
+  SMILE_IO_VIP_TIERS: "smile_io.vip_tiers",
+  SMILE_IO_EARNING_RULES: "smile_io.earning_rules",
+  SMILE_IO_REWARDS: "smile_io.rewards",
+  YOTPO_PRODUCT_REVIEWS: "yotpo.product_reviews",
+  YOTPO_PRODUCT_REVIEW_AGGREGATE: "yotpo.product_review_aggregate",
+  REVIEWS_IO_PRODUCT_REVIEWS: "reviews_io.product_reviews",
+  REVIEWS_IO_PRODUCT_REVIEW_AGGREGATE: "reviews_io.product_review_aggregate",
+  STATSIG_EXPERIMENT: "statsig.experiment",
+  CONTENTFUL_ENTRY: "contentful.entry",
+  CONTENTFUL_ENTRIES: "contentful.entries"
+};
+
+export { DATA_LOADER_KEYS };

package/_vendor/schemas/money.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { ReploError } from "./errors";
+export declare class InvalidAmountError extends ReploError {
+}
+export declare class UnsupportedCurrencyError extends ReploError {
+}
+/**
+ * Converts a decimal major-unit amount (e.g. "19.99", 19.99) into integer
+ * minor units (1999) using the currency's Stripe exponent. Half-away-from-zero
+ * rounding for the non-negative amounts this domain uses (prices, totals),
+ * matching Stripe. Throws on non-numeric input.
+ */
+export declare function fromMajorUnitsToMinorUnits({ amount, currencyCode, }: {
+    amount: number | string;
+    currencyCode: string;
+}): number;
+/**
+ * NOTE (Max, 2026-08-03): safe companion to fromMajorUnitsToMinorUnits for
+ * possibly-blank or user/CSV/provider-entered decimal strings — returns null
+ * for blank or non-numeric input instead of throwing. Callers with a
+ * source-specific cleaning or validation policy sanitize first, then convert
+ * here, so every "decimal string → minor units" path shares one converter.
+ */
+export declare function parseDecimalToMinorUnits({ value, currencyCode, }: {
+    value: string | null;
+    currencyCode: string;
+}): number | null;
+/**
+ * Converts integer minor units (1999) back into a decimal major-unit number
+ * (19.99). Only for true decimal boundaries: display, analytics events, and
+ * third-party APIs that speak major units.
+ */
+export declare function fromMinorUnitsToMajorUnits({ amount, currencyCode, }: {
+    amount: number;
+    currencyCode: string;
+}): number;
+/**
+ * Renders integer minor units as a plain decimal string for providers that
+ * speak decimal money (e.g. Printful retail_price): 1999 -> "19.99" (USD),
+ * "1999" (JPY), "1.999" (KWD).
+ */
+export declare function fromMinorUnitsToMajorUnitsString({ amount, currencyCode, }: {
+    amount: number;
+    currencyCode: string;
+}): string;
+/**
+ * Formats integer minor units for display, e.g. 1999 -> "$19.99" (USD),
+ * "¥1,999" (JPY).
+ */
+export declare function formatAmount({ amount, currencyCode, locale, }: {
+    amount: number;
+    currencyCode: string;
+    locale?: string;
+}): string;
+export declare const amountSchema: z.ZodNumber;
+/** An amount in minor units paired with its ISO 4217 currency code. */
+export declare const amountWithCurrencyCodeSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    currencyCode: z.ZodString;
+}, z.core.$strip>;