@replohq/sdk 2.4.0 → 2.7.0

package/cart/start-stripe-checkout.d.ts

@@ -0,0 +1,40 @@
+import type { CartLineAttribute } from "./cart-types";
+import { CanopyError } from "../lib/canopy-error";
+export declare class StripeCheckoutError extends CanopyError {
+}
+export type StripeCheckoutOutcome = {
+    result: "created";
+    redirectUrl: string;
+} | {
+    result: "restartCheckout";
+    message: string;
+} | {
+    result: "outOfStock";
+    variants: {
+        variantId: string;
+        available: number;
+    }[];
+};
+/**
+ * Opens a Stripe Checkout session for a cart: Stripe's hosted page, or the
+ * site's own `paymentPagePath` page (built on `<CheckoutSessionProvider>`) with
+ * the session in the URL fragment. Canopy answers an embedded request with a
+ * hosted session where it can't serve embedded checkout.
+ */
+export declare function startStripeCheckout({ checkoutAttemptId, lineItems, discountCodes, pageUrl, ui, }: {
+    checkoutAttemptId: string | null;
+    lineItems: {
+        variantId: string;
+        quantity: number;
+        sellingPlanId: string | null;
+        properties: CartLineAttribute[];
+    }[];
+    discountCodes: string[];
+    pageUrl: string;
+    ui: {
+        mode: "hosted";
+    } | {
+        mode: "form";
+        paymentPagePath: string;
+    };
+}): Promise<StripeCheckoutOutcome>;

package/cart/start-stripe-checkout.js

@@ -0,0 +1,75 @@
+import { headers } from "next/headers";
+import { v4 as uuidv4 } from "uuid";
+import { getCanopyApiGateway } from "../gateways/canopy-api";
+import { CanopyError } from "../lib/canopy-error";
+import { REPLO_ATTRIBUTION_PROPERTY } from "./cart-types";
+import { getReturnUrls } from "./return-urls";
+class StripeCheckoutError extends CanopyError {
+}
+async function startStripeCheckout({
+  checkoutAttemptId,
+  lineItems,
+  discountCodes,
+  pageUrl,
+  ui
+}) {
+  const headersList = await headers();
+  const host = headersList.get("host");
+  if (!host) {
+    throw new StripeCheckoutError({ message: "Missing host header" });
+  }
+  const { origin, cancelUrl } = getReturnUrls({
+    host,
+    forwardedHost: headersList.get("x-forwarded-host"),
+    forwardedProto: headersList.get("x-forwarded-proto"),
+    requestOrigin: headersList.get("origin"),
+    pageUrl
+  });
+  const checkoutPage = ui.mode === "form" ? new URL(ui.paymentPagePath, origin) : null;
+  if (checkoutPage && checkoutPage.origin !== origin) {
+    throw new StripeCheckoutError({
+      message: "paymentPagePath must be a path on this site",
+      additionalData: { paymentPagePath: checkoutPage.toString() }
+    });
+  }
+  if (discountCodes.length > 0 || lineItems.some((lineItem) => Boolean(lineItem.sellingPlanId))) {
+    console.warn(
+      "[Replo] Stripe buy now does not support selling plans or discount codes; those options were ignored."
+    );
+  }
+  const outcome = await (await getCanopyApiGateway()).createStripeCheckoutSession({
+    checkoutAttemptId: checkoutAttemptId ?? uuidv4(),
+    lines: lineItems.map((item) => ({
+      variantId: item.variantId,
+      quantity: item.quantity,
+      properties: item.properties.some((property) => {
+        return property.key === REPLO_ATTRIBUTION_PROPERTY.key;
+      }) ? item.properties : [REPLO_ATTRIBUTION_PROPERTY, ...item.properties]
+    })),
+    successUrl: `${origin}/checkout/success`,
+    cancelUrl,
+    uiMode: ui.mode
+  });
+  if (outcome.result !== "created") {
+    return outcome;
+  }
+  const session = outcome.session;
+  if (checkoutPage && session.form) {
+    const { hasLiveShipping, ...config } = session.form;
+    checkoutPage.hash = new URLSearchParams({
+      ...config,
+      ...hasLiveShipping ? { hasLiveShipping: "1" } : {}
+    }).toString();
+    return { result: "created", redirectUrl: checkoutPage.toString() };
+  }
+  if (!session.url) {
+    throw new StripeCheckoutError({
+      message: "Stripe checkout session response has no page to open"
+    });
+  }
+  return { result: "created", redirectUrl: session.url };
+}
+export {
+  StripeCheckoutError,
+  startStripeCheckout
+};

package/cart/utils/shopify-shared-cart.d.ts

@@ -0,0 +1,9 @@
+import type { Cart } from "../cart-types";
+export declare const SHARED_SHOPIFY_CART_COOKIE_NAME = "replo_shared_cart";
+export declare const SHOPIFY_CART_ID_PREFIX = "gid://shopify/Cart/";
+/**
+ * Shopify reports the store's primary domain as the checkout URL host, so a
+ * site served from a subdomain of it (shop.brand.com next to brand.com) can
+ * share its cart with the theme without any per-site configuration.
+ */
+export declare function shareShopifyCart(cart: Cart): Promise<void>;

package/cart/utils/shopify-shared-cart.js

@@ -0,0 +1,33 @@
+import { cookies, headers } from "next/headers";
+const SHARED_SHOPIFY_CART_COOKIE_NAME = "replo_shared_cart";
+const SHOPIFY_CART_ID_PREFIX = "gid://shopify/Cart/";
+async function shareShopifyCart(cart) {
+  if (process.env.IS_REPLO_SANDBOX || !cart.id.startsWith(SHOPIFY_CART_ID_PREFIX) || !cart.checkoutUrl || !URL.canParse(cart.checkoutUrl)) {
+    return;
+  }
+  const domain = new URL(cart.checkoutUrl).hostname.toLowerCase().replace(/^www\./, "");
+  const host = (await headers()).get("host")?.toLowerCase().split(":")[0];
+  if (!host?.endsWith(`.${domain}`)) {
+    return;
+  }
+  try {
+    (await cookies()).set(
+      SHARED_SHOPIFY_CART_COOKIE_NAME,
+      cart.id.slice(SHOPIFY_CART_ID_PREFIX.length),
+      {
+        domain: `.${domain}`,
+        path: "/",
+        secure: true,
+        httpOnly: false,
+        sameSite: "lax",
+        maxAge: 60 * 60 * 24 * 30
+      }
+    );
+  } catch {
+  }
+}
+export {
+  SHARED_SHOPIFY_CART_COOKIE_NAME,
+  SHOPIFY_CART_ID_PREFIX,
+  shareShopifyCart
+};

package/{chunk-TTEBDCWT.mjs → chunk-4YTXURVN.mjs}

@@ -1,6 +1,6 @@
 import { CONTENT_SEO_VALUE_KEYS, CONTENT_RELATED_VALUE_STORAGE_KEY, CONTENT_PRIVATE_VALUE_KEYS, LEGACY_CONTENT_ENTRY_STATUSES, isContentPrivateValueKey, getContentFieldValueSchema } from './chunk-RQ76VK3L.mjs';
-import { MapCache_default, getAllKeysIn_default, identity_default, isIndex_default, assignValue_default, keys_default, Stack_default, isLength_default, isArguments_default, getTag_default, isBuffer_default, isTypedArray_default, eq_default, Uint8Array_default, getAllKeys_default } from './chunk-XWWFRIXV.mjs';
-import { Symbol_default, isArray_default, isObject_default, isObjectLike_default, baseGetTag_default } from './chunk-ZPDXVFCR.mjs';
+import { MapCache_default, getAllKeysIn_default, identity_default, isIndex_default, assignValue_default, keys_default, Stack_default, isLength_default, isArguments_default, getTag_default, isBuffer_default, isTypedArray_default, eq_default, Uint8Array_default, getAllKeys_default } from './chunk-N4WC2Z43.mjs';
+import { Symbol_default, isArray_default, isObject_default, isObjectLike_default, baseGetTag_default } from './chunk-JBCOJHZN.mjs';
 import { stringify, parseDocument } from 'yaml';
 import * as z2 from 'zod';
 

package/{chunk-O4QBR4QC.mjs → chunk-DMJ5VUD6.mjs}

@@ -1,5 +1,5 @@
-import { isString_default, isNumber_default } from './chunk-OPKMOW43.mjs';
-import { isObject_default } from './chunk-ZPDXVFCR.mjs';
+import { isString_default, isNumber_default } from './chunk-GNIXARC7.mjs';
+import { isObject_default } from './chunk-JBCOJHZN.mjs';
 
 var has = Object.prototype.hasOwnProperty;
 function dequal(foo, bar) {

package/{chunk-OPKMOW43.mjs → chunk-GNIXARC7.mjs}

@@ -1,4 +1,4 @@
-import { isObjectLike_default, baseGetTag_default, isArray_default } from './chunk-ZPDXVFCR.mjs';
+import { isObjectLike_default, baseGetTag_default, isArray_default } from './chunk-JBCOJHZN.mjs';
 
 var numberTag = "[object Number]";
 function isNumber(value) {

package/{chunk-XWWFRIXV.mjs → chunk-N4WC2Z43.mjs}

@@ -1,4 +1,4 @@
-import { isObjectLike_default, root_default, freeGlobal_default, baseGetTag_default, isObject_default, isArray_default } from './chunk-ZPDXVFCR.mjs';
+import { isObjectLike_default, root_default, freeGlobal_default, baseGetTag_default, isObject_default, isArray_default } from './chunk-JBCOJHZN.mjs';
 
 var asyncTag = "[object AsyncFunction]";
 var funcTag = "[object Function]";

package/{chunk-PSYP2DYM.mjs → chunk-QYGRVXWQ.mjs}

@@ -1,4 +1,4 @@
-import { omit } from './chunk-O4QBR4QC.mjs';
+import { omit } from './chunk-DMJ5VUD6.mjs';
 
 function parseJsonOrNull(json) {
   try {

package/env.d.ts

@@ -3,6 +3,7 @@ type Env = {
     PROJECT_ID: string;
     ANALYTICS_FIRE_API_URL?: string;
     REPLO_ANALYTICS_PIXEL_URL?: string;
+    REPLO_SITE_VERSION?: string;
     CHECKOUT_PROVIDER?: "shopify" | "stripe" | "none";
 };
 export declare const getEnv: () => Promise<Env>;

package/env.js

@@ -7,6 +7,7 @@ const envSchema = z.object({
   PROJECT_ID: z.uuid(),
   ANALYTICS_FIRE_API_URL: z.string().optional(),
   REPLO_ANALYTICS_PIXEL_URL: z.string().optional(),
+  REPLO_SITE_VERSION: z.string().optional(),
   CHECKOUT_PROVIDER: z.enum(["shopify", "stripe", "none"]).optional()
 });
 const wranglerConfigSchema = z.object({ vars: envSchema });

package/gateways/canopy-api.d.ts

@@ -1,4 +1,5 @@
 import type { Cart } from "../cart/cart-schema";
+import type { CartLineAttribute } from "../cart/cart-types";
 import type { StorefrontCountryCode } from "../loaders/markets";
 import * as z from "zod";
 import { CanopyError } from "../lib/canopy-error";
@@ -24,6 +25,68 @@ declare const reconciledCartLineSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     status: z.ZodLiteral<"unavailable">;
 }, z.core.$strip>], "status">;
 export type ReconciledCartLine = z.infer<typeof reconciledCartLineSchema>;
+declare const createdStripeSessionSchema: z.ZodObject<{
+    url: z.ZodNullable<z.ZodString>;
+    form: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        clientSecret: z.ZodString;
+        publishableKey: z.ZodString;
+        stripeAccountId: z.ZodString;
+        hasLiveShipping: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const outOfStockSchema: z.ZodObject<{
+    result: z.ZodLiteral<"outOfStock">;
+    variants: z.ZodArray<z.ZodObject<{
+        variantId: z.ZodString;
+        available: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const checkoutUpdateOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"accept">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reject">;
+    message: z.ZodString;
+}, z.core.$strip>], "type">;
+/**
+ * What the embedded checkout form shows after a cart or address change:
+ * `accept`, or `reject` with a message for the buyer.
+ */
+export type CheckoutUpdateOutcome = z.infer<typeof checkoutUpdateOutcomeSchema>;
+declare const crossSellSchema: z.ZodObject<{
+    productId: z.ZodString;
+    variantId: z.ZodString;
+    title: z.ZodString;
+    variantTitle: z.ZodNullable<z.ZodString>;
+    imageUrl: z.ZodNullable<z.ZodString>;
+    unitPriceMinor: z.ZodNumber;
+    currencyCode: z.ZodString;
+}, z.core.$strip>;
+/** A product offered beside the cart: one variant of a live product. */
+export type CrossSell = z.infer<typeof crossSellSchema>;
+declare const addCrossSellOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"accept">;
+    products: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        variantId: z.ZodString;
+        title: z.ZodString;
+        variantTitle: z.ZodNullable<z.ZodString>;
+        imageUrl: z.ZodNullable<z.ZodString>;
+        unitPriceMinor: z.ZodNumber;
+        currencyCode: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reject">;
+    message: z.ZodString;
+}, z.core.$strip>], "type">;
+export type AddCrossSellOutcome = z.infer<typeof addCrossSellOutcomeSchema>;
+export type CheckoutAddress = {
+    country: string;
+    line1: string;
+    line2: string | null;
+    city: string | null;
+    state: string | null;
+    postalCode: string | null;
+};
 export declare function shouldIncludeInactiveProducts(): boolean;
 declare class CanopyApiGateway {
     private apiHost;
@@ -125,6 +188,40 @@ declare class CanopyApiGateway {
             value: string;
         }[];
     }): Promise<Cart>;
+    private _stripeCheckoutPost;
+    /**
+     * Opens a Stripe Checkout session for a cart. A hosted request's body is
+     * exactly what every published SDK sends, so canopy treats it the same.
+     */
+    createStripeCheckoutSession({ checkoutAttemptId, lines, successUrl, cancelUrl, uiMode, }: {
+        checkoutAttemptId: string;
+        lines: {
+            variantId: string;
+            quantity: number;
+            properties: CartLineAttribute[];
+        }[];
+        successUrl: string;
+        cancelUrl: string;
+        uiMode: "hosted" | "form";
+    }): Promise<{
+        result: "created";
+        session: z.infer<typeof createdStripeSessionSchema>;
+    } | {
+        result: "restartCheckout";
+        message: string;
+    } | z.infer<typeof outOfStockSchema>>;
+    updateCheckoutShipping(body: {
+        sessionId: string;
+        address: CheckoutAddress;
+    }): Promise<CheckoutUpdateOutcome>;
+    findCrossSells(body: {
+        sessionId: string | null;
+        excludeVariantIds: string[];
+    }): Promise<CrossSell[]>;
+    addCrossSell(body: {
+        sessionId: string;
+        variantId: string;
+    }): Promise<AddCrossSellOutcome>;
 }
 export declare function getCanopyApiGateway(): Promise<CanopyApiGateway>;
 export {};

package/gateways/canopy-api.js

@@ -49,6 +49,46 @@ const reconciledCartLineSchema = z.discriminatedUnion("status", [
 const reconcileCartLinesResponseSchema = z.object({
   lines: z.array(reconciledCartLineSchema)
 });
+const createdStripeSessionSchema = z.object({
+  url: z.string().nullable(),
+  form: z.object({
+    clientSecret: z.string(),
+    publishableKey: z.string(),
+    stripeAccountId: z.string(),
+    hasLiveShipping: z.boolean()
+  }).nullish()
+});
+const outOfStockSchema = z.object({
+  result: z.literal("outOfStock"),
+  variants: z.array(
+    z.object({ variantId: z.string(), available: z.number().int().min(0) })
+  )
+});
+const restartCheckoutSchema = z.object({
+  error: z.literal("checkoutUnavailable"),
+  retry: z.literal("newAttempt"),
+  message: z.string().min(1)
+});
+const checkoutUpdateOutcomeSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("accept") }),
+  z.object({ type: z.literal("reject"), message: z.string() })
+]);
+const crossSellSchema = z.object({
+  productId: z.string(),
+  variantId: z.string(),
+  title: z.string(),
+  variantTitle: z.string().nullable(),
+  imageUrl: z.string().nullable(),
+  unitPriceMinor: z.number(),
+  currencyCode: z.string()
+});
+const addCrossSellOutcomeSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("accept"),
+    products: z.array(crossSellSchema)
+  }),
+  z.object({ type: z.literal("reject"), message: z.string() })
+]);
 function shouldIncludeInactiveProducts() {
   return Boolean(process.env.IS_REPLO_SANDBOX);
 }
@@ -241,6 +281,86 @@ If you're running locally, make sure the canopy-api cloudflare worker is running
   }) {
     return this._cartPost("/replace-attributes", { cartId, attributes });
   }
+  async _stripeCheckoutPost({
+    path,
+    body,
+    schema
+  }) {
+    const env = await getEnv();
+    const response = await this._post(
+      `${this.baseUrl}/api/v1/stripe-checkout/${path}`,
+      { projectId: env.PROJECT_ID, ...body }
+    );
+    if (!response.ok) {
+      throw new CanopyApiGatewayError({
+        message: `Stripe checkout ${path} failed: ${response.status} ${response.statusText}`,
+        statusCode: response.status
+      });
+    }
+    return schema.parse(await response.json());
+  }
+  async createStripeCheckoutSession({
+    checkoutAttemptId,
+    lines,
+    successUrl,
+    cancelUrl,
+    uiMode
+  }) {
+    const env = await getEnv();
+    const response = await this._post(
+      `${this.baseUrl}/api/v1/stripe-checkout/create-session`,
+      {
+        cartId: checkoutAttemptId,
+        checkoutAttemptId,
+        lines,
+        projectId: env.PROJECT_ID,
+        successUrl,
+        cancelUrl,
+        ...uiMode === "form" ? { uiMode } : {}
+      }
+    );
+    if (!response.ok) {
+      const restart = response.status === 409 ? restartCheckoutSchema.safeParse(await response.json()) : null;
+      if (restart?.success) {
+        return { result: "restartCheckout", message: restart.data.message };
+      }
+      throw new CanopyApiGatewayError({
+        message: `Failed to create Stripe checkout session: ${response.status} ${response.statusText}`,
+        statusCode: response.status
+      });
+    }
+    const payload = await response.json();
+    const outOfStock = outOfStockSchema.safeParse(payload);
+    if (outOfStock.success) {
+      return outOfStock.data;
+    }
+    return {
+      result: "created",
+      session: createdStripeSessionSchema.parse(payload)
+    };
+  }
+  async updateCheckoutShipping(body) {
+    return await this._stripeCheckoutPost({
+      path: "update-shipping",
+      body,
+      schema: checkoutUpdateOutcomeSchema
+    });
+  }
+  async findCrossSells(body) {
+    const { products } = await this._stripeCheckoutPost({
+      path: "cross-sells",
+      body,
+      schema: z.object({ products: z.array(crossSellSchema) })
+    });
+    return products;
+  }
+  async addCrossSell(body) {
+    return await this._stripeCheckoutPost({
+      path: "add-cross-sell",
+      body,
+      schema: addCrossSellOutcomeSchema
+    });
+  }
 }
 async function getCanopyApiGateway() {
   return CanopyApiGateway.setup();

package/lib/buildMetadata.js

@@ -1,7 +1,7 @@
 export const BUILD_METADATA = {
   "packageName": "@replohq/sdk",
-  "version": "2.4.0",
+  "version": "2.7.0",
   "branch": "HEAD",
-  "commit": "a20152029da76f3b8edd0d538187209442f20e23",
-  "builtAt": "2026-10-22T05:49:26.854Z"
+  "commit": "1aa1f09e1dd141b243b7bb3b1ff1bc947fa01371",
+  "builtAt": "2026-10-23T05:44:46.035Z"
 };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@replohq/sdk",
-  "version": "2.4.0",
+  "version": "2.7.0",
   "reploBuild": {
     "packageName": "@replohq/sdk",
-    "version": "2.4.0",
+    "version": "2.7.0",
     "branch": "HEAD",
-    "commit": "a20152029da76f3b8edd0d538187209442f20e23",
-    "builtAt": "2026-10-22T05:49:26.854Z"
+    "commit": "1aa1f09e1dd141b243b7bb3b1ff1bc947fa01371",
+    "builtAt": "2026-10-23T05:44:46.035Z"
   },
   "description": "Replo SDK — cart, analytics, and data loaders for agent-built Next.js sites.",
   "license": "SEE LICENSE IN LICENSE",
@@ -49,6 +49,14 @@
       "types": "./cart/buy-now-action.d.ts",
       "default": "./cart/buy-now-action.js"
     },
+    "./cart/checkout": {
+      "types": "./cart/checkout.d.ts",
+      "default": "./cart/checkout.js"
+    },
+    "./cart/checkout-actions": {
+      "types": "./cart/checkout-actions.d.ts",
+      "default": "./cart/checkout-actions.js"
+    },
     "./cart/utils/cart-utils": {
       "types": "./cart/utils/cart-utils.d.ts",
       "default": "./cart/utils/cart-utils.js"
@@ -310,6 +318,8 @@
   "dependencies": {
     "@formatjs/intl-localematcher": "^0.8.13",
     "@kachingappz/bundles-react": "0.5.3",
+    "@stripe/react-stripe-js": "7.0.0",
+    "@stripe/stripe-js": "10.1.0",
     "negotiator": "^1.0.0",
     "react-markdown": "^9.1.0",
     "remark-gfm": "^4.0.1",

package/_vendor/replo-utils/lib/errors.d.ts

@@ -1,84 +0,0 @@
-type ValueOfType<ObjectType> = ObjectType[keyof ObjectType];
-/**
- * Mostly taken from
- * https://gist.githubusercontent.com/scokmen/f813c904ef79022e84ab2409574d1b45/raw/cd8709a2fccb005bb53e9bfb2461e07d40b4e8d8/HttpStatusCode.ts
- */
-export declare const HTTP_STATUS_CODES: {
-    readonly CONTINUE: 100;
-    readonly SWITCHING_PROTOCOLS: 101;
-    readonly PROCESSING: 102;
-    readonly OK: 200;
-    readonly CREATED: 201;
-    readonly ACCEPTED: 202;
-    readonly NON_AUTHORITATIVE_INFORMATION: 203;
-    readonly NO_CONTENT: 204;
-    readonly RESET_CONTENT: 205;
-    readonly PARTIAL_CONTENT: 206;
-    readonly MULTI_STATUS: 207;
-    readonly ALREADY_REPORTED: 208;
-    readonly IM_USED: 226;
-    readonly MULTIPLE_CHOICES: 300;
-    readonly MOVED_PERMANENTLY: 301;
-    readonly FOUND: 302;
-    readonly SEE_OTHER: 303;
-    readonly NOT_MODIFIED: 304;
-    readonly USE_PROXY: 305;
-    readonly SWITCH_PROXY: 306;
-    readonly TEMPORARY_REDIRECT: 307;
-    readonly PERMANENT_REDIRECT: 308;
-    readonly BAD_REQUEST: 400;
-    readonly UNAUTHORIZED: 401;
-    readonly PAYMENT_REQUIRED: 402;
-    readonly FORBIDDEN: 403;
-    readonly NOT_FOUND: 404;
-    readonly METHOD_NOT_ALLOWED: 405;
-    readonly NOT_ACCEPTABLE: 406;
-    readonly PROXY_AUTHENTICATION_REQUIRED: 407;
-    readonly REQUEST_TIMEOUT: 408;
-    readonly CONFLICT: 409;
-    readonly GONE: 410;
-    readonly LENGTH_REQUIRED: 411;
-    readonly PRECONDITION_FAILED: 412;
-    readonly PAYLOAD_TOO_LARGE: 413;
-    readonly URI_TOO_LONG: 414;
-    readonly UNSUPPORTED_MEDIA_TYPE: 415;
-    readonly RANGE_NOT_SATISFIABLE: 416;
-    readonly EXPECTATION_FAILED: 417;
-    readonly I_AM_A_TEAPOT: 418;
-    readonly MISDIRECTED_REQUEST: 421;
-    readonly UNPROCESSABLE_ENTITY: 422;
-    readonly LOCKED: 423;
-    readonly FAILED_DEPENDENCY: 424;
-    readonly UPGRADE_REQUIRED: 426;
-    readonly PRECONDITION_REQUIRED: 428;
-    readonly TOO_MANY_REQUESTS: 429;
-    readonly REQUEST_HEADER_FIELDS_TOO_LARGE: 431;
-    readonly UNAVAILABLE_FOR_LEGAL_REASONS: 451;
-    readonly INTERNAL_SERVER_ERROR: 500;
-    readonly NOT_IMPLEMENTED: 501;
-    readonly BAD_GATEWAY: 502;
-    readonly SERVICE_UNAVAILABLE: 503;
-    readonly GATEWAY_TIMEOUT: 504;
-    readonly HTTP_VERSION_NOT_SUPPORTED: 505;
-    readonly VARIANT_ALSO_NEGOTIATES: 506;
-    readonly INSUFFICIENT_STORAGE: 507;
-    readonly LOOP_DETECTED: 508;
-    readonly NOT_EXTENDED: 510;
-    readonly NETWORK_AUTHENTICATION_REQUIRED: 511;
-    readonly UPSTREAM_WEBSERVER_ERROR: 520;
-};
-export type HttpStatusCode = ValueOfType<typeof HTTP_STATUS_CODES>;
-/**
- * Checks if an error message indicates a network error (e.g., connectivity issues,
- * request timeouts, DNS failures). These errors typically don't need to be tracked
- * in error monitoring systems like Sentry since they're user-side connectivity issues.
- */
-export declare function isNetworkErrorMessage(message: string): boolean;
-/**
- * Extracts a human-readable message from an unknown caught value. If the value
- * is an Error, returns its message; otherwise falls back to the provided
- * fallback string or `String(error)`.
- */
-export declare function getErrorMessage(error: unknown, fallback?: string): string;
-export declare function appendErrorId(detail: string, errorId: string | null | undefined): string;
-export {};