@tonytang99/integration-canonical 1.0.0 → 1.2.0

package/dist/types/common.d.ts

@@ -0,0 +1,284 @@
+import { z } from 'zod';
+/**
+ * Currency codes following ISO 4217
+ * Common currencies for e-commerce
+ */
+export declare const CurrencyCode: z.ZodEnum<["USD", "EUR", "GBP", "AUD", "CAD", "NZD", "JPY", "CNY", "INR", "SGD", "HKD", "MXN", "BRL", "ZAR"]>;
+export type CurrencyCode = z.infer<typeof CurrencyCode>;
+/**
+ * Money representation using minor units (cents)
+ *
+ * Examples:
+ * - $19.99 USD = { amount: 1999, currency: 'USD' }
+ * - €50.00 EUR = { amount: 5000, currency: 'EUR' }
+ * - ¥1000 JPY = { amount: 1000, currency: 'JPY' } (JPY has no minor units)
+ *
+ * @property amount - Amount in minor units (cents). Always an integer.
+ * @property currency - ISO 4217 currency code
+ */
+export declare const MoneySchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    currency: z.ZodEnum<["USD", "EUR", "GBP", "AUD", "CAD", "NZD", "JPY", "CNY", "INR", "SGD", "HKD", "MXN", "BRL", "ZAR"]>;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    currency: "USD" | "EUR" | "GBP" | "AUD" | "CAD" | "NZD" | "JPY" | "CNY" | "INR" | "SGD" | "HKD" | "MXN" | "BRL" | "ZAR";
+}, {
+    amount: number;
+    currency: "USD" | "EUR" | "GBP" | "AUD" | "CAD" | "NZD" | "JPY" | "CNY" | "INR" | "SGD" | "HKD" | "MXN" | "BRL" | "ZAR";
+}>;
+export type Money = z.infer<typeof MoneySchema>;
+/**
+ * Helper functions for Money
+ */
+export declare const MoneyHelper: {
+    /**
+     * Create Money from major units (dollars)
+     * @example MoneyHelper.fromMajor(19.99, 'USD') // { amount: 1999, currency: 'USD' }
+     */
+    fromMajor(majorAmount: number, currency: CurrencyCode): Money;
+    /**
+     * Convert Money to major units (dollars)
+     * @example MoneyHelper.toMajor({ amount: 1999, currency: 'USD' }) // 19.99
+     */
+    toMajor(money: Money): number;
+    /**
+     * Get number of minor units (decimal places) for a currency
+     */
+    getMinorUnits(currency: CurrencyCode): number;
+    /**
+     * Format Money for display
+     * @example MoneyHelper.format({ amount: 1999, currency: 'USD' }) // "$19.99"
+     */
+    format(money: Money, locale?: string): string;
+    /**
+     * Add two Money values (must be same currency)
+     */
+    add(a: Money, b: Money): Money;
+    /**
+     * Subtract two Money values (must be same currency)
+     */
+    subtract(a: Money, b: Money): Money;
+    /**
+     * Multiply Money by a scalar
+     */
+    multiply(money: Money, multiplier: number): Money;
+    /**
+     * Check if money is zero
+     */
+    isZero(money: Money): boolean;
+    /**
+     * Check if money is positive
+     */
+    isPositive(money: Money): boolean;
+    /**
+     * Check if money is negative
+     */
+    isNegative(money: Money): boolean;
+    /**
+     * Get absolute value
+     */
+    abs(money: Money): Money;
+    /**
+     * Create zero money
+     */
+    zero(currency: CurrencyCode): Money;
+};
+/**
+ * Country codes following ISO 3166-1 alpha-2
+ */
+export declare const CountryCode: z.ZodEnum<["US", "CA", "GB", "AU", "NZ", "DE", "FR", "IT", "ES", "NL", "BE", "CH", "AT", "SE", "NO", "DK", "FI", "IE", "PT", "PL", "CZ", "JP", "CN", "IN", "SG", "HK", "MX", "BR", "ZA"]>;
+export type CountryCode = z.infer<typeof CountryCode>;
+/**
+ * Address type classification
+ */
+export declare const AddressType: z.ZodEnum<["billing", "shipping", "both"]>;
+export type AddressType = z.infer<typeof AddressType>;
+/**
+ * Base address schema with all common fields
+ * Designed to accommodate addresses from BigCommerce, MYOB, Adobe Commerce, etc.
+ */
+export declare const AddressSchema: z.ZodObject<{
+    street1: z.ZodString;
+    street2: z.ZodOptional<z.ZodString>;
+    street3: z.ZodOptional<z.ZodString>;
+    city: z.ZodString;
+    state: z.ZodOptional<z.ZodString>;
+    stateCode: z.ZodOptional<z.ZodString>;
+    postalCode: z.ZodString;
+    country: z.ZodString;
+    countryCode: z.ZodOptional<z.ZodEnum<["US", "CA", "GB", "AU", "NZ", "DE", "FR", "IT", "ES", "NL", "BE", "CH", "AT", "SE", "NO", "DK", "FI", "IE", "PT", "PL", "CZ", "JP", "CN", "IN", "SG", "HK", "MX", "BR", "ZA"]>>;
+    company: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["billing", "shipping", "both"]>>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    isResidential: z.ZodOptional<z.ZodBoolean>;
+    isValidated: z.ZodOptional<z.ZodBoolean>;
+    validationSource: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    street1: string;
+    city: string;
+    postalCode: string;
+    country: string;
+    type?: "billing" | "shipping" | "both" | undefined;
+    street2?: string | undefined;
+    street3?: string | undefined;
+    state?: string | undefined;
+    stateCode?: string | undefined;
+    countryCode?: "US" | "CA" | "GB" | "AU" | "NZ" | "DE" | "FR" | "IT" | "ES" | "NL" | "BE" | "CH" | "AT" | "SE" | "NO" | "DK" | "FI" | "IE" | "PT" | "PL" | "CZ" | "JP" | "CN" | "IN" | "SG" | "HK" | "MX" | "BR" | "ZA" | undefined;
+    company?: string | undefined;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    phone?: string | undefined;
+    email?: string | undefined;
+    isDefault?: boolean | undefined;
+    isResidential?: boolean | undefined;
+    isValidated?: boolean | undefined;
+    validationSource?: string | undefined;
+}, {
+    street1: string;
+    city: string;
+    postalCode: string;
+    country: string;
+    type?: "billing" | "shipping" | "both" | undefined;
+    street2?: string | undefined;
+    street3?: string | undefined;
+    state?: string | undefined;
+    stateCode?: string | undefined;
+    countryCode?: "US" | "CA" | "GB" | "AU" | "NZ" | "DE" | "FR" | "IT" | "ES" | "NL" | "BE" | "CH" | "AT" | "SE" | "NO" | "DK" | "FI" | "IE" | "PT" | "PL" | "CZ" | "JP" | "CN" | "IN" | "SG" | "HK" | "MX" | "BR" | "ZA" | undefined;
+    company?: string | undefined;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    phone?: string | undefined;
+    email?: string | undefined;
+    isDefault?: boolean | undefined;
+    isResidential?: boolean | undefined;
+    isValidated?: boolean | undefined;
+    validationSource?: string | undefined;
+}>;
+export type Address = z.infer<typeof AddressSchema>;
+/**
+ * Minimal address schema for cases where full address isn't required
+ */
+export declare const MinimalAddressSchema: z.ZodObject<{
+    street1: z.ZodString;
+    city: z.ZodString;
+    postalCode: z.ZodString;
+    country: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    street1: string;
+    city: string;
+    postalCode: string;
+    country: string;
+}, {
+    street1: string;
+    city: string;
+    postalCode: string;
+    country: string;
+}>;
+export type MinimalAddress = z.infer<typeof MinimalAddressSchema>;
+/**
+ * Helper functions for Address
+ */
+export declare const AddressHelper: {
+    /**
+     * Format address as a multi-line string
+     */
+    format(address: Address): string;
+    /**
+     * Format address as a single line
+     */
+    formatSingleLine(address: Address): string;
+    /**
+     * Check if two addresses are similar (fuzzy match)
+     */
+    areSimilar(a: Address, b: Address): boolean;
+    /**
+     * Create a minimal address from full address
+     */
+    toMinimal(address: Address): MinimalAddress;
+    /**
+     * Validate postal code format for specific countries
+     */
+    isValidPostalCode(postalCode: string, countryCode: CountryCode): boolean;
+    /**
+     * Get full name from address
+     */
+    getFullName(address: Address): string | null;
+    /**
+     * Check if address is complete (has all required fields)
+     */
+    isComplete(address: Partial<Address>): boolean;
+    /**
+     * Create a copy of address with specific type
+     */
+    withType(address: Address, type: AddressType): Address;
+};
+/**
+ * Phone number schema with international support
+ */
+export declare const PhoneNumberSchema: z.ZodObject<{
+    number: z.ZodString;
+    countryCode: z.ZodOptional<z.ZodString>;
+    extension: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["mobile", "home", "work", "fax", "other"]>>;
+}, "strip", z.ZodTypeAny, {
+    number: string;
+    type?: "mobile" | "home" | "work" | "fax" | "other" | undefined;
+    countryCode?: string | undefined;
+    extension?: string | undefined;
+}, {
+    number: string;
+    type?: "mobile" | "home" | "work" | "fax" | "other" | undefined;
+    countryCode?: string | undefined;
+    extension?: string | undefined;
+}>;
+export type PhoneNumber = z.infer<typeof PhoneNumberSchema>;
+/**
+ * Helper functions for PhoneNumber
+ */
+export declare const PhoneNumberHelper: {
+    /**
+     * Format phone number for display
+     */
+    format(phone: PhoneNumber): string;
+    /**
+     * Parse phone number string into components
+     */
+    parse(phoneString: string): PhoneNumber;
+};
+export declare const WeightUnit: z.ZodEnum<["g", "kg", "oz", "lb"]>;
+export type WeightUnit = z.infer<typeof WeightUnit>;
+export declare const WeightSchema: z.ZodObject<{
+    value: z.ZodNumber;
+    unit: z.ZodEnum<["g", "kg", "oz", "lb"]>;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    unit: "g" | "kg" | "oz" | "lb";
+}, {
+    value: number;
+    unit: "g" | "kg" | "oz" | "lb";
+}>;
+export type Weight = z.infer<typeof WeightSchema>;
+export declare const DimensionUnit: z.ZodEnum<["cm", "m", "mm", "in", "ft"]>;
+export type DimensionUnit = z.infer<typeof DimensionUnit>;
+export declare const DimensionsSchema: z.ZodObject<{
+    length: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    unit: z.ZodEnum<["cm", "m", "mm", "in", "ft"]>;
+}, "strip", z.ZodTypeAny, {
+    length: number;
+    unit: "cm" | "m" | "mm" | "in" | "ft";
+    width: number;
+    height: number;
+}, {
+    length: number;
+    unit: "cm" | "m" | "mm" | "in" | "ft";
+    width: number;
+    height: number;
+}>;
+export type Dimensions = z.infer<typeof DimensionsSchema>;
+//# sourceMappingURL=common.d.ts.map

package/dist/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"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"}

package/dist/types/common.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DimensionsSchema = exports.DimensionUnit = exports.WeightSchema = exports.WeightUnit = exports.PhoneNumberHelper = exports.PhoneNumberSchema = exports.AddressHelper = exports.MinimalAddressSchema = exports.AddressSchema = exports.AddressType = exports.CountryCode = exports.MoneyHelper = exports.MoneySchema = exports.CurrencyCode = void 0;
+// packages/canonical/src/types/common.ts
+const zod_1 = require("zod");
+// ============================================================================
+// MONEY SCHEMA
+// ============================================================================
+/**
+ * Currency codes following ISO 4217
+ * Common currencies for e-commerce
+ */
+exports.CurrencyCode = zod_1.z.enum([
+    'USD', // US Dollar
+    'EUR', // Euro
+    'GBP', // British Pound
+    'AUD', // Australian Dollar
+    'CAD', // Canadian Dollar
+    'NZD', // New Zealand Dollar
+    'JPY', // Japanese Yen
+    'CNY', // Chinese Yuan
+    'INR', // Indian Rupee
+    'SGD', // Singapore Dollar
+    'HKD', // Hong Kong Dollar
+    'MXN', // Mexican Peso
+    'BRL', // Brazilian Real
+    'ZAR', // South African Rand
+]);
+/**
+ * Money representation using minor units (cents)
+ *
+ * Examples:
+ * - $19.99 USD = { amount: 1999, currency: 'USD' }
+ * - €50.00 EUR = { amount: 5000, currency: 'EUR' }
+ * - ¥1000 JPY = { amount: 1000, currency: 'JPY' } (JPY has no minor units)
+ *
+ * @property amount - Amount in minor units (cents). Always an integer.
+ * @property currency - ISO 4217 currency code
+ */
+exports.MoneySchema = zod_1.z.object({
+    amount: zod_1.z.number().int('Amount must be in minor units (cents)'),
+    currency: exports.CurrencyCode,
+});
+/**
+ * Helper functions for Money
+ */
+exports.MoneyHelper = {
+    /**
+     * Create Money from major units (dollars)
+     * @example MoneyHelper.fromMajor(19.99, 'USD') // { amount: 1999, currency: 'USD' }
+     */
+    fromMajor(majorAmount, currency) {
+        const minorUnits = this.getMinorUnits(currency);
+        return {
+            amount: Math.round(majorAmount * Math.pow(10, minorUnits)),
+            currency,
+        };
+    },
+    /**
+     * Convert Money to major units (dollars)
+     * @example MoneyHelper.toMajor({ amount: 1999, currency: 'USD' }) // 19.99
+     */
+    toMajor(money) {
+        const minorUnits = this.getMinorUnits(money.currency);
+        return money.amount / Math.pow(10, minorUnits);
+    },
+    /**
+     * Get number of minor units (decimal places) for a currency
+     */
+    getMinorUnits(currency) {
+        // Most currencies have 2 decimal places
+        const noDecimalCurrencies = ['JPY', 'KRW']; // Japanese Yen, Korean Won
+        return noDecimalCurrencies.includes(currency) ? 0 : 2;
+    },
+    /**
+     * Format Money for display
+     * @example MoneyHelper.format({ amount: 1999, currency: 'USD' }) // "$19.99"
+     */
+    format(money, locale = 'en-US') {
+        const major = this.toMajor(money);
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: money.currency,
+        }).format(major);
+    },
+    /**
+     * Add two Money values (must be same currency)
+     */
+    add(a, b) {
+        if (a.currency !== b.currency) {
+            throw new Error(`Cannot add different currencies: ${a.currency} and ${b.currency}`);
+        }
+        return {
+            amount: a.amount + b.amount,
+            currency: a.currency,
+        };
+    },
+    /**
+     * Subtract two Money values (must be same currency)
+     */
+    subtract(a, b) {
+        if (a.currency !== b.currency) {
+            throw new Error(`Cannot subtract different currencies: ${a.currency} and ${b.currency}`);
+        }
+        return {
+            amount: a.amount - b.amount,
+            currency: a.currency,
+        };
+    },
+    /**
+     * Multiply Money by a scalar
+     */
+    multiply(money, multiplier) {
+        return {
+            amount: Math.round(money.amount * multiplier),
+            currency: money.currency,
+        };
+    },
+    /**
+     * Check if money is zero
+     */
+    isZero(money) {
+        return money.amount === 0;
+    },
+    /**
+     * Check if money is positive
+     */
+    isPositive(money) {
+        return money.amount > 0;
+    },
+    /**
+     * Check if money is negative
+     */
+    isNegative(money) {
+        return money.amount < 0;
+    },
+    /**
+     * Get absolute value
+     */
+    abs(money) {
+        return {
+            amount: Math.abs(money.amount),
+            currency: money.currency,
+        };
+    },
+    /**
+     * Create zero money
+     */
+    zero(currency) {
+        return {
+            amount: 0,
+            currency,
+        };
+    },
+};
+// ============================================================================
+// ADDRESS SCHEMA
+// ============================================================================
+/**
+ * Country codes following ISO 3166-1 alpha-2
+ */
+exports.CountryCode = zod_1.z.enum([
+    'US', // United States
+    'CA', // Canada
+    'GB', // United Kingdom
+    'AU', // Australia
+    'NZ', // New Zealand
+    'DE', // Germany
+    'FR', // France
+    'IT', // Italy
+    'ES', // Spain
+    'NL', // Netherlands
+    'BE', // Belgium
+    'CH', // Switzerland
+    'AT', // Austria
+    'SE', // Sweden
+    'NO', // Norway
+    'DK', // Denmark
+    'FI', // Finland
+    'IE', // Ireland
+    'PT', // Portugal
+    'PL', // Poland
+    'CZ', // Czech Republic
+    'JP', // Japan
+    'CN', // China
+    'IN', // India
+    'SG', // Singapore
+    'HK', // Hong Kong
+    'MX', // Mexico
+    'BR', // Brazil
+    'ZA', // South Africa
+]);
+/**
+ * Address type classification
+ */
+exports.AddressType = zod_1.z.enum([
+    'billing',
+    'shipping',
+    'both',
+]);
+/**
+ * Base address schema with all common fields
+ * Designed to accommodate addresses from BigCommerce, MYOB, Adobe Commerce, etc.
+ */
+exports.AddressSchema = zod_1.z.object({
+    // Primary address lines
+    street1: zod_1.z.string().min(1, 'Street address is required'),
+    street2: zod_1.z.string().optional(),
+    street3: zod_1.z.string().optional(), // Some systems support 3 lines
+    // Location details
+    city: zod_1.z.string().min(1, 'City is required'),
+    state: zod_1.z.string().optional(), // State/Province/Region
+    stateCode: zod_1.z.string().optional(), // State code (e.g., 'CA', 'NSW')
+    postalCode: zod_1.z.string().min(1, 'Postal code is required'),
+    country: zod_1.z.string().min(1, 'Country is required'),
+    countryCode: exports.CountryCode.optional(),
+    // Contact information (optional at address level)
+    company: zod_1.z.string().optional(),
+    firstName: zod_1.z.string().optional(),
+    lastName: zod_1.z.string().optional(),
+    phone: zod_1.z.string().optional(),
+    email: zod_1.z.string().email().optional(),
+    // Address metadata
+    type: exports.AddressType.optional(),
+    isDefault: zod_1.z.boolean().optional(),
+    isResidential: zod_1.z.boolean().optional(),
+    // Validation/verification flags
+    isValidated: zod_1.z.boolean().optional(),
+    validationSource: zod_1.z.string().optional(),
+});
+/**
+ * Minimal address schema for cases where full address isn't required
+ */
+exports.MinimalAddressSchema = zod_1.z.object({
+    street1: zod_1.z.string(),
+    city: zod_1.z.string(),
+    postalCode: zod_1.z.string(),
+    country: zod_1.z.string(),
+});
+/**
+ * Helper functions for Address
+ */
+exports.AddressHelper = {
+    /**
+     * Format address as a multi-line string
+     */
+    format(address) {
+        const lines = [];
+        // Name/Company line
+        if (address.company) {
+            lines.push(address.company);
+        }
+        if (address.firstName || address.lastName) {
+            lines.push([address.firstName, address.lastName].filter(Boolean).join(' '));
+        }
+        // Street lines
+        lines.push(address.street1);
+        if (address.street2)
+            lines.push(address.street2);
+        if (address.street3)
+            lines.push(address.street3);
+        // City, State, Postal Code
+        const cityLine = [
+            address.city,
+            address.stateCode || address.state,
+            address.postalCode,
+        ].filter(Boolean).join(', ');
+        lines.push(cityLine);
+        // Country
+        lines.push(address.country);
+        return lines.join('\n');
+    },
+    /**
+     * Format address as a single line
+     */
+    formatSingleLine(address) {
+        return this.format(address).replace(/\n/g, ', ');
+    },
+    /**
+     * Check if two addresses are similar (fuzzy match)
+     */
+    areSimilar(a, b) {
+        const normalize = (str) => str.toLowerCase().replace(/[^a-z0-9]/g, '');
+        return (normalize(a.street1) === normalize(b.street1) &&
+            normalize(a.city) === normalize(b.city) &&
+            normalize(a.postalCode) === normalize(b.postalCode) &&
+            normalize(a.country) === normalize(b.country));
+    },
+    /**
+     * Create a minimal address from full address
+     */
+    toMinimal(address) {
+        return {
+            street1: address.street1,
+            city: address.city,
+            postalCode: address.postalCode,
+            country: address.country,
+        };
+    },
+    /**
+     * Validate postal code format for specific countries
+     */
+    isValidPostalCode(postalCode, countryCode) {
+        const patterns = {
+            US: /^\d{5}(-\d{4})?$/, // 12345 or 12345-6789
+            CA: /^[A-Z]\d[A-Z] \d[A-Z]\d$/i, // A1A 1A1
+            GB: /^[A-Z]{1,2}\d{1,2}[A-Z]? \d[A-Z]{2}$/i, // SW1A 1AA
+            AU: /^\d{4}$/, // 2000
+            DE: /^\d{5}$/, // 12345
+            FR: /^\d{5}$/, // 75001
+            JP: /^\d{3}-\d{4}$/, // 123-4567
+        };
+        const pattern = patterns[countryCode];
+        return pattern ? pattern.test(postalCode) : true; // Default to valid if no pattern
+    },
+    /**
+     * Get full name from address
+     */
+    getFullName(address) {
+        if (!address.firstName && !address.lastName) {
+            return null;
+        }
+        return [address.firstName, address.lastName].filter(Boolean).join(' ');
+    },
+    /**
+     * Check if address is complete (has all required fields)
+     */
+    isComplete(address) {
+        return !!(address.street1 &&
+            address.city &&
+            address.postalCode &&
+            address.country);
+    },
+    /**
+     * Create a copy of address with specific type
+     */
+    withType(address, type) {
+        return {
+            ...address,
+            type,
+        };
+    },
+};
+// ============================================================================
+// PHONE NUMBER SCHEMA
+// ============================================================================
+/**
+ * Phone number schema with international support
+ */
+exports.PhoneNumberSchema = zod_1.z.object({
+    number: zod_1.z.string().min(1, 'Phone number is required'),
+    countryCode: zod_1.z.string().optional(), // e.g., '+1', '+44'
+    extension: zod_1.z.string().optional(),
+    type: zod_1.z.enum(['mobile', 'home', 'work', 'fax', 'other']).optional(),
+});
+/**
+ * Helper functions for PhoneNumber
+ */
+exports.PhoneNumberHelper = {
+    /**
+     * Format phone number for display
+     */
+    format(phone) {
+        let formatted = phone.countryCode ? `${phone.countryCode} ${phone.number}` : phone.number;
+        if (phone.extension) {
+            formatted += ` ext. ${phone.extension}`;
+        }
+        return formatted;
+    },
+    /**
+     * Parse phone number string into components
+     */
+    parse(phoneString) {
+        // Simple parsing - in production, use libphonenumber-js
+        const match = phoneString.match(/^(\+\d+)?\s*([\d\s\-\(\)]+?)(?:\s*(?:ext|x)\s*(\d+))?$/i);
+        if (!match) {
+            return { number: phoneString };
+        }
+        return {
+            countryCode: match[1] || undefined,
+            number: match[2].replace(/[\s\-\(\)]/g, ''),
+            extension: match[3] || undefined,
+        };
+    },
+};
+// ============================================================================
+// WEIGHT & DIMENSIONS
+// ============================================================================
+exports.WeightUnit = zod_1.z.enum(['g', 'kg', 'oz', 'lb']);
+exports.WeightSchema = zod_1.z.object({
+    value: zod_1.z.number().min(0),
+    unit: exports.WeightUnit,
+});
+exports.DimensionUnit = zod_1.z.enum(['cm', 'm', 'mm', 'in', 'ft']);
+exports.DimensionsSchema = zod_1.z.object({
+    length: zod_1.z.number().min(0),
+    width: zod_1.z.number().min(0),
+    height: zod_1.z.number().min(0),
+    unit: exports.DimensionUnit,
+});
+//# sourceMappingURL=common.js.map