@kizlo/woocommerce 0.1.0

package/dist/index.js

@@ -0,0 +1,1796 @@
+import { CurrencyFormat, IdentifierInput, KizloError, ListMetadata, Media, Seo, WC_CORE_BASE, WC_STORE_BASE, WP_KIZLO_BASE, createExtension, createMiddleware, createProcedure, defineErrorMap, deserializeCurrencyFormat, deserializeListMetadata } from "kizlo";
+import { BooleanLike, Metadata, NumberLike, arrayable, normalizeArrayableValue, random, seconds, timestampSec, toPublicMetadata, tryCatch } from "@kizlo/shared";
+import { SignJWT, jwtVerify } from "jose";
+import z$1, { z } from "zod/v4";
+import z$2 from "zod";
+
+//#region src/session.ts
+async function mintGuestToken(secret, ttlSeconds) {
+	const sub = random({
+		length: 32,
+		prefix: "t"
+	});
+	return {
+		jwt: await new SignJWT().setProtectedHeader({
+			alg: "HS256",
+			typ: "JWT"
+		}).setSubject(sub).setIssuedAt().setExpirationTime(timestampSec() + ttlSeconds).sign(encodeSecret(secret)),
+		sub
+	};
+}
+async function verifyToken(token, secret) {
+	const { payload } = await jwtVerify(token, encodeSecret(secret));
+	return payload;
+}
+function encodeSecret(secret) {
+	return new TextEncoder().encode(secret);
+}
+function getCartHeaders(options) {
+	const { connInfo, userId, token } = options;
+	const headers = {};
+	if (token) headers["X-Kizlo-Guest-Token"] = token;
+	if (userId) headers["X-Kizlo-User-Id"] = String(userId);
+	if (connInfo?.city) headers["X-Kizlo-Geo-City"] = connInfo.city;
+	if (connInfo?.state) headers["X-Kizlo-Geo-State"] = connInfo.state;
+	if (connInfo?.country) headers["X-Kizlo-Geo-Country"] = connInfo.country;
+	if (connInfo?.postcode) headers["X-Kizlo-Geo-Postcode"] = connInfo.postcode;
+	return headers;
+}
+function sessionMiddleware(options) {
+	const cookieName = options?.cookieName ?? "guest-session";
+	const ttlSeconds = seconds(options?.ttl ?? "48 hours");
+	return createMiddleware(async ({ context, next }) => {
+		const connInfo = await context.getConnInfo();
+		const auth = await context.getAuthUser();
+		const foundToken = await context.cookies.get(cookieName);
+		if (!auth) {
+			if (!foundToken) {
+				const { jwt, sub } = await mintGuestToken(context.config.siteSecret, ttlSeconds);
+				await context.cookies.set({
+					name: cookieName,
+					value: jwt,
+					options: {
+						httpOnly: true,
+						sameSite: "lax"
+					}
+				});
+				return next({ context: { sessionHeaders: getCartHeaders({
+					token: sub,
+					connInfo
+				}) } });
+			}
+			const [err, data] = await tryCatch(verifyToken(foundToken, context.config.siteSecret));
+			if (err) {
+				const { jwt } = await mintGuestToken(context.config.siteSecret, ttlSeconds);
+				await context.cookies.set({
+					name: cookieName,
+					value: jwt,
+					options: {
+						httpOnly: true,
+						sameSite: "lax"
+					}
+				});
+				throw new KizloError("CART_SESSION_EXPIRED");
+			}
+			return next({ context: { sessionHeaders: getCartHeaders({
+				token: data.sub,
+				connInfo
+			}) } });
+		}
+		if (foundToken) {
+			const [err, data] = await tryCatch(verifyToken(foundToken, context.config.siteSecret));
+			if (!err) {
+				const response = await context.service.wordpress.post("/cart/merge", {
+					base: WP_KIZLO_BASE,
+					headers: getCartHeaders({
+						userId: auth.id,
+						token: data.sub,
+						connInfo
+					})
+				});
+				if (response.error) context.logger.error("CART_MERGE_FAILED", response.error);
+			}
+			await context.cookies.delete(cookieName);
+		}
+		return next({ context: { sessionHeaders: getCartHeaders({
+			userId: auth.id,
+			connInfo
+		}) } });
+	});
+}
+
+//#endregion
+//#region src/cart/error.ts
+const GET_CART_ERROR_MAP = defineErrorMap({});
+const UPDATE_CART_ERROR_MAP = defineErrorMap({});
+const ADD_CART_ITEM_ERROR_MAP = defineErrorMap({
+	CART_ITEM_OUT_OF_STOCK: {
+		status: 409,
+		message: "Product is out of stock."
+	},
+	CART_ITEM_INSUFFICIENT_STOCK: {
+		status: 409,
+		message: "Not enough stock for the requested quantity."
+	},
+	CART_ITEM_NOT_PURCHASABLE: {
+		status: 400,
+		message: "Product is not purchasable."
+	},
+	CART_ITEM_INVALID_QUANTITY: {
+		status: 400,
+		message: "Invalid quantity for the cart item."
+	},
+	CART_ITEM_EXISTS: {
+		status: 409,
+		message: "Item already exists in the cart."
+	},
+	CART_PRODUCT_INVALID: {
+		status: 404,
+		message: "The requested product is invalid."
+	},
+	CART_VARIATION_INVALID: {
+		status: 400,
+		message: "Variation data is invalid or missing."
+	}
+});
+const UPDATE_CART_ITEM_ERROR_MAP = defineErrorMap({
+	CART_ITEM_NOT_FOUND: {
+		status: 404,
+		message: "Cart item not found."
+	},
+	CART_PRODUCT_INVALID: {
+		status: 404,
+		message: "The requested product is invalid."
+	},
+	CART_ITEM_OUT_OF_STOCK: {
+		status: 409,
+		message: "Product is out of stock."
+	},
+	CART_ITEM_INSUFFICIENT_STOCK: {
+		status: 409,
+		message: "Not enough stock for the requested quantity."
+	},
+	CART_ITEM_INVALID_QUANTITY: {
+		status: 400,
+		message: "Invalid quantity for the cart item."
+	}
+});
+const REMOVE_CART_ITEM_ERROR_MAP = defineErrorMap({ CART_ITEM_NOT_FOUND: {
+	status: 404,
+	message: "Cart item not found."
+} });
+const SELECT_SHIPPING_RATE_ERROR_MAP = defineErrorMap({
+	CART_SHIPPING_RATE_NOT_FOUND: {
+		status: 404,
+		message: "The selected shipping rate is no longer available."
+	},
+	CART_SHIPPING_DISABLED: {
+		status: 400,
+		message: "Shipping is not available for this cart."
+	}
+});
+const APPLY_COUPON_ERROR_MAP = defineErrorMap({
+	CART_COUPON_INVALID: {
+		status: 400,
+		message: "The coupon could not be applied to the cart."
+	},
+	CART_COUPON_DISABLED: {
+		status: 400,
+		message: "Coupons are disabled."
+	}
+});
+const REMOVE_COUPON_ERROR_MAP = defineErrorMap({
+	CART_COUPON_INVALID: {
+		status: 400,
+		message: "The coupon could not be removed from the cart."
+	},
+	CART_COUPON_DISABLED: {
+		status: 400,
+		message: "Coupons are disabled."
+	},
+	CART_COUPON_NOT_FOUND: {
+		status: 404,
+		message: "Coupon was not applied to the cart."
+	}
+});
+
+//#endregion
+//#region src/product/schema.ts
+const SWATCH_TYPES = [
+	"text",
+	"color",
+	"image"
+];
+const SwatchType = z.enum(SWATCH_TYPES);
+const PRODUCT_TYPES = [
+	"simple",
+	"grouped",
+	"external",
+	"variable",
+	"variation"
+];
+const ProductType = z.enum(PRODUCT_TYPES);
+const ProductTagRef = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string()
+});
+const ProductBrandRef = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string()
+});
+const ProductAttributeTermRef = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string()
+});
+const ProductAttributeRef = z.object({
+	id: z.number(),
+	name: z.string(),
+	taxonomy: z.string(),
+	hasVariations: z.boolean(),
+	terms: z.array(ProductAttributeTermRef)
+});
+const ProductCategoryRef = z.object({
+	id: z.number(),
+	name: z.string(),
+	slug: z.string()
+});
+const ProductVariationAttributeRef = z.object({
+	name: z.string(),
+	value: z.string()
+});
+const ProductVariationRef = z.object({
+	id: z.number(),
+	attributes: z.array(ProductVariationAttributeRef)
+});
+const ProductPrices = z.object({
+	price: z.number(),
+	salePrice: z.number().nullable(),
+	regularPrice: z.number()
+});
+const Product = z.object({
+	id: z.number(),
+	parentId: z.number(),
+	type: ProductType,
+	name: z.string(),
+	slug: z.string(),
+	sku: z.string().nullable(),
+	shortDescription: z.string(),
+	description: z.string(),
+	onSaleFrom: z.number().nullable(),
+	onSaleTo: z.number().nullable(),
+	isOnSale: z.boolean(),
+	prices: ProductPrices,
+	averageRating: z.string(),
+	reviewCount: z.number(),
+	images: z.array(Media),
+	categories: z.array(ProductCategoryRef),
+	tags: z.array(ProductTagRef),
+	brands: z.array(ProductBrandRef),
+	attributes: z.array(ProductAttributeRef),
+	variations: z.array(ProductVariationRef),
+	groupedProducts: z.array(z.number()),
+	isSoldIndividually: z.boolean(),
+	hasOptions: z.boolean(),
+	isPurchasable: z.boolean(),
+	isInStock: z.boolean(),
+	isOnBackorder: z.boolean(),
+	stock: z.number().nullable(),
+	lowStockRemaining: z.number().nullable(),
+	seo: Seo.nullable(),
+	currencyFormat: CurrencyFormat,
+	meta: Metadata
+});
+const ProductList = z.object({
+	items: z.array(Product),
+	meta: ListMetadata
+});
+const RetrieveProductInput = z.object({
+	identifier: IdentifierInput,
+	previewToken: z.string().optional()
+});
+const PRODUCTS_ORDER_BYS = [
+	"date",
+	"id",
+	"include",
+	"title",
+	"slug",
+	"price",
+	"popularity",
+	"rating",
+	"menu_order",
+	"comment_count"
+];
+const ProductOrderBy = z.enum(PRODUCTS_ORDER_BYS);
+const PRODUCT_TAXONOMY_OPERATORS = [
+	"in",
+	"not_in",
+	"and"
+];
+const ProductTaxonomyOperator = z.enum(PRODUCT_TAXONOMY_OPERATORS);
+const PRODUCT_ATTRIBUTE_RELATIONS = ["in", "and"];
+const ProductAttributeRelation = z.enum(PRODUCT_ATTRIBUTE_RELATIONS);
+const PRODUCT_STOCK_STATUSES = [
+	"instock",
+	"outofstock",
+	"onbackorder"
+];
+const ProductStockStatus = z.enum(PRODUCT_STOCK_STATUSES);
+const PRODUCT_CATALOG_VISIBILITIES = [
+	"any",
+	"visible",
+	"catalog",
+	"search",
+	"hidden"
+];
+const ProductCatalogVisibility = z.enum(PRODUCT_CATALOG_VISIBILITIES);
+const PRODUCT_RATINGS = [
+	"1",
+	"2",
+	"3",
+	"4",
+	"5"
+];
+const ProductRating = z.enum(PRODUCT_RATINGS);
+const ProductAttributeFilter = z.object({
+	attribute: z.string().optional(),
+	slug: arrayable(z.string()).optional(),
+	termId: arrayable(NumberLike).optional(),
+	operator: ProductTaxonomyOperator.optional()
+});
+const ListProductInput = z.object({
+	page: NumberLike.optional(),
+	perPage: NumberLike.optional(),
+	search: z.string().optional(),
+	slug: z.string().optional(),
+	after: z.string().optional(),
+	before: z.string().optional(),
+	exclude: arrayable(NumberLike).optional(),
+	include: arrayable(NumberLike).optional(),
+	offset: NumberLike.optional(),
+	order: z.enum(["asc", "desc"]).optional(),
+	orderby: ProductOrderBy.optional(),
+	parent: arrayable(NumberLike).optional(),
+	parentExclude: arrayable(NumberLike).optional(),
+	type: ProductType.optional(),
+	sku: z.string().optional(),
+	featured: BooleanLike.optional(),
+	category: z.string().optional(),
+	categoryOperator: ProductTaxonomyOperator.optional(),
+	brand: z.string().optional(),
+	brandOperator: ProductTaxonomyOperator.optional(),
+	tag: z.string().optional(),
+	tagOperator: ProductTaxonomyOperator.optional(),
+	onSale: BooleanLike.optional(),
+	minPrice: z.string().optional(),
+	maxPrice: z.string().optional(),
+	stockStatus: arrayable(ProductStockStatus).optional(),
+	attributes: z.array(ProductAttributeFilter).optional(),
+	attributeRelation: ProductAttributeRelation.optional(),
+	catalogVisibility: ProductCatalogVisibility.optional(),
+	rating: arrayable(ProductRating).optional(),
+	related: NumberLike.optional()
+});
+const ProductFiltersPriceRange = z.object({
+	minPrice: z.number(),
+	maxPrice: z.number()
+});
+const ProductFiltersStockStatus = z.object({
+	count: z.number(),
+	status: ProductStockStatus
+});
+const ProductFiltersTerm = z.object({
+	id: z.number(),
+	parentId: z.number().nullable(),
+	name: z.string(),
+	slug: z.string(),
+	taxonomy: z.string(),
+	description: z.string(),
+	count: z.number()
+});
+const ProductFiltersTaxonomyTerm = ProductFiltersTerm.extend({ image: Media.nullable() });
+const ProductFiltersAttributeTerm = ProductFiltersTerm.extend({
+	type: SwatchType,
+	swatch: z.string().nullable()
+});
+const ProductFilters = z.object({
+	priceRange: ProductFiltersPriceRange,
+	stockStatuses: z.array(ProductFiltersStockStatus),
+	attributeTerms: z.array(ProductFiltersAttributeTerm),
+	taxonomyTerms: z.array(ProductFiltersTaxonomyTerm),
+	currencyFormat: CurrencyFormat
+});
+const CalculateAttributeFilter = z.object({
+	taxonomy: z.string(),
+	queryType: z.enum(["or", "and"]).optional()
+});
+const RetrieveProductFiltersInput = ListProductInput.extend({
+	ratingFilters: BooleanLike.optional(),
+	stockStatusFilters: BooleanLike.optional(),
+	taxonomyFilters: z.array(z.string()).optional(),
+	attributeFilters: z.array(CalculateAttributeFilter).optional()
+});
+
+//#endregion
+//#region src/schema.ts
+const Totals = z$1.object({
+	discountTotal: z$1.number(),
+	discountTaxTotal: z$1.number(),
+	shippingTotal: z$1.number(),
+	shippingTaxTotal: z$1.number(),
+	feeTotal: z$1.number(),
+	feeTaxTotal: z$1.number(),
+	taxTotal: z$1.number(),
+	total: z$1.number()
+});
+const ItemTotals = z$1.object({
+	unitPrice: z$1.number(),
+	grossAmount: z$1.number(),
+	discountAmount: z$1.number(),
+	discountTaxAmount: z$1.number(),
+	netAmount: z$1.number(),
+	taxAmount: z$1.number(),
+	total: z$1.number()
+});
+const ShippingAddress = z$1.object({
+	firstName: z$1.string(),
+	lastName: z$1.string(),
+	phone: z$1.string(),
+	company: z$1.string().optional(),
+	address1: z$1.string(),
+	address2: z$1.string().optional(),
+	city: z$1.string(),
+	postcode: z$1.string(),
+	state: z$1.string(),
+	country: z$1.string()
+});
+const BillingAddress = z$1.object({
+	firstName: z$1.string(),
+	lastName: z$1.string(),
+	phone: z$1.string(),
+	company: z$1.string().optional(),
+	address1: z$1.string(),
+	address2: z$1.string().optional(),
+	city: z$1.string(),
+	postcode: z$1.string(),
+	state: z$1.string(),
+	country: z$1.string(),
+	email: z$1.string()
+});
+
+//#endregion
+//#region src/cart/schema.ts
+const CART_ITEM_STATUSES = [
+	"insufficient_stock",
+	"low_stock",
+	"out_of_stock",
+	"unavailable",
+	"available"
+];
+const CartLineItemStatus = z$1.enum(CART_ITEM_STATUSES);
+const PackageAddress = z$1.object({
+	address1: z$1.string(),
+	address2: z$1.string(),
+	city: z$1.string(),
+	state: z$1.string(),
+	postcode: z$1.string(),
+	country: z$1.string()
+});
+const CartPackageItem = z$1.object({
+	key: z$1.string(),
+	name: z$1.string(),
+	quantity: z$1.number()
+});
+const CartPackageRate = z$1.object({
+	id: z$1.string(),
+	methodId: z$1.string(),
+	name: z$1.string(),
+	isSelected: z$1.boolean(),
+	description: z$1.string(),
+	deliveryTime: z$1.string(),
+	amount: z$1.number(),
+	taxAmount: z$1.number(),
+	total: z$1.number()
+});
+const CartPackageLine = z$1.object({
+	id: z$1.number(),
+	name: z$1.string(),
+	address: PackageAddress,
+	items: z$1.array(CartPackageItem),
+	rates: z$1.array(CartPackageRate)
+});
+const CartItemVariation = z$1.object({
+	name: z$1.string(),
+	attribute: z$1.string(),
+	value: z$1.string()
+});
+const CartItem = z$1.object({
+	key: z$1.string(),
+	type: z$1.string(),
+	status: CartLineItemStatus,
+	productId: z$1.number(),
+	variationId: z$1.number().nullable(),
+	name: z$1.string(),
+	description: z$1.string(),
+	shortDescription: z$1.string(),
+	sku: z$1.string(),
+	slug: z$1.string(),
+	lowStockCount: z$1.number().nullable(),
+	isSoldIndividually: z$1.boolean(),
+	images: z$1.array(Media),
+	variations: z$1.array(CartItemVariation),
+	prices: ProductPrices,
+	quantity: z$1.number(),
+	totals: ItemTotals
+});
+const AddCartItemInput = z$1.object({
+	productId: z$1.number(),
+	quantity: z$1.number(),
+	variations: z$1.array(z$1.object({
+		attribute: z$1.string(),
+		value: z$1.string()
+	})).optional()
+});
+const UpdateCartItemInput = z$1.object({
+	key: z$1.string(),
+	quantity: z$1.number()
+});
+const RemoveCartItemInput = z$1.object({ key: z$1.string() });
+const CartCouponLine = z$1.object({
+	id: z$1.string(),
+	type: z$1.string(),
+	code: z$1.string(),
+	amount: z$1.number(),
+	taxAmount: z$1.number()
+});
+const ApplyCouponInput = z$1.object({ code: z$1.string() });
+const RemoveCouponInput = z$1.object({ code: z$1.string() });
+const CartShippingLine = z$1.object({
+	id: z$1.string(),
+	label: z$1.string(),
+	amount: z$1.number(),
+	taxAmount: z$1.number()
+});
+const CartShippingAddress = ShippingAddress.extend({ id: z$1.string().optional() });
+const CartBillingAddress = BillingAddress.extend({ id: z$1.string().optional() });
+const Cart = z$1.object({
+	totalItems: z$1.number(),
+	lineItems: z$1.array(CartItem),
+	billing: CartBillingAddress.nullable(),
+	shipping: CartShippingAddress.nullable(),
+	packageLines: z$1.array(CartPackageLine),
+	couponLines: z$1.array(CartCouponLine),
+	shippingLines: z$1.array(CartShippingLine),
+	currencyFormat: CurrencyFormat,
+	totals: Totals
+});
+const SelectCartShippingRateInput = z$1.object({
+	rateId: z$1.string(),
+	packageId: z$1.number()
+});
+const AddressInput = (schema) => {
+	return schema.extend({ id: z$1.string().optional() });
+};
+const UpdateCartInput = z$1.object({
+	shipping: AddressInput(ShippingAddress).nullable().optional(),
+	billing: AddressInput(BillingAddress).nullable().optional()
+});
+
+//#endregion
+//#region src/cart/utils.ts
+function deserializeCart(data) {
+	const lineItems = data.items.map((item) => {
+		const totals = calculateLineItemTotals({
+			quantity: item.quantity,
+			subtotal: Number(item.totals.line_subtotal),
+			subtotal_tax: Number(item.totals.line_subtotal_tax),
+			total: Number(item.totals.line_total),
+			total_tax: Number(item.totals.line_total_tax)
+		});
+		let itemStatus = "available";
+		const error = data.errors.find((e) => e.message.includes(item.name));
+		if (error) switch (error.code) {
+			case "woocommerce_rest_product_out_of_stock":
+				itemStatus = "out_of_stock";
+				break;
+			case "woocommerce_rest_cart_item_error":
+				itemStatus = "unavailable";
+				break;
+		}
+		if (item.low_stock_remaining) itemStatus = "low_stock";
+		const productSlug = new URL(item.permalink).pathname;
+		return {
+			key: item.key,
+			productId: item.id,
+			variationId: null,
+			type: item.type,
+			name: item.name,
+			sku: item.sku,
+			status: itemStatus,
+			quantity: item.quantity,
+			isSoldIndividually: item.sold_individually,
+			images: item.images.map((item$1) => ({
+				id: item$1.id,
+				name: item$1.name,
+				alt: item$1.alt,
+				src: item$1.src
+			})),
+			variations: item.variation.map((a) => ({
+				name: a.attribute,
+				attribute: a.raw_attribute,
+				value: a.value
+			})),
+			slug: productSlug,
+			description: item.description,
+			soldIndividually: item.sold_individually,
+			lowStockCount: item.low_stock_remaining,
+			prices: {
+				price: Number(item.prices.price),
+				salePrice: Number(item.prices.sale_price),
+				regularPrice: Number(item.prices.regular_price)
+			},
+			totals,
+			shortDescription: item.short_description
+		};
+	});
+	const couponLines = data.coupons.map((coupon) => {
+		return {
+			id: coupon.code,
+			code: coupon.code,
+			type: coupon.discount_type,
+			amount: Number(coupon.totals.total_discount),
+			taxAmount: Number(coupon.totals.total_discount_tax)
+		};
+	});
+	const packageLines = data.shipping_rates.map((pkg) => ({
+		id: Number(pkg.package_id),
+		name: pkg.name,
+		address: {
+			address1: pkg.destination.address_1,
+			address2: pkg.destination.address_2,
+			city: pkg.destination.city,
+			state: pkg.destination.state,
+			postcode: pkg.destination.postcode,
+			country: pkg.destination.country
+		},
+		items: pkg.items.map((item) => ({
+			key: item.key,
+			name: item.name,
+			quantity: item.quantity
+		})),
+		rates: pkg.shipping_rates.map((rate) => ({
+			id: rate.rate_id,
+			name: rate.name,
+			description: rate.description,
+			deliveryTime: rate.delivery_time,
+			amount: Number(rate.price),
+			taxAmount: Number(rate.taxes),
+			total: Number(rate.price) + Number(rate.taxes),
+			isSelected: rate.selected,
+			methodId: rate.method_id
+		}))
+	}));
+	const shippingLines = packageLines.reduce((acc, item) => {
+		const found = item.rates.find((a) => a.isSelected);
+		if (found) acc.push({
+			id: found.id,
+			label: found.name,
+			amount: found.amount,
+			taxAmount: found.taxAmount
+		});
+		return acc;
+	}, []);
+	const discountTotal = Number(data.totals.total_discount);
+	const discountTaxTotal = Number(data.totals.total_discount_tax);
+	const shippingTotal = Number(data.totals.total_shipping);
+	const shippingTaxTotal = Number(data.totals.total_shipping_tax);
+	const feeTotal = Number(data.totals.total_fees);
+	const feeTaxTotal = Number(data.totals.total_fees_tax);
+	const taxTotal = Number(data.totals.total_tax);
+	const total = Number(data.totals.total_price);
+	return {
+		lineItems,
+		couponLines,
+		packageLines,
+		shippingLines,
+		totalItems: data.items_count,
+		billing: data.billing_address.address_1.length ? deserializeCartBillingAddress(data) : null,
+		shipping: data.shipping_address.address_1.length ? deserializeCartShippingAddress(data) : null,
+		currencyFormat: deserializeCurrencyFormat(data.totals),
+		totals: {
+			discountTotal,
+			discountTaxTotal,
+			shippingTotal,
+			shippingTaxTotal,
+			feeTotal,
+			feeTaxTotal,
+			taxTotal,
+			total
+		}
+	};
+}
+function deserializeCartShippingAddress(cart) {
+	return {
+		address1: cart.shipping_address.address_1,
+		address2: cart.shipping_address.address_2,
+		city: cart.shipping_address.city,
+		company: cart.shipping_address.company,
+		country: cart.shipping_address.country,
+		firstName: cart.shipping_address.first_name,
+		lastName: cart.shipping_address.last_name,
+		phone: cart.shipping_address.phone,
+		postcode: cart.shipping_address.postcode,
+		state: cart.shipping_address.state
+	};
+}
+function deserializeCartBillingAddress(cart) {
+	return {
+		address1: cart.billing_address.address_1,
+		address2: cart.billing_address.address_2,
+		city: cart.billing_address.city,
+		company: cart.billing_address.company,
+		country: cart.billing_address.country,
+		firstName: cart.billing_address.first_name,
+		lastName: cart.billing_address.last_name,
+		phone: cart.billing_address.phone,
+		postcode: cart.billing_address.postcode,
+		state: cart.billing_address.state,
+		email: cart.billing_address.email
+	};
+}
+function calculateLineItemTotals(input) {
+	const unitPrice = input.subtotal / input.quantity;
+	const grossAmount = input.subtotal;
+	return {
+		unitPrice,
+		discountAmount: input.subtotal - input.total,
+		discountTaxAmount: input.subtotal_tax - input.total_tax,
+		grossAmount,
+		netAmount: input.total,
+		taxAmount: input.total_tax,
+		total: input.total + input.total_tax
+	};
+}
+
+//#endregion
+//#region src/cart/index.ts
+const CART_ROUTER = {
+	get: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/cart",
+		output: Cart.nullable(),
+		errors: GET_CART_ERROR_MAP,
+		middlewares: [sessionMiddleware()]
+	}, async ({ context, errors }) => {
+		const response = await context.service.wordpress.get("/cart", {
+			base: WC_STORE_BASE,
+			headers: context.sessionHeaders
+		});
+		if (response.error) switch (response.error.code) {
+			default:
+				context.logger.error("Get cart unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeCart(response.data);
+	}),
+	update: createProcedure({
+		scope: "api",
+		method: "PUT",
+		path: "/cart",
+		output: Cart,
+		body: UpdateCartInput,
+		errors: UPDATE_CART_ERROR_MAP,
+		middlewares: [sessionMiddleware()]
+	}, async ({ context, input: { body: input }, errors }) => {
+		const connInfo = await context.getConnInfo();
+		const defaultBilling = input.billing ?? {
+			...input.shipping,
+			email: void 0
+		};
+		const updateData = {
+			billing_address: defaultBilling !== void 0 ? {
+				first_name: defaultBilling?.firstName ?? "",
+				last_name: defaultBilling?.lastName ?? "",
+				address_1: defaultBilling?.address1 ?? "",
+				address_2: defaultBilling?.address2 ?? "",
+				company: defaultBilling?.company ?? "",
+				email: defaultBilling?.email ?? "",
+				phone: defaultBilling?.phone ?? "",
+				city: defaultBilling?.city ?? "",
+				state: defaultBilling?.state ?? connInfo?.state ?? void 0,
+				country: defaultBilling?.country ?? connInfo?.country ?? void 0,
+				postcode: defaultBilling?.postcode ?? connInfo?.postcode ?? ""
+			} : {},
+			shipping_address: input.shipping !== void 0 ? {
+				first_name: input.shipping?.firstName ?? "",
+				last_name: input.shipping?.lastName ?? "",
+				address_1: input.shipping?.address1 ?? "",
+				address_2: input.shipping?.address2 ?? "",
+				company: input.shipping?.company ?? "",
+				phone: input.shipping?.phone ?? "",
+				city: input.shipping?.city ?? "",
+				state: input.shipping?.state ?? connInfo?.state ?? void 0,
+				country: input.shipping?.country ?? connInfo?.country ?? void 0,
+				postcode: input.shipping?.postcode ?? connInfo?.postcode ?? ""
+			} : {}
+		};
+		const response = await context.service.wordpress.post("/cart/update-customer", {
+			base: WC_STORE_BASE,
+			body: {
+				billing_address: updateData.billing_address,
+				shipping_address: updateData.shipping_address
+			},
+			headers: context.sessionHeaders
+		});
+		if (response.error) switch (response.error.code) {
+			default:
+				context.logger.error("Update cart customer unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeCart(response.data);
+	}),
+	selectShippingRate: createProcedure({
+		scope: "api",
+		method: "PUT",
+		path: "/cart/shipping-rate",
+		body: SelectCartShippingRateInput,
+		output: Cart,
+		errors: SELECT_SHIPPING_RATE_ERROR_MAP,
+		middlewares: [sessionMiddleware()]
+	}, async ({ context, input: { body }, errors }) => {
+		const response = await context.service.wordpress.post("/cart/select-shipping-rate", {
+			base: WC_STORE_BASE,
+			headers: context.sessionHeaders,
+			body: {
+				rate_id: body.rateId,
+				package_id: body.packageId
+			}
+		});
+		if (response.error) switch (response.error.code) {
+			case "woocommerce_rest_cart_shipping_rate_not_found": throw errors.CART_SHIPPING_RATE_NOT_FOUND({ message: response.error.message });
+			case "woocommerce_rest_shipping_disabled": throw errors.CART_SHIPPING_DISABLED({ message: response.error.message });
+			default:
+				context.logger.error("Select shipping rate unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeCart(response.data);
+	}),
+	items: {
+		add: createProcedure({
+			scope: "api",
+			method: "POST",
+			path: "/cart/items",
+			body: AddCartItemInput,
+			output: Cart,
+			errors: ADD_CART_ITEM_ERROR_MAP,
+			middlewares: [sessionMiddleware()]
+		}, async ({ context, input: { body: input }, errors }) => {
+			const response = await context.service.wordpress.post("/cart/add-item", {
+				body: {
+					id: input.productId,
+					quantity: input.quantity,
+					variation: input.variations ?? []
+				},
+				base: WC_STORE_BASE,
+				headers: context.sessionHeaders
+			});
+			if (response.error) switch (response.error.code) {
+				case "woocommerce_rest_product_out_of_stock": throw errors.CART_ITEM_OUT_OF_STOCK({ message: response.error.message });
+				case "woocommerce_rest_product_partially_out_of_stock": throw errors.CART_ITEM_INSUFFICIENT_STOCK({ message: response.error.message });
+				case "woocommerce_rest_product_not_purchasable": throw errors.CART_ITEM_NOT_PURCHASABLE({ message: response.error.message });
+				case "woocommerce_rest_product_invalid_quantity": throw errors.CART_ITEM_INVALID_QUANTITY({ message: response.error.message });
+				case "woocommerce_rest_cart_item_exists": throw errors.CART_ITEM_EXISTS({ message: response.error.message });
+				case "woocommerce_rest_cart_invalid_product":
+				case "woocommerce_rest_cart_invalid_parent_product": throw errors.CART_PRODUCT_INVALID({ message: response.error.message });
+				case "woocommerce_rest_invalid_variation_data":
+				case "woocommerce_rest_missing_attributes":
+				case "woocommerce_rest_missing_variation_data":
+				case "woocommerce_rest_variation_id_from_variation_data": throw errors.CART_VARIATION_INVALID({ message: response.error.message });
+				default:
+					context.logger.error("Add cart item unhandled error", response.error, { code: response.error.code });
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializeCart(response.data);
+		}),
+		update: createProcedure({
+			scope: "api",
+			method: "PUT",
+			path: "/cart/items/{key}",
+			params: UpdateCartItemInput.pick({ key: true }),
+			body: UpdateCartItemInput.pick({ quantity: true }),
+			output: Cart,
+			errors: UPDATE_CART_ITEM_ERROR_MAP,
+			middlewares: [sessionMiddleware()]
+		}, async ({ context, input: { params, body }, errors }) => {
+			const response = await context.service.wordpress.post("/cart/update-item", {
+				body: {
+					key: params.key,
+					quantity: body.quantity
+				},
+				base: WC_STORE_BASE,
+				headers: context.sessionHeaders
+			});
+			if (response.error) switch (response.error.code) {
+				case "woocommerce_rest_cart_invalid_key": throw errors.CART_ITEM_NOT_FOUND({ message: response.error.message });
+				case "woocommerce_rest_cart_invalid_product": throw errors.CART_PRODUCT_INVALID({ message: response.error.message });
+				case "woocommerce_rest_product_out_of_stock": throw errors.CART_ITEM_OUT_OF_STOCK({ message: response.error.message });
+				case "woocommerce_rest_product_partially_out_of_stock": throw errors.CART_ITEM_INSUFFICIENT_STOCK({ message: response.error.message });
+				case "woocommerce_rest_product_invalid_quantity": throw errors.CART_ITEM_INVALID_QUANTITY({ message: response.error.message });
+				default:
+					context.logger.error("Update cart item unhandled error", response.error, { code: response.error.code });
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializeCart(response.data);
+		}),
+		remove: createProcedure({
+			scope: "api",
+			method: "PATCH",
+			path: "/cart/items/{key}",
+			params: RemoveCartItemInput.pick({ key: true }),
+			output: Cart,
+			errors: REMOVE_CART_ITEM_ERROR_MAP,
+			middlewares: [sessionMiddleware()]
+		}, async ({ context, input: { params }, errors }) => {
+			const response = await context.service.wordpress.post("/cart/remove-item", {
+				body: { key: params.key },
+				base: WC_STORE_BASE,
+				headers: context.sessionHeaders
+			});
+			if (response.error) switch (response.error.code) {
+				case "woocommerce_rest_cart_invalid_key": throw errors.CART_ITEM_NOT_FOUND({ message: response.error.message });
+				default:
+					context.logger.error("Remove cart item unhandled error", response.error, { code: response.error.code });
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializeCart(response.data);
+		})
+	},
+	coupons: {
+		apply: createProcedure({
+			scope: "api",
+			method: "POST",
+			path: "/cart/coupons",
+			body: ApplyCouponInput,
+			output: Cart,
+			errors: APPLY_COUPON_ERROR_MAP,
+			middlewares: [sessionMiddleware()]
+		}, async ({ context, input: { body }, errors }) => {
+			const response = await context.service.wordpress.post("/cart/apply-coupon", {
+				body: { code: body.code },
+				base: WC_STORE_BASE,
+				headers: context.sessionHeaders
+			});
+			if (response.error) switch (response.error.code) {
+				case "woocommerce_rest_cart_coupon_error": throw errors.CART_COUPON_INVALID({ message: response.error.message });
+				case "woocommerce_rest_cart_coupon_disabled": throw errors.CART_COUPON_DISABLED({ message: response.error.message });
+				default:
+					context.logger.error("Apply coupon unhandled error", response.error, { code: response.error.code });
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializeCart(response.data);
+		}),
+		remove: createProcedure({
+			scope: "api",
+			method: "POST",
+			path: "/cart/coupons/{code}",
+			params: RemoveCouponInput.pick({ code: true }),
+			output: Cart,
+			errors: REMOVE_COUPON_ERROR_MAP,
+			middlewares: [sessionMiddleware()]
+		}, async ({ context, input, errors }) => {
+			const response = await context.service.wordpress.post("/cart/remove-coupon", {
+				body: { code: input.params.code },
+				base: WC_STORE_BASE,
+				headers: context.sessionHeaders
+			});
+			if (response.error) switch (response.error.code) {
+				case "woocommerce_rest_cart_coupon_error": throw errors.CART_COUPON_INVALID({ message: response.error.message });
+				case "woocommerce_rest_cart_coupon_disabled": throw errors.CART_COUPON_DISABLED({ message: response.error.message });
+				case "woocommerce_rest_cart_coupon_invalid_code": throw errors.CART_COUPON_NOT_FOUND({ message: response.error.message });
+				default:
+					context.logger.error("Remove coupon unhandled error", response.error, { code: response.error.code });
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializeCart(response.data);
+		})
+	}
+};
+
+//#endregion
+//#region src/checkout/error.ts
+const GET_CHECKOUT_ERROR_MAP = defineErrorMap({ CHECKOUT_ORDER_NOT_FOUND: {
+	status: 404,
+	message: "No checkout order found."
+} });
+const CONFIRM_CHECKOUT_ERROR_MAP = defineErrorMap({
+	CHECKOUT_ADDRESS_COUNTRY_INVALID: {
+		status: 400,
+		message: "The address country is not supported."
+	},
+	CHECKOUT_ADDRESS_INVALID: {
+		status: 400,
+		message: "The provided address is invalid."
+	},
+	CHECKOUT_COUPON_INVALID: {
+		status: 400,
+		message: "A coupon on the cart is no longer valid."
+	},
+	CHECKOUT_EMAIL_INVALID: {
+		status: 400,
+		message: "The provided email address is invalid."
+	},
+	CHECKOUT_EMAIL_MISSING: {
+		status: 400,
+		message: "An email address is required."
+	},
+	CHECKOUT_PAYMENT_FAILED: {
+		status: 400,
+		message: "Payment could not be processed."
+	},
+	CHECKOUT_PAYMENT_METHOD_DISABLED: {
+		status: 400,
+		message: "The selected payment method is not available."
+	},
+	CHECKOUT_PAYMENT_METHOD_MISSING: {
+		status: 400,
+		message: "A payment method is required."
+	},
+	CHECKOUT_VALIDATION_FAILED: {
+		status: 400,
+		message: "Checkout validation failed."
+	},
+	CHECKOUT_GUEST_DISABLED: {
+		status: 403,
+		message: "Guest checkout is not allowed."
+	},
+	CHECKOUT_ORDER_NOT_FOUND: {
+		status: 404,
+		message: "No checkout order found."
+	},
+	CHECKOUT_CART_EMPTY: {
+		status: 409,
+		message: "The cart is empty."
+	},
+	CHECKOUT_CART_INVALID: {
+		status: 409,
+		message: "An item in the cart is no longer valid."
+	},
+	CHECKOUT_COUPONS_REMOVED: {
+		status: 409,
+		message: "One or more coupons were removed from the cart."
+	},
+	CHECKOUT_COUPON_RESERVATION_FAILED: {
+		status: 409,
+		message: "A coupon could not be reserved for this order."
+	},
+	CHECKOUT_PRODUCT_INSUFFICIENT_STOCK: {
+		status: 409,
+		message: "Not enough stock for one or more items in the cart."
+	},
+	CHECKOUT_PRODUCT_NOT_PURCHASABLE: {
+		status: 409,
+		message: "An item in the cart is no longer purchasable."
+	},
+	CHECKOUT_PRODUCT_OUT_OF_STOCK: {
+		status: 409,
+		message: "An item in the cart is out of stock."
+	}
+});
+const RETRY_CHECKOUT_ERROR_MAP = defineErrorMap({
+	CHECKOUT_EMAIL_INVALID: {
+		status: 400,
+		message: "The billing email is invalid."
+	},
+	CHECKOUT_PAYMENT_FAILED: {
+		status: 400,
+		message: "Payment could not be processed."
+	},
+	CHECKOUT_PAYMENT_METHOD_DISABLED: {
+		status: 400,
+		message: "The selected payment method is not available."
+	},
+	CHECKOUT_PAYMENT_METHOD_MISSING: {
+		status: 400,
+		message: "A payment method is required."
+	},
+	CHECKOUT_ORDER_FORBIDDEN: {
+		status: 403,
+		message: "You are not allowed to pay for this order."
+	},
+	CHECKOUT_ORDER_NOT_FOUND: {
+		status: 404,
+		message: "Order not found."
+	},
+	CHECKOUT_ORDER_STATUS_INVALID: {
+		status: 409,
+		message: "This order is not in a state that can be paid."
+	}
+});
+const UPDATE_CHECKOUT_ERROR_MAP = defineErrorMap({
+	CHECKOUT_COUPON_INVALID: {
+		status: 400,
+		message: "A coupon on the cart is no longer valid."
+	},
+	CHECKOUT_PAYMENT_METHOD_DISABLED: {
+		status: 400,
+		message: "The selected payment method is not available."
+	},
+	CHECKOUT_ORDER_NOT_FOUND: {
+		status: 404,
+		message: "No checkout order found."
+	},
+	CHECKOUT_CART_EMPTY: {
+		status: 409,
+		message: "The cart is empty."
+	},
+	CHECKOUT_CART_INVALID: {
+		status: 409,
+		message: "An item in the cart is no longer valid."
+	},
+	CHECKOUT_PRODUCT_INSUFFICIENT_STOCK: {
+		status: 409,
+		message: "Not enough stock for one or more items in the cart."
+	},
+	CHECKOUT_PRODUCT_NOT_PURCHASABLE: {
+		status: 409,
+		message: "An item in the cart is no longer purchasable."
+	},
+	CHECKOUT_PRODUCT_OUT_OF_STOCK: {
+		status: 409,
+		message: "An item in the cart is out of stock."
+	}
+});
+
+//#endregion
+//#region src/checkout/schema.ts
+const CheckoutAdditionalFields = z$2.record(z$2.string(), z$2.union([z$2.string(), z$2.boolean()]));
+const CheckoutPaymentData = z$2.array(z$2.object({
+	key: z$2.string(),
+	value: z$2.union([z$2.string(), z$2.boolean()])
+}));
+const Checkout = z$2.object({
+	cart: Cart.nullable(),
+	billingAddress: BillingAddress,
+	shippingAddress: ShippingAddress,
+	paymentMethod: z$2.string(),
+	customerNote: z$2.string(),
+	additionalFields: CheckoutAdditionalFields,
+	paymentResult: z$2.object({
+		status: z$2.enum([
+			"success",
+			"pending",
+			"failure",
+			"error"
+		]),
+		data: z$2.array(z$2.object({
+			key: z$2.string(),
+			value: z$2.string()
+		})).optional(),
+		redirectUrl: z$2.string()
+	}).nullable()
+});
+const UpdateCheckoutInput = z$2.object({
+	paymentMethod: z$2.string().optional(),
+	customerNote: z$2.string().optional(),
+	recalculateTotals: z$2.boolean().optional(),
+	additionalFields: CheckoutAdditionalFields.optional()
+});
+const ConfirmCheckoutInput = z$2.object({
+	customerPassword: z$2.string().optional(),
+	paymentData: CheckoutPaymentData.optional()
+});
+const RetryCheckoutInput = z$2.object({
+	key: z$2.string(),
+	orderId: NumberLike,
+	paymentMethod: z$2.string(),
+	billingEmail: z$2.email().optional(),
+	billingAddress: BillingAddress.optional(),
+	paymentData: CheckoutPaymentData.optional(),
+	shippingAddress: ShippingAddress.optional()
+});
+
+//#endregion
+//#region src/checkout/utils.ts
+function deserializeCheckout(data) {
+	return {
+		cart: data.__experimentalCart ? deserializeCart(data.__experimentalCart) : null,
+		shippingAddress: {
+			address1: data.shipping_address.address_1,
+			address2: data.shipping_address.address_2,
+			city: data.shipping_address.city,
+			company: data.shipping_address.company,
+			country: data.shipping_address.country,
+			firstName: data.shipping_address.first_name,
+			lastName: data.shipping_address.last_name,
+			phone: data.shipping_address.phone,
+			postcode: data.shipping_address.postcode,
+			state: data.shipping_address.state
+		},
+		billingAddress: {
+			address1: data.billing_address.address_1,
+			address2: data.billing_address.address_2,
+			city: data.billing_address.city,
+			company: data.billing_address.company,
+			country: data.billing_address.country,
+			email: data.billing_address.email,
+			firstName: data.billing_address.first_name,
+			lastName: data.billing_address.last_name,
+			phone: data.billing_address.phone,
+			postcode: data.billing_address.postcode,
+			state: data.billing_address.state
+		},
+		additionalFields: data.additional_fields,
+		customerNote: data.customer_note,
+		paymentMethod: data.payment_method,
+		paymentResult: data.payment_result?.payment_status ? {
+			status: data.payment_result.payment_status,
+			redirectUrl: data.payment_result.redirect_url,
+			data: data.payment_result.payment_details
+		} : null
+	};
+}
+
+//#endregion
+//#region src/checkout/index.ts
+const CHECKOUT_ROUTER = {
+	get: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/checkout",
+		output: Checkout,
+		errors: GET_CHECKOUT_ERROR_MAP,
+		middlewares: [sessionMiddleware()]
+	}, async ({ context, errors }) => {
+		const response = await context.service.wordpress.get("/checkout", {
+			base: WC_STORE_BASE,
+			headers: context.sessionHeaders
+		});
+		if (response.error) switch (response.error.code) {
+			case "woocommerce_rest_checkout_missing_order": throw errors.CHECKOUT_ORDER_NOT_FOUND({ message: response.error.message });
+			default:
+				context.logger.error("Get checkout unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeCheckout(response.data);
+	}),
+	update: createProcedure({
+		scope: "api",
+		method: "PUT",
+		path: "/checkout",
+		body: UpdateCheckoutInput,
+		output: Checkout,
+		errors: UPDATE_CHECKOUT_ERROR_MAP,
+		middlewares: [sessionMiddleware()]
+	}, async ({ context, input, errors }) => {
+		const response = await context.service.wordpress.put("/checkout", {
+			base: WC_STORE_BASE,
+			body: {
+				order_notes: input.body.customerNote,
+				payment_method: input.body.paymentMethod,
+				additional_fields: input.body.additionalFields,
+				__experimental_calc_totals: input.body.recalculateTotals
+			},
+			headers: context.sessionHeaders
+		});
+		if (response.error) switch (response.error.code) {
+			case "woocommerce_rest_cart_coupon_error": throw errors.CHECKOUT_COUPON_INVALID({ message: response.error.message });
+			case "woocommerce_rest_checkout_payment_method_disabled": throw errors.CHECKOUT_PAYMENT_METHOD_DISABLED({ message: response.error.message });
+			case "woocommerce_rest_checkout_missing_order": throw errors.CHECKOUT_ORDER_NOT_FOUND({ message: response.error.message });
+			case "woocommerce_rest_cart_empty": throw errors.CHECKOUT_CART_EMPTY({ message: response.error.message });
+			case "woocommerce_rest_cart_item_error": throw errors.CHECKOUT_CART_INVALID({ message: response.error.message });
+			case "woocommerce_rest_product_partially_out_of_stock": throw errors.CHECKOUT_PRODUCT_INSUFFICIENT_STOCK({ message: response.error.message });
+			case "woocommerce_rest_product_not_purchasable": throw errors.CHECKOUT_PRODUCT_NOT_PURCHASABLE({ message: response.error.message });
+			case "woocommerce_rest_product_out_of_stock": throw errors.CHECKOUT_PRODUCT_OUT_OF_STOCK({ message: response.error.message });
+			default:
+				context.logger.error("Update checkout unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeCheckout(response.data);
+	}),
+	confirm: createProcedure({
+		scope: "api",
+		method: "POST",
+		path: "/checkout",
+		body: ConfirmCheckoutInput,
+		output: Checkout,
+		errors: CONFIRM_CHECKOUT_ERROR_MAP,
+		middlewares: [sessionMiddleware()]
+	}, async ({ context, input, errors }) => {
+		const checkoutResponse = await context.service.wordpress.get("/checkout", {
+			base: WC_STORE_BASE,
+			headers: context.sessionHeaders
+		});
+		if (checkoutResponse.error) switch (checkoutResponse.error.code) {
+			case "woocommerce_rest_checkout_missing_order": throw errors.CHECKOUT_ORDER_NOT_FOUND({ message: checkoutResponse.error.message });
+			default:
+				context.logger.error("Get checkout for confirm unhandled error", checkoutResponse.error, { code: checkoutResponse.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const confirmResponse = await context.service.wordpress.post("/checkout", {
+			base: WC_STORE_BASE,
+			body: {
+				payment_data: input.body.paymentData,
+				customer_password: input.body.customerPassword,
+				customer_note: checkoutResponse.data.customer_note,
+				payment_method: checkoutResponse.data.payment_method,
+				create_account: !!input.body.customerPassword?.length,
+				billing_address: checkoutResponse.data.billing_address,
+				shipping_address: checkoutResponse.data.shipping_address,
+				additional_fields: checkoutResponse.data.additional_fields
+			},
+			headers: context.sessionHeaders
+		});
+		if (confirmResponse.error) switch (confirmResponse.error.code) {
+			case "woocommerce_rest_invalid_address": throw errors.CHECKOUT_ADDRESS_INVALID({ message: confirmResponse.error.message });
+			case "woocommerce_rest_invalid_address_country": throw errors.CHECKOUT_ADDRESS_COUNTRY_INVALID({ message: confirmResponse.error.message });
+			case "woocommerce_rest_cart_coupon_error": throw errors.CHECKOUT_COUPON_INVALID({ message: confirmResponse.error.message });
+			case "woocommerce_rest_invalid_email_address": throw errors.CHECKOUT_EMAIL_INVALID({ message: confirmResponse.error.message });
+			case "woocommerce_rest_missing_email_address": throw errors.CHECKOUT_EMAIL_MISSING({ message: confirmResponse.error.message });
+			case "woocommerce_rest_checkout_process_payment_error": throw errors.CHECKOUT_PAYMENT_FAILED({ message: confirmResponse.error.message });
+			case "woocommerce_rest_checkout_payment_method_disabled": throw errors.CHECKOUT_PAYMENT_METHOD_DISABLED({ message: confirmResponse.error.message });
+			case "woocommerce_rest_checkout_missing_payment_method": throw errors.CHECKOUT_PAYMENT_METHOD_MISSING({ message: confirmResponse.error.message });
+			case "woocommerce_rest_checkout_custom_validation_error": throw errors.CHECKOUT_VALIDATION_FAILED({ message: confirmResponse.error.message });
+			case "woocommerce_rest_guest_checkout_disabled": throw errors.CHECKOUT_GUEST_DISABLED({ message: confirmResponse.error.message });
+			case "woocommerce_rest_checkout_missing_order": throw errors.CHECKOUT_ORDER_NOT_FOUND({ message: confirmResponse.error.message });
+			case "woocommerce_rest_cart_empty": throw errors.CHECKOUT_CART_EMPTY({ message: confirmResponse.error.message });
+			case "woocommerce_rest_cart_item_error": throw errors.CHECKOUT_CART_INVALID({ message: confirmResponse.error.message });
+			case "removed_coupons": throw errors.CHECKOUT_COUPONS_REMOVED({ message: confirmResponse.error.message });
+			case "woocommerce_rest_coupon_reserve_failed": throw errors.CHECKOUT_COUPON_RESERVATION_FAILED({ message: confirmResponse.error.message });
+			case "woocommerce_rest_product_partially_out_of_stock": throw errors.CHECKOUT_PRODUCT_INSUFFICIENT_STOCK({ message: confirmResponse.error.message });
+			case "woocommerce_rest_product_not_purchasable": throw errors.CHECKOUT_PRODUCT_NOT_PURCHASABLE({ message: confirmResponse.error.message });
+			case "woocommerce_rest_product_out_of_stock": throw errors.CHECKOUT_PRODUCT_OUT_OF_STOCK({ message: confirmResponse.error.message });
+			default:
+				context.logger.error("Confirm checkout unhandled error", confirmResponse.error, { code: confirmResponse.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeCheckout(confirmResponse.data);
+	}),
+	retry: createProcedure({
+		scope: "api",
+		method: "POST",
+		path: "/checkout/{orderId}",
+		params: RetryCheckoutInput.pick({ orderId: true }),
+		body: RetryCheckoutInput.omit({ orderId: true }),
+		output: Checkout,
+		errors: RETRY_CHECKOUT_ERROR_MAP,
+		middlewares: [sessionMiddleware()]
+	}, async ({ context, input, errors }) => {
+		const response = await context.service.wordpress.post(`/checkout/${input.params.orderId}`, {
+			base: WC_STORE_BASE,
+			body: {
+				key: input.body.key,
+				id: input.params.orderId,
+				payment_data: input.body.paymentData,
+				billing_email: input.body.billingEmail,
+				payment_method: input.body.paymentMethod,
+				billing_address: input.body.billingAddress ?? {},
+				shipping_address: input.body.shippingAddress ?? {}
+			},
+			headers: context.sessionHeaders
+		});
+		if (response.error) switch (response.error.code) {
+			case "woocommerce_rest_invalid_billing_email": throw errors.CHECKOUT_EMAIL_INVALID({ message: response.error.message });
+			case "woocommerce_rest_checkout_process_payment_error": throw errors.CHECKOUT_PAYMENT_FAILED({ message: response.error.message });
+			case "woocommerce_rest_checkout_payment_method_disabled": throw errors.CHECKOUT_PAYMENT_METHOD_DISABLED({ message: response.error.message });
+			case "woocommerce_rest_checkout_missing_payment_method": throw errors.CHECKOUT_PAYMENT_METHOD_MISSING({ message: response.error.message });
+			case "woocommerce_rest_invalid_user": throw errors.CHECKOUT_ORDER_FORBIDDEN({ message: response.error.message });
+			case "woocommerce_rest_invalid_order": throw errors.CHECKOUT_ORDER_NOT_FOUND({ message: response.error.message });
+			case "invalid_order_update_status": throw errors.CHECKOUT_ORDER_STATUS_INVALID({ message: response.error.message });
+			default:
+				context.logger.error("Retry checkout unhandled error", response.error, {
+					orderId: input.params.orderId,
+					code: response.error.code
+				});
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeCheckout(response.data);
+	})
+};
+
+//#endregion
+//#region src/customer/schema.ts
+const Customer = z$2.object({
+	id: z$2.number(),
+	email: z$2.string(),
+	firstName: z$2.string(),
+	lastName: z$2.string(),
+	role: z$2.string(),
+	username: z$2.string(),
+	billing: BillingAddress,
+	shipping: ShippingAddress,
+	isPayingCustomer: z$2.boolean(),
+	avatarUrl: z$2.string().nullable(),
+	registeredAt: z$2.number(),
+	meta: Metadata
+});
+
+//#endregion
+//#region src/customer/utils.ts
+function deserializeCustomer(data) {
+	return {
+		id: data.id,
+		avatarUrl: data.avatar_url.length ? data.avatar_url : null,
+		billing: {
+			firstName: data.billing.first_name,
+			lastName: data.billing.last_name,
+			address1: data.billing.address_1,
+			city: data.billing.city,
+			country: data.billing.country,
+			email: data.billing.email,
+			phone: data.billing.phone,
+			postcode: data.billing.postcode,
+			state: data.billing.state,
+			address2: data.billing.address_2,
+			company: data.billing.company
+		},
+		shipping: {
+			firstName: data.shipping.first_name,
+			lastName: data.shipping.last_name,
+			address1: data.shipping.address_1,
+			city: data.shipping.city,
+			country: data.shipping.country,
+			phone: data.shipping.phone,
+			postcode: data.shipping.postcode,
+			state: data.shipping.state,
+			address2: data.shipping.address_2,
+			company: data.shipping.company
+		},
+		email: data.email,
+		firstName: data.first_name,
+		lastName: data.last_name,
+		isPayingCustomer: data.is_paying_customer,
+		meta: toPublicMetadata(data.meta_data),
+		registeredAt: new Date(data.date_created).getTime(),
+		role: data.role,
+		username: data.username
+	};
+}
+
+//#endregion
+//#region src/customer/index.ts
+const CUSTOMER_ROUTER = { get: createProcedure({
+	scope: "api",
+	method: "GET",
+	path: "/customers",
+	output: Customer
+}, async ({ context, errors }) => {
+	const auth = await context.getAuthUser();
+	if (!auth) throw errors.FORBIDDEN();
+	const response = await context.service.wordpress.get(`/customers/${auth.id}`, { base: WC_CORE_BASE });
+	if (response.error) throw response.error;
+	return deserializeCustomer(response.data);
+}) };
+
+//#endregion
+//#region src/product/error.ts
+const GET_PRODUCT_ERROR_MAP = defineErrorMap({ PRODUCT_NOT_FOUND: {
+	status: 404,
+	message: "Product not found."
+} });
+const LIST_PRODUCT_ERROR_MAP = defineErrorMap({});
+const FILTER_PRODUCT_ERROR_MAP = defineErrorMap({});
+
+//#endregion
+//#region src/product/utils.ts
+function deserializeProduct(data) {
+	return {
+		id: data.id,
+		type: data.type,
+		slug: data.slug,
+		name: data.name,
+		sku: data.sku,
+		description: data.description,
+		shortDescription: data.short_description,
+		prices: {
+			price: +data.kizlo.prices.price,
+			salePrice: +data.kizlo.prices.sale_price,
+			regularPrice: +data.kizlo.prices.regular_price
+		},
+		isSoldIndividually: data.sold_individually,
+		onSaleFrom: data.date_on_sale_from ? toTimestamp(data.date_on_sale_from) : null,
+		lowStockRemaining: "data.low_stock_amount",
+		onSaleTo: data.date_on_sale_to ? toTimestamp(data.date_on_sale_to) : null,
+		isInStock: data.stock_status === "instock",
+		stock: data.stock_quantity,
+		images: data.images.map((item) => ({
+			id: item.id,
+			src: item.src,
+			name: item.name,
+			alt: item.alt
+		})),
+		categories: data.categories.map((category) => ({
+			id: category.id,
+			name: category.name,
+			slug: category.slug
+		})),
+		tags: data.tags.map((tag) => ({
+			id: tag.id,
+			name: tag.name,
+			slug: tag.slug
+		})),
+		averageRating: data.average_rating,
+		reviewCount: data.rating_count,
+		attributes: data.kizlo.attributes.map((item) => ({
+			id: item.id,
+			hasVariations: item.has_variations,
+			name: item.name,
+			taxonomy: item.taxonomy,
+			terms: item.terms
+		})),
+		groupedProducts: data.grouped_products,
+		isOnBackorder: data.backordered,
+		isPurchasable: data.purchasable,
+		isOnSale: data.on_sale,
+		parentId: data.parent_id,
+		brands: data.brands,
+		variations: data.kizlo.variations,
+		hasOptions: !!data.kizlo.variations.length,
+		currencyFormat: deserializeCurrencyFormat(data.kizlo.currency_format),
+		meta: toPublicMetadata(data.meta_data),
+		seo: null
+	};
+}
+function deserializeStoreProduct(data) {
+	return {
+		id: data.id,
+		type: data.type,
+		name: data.name,
+		slug: data.slug,
+		sku: data.sku,
+		description: data.description,
+		shortDescription: data.short_description,
+		isInStock: data.is_in_stock,
+		reviewCount: data.review_count,
+		averageRating: data.average_rating,
+		lowStockRemaining: data.low_stock_remaining,
+		isSoldIndividually: data.sold_individually,
+		prices: {
+			price: +data.prices.price,
+			salePrice: +data.prices.sale_price,
+			regularPrice: +data.prices.regular_price
+		},
+		images: data.images.map((item) => ({
+			id: item.id,
+			src: item.src,
+			name: item.name,
+			alt: item.alt
+		})),
+		categories: data.categories.map((category) => ({
+			id: category.id,
+			name: category.name,
+			slug: category.slug
+		})),
+		tags: data.tags.map((tag) => ({
+			id: tag.id,
+			name: tag.name,
+			slug: tag.slug
+		})),
+		attributes: data.attributes.map((item) => ({
+			id: item.id,
+			name: item.name,
+			terms: item.terms,
+			taxonomy: item.taxonomy,
+			hasVariations: item.has_variations
+		})),
+		currencyFormat: deserializeCurrencyFormat(data.prices),
+		brands: data.brands,
+		groupedProducts: data.grouped_products,
+		hasOptions: data.has_options,
+		isOnBackorder: data.is_on_backorder,
+		isPurchasable: data.is_purchasable,
+		isOnSale: data.on_sale,
+		parentId: data.parent,
+		variations: data.variations,
+		stock: data.extensions.kizlo.stock,
+		onSaleFrom: data.extensions.kizlo.on_sale_from ? toTimestamp(data.extensions.kizlo.on_sale_from) : null,
+		onSaleTo: data.extensions.kizlo.on_sale_to ? toTimestamp(data.extensions.kizlo.on_sale_to) : null,
+		seo: null,
+		meta: {}
+	};
+}
+function deserializeProductFilters(data) {
+	if (!data.price_range) return null;
+	const maxPrice = +data.price_range.max_price;
+	const minPrice = +data.price_range.min_price;
+	return {
+		stockStatuses: data.stock_status_counts ?? [],
+		taxonomyTerms: data.kizlo.taxonomy_counts.map((item) => ({
+			id: item.id,
+			name: item.name,
+			count: item.count,
+			description: item.description,
+			parentId: item.parent,
+			slug: item.slug,
+			taxonomy: item.taxonomy,
+			image: item.thumbnail ? {
+				id: 0,
+				alt: item.name,
+				name: item.name,
+				src: item.thumbnail
+			} : null
+		})),
+		attributeTerms: data.kizlo.attribute_counts.map((item) => ({
+			id: item.id,
+			name: item.name,
+			count: item.count,
+			description: item.description,
+			parentId: item.parent,
+			slug: item.slug,
+			swatch: item.swatch,
+			type: item.swatch_type,
+			taxonomy: item.taxonomy
+		})),
+		priceRange: {
+			maxPrice,
+			minPrice
+		},
+		currencyFormat: deserializeCurrencyFormat(data.price_range)
+	};
+}
+function serializeProductListInput(data) {
+	return {
+		after: data?.after,
+		attribute_relation: data?.attributeRelation,
+		before: data?.before,
+		brand: data?.brand,
+		brand_operator: data?.brandOperator,
+		catalog_visibility: data?.catalogVisibility,
+		category: data?.category,
+		category_operator: data?.categoryOperator,
+		featured: data?.featured,
+		max_price: data?.maxPrice ? String(data?.maxPrice) : void 0,
+		min_price: data?.minPrice ? String(data?.minPrice) : void 0,
+		on_sale: data?.onSale,
+		orderby: data?.orderby,
+		parent: normalizeArrayableValue(data?.parent),
+		parent_exclude: normalizeArrayableValue(data?.parentExclude),
+		rating: normalizeArrayableValue(data?.rating)?.map(Number),
+		sku: data?.sku,
+		slug: data?.slug,
+		stock_status: normalizeArrayableValue(data?.stockStatus),
+		tag: data?.tag,
+		tag_operator: data?.tagOperator,
+		type: data?.type,
+		attributes: data?.attributes?.map((item) => ({
+			operator: item.operator,
+			attribute: item.attribute,
+			slug: normalizeArrayableValue(item.slug),
+			term_id: normalizeArrayableValue(item.termId)
+		})),
+		exclude: normalizeArrayableValue(data?.exclude),
+		include: normalizeArrayableValue(data?.include),
+		offset: data?.offset,
+		order: data?.order,
+		page: data?.page,
+		per_page: data?.perPage,
+		related: data?.related,
+		search: data?.search
+	};
+}
+function toTimestamp(date) {
+	return new Date(date).getTime();
+}
+
+//#endregion
+//#region src/product/index.ts
+const PRODUCT_ROUTER = {
+	get: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/products/{identifier}",
+		params: RetrieveProductInput.pick({ identifier: true }),
+		query: RetrieveProductInput.pick({ previewToken: true }).optional(),
+		output: Product,
+		errors: GET_PRODUCT_ERROR_MAP
+	}, async ({ context, input, errors }) => {
+		if (input.query?.previewToken) {
+			const result = await context.verifyPreviewToken(input.query.previewToken);
+			if (!result) throw errors.PRODUCT_NOT_FOUND();
+			const response$1 = await context.service.wordpress.get(`/products/${result.id}`, { base: WC_CORE_BASE });
+			if (response$1.error) switch (response$1.error.code) {
+				case "woocommerce_rest_product_invalid_id": throw errors.PRODUCT_NOT_FOUND({ message: response$1.error.message });
+				default:
+					context.logger.error("Get product preview unhandled error", response$1.error, {
+						id: result.id,
+						code: response$1.error.code
+					});
+					throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return deserializeProduct(response$1.data);
+		}
+		const response = await context.service.wordpress.get("/products", {
+			searchParams: { slug: input.params.identifier },
+			base: WC_CORE_BASE
+		});
+		if (response.error) switch (response.error.code) {
+			default:
+				context.logger.error("Get product unhandled error", response.error, {
+					identifier: input.params.identifier,
+					code: response.error.code
+				});
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const data = response.data[0];
+		if (!data) throw errors.PRODUCT_NOT_FOUND();
+		return deserializeProduct(data);
+	}),
+	list: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/products",
+		query: ListProductInput.optional(),
+		output: ProductList,
+		errors: LIST_PRODUCT_ERROR_MAP
+	}, async ({ context, input, errors }) => {
+		const searchParams = serializeProductListInput(input.query);
+		const response = await context.service.wordpress.get("/products", {
+			base: WC_STORE_BASE,
+			searchParams: { ...searchParams }
+		});
+		if (response.error) switch (response.error.code) {
+			default:
+				context.logger.error("List products unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const list = context.service.wordpress.resolveList({
+			data: response.data,
+			headers: response.headers,
+			searchParams: { ...searchParams }
+		});
+		return {
+			items: list.items.map(deserializeStoreProduct),
+			meta: deserializeListMetadata(list.meta)
+		};
+	}),
+	filters: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/products/filters",
+		query: RetrieveProductFiltersInput.optional(),
+		output: ProductFilters.nullable()
+	}, async ({ context, errors, input }) => {
+		const searchParams = serializeProductListInput(input.query);
+		const response = await context.service.wordpress.get("/products/collection-data", {
+			base: WC_STORE_BASE,
+			searchParams: {
+				...searchParams,
+				calculate_price_range: true,
+				calculate_rating_counts: input.query?.ratingFilters,
+				calculate_taxonomy_counts: input.query?.taxonomyFilters,
+				calculate_stock_status_counts: input.query?.stockStatusFilters,
+				calculate_attribute_counts: input.query?.attributeFilters?.map((item) => ({
+					taxonomy: item.taxonomy,
+					query_type: item.queryType
+				}))
+			}
+		});
+		if (response.error) switch (response.error.code) {
+			default:
+				context.logger.error("Filter products unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeProductFilters(response.data);
+	})
+};
+
+//#endregion
+//#region src/index.ts
+function woocommerce() {
+	return createExtension({
+		id: "woocommerce",
+		init: () => {
+			return { router: {
+				cart: CART_ROUTER,
+				products: PRODUCT_ROUTER,
+				checkout: CHECKOUT_ROUTER,
+				customers: CUSTOMER_ROUTER
+			} };
+		}
+	});
+}
+
+//#endregion
+export { woocommerce };