@caldik/client 0.1.6 → 0.1.8

package/README.md

@@ -165,6 +165,10 @@ The following fields are omitted by default unless explicitly requested using `i
 
 ### Cart Management
 
+The SDK manages the `cart_{storeId}` cookie and server persistence automatically. Cart
+requests, responses, and saved browser state do not require version numbers.
+Existing saved carts are restored automatically after upgrading.
+
 **Get the cart**
 
 Refresh the current items and applied discount from the server.
@@ -370,14 +374,95 @@ Omit `rememberMe` to use the default session duration.
 
 ### Session Check
 
-Retrieve the current customer's authentication status, account details, and session expiration.
+Check whether the shopper is authenticated. HTTP 200 has no body and resolves to
+`undefined`; HTTP 401 rejects with `CaldikHttpError`. Customer details are returned
+by `me()`.
+
+```ts
+await caldik.customer.session()
+```
+
+### Current Customer
+
+**Get the signed-in customer**
+
+```ts
+const { customer } = await caldik.customers.me()
+console.log(customer.name, customer.email)
+console.log(customer.totalOrders, customer.totalSpent, customer.currency)
+```
+
+`totalOrders` counts this customer's orders in the store. `totalSpent` is a
+decimal string summing successful payments after discounts in the store's
+currency; unpaid, failed, refunded and other-currency orders are excluded from
+spending. This profile does not include `shortId` or `displayId`.
+
+**List the customer's orders**
+
+```ts
+const { orders, nextCursor } = await caldik.customers.orders.list({ limit: 5 })
+```
+
+**Read the next page**
+
+```ts
+if (nextCursor) {
+  const nextPage = await caldik.customers.orders.list({ cursor: nextCursor })
+}
+```
+
+**Get one of the customer's orders**
 
 ```ts
-const {
-  authenticated,
-  customer,
-  expiresAt,
-} = await caldik.customer.session()
+const { order } = await caldik.customers.orders.get("ORDER_...")
+console.log(order.items)
+```
+
+**Get the customer's balance**
+
+```ts
+const { balance } = await caldik.customers.balance.get()
+console.log(balance.amount, balance.currency)
+```
+
+The default currency is the store's currency. Pass `{ currency: "USD" }` to read
+another balance. Amounts are decimal strings; a missing balance is `"0.00"`.
+
+### Batch Reads
+
+**Fetch several resources in one HTTP request**
+
+```ts
+const data = await caldik.batch({
+  customer: caldik.customers.me(),
+  orders: caldik.orders.list({ limit: 5 }),
+  balance: caldik.customers.balance.get(),
+  rank: caldik.plugins.loyalty.getRank(),
+})
+
+console.log(data.customer.customer.email)
+console.log(data.rank.rank?.name)
+```
+
+Batches accept up to 25 distinct, unstarted read requests from the same client.
+Build the requests in the batch expression; already awaited requests cannot be
+batched. Catalog reads and read-only plugin methods are also supported. Each
+result retains the same shape as an individual call, including `undefined` for
+a successful session check. Batches are independent reads, not a transaction.
+
+**Handle a partially failed batch**
+
+```ts
+import { CaldikBatchError } from "@caldik/client"
+
+try {
+  const data = await caldik.batch({ customer: caldik.customers.me() })
+} catch (error) {
+  if (error instanceof CaldikBatchError) {
+    console.log(error.errors) // HTTP status and response for each failed key
+    console.log(error.results) // successful results remain available
+  }
+}
 ```
 
 ### Password Reset
@@ -454,6 +539,7 @@ await caldik.customer.register.verify(code)
 
 > **Note:** The `username` field is provided by the Customer Usernames plugin. Omit this field when the plugin is not installed.
 
+
 ## Payment Methods and Settings
 
 Retrieve customer authentication settings, checkout configuration, and available payment methods.

package/dist/development.d.mts

@@ -0,0 +1,17 @@
+//#region development/refresh-plugin-types.d.mts
+type PluginContractFetcher = (url: URL, options: RequestInit) => Promise<Response>;
+declare function refreshPluginTypes(options: {
+  storeId: string;
+  apiUrl?: string;
+  output?: string;
+  projectRoot?: string;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  fetcher?: PluginContractFetcher;
+}): Promise<{
+  changed: boolean;
+  output: string;
+  types: string;
+}>;
+//#endregion
+export { type PluginContractFetcher, refreshPluginTypes };

package/dist/development.mjs

@@ -0,0 +1,204 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region development/plugin-types.mjs
+const types = /* @__PURE__ */ new Set([
+	"object",
+	"array",
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"null"
+]);
+const safeKey = (value) => typeof value === "string" && /^[a-zA-Z][a-zA-Z0-9_\-]{0,63}$/.test(value) && ![
+	"constructor",
+	"prototype",
+	"then"
+].includes(value);
+const reservedParameters = new Set("await break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield let static implements interface package private protected public".split(" "));
+function schemaType(schema, depth = 0) {
+	if (depth > 8 || !schema || typeof schema !== "object" || Array.isArray(schema)) throw new Error("Invalid plugin type schema");
+	if (schema.enum) {
+		if (!Array.isArray(schema.enum) || !schema.enum.length || schema.enum.length > 64 || schema.enum.some((value) => value !== null && ![
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof value))) throw new Error("Invalid plugin enum");
+		return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+	}
+	if (schema.anyOf) {
+		if (!Array.isArray(schema.anyOf) || !schema.anyOf.length || schema.anyOf.length > 8) throw new Error("Invalid plugin union");
+		return schema.anyOf.map((value) => `(${schemaType(value, depth + 1)})`).join(" | ");
+	}
+	if (!types.has(schema.type)) throw new Error("Unsupported plugin type");
+	if (schema.type === "array") return `Array<${schemaType(schema.items, depth + 1)}>`;
+	if (schema.type === "object") {
+		const properties = schema.properties ?? {};
+		if (!properties || typeof properties !== "object" || Array.isArray(properties) || Object.keys(properties).length > 32) throw new Error("Invalid plugin object");
+		const required = schema.required ?? [];
+		if (!Array.isArray(required) || !required.every((value) => typeof value === "string" && Object.hasOwn(properties, value))) throw new Error("Invalid required properties");
+		return `{ ${Object.entries(properties).map(([name, value]) => `${JSON.stringify(name)}${required.includes(name) ? "" : "?"}: ${schemaType(value, depth + 1)};`).join(" ")} }`;
+	}
+	return schema.type === "integer" ? "number" : schema.type;
+}
+function generatePluginTypes(metadata) {
+	if (!metadata || !Array.isArray(metadata.plugins) || metadata.plugins.length > 100) throw new Error("Invalid installed plugin metadata");
+	const names = /* @__PURE__ */ new Set();
+	const lines = [
+		"// Generated by Caldik.",
+		`import type { CaldikRequest${metadata.plugins.some((plugin) => plugin?.methods && typeof plugin.methods === "object" && Object.values(plugin.methods).some((method) => method?.subscription)) ? ", CaldikSubscriptionOptions" : ""} } from "@caldik/client";`,
+		"",
+		"declare module \"@caldik/client\" {",
+		"  interface CaldikPlugins {"
+	];
+	for (const plugin of [...metadata.plugins].sort((a, b) => String(a.namespace).localeCompare(String(b.namespace)))) {
+		if (!safeKey(plugin.namespace) || names.has(plugin.namespace) || !plugin.methods || typeof plugin.methods !== "object" || Array.isArray(plugin.methods) || Object.keys(plugin.methods).length > 16) throw new Error("Invalid plugin namespace");
+		names.add(plugin.namespace);
+		lines.push(`    readonly ${JSON.stringify(plugin.namespace)}: {`);
+		const tree = Object.create(null);
+		for (const [name, method] of Object.entries(plugin.methods).sort(([a], [b]) => a.localeCompare(b))) {
+			const keys = name.split(".");
+			if (keys.length > 4 || !keys.every(safeKey) || !method || typeof method !== "object") throw new Error("Invalid plugin method");
+			let branch = tree;
+			for (const key of keys.slice(0, -1)) {
+				branch[key] ??= { children: Object.create(null) };
+				if (!branch[key].children) throw new Error("Conflicting plugin method group");
+				branch = branch[key].children;
+			}
+			if (branch[keys.at(-1)]) throw new Error("Conflicting plugin method group");
+			branch[keys.at(-1)] = { method };
+		}
+		const render = (branch, indent) => {
+			for (const [name, entry] of Object.entries(branch)) {
+				if (entry.children) {
+					lines.push(`${indent}readonly ${JSON.stringify(name)}: {`);
+					render(entry.children, indent + "  ");
+					lines.push(`${indent}};`);
+					continue;
+				}
+				const method = entry.method, input = schemaType(method.input), output = schemaType(method.output);
+				let parameters;
+				if (method.parameters !== void 0) {
+					const properties = method.input.properties ?? {}, required = method.input.required ?? [];
+					if (!Array.isArray(method.parameters) || !method.parameters.length || method.parameters.length > 4 || new Set(method.parameters).size !== method.parameters.length || method.input.type !== "object" || method.parameters.some((key) => !safeKey(key) || !Object.hasOwn(properties, key)) || Object.keys(properties).some((key) => !method.parameters.includes(key))) throw new Error("Invalid plugin parameters");
+					let optional = false;
+					parameters = method.parameters.map((key, index) => {
+						const needed = required.includes(key);
+						if (needed && optional) throw new Error("Required parameter follows optional parameter");
+						optional ||= !needed;
+						let identifier = key;
+						if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(key) || reservedParameters.has(key)) {
+							identifier = `argument_${index + 1}`;
+							while (method.parameters.includes(identifier)) identifier += "_";
+						}
+						return `${identifier}${needed ? "" : "?"}: ${schemaType(properties[key])}`;
+					}).join(", ");
+				} else {
+					const empty = method.input.type === "object" && !Object.keys(method.input.properties ?? {}).length;
+					const optional = method.input.type === "object" && !method.input.required?.length;
+					parameters = empty ? "" : `input${optional ? "?" : ""}: ${input}`;
+				}
+				if (method.subscription) {
+					const events = method.subscription.events;
+					if (!method.parameters || method.parameters.some((key) => !method.input.required?.includes(key)) || !events || typeof events !== "object" || Array.isArray(events) || !Object.keys(events).length || Object.keys(events).length > 8 || Object.keys(events).some((key) => !safeKey(key) || [
+						"onError",
+						"ready",
+						"error"
+					].includes(key))) throw new Error("Invalid plugin subscription");
+					const type = `{ ${Object.entries(events).map(([key, schema]) => `${JSON.stringify(key)}: ${schemaType(schema)};`).join(" ")} }`;
+					let optionName = "callbacks";
+					while (method.parameters.includes(optionName)) optionName += "_";
+					lines.push(`${indent}readonly ${JSON.stringify(name)}: (${parameters}${parameters ? ", " : ""}${optionName}: CaldikSubscriptionOptions<${type}>) => () => void;`);
+				} else lines.push(`${indent}readonly ${JSON.stringify(name)}: (${parameters}) => CaldikRequest<${output}>;`);
+			}
+		};
+		render(tree, "      ");
+		lines.push("    };");
+	}
+	lines.push("  }", "}", "");
+	return lines.join("\n");
+}
+const packageTypesPath = resolve(fileURLToPath(new URL("../", import.meta.url)), "types/plugins.d.ts");
+const generatedPrefix = "// Generated by Caldik.";
+async function readOptional(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return "";
+		throw error;
+	}
+}
+/** Replace the directory entry so Bun's hard-linked package cache is never modified. */
+async function writeGeneratedTypes(output, types) {
+	const previous = await readOptional(output);
+	if (previous && !previous.startsWith(generatedPrefix)) throw new Error("Output contains handwritten declarations; choose another output path");
+	if (previous === types) return false;
+	await mkdir(dirname(output), { recursive: true });
+	const temporary = `${output}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(temporary, types, "utf8");
+		await rename(temporary, output);
+	} finally {
+		await rm(temporary, { force: true });
+	}
+	return true;
+}
+async function responseText(response) {
+	const reader = response.body?.getReader();
+	if (!reader) throw new Error("Empty plugin contract response");
+	const chunks = [];
+	let bytes = 0;
+	try {
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			bytes += value.byteLength;
+			if (bytes > 1048576) throw new Error("Plugin contracts exceed 1 MiB");
+			chunks.push(value);
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+async function refreshPluginTypes({ storeId, apiUrl = "https://api.caldik.com", output = packageTypesPath, projectRoot, signal, timeoutMs = 5e3, fetcher = fetch }) {
+	signal?.throwIfAborted();
+	if (typeof storeId !== "string" || !/^STORE_[a-f0-9]{32}$/i.test(storeId)) throw new Error("The development store ID is invalid");
+	const base = new URL(apiUrl);
+	if (!["https:", "http:"].includes(base.protocol) || base.username || base.password || base.search || base.hash) throw new Error("API URL must be an HTTP(S) base URL without credentials, query or fragment");
+	const url = new URL(`${base.href.replace(/\/+$/, "")}/v1/stores/${encodeURIComponent(storeId)}/plugins/sdk`);
+	output = resolve(output);
+	if (!output.endsWith(".d.ts")) throw new Error("Plugin types must use a .d.ts output path");
+	const writeTypes = async (types) => {
+		const changed = await writeGeneratedTypes(output, types);
+		if (projectRoot && output === packageTypesPath) {
+			const snapshot = resolve(projectRoot, await stat(resolve(projectRoot, "src")).then((value) => value.isDirectory()).catch(() => false) ? "src/caldik.plugins.d.ts" : "caldik.plugins.d.ts");
+			const current = await readOptional(snapshot);
+			if (!current || current.startsWith(generatedPrefix)) await writeGeneratedTypes(snapshot, types);
+		}
+		return changed;
+	};
+	const context = `// Context: ${createHash("sha256").update(url.href).digest("hex")}\n`;
+	const previous = await readOptional(output);
+	if (previous.startsWith(generatedPrefix) && previous.includes("// Context: ") && !previous.includes(context)) await writeTypes(generatePluginTypes({ plugins: [] }));
+	const requestSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
+	const response = await fetcher(url, {
+		signal: requestSignal,
+		credentials: "omit",
+		headers: { Accept: "application/json" }
+	});
+	if (!response.ok) throw new Error(`Plugin contract request failed (HTTP ${response.status})`);
+	const metadata = JSON.parse(await responseText(response));
+	if (metadata.success !== true || metadata.storeId !== storeId) throw new Error("The API returned invalid contracts or contracts for another store");
+	const types = generatePluginTypes(metadata).replace(/\n/, `\n${context}`);
+	requestSignal.throwIfAborted();
+	return {
+		changed: await writeTypes(types),
+		output,
+		types
+	};
+}
+//#endregion
+export { refreshPluginTypes };

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+/// <reference path="../types/plugins.d.ts" />
 //#region src/payment-providers.generated.d.ts
 declare const paymentProviderIds: readonly ["customer_balance", "stripe", "ovgc"];
 declare const checkoutPaymentProviderIds: readonly ["customer_balance", "stripe", "ovgc"];
@@ -200,9 +201,10 @@ interface StorefrontOrder {
   subtotal: string;
   amount: string;
   discount: {
-    code: string;
+    code: string | null;
     percentage: string;
     amount: string;
+    source: "code" | "plugin";
   } | null;
   currency: string;
 }
@@ -294,15 +296,7 @@ interface CustomerEmailLoginInput {
   email: string;
   rememberMe?: boolean;
 }
-interface CustomerSessionResponse {
-  success: boolean;
-  authenticated: boolean;
-  customer: {
-    id: string;
-    email: string | null;
-  } | null;
-  expiresAt: number | null;
-}
+type CustomerSessionResponse = void;
 interface CustomerPasswordResetResponse extends CustomerLoginResponse {
   expiresAt: number;
   message: string;
@@ -330,14 +324,73 @@ interface CustomerProfileResponse {
   success: boolean;
   customer: {
     id: string;
+    name: string | null;
     email: string | null;
-    extensions?: Record<string, Record<string, string | number | boolean>>;
+    phone: string | null; /** All orders belonging to this customer in this store. */
+    totalOrders: number; /** Successfully paid order amounts in the store currency, as a decimal string. */
+    totalSpent: string;
+    currency: string;
+    createdAt: number;
+    updatedAt: number;
+    extensions: Record<string, Record<string, string | number | boolean>>;
   };
-  balances: Array<{
+}
+interface CustomerBalanceResponse {
+  success: boolean;
+  balance: {
     currency: string;
     amount: string;
+  };
+}
+interface CustomerOrderListOptions {
+  limit?: number;
+  cursor?: string;
+}
+interface CustomerOrder {
+  id: string;
+  shortId: string;
+  displayId: string;
+  paymentStatus: string;
+  fulfillmentStatus: string;
+  amount: string;
+  subtotal: string;
+  currency: string;
+  createdAt: number;
+  updatedAt: number;
+  discount: {
+    code: string | null;
+    percentage: string;
+    amount: string;
+    source: "code" | "plugin";
+  } | null;
+}
+interface CustomerOrderItem {
+  id: string;
+  productId: string | null;
+  productVariantId: string | null;
+  name: string;
+  description: string | null;
+  quantity: number;
+  unitAmount: string;
+  totalAmount: string;
+  customFields: Array<{
+    id: string;
+    name: string;
+    inputType: string;
+    value: string | number | boolean;
   }>;
 }
+interface CustomerOrdersResponse {
+  success: boolean;
+  orders: CustomerOrder[];
+  nextCursor: string | null;
+}
+interface CustomerOrderResponse {
+  success: boolean;
+  order: CustomerOrder & {
+    items: CustomerOrderItem[];
+  };
+}
 interface CustomerLoginSettings {
   passwordEnabled: boolean;
 }
@@ -373,6 +426,8 @@ interface CheckoutPaymentMethodsResponse {
 //#endregion
 //#region src/internal/types.d.ts
 interface RequestOptions {
+  /** Response intentionally has no JSON body. */
+  empty?: boolean;
   edgeCache?: boolean;
   /** Internal authorization policy. Protected hosted calls are the default. */
   access?: "public" | "runtime";
@@ -380,6 +435,29 @@ interface RequestOptions {
   headers?: Record<string, string>;
 }
 //#endregion
+//#region src/internal/request.d.ts
+interface RequestDescriptor {
+  method: "GET" | "POST";
+  path: string;
+  params?: Record<string, string | number>;
+  input?: unknown;
+  empty?: boolean;
+}
+/** Normal Promise scheduled on the next microtask so synchronous calls can join a batch. */
+declare class CaldikRequest<T> extends Promise<T> {
+  readonly owner: object;
+  readonly descriptor: RequestDescriptor;
+  static get [Symbol.species](): PromiseConstructor;
+  private dispatched;
+  private bound;
+  private resolveRequest;
+  private rejectRequest;
+  constructor(owner: object, descriptor: RequestDescriptor, execute: () => Promise<T>);
+  get started(): boolean;
+  cancel(error: unknown): void;
+  bind(promise: Promise<T>): void;
+}
+//#endregion
 //#region src/internal/client.d.ts
 type HttpClientOptions = {
   apiKey?: string;
@@ -388,6 +466,10 @@ type HttpClientOptions = {
   request?: Request;
   onSetCookie?: (cookie: string) => void | Promise<void>;
 };
+declare class CaldikHttpError extends Error {
+  readonly status: number;
+  constructor(message: string, status: number);
+}
 declare class CaldikHttpClient {
   private readonly apiKey?;
   private readonly apiUrl;
@@ -403,60 +485,78 @@ declare class CaldikHttpClient {
   customerAuthenticated(): Promise<void>;
   private captureCookies;
   private baseUrl;
+  private response;
   private request;
-  get<T>(path: string, params?: Record<string, string | number>, options?: RequestOptions): Promise<T>;
-  post<T>(path: string, input?: unknown, options?: RequestOptions): Promise<T>;
+  stream(path: string, input: unknown, signal: AbortSignal, cursor?: string): Promise<Response>;
+  get<T>(path: string, params?: Record<string, string | number>, options?: RequestOptions): CaldikRequest<T>;
+  post<T>(path: string, input?: unknown, options?: RequestOptions): CaldikRequest<T>;
+}
+//#endregion
+//#region src/batch.d.ts
+type BatchInput = Record<string, CaldikRequest<any>>;
+type BatchResult<T extends BatchInput> = { [K in keyof T]: Awaited<T[K]> };
+declare class CaldikBatchError extends Error {
+  readonly results: Record<string, unknown>;
+  readonly errors: Record<string, {
+    status: number;
+    body: unknown;
+  }>;
+  constructor(results: Record<string, unknown>, errors: Record<string, {
+    status: number;
+    body: unknown;
+  }>);
 }
+declare function batchRequests<T extends BatchInput>(client: CaldikHttpClient, input: T): Promise<BatchResult<T>>;
 //#endregion
 //#region src/categories.d.ts
 declare class CategoriesApi {
   private client;
   constructor(client: CaldikHttpClient);
-  list(options?: number | CategoryListOptions): Promise<CategoriesResponse>;
-  get(categoryId: string): Promise<CategoryResponse>;
+  list(options?: number | CategoryListOptions): CaldikRequest<CategoriesResponse>;
+  get(categoryId: string): CaldikRequest<CategoryResponse>;
 }
 //#endregion
 //#region src/products.d.ts
 declare class ProductsApi {
   private client;
   constructor(client: CaldikHttpClient);
-  list(): Promise<ProductsResponse>;
-  get(productIdOrSlug: string, options?: ProductGetOptions): Promise<ProductResponse>;
+  list(): CaldikRequest<ProductsResponse>;
+  get(productIdOrSlug: string, options?: ProductGetOptions): CaldikRequest<ProductResponse>;
 }
 //#endregion
 //#region src/reviews.d.ts
 declare class ReviewsApi {
   private client;
   constructor(client: CaldikHttpClient);
-  list(limit?: number): Promise<ReviewsResponse>;
+  list(limit?: number): CaldikRequest<ReviewsResponse>;
 }
 //#endregion
 //#region src/store.d.ts
 declare class StoreApi {
   private client;
   constructor(client: CaldikHttpClient);
-  get(): Promise<StoreResponse>;
+  get(): CaldikRequest<StoreResponse>;
 }
 //#endregion
 //#region src/checkout.d.ts
 declare class CheckoutApi {
   private client;
   readonly paymentmethods: {
-    list: () => Promise<CheckoutPaymentMethodsResponse>;
+    list: () => CaldikRequest<CheckoutPaymentMethodsResponse>;
   };
   readonly settings: {
-    get: () => Promise<CheckoutSettingsResponse>;
+    get: () => CaldikRequest<CheckoutSettingsResponse>;
   };
   constructor(client: CaldikHttpClient);
-  create(input: CreateOrderInput): Promise<OrderResponse>;
-  payWithBalance(orderId: string): Promise<OrderResponse>;
+  create(input: CreateOrderInput): CaldikRequest<OrderResponse>;
+  payWithBalance(orderId: string): CaldikRequest<OrderResponse>;
 }
 //#endregion
 //#region src/customer.d.ts
 declare class CustomerApi {
   private client;
   readonly settings: {
-    get: () => Promise<CustomerLoginSettingsResponse>;
+    get: () => CaldikRequest<CustomerLoginSettingsResponse>;
   };
   readonly login: {
     (email: string, options?: {
@@ -477,18 +577,27 @@ declare class CustomerApi {
     requestReset: (email: string) => Promise<CustomerPasswordResetResponse>;
     reset: (input: CustomerPasswordResetInput) => Promise<CustomerPasswordResetVerifyResponse>;
   };
+  readonly orders: {
+    list: (options?: CustomerOrderListOptions) => CaldikRequest<CustomerOrdersResponse>;
+    get: (id: string) => CaldikRequest<CustomerOrderResponse>;
+  };
+  readonly balance: {
+    get: (options?: {
+      currency?: string;
+    }) => CaldikRequest<CustomerBalanceResponse>;
+  };
   constructor(client: CaldikHttpClient);
-  /** Check a store-scoped session without raising an error for signed-out customers. */
-  session(): Promise<CustomerSessionResponse>;
-  /** Read the signed-in customer and their balances. */
-  me(): Promise<CustomerProfileResponse>;
+  /** Resolves without a body on HTTP 200; rejects with status 401 when signed out. */
+  session(): CaldikRequest<void>;
+  /** Read the signed-in customer's profile. */
+  me(): CaldikRequest<CustomerProfileResponse>;
 }
 //#endregion
 //#region src/subscriptions.d.ts
 declare class SubscriptionsApi {
   private client;
   constructor(client: CaldikHttpClient);
-  create(input: CreateSubscriptionInput): Promise<SubscriptionResponse>;
+  create(input: CreateSubscriptionInput): CaldikRequest<SubscriptionResponse>;
 }
 //#endregion
 //#region src/discounts.d.ts
@@ -511,7 +620,7 @@ interface DiscountQuoteResponse {
 declare class DiscountsApi {
   private client;
   constructor(client: CaldikHttpClient);
-  check(input: CheckDiscountInput): Promise<DiscountQuoteResponse>;
+  check(input: CheckDiscountInput): CaldikRequest<DiscountQuoteResponse>;
 }
 //#endregion
 //#region src/cart.d.ts
@@ -549,7 +658,7 @@ declare class CartApi {
   private resolve;
   private reset;
   private mutate;
-  private save;
+  private saveDiscount;
   private quote;
   get(): Promise<CartSnapshot>;
   add(item: ProductCommerceItem): Promise<CartSnapshot>;
@@ -562,7 +671,14 @@ declare class CartApi {
   checkout(input?: CartCheckoutInput): Promise<OrderResponse>;
 }
 //#endregion
+//#region src/internal/realtime.d.ts
+type CaldikSubscriptionOptions<T extends Record<string, unknown>> = { [K in keyof T]?: (value: T[K]) => void } & {
+  onError?: (error: Error) => void;
+};
+//#endregion
 //#region src/index.d.ts
+/** Populated automatically from the store's plugin contracts during caldik dev. */
+interface CaldikPlugins {}
 interface CaldikClientOptions {
   /** Store ID override for external servers or local browser development. */
   storeId?: string;
@@ -581,10 +697,18 @@ declare class CaldikClient {
   readonly store: StoreApi;
   readonly checkout: CheckoutApi;
   readonly customer: CustomerApi;
+  readonly customers: CustomerApi;
+  readonly orders: {
+    list: (options?: CustomerOrderListOptions) => CaldikRequest<CustomerOrdersResponse>;
+    get: (id: string) => CaldikRequest<CustomerOrderResponse>;
+  };
+  readonly plugins: CaldikPlugins;
   readonly subscriptions: SubscriptionsApi;
   readonly discounts: DiscountsApi;
   readonly cart: CartApi;
+  private readonly client;
   constructor(options?: CaldikClientOptions);
+  batch<T extends BatchInput>(input: T): Promise<BatchResult<T>>;
 }
 //#endregion
-export { AppliedDiscount, CaldikClient, CaldikClientOptions, CartApi, CartCheckoutInput, CartDiscount, CartItem, CartSnapshot, CategoriesResponse, Category, CategoryDetails, CategoryInclude, CategoryListOptions, CategoryMetadata, CategoryProduct, CategoryResponse, CheckDiscountInput, CheckoutPayment, CheckoutPaymentMethod, CheckoutPaymentMethodsResponse, CheckoutPaymentProviderId, CheckoutSettings, CheckoutSettingsResponse, CommerceItem, CreateOrderInput, CreateSubscriptionInput, CustomerEmailLoginInput, CustomerLoginResponse, CustomerLoginSettings, CustomerLoginSettingsResponse, CustomerLoginVerifyResponse, CustomerPasswordInput, CustomerPasswordResetInput, CustomerPasswordResetResponse, CustomerPasswordResetVerifyResponse, CustomerPasswordResponse, CustomerProfileResponse, CustomerRegistrationInput, CustomerRegistrationResponse, CustomerSessionResponse, DiscountQuoteResponse, DiscountsApi, ManualCommerceItem, OrderResponse, PaymentProviderId, Product, ProductCommerceItem, ProductCustomField, ProductCustomFieldInputType, ProductCustomFieldOption, ProductGetOptions, ProductImage, ProductMetadata, ProductResponse, ProductTag, ProductVariant, ProductsResponse, Review, ReviewsResponse, Store, StoreResponse, StoreSocials, StoreWebhookEvent, StoreWebhookEventName, StorefrontMetadata, StorefrontOrder, SubscriptionPaymentProviderId, SubscriptionResponse, checkoutPaymentProviderIds, paymentProviderIds, storeWebhookEventNames, subscriptionPaymentProviderIds };
+export { AppliedDiscount, BatchInput, BatchResult, CaldikBatchError, CaldikClient, CaldikClientOptions, CaldikHttpError, CaldikPlugins, CaldikRequest, type CaldikSubscriptionOptions, CartApi, CartCheckoutInput, CartDiscount, CartItem, CartSnapshot, CategoriesResponse, Category, CategoryDetails, CategoryInclude, CategoryListOptions, CategoryMetadata, CategoryProduct, CategoryResponse, CheckDiscountInput, CheckoutPayment, CheckoutPaymentMethod, CheckoutPaymentMethodsResponse, CheckoutPaymentProviderId, CheckoutSettings, CheckoutSettingsResponse, CommerceItem, CreateOrderInput, CreateSubscriptionInput, CustomerBalanceResponse, CustomerEmailLoginInput, CustomerLoginResponse, CustomerLoginSettings, CustomerLoginSettingsResponse, CustomerLoginVerifyResponse, CustomerOrder, CustomerOrderItem, CustomerOrderListOptions, CustomerOrderResponse, CustomerOrdersResponse, CustomerPasswordInput, CustomerPasswordResetInput, CustomerPasswordResetResponse, CustomerPasswordResetVerifyResponse, CustomerPasswordResponse, CustomerProfileResponse, CustomerRegistrationInput, CustomerRegistrationResponse, CustomerSessionResponse, DiscountQuoteResponse, DiscountsApi, ManualCommerceItem, OrderResponse, PaymentProviderId, Product, ProductCommerceItem, ProductCustomField, ProductCustomFieldInputType, ProductCustomFieldOption, ProductGetOptions, ProductImage, ProductMetadata, ProductResponse, ProductTag, ProductVariant, ProductsResponse, Review, ReviewsResponse, Store, StoreResponse, StoreSocials, StoreWebhookEvent, StoreWebhookEventName, StorefrontMetadata, StorefrontOrder, SubscriptionPaymentProviderId, SubscriptionResponse, batchRequests, checkoutPaymentProviderIds, paymentProviderIds, storeWebhookEventNames, subscriptionPaymentProviderIds };

package/dist/index.mjs

@@ -23,6 +23,56 @@ function defaultApiUrl(browser) {
 	return environmentApiUrl(browser) || (typeof API_URL !== "undefined" ? API_URL : "https://api.caldik.com");
 }
 //#endregion
+//#region src/internal/request.ts
+/** Normal Promise scheduled on the next microtask so synchronous calls can join a batch. */
+var CaldikRequest = class extends Promise {
+	owner;
+	descriptor;
+	static get [Symbol.species]() {
+		return Promise;
+	}
+	dispatched = false;
+	bound = false;
+	resolveRequest;
+	rejectRequest;
+	constructor(owner, descriptor, execute) {
+		let resolve;
+		let reject;
+		super((yes, no) => {
+			resolve = yes;
+			reject = no;
+		});
+		this.owner = owner;
+		this.descriptor = descriptor;
+		this.resolveRequest = resolve;
+		this.rejectRequest = reject;
+		queueMicrotask(() => {
+			if (this.bound) return;
+			this.dispatched = true;
+			try {
+				execute().then(resolve, reject);
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	get started() {
+		return this.dispatched || this.bound;
+	}
+	cancel(error) {
+		if (this.started) return;
+		this.bound = true;
+		this.rejectRequest(error);
+		this.catch(() => void 0);
+	}
+	bind(promise) {
+		if (this.started) throw new Error("An already started request cannot be batched");
+		this.bound = true;
+		promise.then(this.resolveRequest, this.rejectRequest);
+		this.catch(() => void 0);
+	}
+};
+//#endregion
 //#region src/internal/client.ts
 const STORE_ID_PATTERN = /^STORE_[a-f0-9]{32}$/i;
 const STOREFRONT_STORE_ID_ATTRIBUTE = "data-caldik-store-id";
@@ -74,6 +124,7 @@ var CaldikHttpClient = class {
 		return this.storeId || boundRuntimeStoreId();
 	}
 	hasCartSession() {
+		if (this.cookies.has(`cart_${this.storeContextId()}`) || this.cookies.has("session")) return true;
 		const prefix = `caldik_cart_session_${this.storeContextId()}`;
 		return [...this.cookies.keys()].some((name) => name === prefix || name.startsWith(`${prefix}_`));
 	}
@@ -112,7 +163,7 @@ var CaldikHttpClient = class {
 		if (!boundStoreId && !this.apiKey) throw new Error("Caldik authentication is unavailable. External servers must provide a private apiKey.");
 		return `${this.apiUrl.replace(/\/+$/, "")}/v1/stores/${encodeURIComponent(storeId)}`;
 	}
-	async request(method, path, input, params, options) {
+	async response(method, path, input, params, options, signal) {
 		const url = new URL(`${this.baseUrl()}${path}`);
 		if (params) for (const [key, value] of Object.entries(params)) url.searchParams.set(key, String(value));
 		const headers = { ...options?.headers };
@@ -128,20 +179,45 @@ var CaldikHttpClient = class {
 			headers,
 			...input !== void 0 ? { body: JSON.stringify(input) } : {},
 			cache: "default",
-			credentials: "include"
+			credentials: "include",
+			signal
 		});
 		if (!isBrowserRuntime() && options?.access === "public") await this.captureCookies(response);
 		if (!response.ok) {
 			const error = await response.clone().json().catch(() => null);
 			throw new CaldikHttpError(typeof error?.message === "string" && error.message ? error.message : `${response.status} ${response.statusText}`.trim(), response.status);
 		}
+		return response;
+	}
+	async request(method, path, input, params, options) {
+		const response = await this.response(method, path, input, params, options);
+		if (options?.empty) return void 0;
 		return response.json();
 	}
+	stream(path, input, signal, cursor) {
+		return this.response("POST", path, input, void 0, {
+			access: "public",
+			headers: {
+				Accept: "text/event-stream",
+				...cursor ? { "Last-Event-ID": cursor } : {}
+			}
+		}, signal);
+	}
 	get(path, params, options) {
-		return this.request("GET", path, void 0, params, options);
+		return new CaldikRequest(this, {
+			method: "GET",
+			path,
+			params,
+			empty: options?.empty
+		}, () => this.request("GET", path, void 0, params, options));
 	}
 	post(path, input, options) {
-		return this.request("POST", path, input, void 0, options);
+		return new CaldikRequest(this, {
+			method: "POST",
+			path,
+			input,
+			empty: options?.empty
+		}, () => this.request("POST", path, input, void 0, options));
 	}
 };
 //#endregion
@@ -224,8 +300,15 @@ var CustomerApi = class {
 	login;
 	register;
 	password;
+	orders;
+	balance;
 	constructor(client) {
 		this.client = client;
+		this.orders = {
+			list: (options = {}) => client.get("/customers/orders", { ...options }, { access: "public" }),
+			get: (id) => client.get(`/customers/orders/${encodeURIComponent(id)}`, void 0, { access: "public" })
+		};
+		this.balance = { get: (options = {}) => client.get("/customers/balance", { ...options }, { access: "public" }) };
 		this.settings = { get: () => this.client.get("/customers/settings", void 0, { access: "public" }) };
 		let pendingResetId;
 		this.password = {
@@ -293,11 +376,14 @@ verify: async (code, challengeId = pendingRegistrationId) => {
 			return response;
 		} });
 	}
-	/** Check a store-scoped session without raising an error for signed-out customers. */
+	/** Resolves without a body on HTTP 200; rejects with status 401 when signed out. */
 	session() {
-		return this.client.get("/customers/session", void 0, { access: "public" });
+		return this.client.get("/customers/session", void 0, {
+			access: "public",
+			empty: true
+		});
 	}
-	/** Read the signed-in customer and their balances. */
+	/** Read the signed-in customer's profile. */
 	me() {
 		return this.client.get("/customers/me", void 0, { access: "public" });
 	}
@@ -378,7 +464,6 @@ function discountFromQuote(quote) {
 var CartApi = class {
 	client;
 	cache = {
-		version: 2,
 		reference: null,
 		snapshot: {
 			items: [],
@@ -411,18 +496,16 @@ var CartApi = class {
 		if (!storage) return;
 		try {
 			const parsed = JSON.parse(storage.getItem(this.key()) || "null");
-			if (parsed?.version === 2) {
+			if (parsed?.snapshot) {
 				const snapshot = parsed.snapshot;
 				if (snapshot && Array.isArray(snapshot.items) && snapshot.items.every(isCartItem) && (parsed.reference === null || isReference(parsed.reference))) this.cache = {
-					version: 2,
 					reference: parsed.reference,
 					snapshot: cloneSnapshot({
 						items: snapshot.items,
 						discount: isCartDiscount(snapshot.discount) ? snapshot.discount : null
 					})
 				};
-			} else if (parsed?.version === 1 && Array.isArray(parsed.items) && parsed.items.every(isCartItem)) this.cache = {
-				version: 2,
+			} else if (parsed && Array.isArray(parsed.items) && parsed.items.every(isCartItem)) this.cache = {
 				reference: null,
 				snapshot: cloneSnapshot({
 					items: parsed.items,
@@ -444,7 +527,6 @@ var CartApi = class {
 	}
 	write(cart, token = this.cache.reference?.token, discount = null) {
 		this.cache = {
-			version: 2,
 			reference: {
 				id: cart.id,
 				token: cart.customerId ? null : token
@@ -492,7 +574,6 @@ var CartApi = class {
 	}
 	reset() {
 		this.cache = {
-			version: 2,
 			reference: null,
 			snapshot: {
 				items: [],
@@ -502,25 +583,11 @@ var CartApi = class {
 		this.persistCache();
 	}
 	async mutate(operation, seed = true) {
-		let cart = await this.resolve(false, seed);
-		let response;
-		try {
-			response = await operation(cart);
-		} catch (error) {
-			if (!(error instanceof CaldikHttpError) || error.status !== 409) throw error;
-			const refreshed = await this.resolve();
-			if (refreshed.id !== cart.id || refreshed.status !== "active") throw error;
-			cart = refreshed;
-			response = await operation(cart);
-		}
+		const response = await operation(await this.resolve(false, seed));
 		return this.write(response.cart);
 	}
-	save(cart, items, discountCode) {
-		return this.client.post(`/carts/${cart.id}`, {
-			items: commerceItems(items),
-			version: cart.version,
-			discountCode
-		}, this.options());
+	saveDiscount(cart, code) {
+		return this.client.post(`/carts/${cart.id}/discount`, { code }, this.options());
 	}
 	quote(cart, code) {
 		if (!cart.items.length) throw new Error("Cannot check a discount on an empty cart");
@@ -541,7 +608,7 @@ var CartApi = class {
 					404,
 					422
 				].includes(error.status)) throw error;
-				cart = (await this.save(cart, cart.items, null)).cart;
+				cart = (await this.saveDiscount(cart, null)).cart;
 			}
 			return this.write(cart, this.cache.reference?.token, discount);
 		});
@@ -554,10 +621,7 @@ var CartApi = class {
 				productId: item.productId.trim(),
 				quantity: quantity(item.quantity)
 			};
-			return this.mutate((cart) => this.client.post(`/carts/${cart.id}/items`, {
-				item: normalized,
-				version: cart.version
-			}, this.options()));
+			return this.mutate((cart) => this.client.post(`/carts/${cart.id}/items`, { item: normalized }, this.options()));
 		});
 	}
 	updateQuantity(itemId, nextQuantity) {
@@ -565,11 +629,10 @@ var CartApi = class {
 			const normalized = quantity(nextQuantity, true);
 			return this.mutate((cart) => {
 				if (!cart.items.some((item) => item.id === itemId)) throw new Error("Cart item not found");
-				const items = cart.items.map((item) => item.id === itemId ? {
-					...item,
+				return this.client.post(`/carts/${cart.id}/items/quantity`, {
+					itemId,
 					quantity: normalized
-				} : item).filter((item) => item.quantity > 0);
-				return this.save(cart, items, null);
+				}, this.options());
 			});
 		});
 	}
@@ -577,7 +640,7 @@ var CartApi = class {
 		return this.updateQuantity(itemId, 0);
 	}
 	clear() {
-		return this.enqueue(() => this.mutate((cart) => this.save(cart, [], null), false));
+		return this.enqueue(() => this.mutate((cart) => this.client.post(`/carts/${cart.id}/clear`, {}, this.options()), false));
 	}
 	checkDiscount(code) {
 		return this.enqueue(async () => this.quote(await this.resolve(), code));
@@ -587,7 +650,9 @@ var CartApi = class {
 			let quote;
 			const snapshot = await this.mutate(async (cart) => {
 				quote = await this.quote(cart, code);
-				return this.save(cart, cart.items, quote.discount.code);
+				const response = await this.saveDiscount(cart, quote.discount.code);
+				quote = await this.quote(response.cart, quote.discount.code);
+				return response;
 			});
 			snapshot.discount = discountFromQuote(quote);
 			this.cache.snapshot = cloneSnapshot(snapshot);
@@ -596,22 +661,193 @@ var CartApi = class {
 		});
 	}
 	removeDiscount() {
-		return this.enqueue(() => this.mutate((cart) => this.save(cart, cart.items, null)));
+		return this.enqueue(() => this.mutate((cart) => this.saveDiscount(cart, null)));
 	}
 	checkout(input = {}) {
 		return this.enqueue(async () => {
 			const cart = await this.resolve(true);
 			if (!cart.items.length) throw new Error("Cannot checkout an empty cart");
-			const response = await this.client.post(`/carts/${cart.id}/checkout`, {
-				...input,
-				version: cart.version
-			}, this.options());
+			const response = await this.client.post(`/carts/${cart.id}/checkout`, input, this.options());
 			this.reset();
 			return response;
 		});
 	}
 };
 //#endregion
+//#region src/batch.ts
+var CaldikBatchError = class extends Error {
+	results;
+	errors;
+	constructor(results, errors) {
+		super(`Batch requests failed: ${Object.keys(errors).join(", ")}`);
+		this.results = results;
+		this.errors = errors;
+		this.name = "CaldikBatchError";
+	}
+};
+function batchRequests(client, input) {
+	const entries = Object.entries(input);
+	const seen = /* @__PURE__ */ new Set();
+	try {
+		if (!entries.length || entries.length > 25) throw new Error("A batch must contain between 1 and 25 requests");
+		for (const [key, request] of entries) {
+			if (!/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/.test(key) || ["constructor", "prototype"].includes(key)) throw new Error("Invalid batch key");
+			if (!(request instanceof CaldikRequest) || request.owner !== client || request.started || seen.has(request)) throw new Error("Batch values must be unstarted, distinct requests from the same Caldik client");
+			if (request.descriptor.method !== "GET" && !/^\/plugins\/sdk\/[^/]+\/[^/]+$/.test(request.descriptor.path)) throw new Error("Batches support read requests only");
+			seen.add(request);
+		}
+	} catch (error) {
+		for (const [, request] of entries) if (request instanceof CaldikRequest) request.cancel(error);
+		throw error;
+	}
+	const response = client.post("/batch", { requests: Object.fromEntries(entries.map(([key, request]) => [key, {
+		method: request.descriptor.method,
+		path: request.descriptor.path,
+		query: request.descriptor.params,
+		input: request.descriptor.input
+	}])) }, { access: "public" }).then((value) => value.results);
+	for (const [key, request] of entries) request.bind(response.then((results) => {
+		const result = results[key];
+		if (!result) throw new Error(`Missing batch result: ${key}`);
+		if (result.status < 200 || result.status >= 300) {
+			const body = result.body;
+			throw new CaldikHttpError(body?.message || `HTTP ${result.status}`, result.status);
+		}
+		return request.descriptor.empty ? void 0 : result.body;
+	}));
+	return response.then((results) => {
+		const values = {};
+		const errors = {};
+		for (const [key, request] of entries) {
+			const result = results[key];
+			if (!result) throw new Error(`Missing batch result: ${key}`);
+			if (result.status >= 200 && result.status < 300) values[key] = request.descriptor.empty ? void 0 : result.body;
+			else errors[key] = result;
+		}
+		if (Object.keys(errors).length) throw new CaldikBatchError(values, errors);
+		return values;
+	});
+}
+//#endregion
+//#region src/internal/realtime.ts
+/** Native SSE transport. */
+function subscribePlugin(client, path, args, callbacks) {
+	const controller = new AbortController();
+	let cursor;
+	let timer;
+	let retries = 0;
+	const report = (error) => {
+		try {
+			if (typeof callbacks.onError === "function") callbacks.onError(error instanceof Error ? error : /* @__PURE__ */ new Error("Realtime connection failed"));
+		} catch {}
+	};
+	const frame = (value) => {
+		let event = "message", data = "", id;
+		for (const line of value.split("\n")) if (line.startsWith("event:")) event = line.slice(6).trim();
+		else if (line.startsWith("data:")) data += (data ? "\n" : "") + line.slice(5).trimStart();
+		else if (line.startsWith("id:")) id = line.slice(3).trim();
+		if (event === "error") throw new CaldikHttpError("Subscription authorization changed", 403);
+		if (id && /^\d{1,20}$/.test(id)) cursor = id;
+		if (["ready", "heartbeat"].includes(event) || !data) return;
+		const callback = Object.hasOwn(callbacks, event) ? callbacks[event] : void 0;
+		if (typeof callback === "function") {
+			let parsed;
+			try {
+				parsed = JSON.parse(data);
+			} catch {
+				throw new Error("Invalid realtime event");
+			}
+			try {
+				callback(parsed);
+			} catch (error) {
+				report(error);
+			}
+		}
+	};
+	const connect = async () => {
+		let reader;
+		try {
+			const response = await client.stream(path, args, controller.signal, cursor);
+			if (!response.headers.get("Content-Type")?.startsWith("text/event-stream") || !response.body) throw new Error("Invalid realtime response");
+			reader = response.body.getReader();
+			retries = 0;
+			const decoder = new TextDecoder();
+			let buffer = "";
+			while (!controller.signal.aborted) {
+				const { value, done } = await reader.read();
+				if (done) break;
+				buffer += decoder.decode(value, { stream: true });
+				buffer = buffer.replaceAll("\r\n", "\n");
+				let end;
+				while ((end = buffer.indexOf("\n\n")) !== -1) {
+					const next = buffer.slice(0, end);
+					buffer = buffer.slice(end + 2);
+					if (next.length > 65536) throw new Error("Realtime event exceeds its size limit");
+					frame(next);
+				}
+				if (buffer.length > 65536) throw new Error("Realtime event exceeds its size limit");
+			}
+		} catch (error) {
+			if (controller.signal.aborted) return;
+			report(error);
+			if (error instanceof CaldikHttpError && [
+				400,
+				401,
+				403,
+				404,
+				405
+			].includes(error.status)) {
+				controller.abort();
+				return;
+			}
+		} finally {
+			await reader?.cancel().catch(() => void 0);
+		}
+		if (!controller.signal.aborted) timer = setTimeout(() => {
+			connect();
+		}, Math.min(1e4, 500 * 2 ** Math.min(retries++, 5)));
+	};
+	connect();
+	return () => {
+		controller.abort();
+		if (timer) clearTimeout(timer);
+	};
+}
+//#endregion
+//#region src/plugins.ts
+function createPluginApi(client) {
+	const namespaces = /* @__PURE__ */ new Map();
+	const safe = (value) => /^[a-zA-Z][a-zA-Z0-9_\-]{0,63}$/.test(value) && ![
+		"constructor",
+		"prototype",
+		"then"
+	].includes(value);
+	return new Proxy(Object.create(null), { get(_target, namespace) {
+		if (typeof namespace !== "string" || !safe(namespace)) return void 0;
+		const methodProxy = (keys) => new Proxy(() => void 0, {
+			get(_target, key) {
+				if (typeof key !== "string" || !safe(key) || keys.length >= 4) return void 0;
+				return methodProxy([...keys, key]);
+			},
+			apply(_target, _this, args) {
+				while (args.length && args.at(-1) === void 0) args.pop();
+				const path = `/plugins/sdk/${encodeURIComponent(namespace)}/${encodeURIComponent(keys.join("."))}`;
+				if (keys.at(-1) === "subscribe") {
+					const callbacks = args.at(-1);
+					if (!callbacks || typeof callbacks !== "object" || Array.isArray(callbacks)) throw new Error("Provide subscription callbacks");
+					return subscribePlugin(client, path, args.slice(0, -1), callbacks);
+				}
+				return client.post(path, keys.length > 1 ? args : args[0] ?? {}, { access: "public" });
+			}
+		});
+		if (!namespaces.has(namespace)) namespaces.set(namespace, new Proxy(Object.create(null), { get(_target, method) {
+			if (typeof method !== "string" || !safe(method)) return void 0;
+			return methodProxy([method]);
+		} }));
+		return namespaces.get(namespace);
+	} });
+}
+//#endregion
 //#region src/payment-providers.generated.ts
 const paymentProviderIds = [
 	"customer_balance",
@@ -662,9 +898,13 @@ var CaldikClient = class {
 	store;
 	checkout;
 	customer;
+	customers;
+	orders;
+	plugins;
 	subscriptions;
 	discounts;
 	cart;
+	client;
 	constructor(options = {}) {
 		const client = new CaldikHttpClient({
 			apiKey: options.apiKey,
@@ -673,16 +913,23 @@ var CaldikClient = class {
 			request: options.request,
 			onSetCookie: options.onSetCookie
 		});
+		this.client = client;
 		this.categories = new CategoriesApi(client);
 		this.products = new ProductsApi(client);
 		this.reviews = new ReviewsApi(client);
 		this.store = new StoreApi(client);
 		this.checkout = new CheckoutApi(client);
 		this.customer = new CustomerApi(client);
+		this.customers = this.customer;
+		this.orders = this.customer.orders;
+		this.plugins = createPluginApi(client);
 		this.subscriptions = new SubscriptionsApi(client);
 		this.discounts = new DiscountsApi(client);
 		this.cart = new CartApi(client);
 	}
+	batch(input) {
+		return batchRequests(this.client, input);
+	}
 };
 //#endregion
-export { CaldikClient, CartApi, DiscountsApi, checkoutPaymentProviderIds, paymentProviderIds, storeWebhookEventNames, subscriptionPaymentProviderIds };
+export { CaldikBatchError, CaldikClient, CaldikHttpError, CaldikRequest, CartApi, DiscountsApi, batchRequests, checkoutPaymentProviderIds, paymentProviderIds, storeWebhookEventNames, subscriptionPaymentProviderIds };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caldik/client",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
@@ -8,16 +8,22 @@
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
+    },
+    "./development": {
+      "types": "./dist/development.d.mts",
+      "default": "./dist/development.mjs"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "types"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown && node development/prepare-types.mjs",
+    "prepack": "node development/prepare-types.mjs",
     "sync:api-contracts": "bun scripts/sync-api-contracts.ts",
     "test": "bun test"
   },

package/types/plugins.d.ts

@@ -0,0 +1,7 @@
+// Generated by Caldik.
+import type { CaldikRequest } from "@caldik/client";
+
+declare module "@caldik/client" {
+  interface CaldikPlugins {
+  }
+}