@replohq/sdk 2.5.0 → 2.8.0

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.5.0",
+  "version": "2.8.0",
   "branch": "HEAD",
-  "commit": "f408d4d2ca21640258e7b9a8d20c5a92515cf9d6",
-  "builtAt": "2026-10-22T19:30:37.074Z"
+  "commit": "419304cd8a77ac16dd72b88ad09b17f58b805e11",
+  "builtAt": "2026-10-24T18:15:19.700Z"
 };

package/loaders/junip-review-aggregate-loader.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+import type { z } from "zod";
+import type { junipProductReviewAggregateLoaderOutputSchema } from "./loader-schemas";
+type JunipReviewAggregateData = z.infer<typeof junipProductReviewAggregateLoaderOutputSchema>;
+type JunipReviewAggregateLoaderProps = {
+    loaderKey: string;
+    productId: string;
+    children: (data: JunipReviewAggregateData) => ReactNode;
+    fallback?: ReactNode;
+};
+export declare function JunipReviewAggregateLoader({ loaderKey, productId, children, fallback, }: JunipReviewAggregateLoaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/loaders/junip-review-aggregate-loader.js

@@ -0,0 +1,53 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { useSuspenseQuery } from "@tanstack/react-query";
+import { invokeLoader } from "./invoke-loader";
+import { LoaderErrorBoundary } from "./loader-error-boundary";
+function JunipReviewAggregateLoaderInner({
+  loaderKey,
+  productId,
+  children
+}) {
+  const { data } = useSuspenseQuery({
+    queryKey: [loaderKey, { productId }],
+    queryFn: async () => {
+      const [loadedData, schemas] = await Promise.all([
+        invokeLoader({
+          loaderKey,
+          args: { productId }
+        }),
+        import("./loader-schemas")
+      ]);
+      return schemas.junipProductReviewAggregateLoaderOutputSchema.parse(
+        loadedData
+      );
+    }
+  });
+  return /* @__PURE__ */ jsx(Fragment, { children: children(data) });
+}
+function JunipReviewAggregateLoader({
+  loaderKey,
+  productId,
+  children,
+  fallback
+}) {
+  return /* @__PURE__ */ jsx(
+    LoaderErrorBoundary,
+    {
+      fallback: fallback ?? null,
+      resetKey: `${loaderKey}:${productId}`,
+      children: /* @__PURE__ */ jsx(Suspense, { fallback: fallback ?? null, children: /* @__PURE__ */ jsx(
+        JunipReviewAggregateLoaderInner,
+        {
+          loaderKey,
+          productId,
+          children
+        }
+      ) })
+    }
+  );
+}
+export {
+  JunipReviewAggregateLoader
+};

package/loaders/junip-reviews-loader.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+import type { z } from "zod";
+import type { junipProductReviewsLoaderOutputSchema } from "./loader-schemas";
+type JunipReviewsData = z.infer<typeof junipProductReviewsLoaderOutputSchema>;
+type JunipReviewsLoaderProps = {
+    loaderKey: string;
+    productId: string;
+    perPage?: number;
+    children: (data: JunipReviewsData) => ReactNode;
+    fallback?: ReactNode;
+};
+export declare function JunipReviewsLoader({ loaderKey, productId, perPage, children, fallback, }: JunipReviewsLoaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/loaders/junip-reviews-loader.js

@@ -0,0 +1,58 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { useSuspenseQuery } from "@tanstack/react-query";
+import { invokeLoader } from "./invoke-loader";
+import { LoaderErrorBoundary } from "./loader-error-boundary";
+function buildReviewsArgs({
+  productId,
+  perPage
+}) {
+  return { productId, ...perPage !== void 0 ? { perPage } : {} };
+}
+function JunipReviewsLoaderInner({
+  loaderKey,
+  productId,
+  perPage,
+  children
+}) {
+  const args = buildReviewsArgs({ productId, perPage });
+  const { data } = useSuspenseQuery({
+    queryKey: [loaderKey, args],
+    queryFn: async () => {
+      const [loadedData, schemas] = await Promise.all([
+        invokeLoader({ loaderKey, args }),
+        import("./loader-schemas")
+      ]);
+      return schemas.junipProductReviewsLoaderOutputSchema.parse(loadedData);
+    }
+  });
+  return /* @__PURE__ */ jsx(Fragment, { children: children(data) });
+}
+function JunipReviewsLoader({
+  loaderKey,
+  productId,
+  perPage,
+  children,
+  fallback
+}) {
+  return /* @__PURE__ */ jsx(
+    LoaderErrorBoundary,
+    {
+      fallback: fallback ?? null,
+      resetKey: `${loaderKey}:${productId}:${perPage ?? ""}`,
+      children: /* @__PURE__ */ jsx(Suspense, { fallback: fallback ?? null, children: /* @__PURE__ */ jsx(
+        JunipReviewsLoaderInner,
+        {
+          loaderKey,
+          productId,
+          perPage,
+          children
+        }
+      ) })
+    }
+  );
+}
+export {
+  JunipReviewsLoader
+};

package/loaders/loader-keys.d.ts

@@ -37,6 +37,8 @@ export declare const DATA_LOADER_KEYS: {
     readonly LOOX_PRODUCT_REVIEW_AGGREGATE: "loox.product_review_aggregate";
     readonly JUDGEME_PRODUCT_REVIEWS: "judgeme.product_reviews";
     readonly JUDGEME_PRODUCT_REVIEW_AGGREGATE: "judgeme.product_review_aggregate";
+    readonly JUNIP_PRODUCT_REVIEWS: "junip.product_reviews";
+    readonly JUNIP_PRODUCT_REVIEW_AGGREGATE: "junip.product_review_aggregate";
     readonly STATSIG_EXPERIMENT: "statsig.experiment";
     readonly CONTENTFUL_ENTRY: "contentful.entry";
     readonly CONTENTFUL_ENTRIES: "contentful.entries";

package/loaders/loader-keys.js

@@ -26,6 +26,8 @@ const DATA_LOADER_KEYS = {
   LOOX_PRODUCT_REVIEW_AGGREGATE: "loox.product_review_aggregate",
   JUDGEME_PRODUCT_REVIEWS: "judgeme.product_reviews",
   JUDGEME_PRODUCT_REVIEW_AGGREGATE: "judgeme.product_review_aggregate",
+  JUNIP_PRODUCT_REVIEWS: "junip.product_reviews",
+  JUNIP_PRODUCT_REVIEW_AGGREGATE: "junip.product_review_aggregate",
   STATSIG_EXPERIMENT: "statsig.experiment",
   CONTENTFUL_ENTRY: "contentful.entry",
   CONTENTFUL_ENTRIES: "contentful.entries"

package/loaders/loader-schemas.d.ts

@@ -983,6 +983,33 @@ export declare const judgemeProductReviewAggregateLoaderOutputSchema: z.ZodObjec
     totalReviews: z.ZodNumber;
     starDistribution: z.ZodRecord<z.ZodString, z.ZodNumber>;
 }, z.core.$strip>;
+export declare const junipReviewLoaderItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    content: z.ZodNullable<z.ZodString>;
+    score: z.ZodNumber;
+    createdAt: z.ZodString;
+    verifiedBuyer: z.ZodBoolean;
+    reviewerName: z.ZodNullable<z.ZodString>;
+    photoUrls: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const junipProductReviewsLoaderOutputSchema: z.ZodObject<{
+    reviews: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        content: z.ZodNullable<z.ZodString>;
+        score: z.ZodNumber;
+        createdAt: z.ZodString;
+        verifiedBuyer: z.ZodBoolean;
+        reviewerName: z.ZodNullable<z.ZodString>;
+        photoUrls: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const junipProductReviewAggregateLoaderOutputSchema: z.ZodObject<{
+    averageScore: z.ZodNumber;
+    totalReviews: z.ZodNumber;
+    starDistribution: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
 export declare const loyaltyLionEarningRuleVariantSchema: z.ZodObject<{
     tierId: z.ZodNullable<z.ZodNumber>;
     title: z.ZodString;

package/loaders/loader-schemas.js

@@ -328,6 +328,24 @@ const judgemeProductReviewAggregateLoaderOutputSchema = z.object({
   totalReviews: z.number(),
   starDistribution: z.record(z.string(), z.number())
 });
+const junipReviewLoaderItemSchema = z.object({
+  id: z.string(),
+  title: z.string().nullable(),
+  content: z.string().nullable(),
+  score: z.number(),
+  createdAt: z.string(),
+  verifiedBuyer: z.boolean(),
+  reviewerName: z.string().nullable(),
+  photoUrls: z.array(z.string())
+});
+const junipProductReviewsLoaderOutputSchema = z.object({
+  reviews: z.array(junipReviewLoaderItemSchema)
+});
+const junipProductReviewAggregateLoaderOutputSchema = z.object({
+  averageScore: z.number(),
+  totalReviews: z.number(),
+  starDistribution: z.record(z.string(), z.number())
+});
 const loyaltyLionEarningRuleVariantSchema = z.object({
   tierId: z.number().nullable(),
   title: z.string(),
@@ -476,6 +494,9 @@ export {
   judgemeProductReviewAggregateLoaderOutputSchema,
   judgemeProductReviewsLoaderOutputSchema,
   judgemeReviewLoaderItemSchema,
+  junipProductReviewAggregateLoaderOutputSchema,
+  junipProductReviewsLoaderOutputSchema,
+  junipReviewLoaderItemSchema,
   levantaProductFullSchema,
   looxProductReviewAggregateLoaderOutputSchema,
   looxProductReviewsLoaderOutputSchema,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@replohq/sdk",
-  "version": "2.5.0",
+  "version": "2.8.0",
   "reploBuild": {
     "packageName": "@replohq/sdk",
-    "version": "2.5.0",
+    "version": "2.8.0",
     "branch": "HEAD",
-    "commit": "f408d4d2ca21640258e7b9a8d20c5a92515cf9d6",
-    "builtAt": "2026-10-22T19:30:37.074Z"
+    "commit": "419304cd8a77ac16dd72b88ad09b17f58b805e11",
+    "builtAt": "2026-10-24T18:15:19.700Z"
   },
   "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"
@@ -129,6 +137,14 @@
       "types": "./loaders/judgeme-reviews-loader.d.ts",
       "default": "./loaders/judgeme-reviews-loader.js"
     },
+    "./loaders/junip-review-aggregate-loader": {
+      "types": "./loaders/junip-review-aggregate-loader.d.ts",
+      "default": "./loaders/junip-review-aggregate-loader.js"
+    },
+    "./loaders/junip-reviews-loader": {
+      "types": "./loaders/junip-reviews-loader.d.ts",
+      "default": "./loaders/junip-reviews-loader.js"
+    },
     "./loaders/kaching-bundles-loader": {
       "types": "./loaders/kaching-bundles-loader.d.ts",
       "default": "./loaders/kaching-bundles-loader.js"
@@ -310,6 +326,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 {};