@cimplify/sdk 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -536,6 +536,156 @@ interface ProductTimeProfile {
     metadata?: Record<string, unknown>;
 }
 
+/**
+ * A Result type that makes errors explicit in the type system.
+ * Inspired by Rust's Result and fp-ts Either.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.cart.addItemSafe({ item_id: "prod_123" });
+ *
+ * if (result.ok) {
+ *   console.log(result.value); // Cart
+ * } else {
+ *   console.log(result.error); // CimplifyError
+ * }
+ * ```
+ */
+type Result<T, E = Error> = Ok<T> | Err<E>;
+interface Ok<T> {
+    readonly ok: true;
+    readonly value: T;
+}
+interface Err<E> {
+    readonly ok: false;
+    readonly error: E;
+}
+/** Create a successful Result */
+declare function ok<T>(value: T): Ok<T>;
+/** Create a failed Result */
+declare function err<E>(error: E): Err<E>;
+/** Check if Result is Ok */
+declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
+/** Check if Result is Err */
+declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+/**
+ * Transform the success value of a Result.
+ *
+ * @example
+ * ```typescript
+ * const result = ok(5);
+ * const doubled = mapResult(result, (n) => n * 2);
+ * // doubled = { ok: true, value: 10 }
+ * ```
+ */
+declare function mapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/**
+ * Transform the error value of a Result.
+ *
+ * @example
+ * ```typescript
+ * const result = err(new Error("oops"));
+ * const mapped = mapError(result, (e) => new CustomError(e.message));
+ * ```
+ */
+declare function mapError<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+/**
+ * Chain Results together. If the first Result is Ok, apply the function.
+ * If it's Err, propagate the error.
+ *
+ * @example
+ * ```typescript
+ * const getUser = (id: string): Result<User, Error> => { ... }
+ * const getOrders = (user: User): Result<Order[], Error> => { ... }
+ *
+ * const result = flatMap(getUser("123"), (user) => getOrders(user));
+ * ```
+ */
+declare function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+/**
+ * Get the value or a default if the Result is Err.
+ *
+ * @example
+ * ```typescript
+ * const result = err(new Error("failed"));
+ * const value = getOrElse(result, () => defaultCart);
+ * ```
+ */
+declare function getOrElse<T, E>(result: Result<T, E>, defaultFn: () => T): T;
+/**
+ * Get the value or throw the error.
+ * Use sparingly - defeats the purpose of Result!
+ *
+ * @example
+ * ```typescript
+ * const cart = unwrap(result); // throws if Err
+ * ```
+ */
+declare function unwrap<T, E>(result: Result<T, E>): T;
+/**
+ * Get the value or undefined if Err.
+ *
+ * @example
+ * ```typescript
+ * const cart = toNullable(result); // Cart | undefined
+ * ```
+ */
+declare function toNullable<T, E>(result: Result<T, E>): T | undefined;
+/**
+ * Convert a Promise that might throw into a Result.
+ *
+ * @example
+ * ```typescript
+ * const result = await fromPromise(
+ *   fetch("/api/data"),
+ *   (error) => new NetworkError(error.message)
+ * );
+ * ```
+ */
+declare function fromPromise<T, E>(promise: Promise<T>, mapError: (error: unknown) => E): Promise<Result<T, E>>;
+/**
+ * Convert a function that might throw into one that returns Result.
+ *
+ * @example
+ * ```typescript
+ * const safeParse = tryCatch(
+ *   () => JSON.parse(input),
+ *   (e) => new ParseError(e.message)
+ * );
+ * ```
+ */
+declare function tryCatch<T, E>(fn: () => T, mapError: (error: unknown) => E): Result<T, E>;
+/**
+ * Combine multiple Results. Returns Ok with array of values if all succeed,
+ * or the first Err encountered.
+ *
+ * @example
+ * ```typescript
+ * const results = await Promise.all([
+ *   client.cart.getSafe(),
+ *   client.business.getSafe(),
+ * ]);
+ * const combined = combine(results);
+ * // Result<[Cart, Business], CimplifyError>
+ * ```
+ */
+declare function combine<T, E>(results: Result<T, E>[]): Result<T[], E>;
+/**
+ * Like combine, but for an object of Results.
+ *
+ * @example
+ * ```typescript
+ * const data = combineObject({
+ *   cart: await client.cart.getSafe(),
+ *   business: await client.business.getSafe(),
+ * });
+ * // Result<{ cart: Cart, business: Business }, CimplifyError>
+ * ```
+ */
+declare function combineObject<T extends Record<string, Result<unknown, unknown>>>(results: T): Result<{
+    [K in keyof T]: T[K] extends Result<infer V, unknown> ? V : never;
+}, T[keyof T] extends Result<unknown, infer E> ? E : never>;
+
 interface GetProductsOptions {
     category?: string;
     collection?: string;
@@ -554,51 +704,67 @@ interface SearchOptions {
     limit?: number;
     category?: string;
 }
+/**
+ * Catalogue queries with explicit error handling via Result type.
+ *
+ * All methods return `Result<T, CimplifyError>` - no exceptions thrown.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.catalogue.getProducts({ category: "burgers" });
+ *
+ * if (result.ok) {
+ *   console.log("Products:", result.value);
+ * } else {
+ *   console.error("Failed:", result.error.code);
+ * }
+ * ```
+ */
 declare class CatalogueQueries {
     private client;
     constructor(client: CimplifyClient);
-    getProducts(options?: GetProductsOptions): Promise<Product[]>;
-    getProduct(id: string): Promise<ProductWithDetails>;
-    getProductBySlug(slug: string): Promise<ProductWithDetails>;
-    getVariants(productId: string): Promise<ProductVariant[]>;
-    getVariantAxes(productId: string): Promise<VariantAxis[]>;
+    getProducts(options?: GetProductsOptions): Promise<Result<Product[], CimplifyError>>;
+    getProduct(id: string): Promise<Result<ProductWithDetails, CimplifyError>>;
+    getProductBySlug(slug: string): Promise<Result<ProductWithDetails, CimplifyError>>;
+    getVariants(productId: string): Promise<Result<ProductVariant[], CimplifyError>>;
+    getVariantAxes(productId: string): Promise<Result<VariantAxis[], CimplifyError>>;
     /**
      * Find a variant by axis selections (e.g., { "Size": "Large", "Color": "Red" })
      * Returns the matching variant or null if no match found.
      */
-    getVariantByAxisSelections(productId: string, selections: VariantAxisSelection): Promise<ProductVariant | null>;
+    getVariantByAxisSelections(productId: string, selections: VariantAxisSelection): Promise<Result<ProductVariant | null, CimplifyError>>;
     /**
      * Get a specific variant by its ID
      */
-    getVariantById(productId: string, variantId: string): Promise<ProductVariant>;
-    getAddOns(productId: string): Promise<AddOn[]>;
-    getCategories(): Promise<Category[]>;
-    getCategory(id: string): Promise<Category>;
-    getCategoryBySlug(slug: string): Promise<Category>;
-    getCategoryProducts(categoryId: string): Promise<Product[]>;
-    getCollections(): Promise<Collection[]>;
-    getCollection(id: string): Promise<Collection>;
-    getCollectionBySlug(slug: string): Promise<Collection>;
-    getCollectionProducts(collectionId: string): Promise<Product[]>;
-    searchCollections(query: string, limit?: number): Promise<Collection[]>;
-    getBundles(): Promise<Bundle[]>;
-    getBundle(id: string): Promise<BundleWithDetails>;
-    getBundleBySlug(slug: string): Promise<BundleWithDetails>;
-    searchBundles(query: string, limit?: number): Promise<Bundle[]>;
+    getVariantById(productId: string, variantId: string): Promise<Result<ProductVariant, CimplifyError>>;
+    getAddOns(productId: string): Promise<Result<AddOn[], CimplifyError>>;
+    getCategories(): Promise<Result<Category[], CimplifyError>>;
+    getCategory(id: string): Promise<Result<Category, CimplifyError>>;
+    getCategoryBySlug(slug: string): Promise<Result<Category, CimplifyError>>;
+    getCategoryProducts(categoryId: string): Promise<Result<Product[], CimplifyError>>;
+    getCollections(): Promise<Result<Collection[], CimplifyError>>;
+    getCollection(id: string): Promise<Result<Collection, CimplifyError>>;
+    getCollectionBySlug(slug: string): Promise<Result<Collection, CimplifyError>>;
+    getCollectionProducts(collectionId: string): Promise<Result<Product[], CimplifyError>>;
+    searchCollections(query: string, limit?: number): Promise<Result<Collection[], CimplifyError>>;
+    getBundles(): Promise<Result<Bundle[], CimplifyError>>;
+    getBundle(id: string): Promise<Result<BundleWithDetails, CimplifyError>>;
+    getBundleBySlug(slug: string): Promise<Result<BundleWithDetails, CimplifyError>>;
+    searchBundles(query: string, limit?: number): Promise<Result<Bundle[], CimplifyError>>;
     getComposites(options?: {
         limit?: number;
-    }): Promise<Composite[]>;
-    getComposite(id: string): Promise<CompositeWithDetails>;
-    getCompositeByProductId(productId: string): Promise<CompositeWithDetails>;
-    calculateCompositePrice(compositeId: string, selections: ComponentSelectionInput[], locationId?: string): Promise<CompositePriceResult>;
-    search(query: string, options?: SearchOptions): Promise<Product[]>;
-    searchProducts(query: string, options?: SearchOptions): Promise<Product[]>;
+    }): Promise<Result<Composite[], CimplifyError>>;
+    getComposite(id: string): Promise<Result<CompositeWithDetails, CimplifyError>>;
+    getCompositeByProductId(productId: string): Promise<Result<CompositeWithDetails, CimplifyError>>;
+    calculateCompositePrice(compositeId: string, selections: ComponentSelectionInput[], locationId?: string): Promise<Result<CompositePriceResult, CimplifyError>>;
+    search(query: string, options?: SearchOptions): Promise<Result<Product[], CimplifyError>>;
+    searchProducts(query: string, options?: SearchOptions): Promise<Result<Product[], CimplifyError>>;
     getMenu(options?: {
         category?: string;
         limit?: number;
-    }): Promise<Product[]>;
-    getMenuCategory(categoryId: string): Promise<Product[]>;
-    getMenuItem(itemId: string): Promise<ProductWithDetails>;
+    }): Promise<Result<Product[], CimplifyError>>;
+    getMenuCategory(categoryId: string): Promise<Result<Product[], CimplifyError>>;
+    getMenuItem(itemId: string): Promise<Result<ProductWithDetails, CimplifyError>>;
 }
 
 type CartStatus = "active" | "converting" | "converted" | "expired" | "abandoned";
@@ -1075,156 +1241,6 @@ interface CartSummary {
     currency: string;
 }
 
-/**
- * A Result type that makes errors explicit in the type system.
- * Inspired by Rust's Result and fp-ts Either.
- *
- * @example
- * ```typescript
- * const result = await client.cart.addItemSafe({ item_id: "prod_123" });
- *
- * if (result.ok) {
- *   console.log(result.value); // Cart
- * } else {
- *   console.log(result.error); // CimplifyError
- * }
- * ```
- */
-type Result<T, E = Error> = Ok<T> | Err<E>;
-interface Ok<T> {
-    readonly ok: true;
-    readonly value: T;
-}
-interface Err<E> {
-    readonly ok: false;
-    readonly error: E;
-}
-/** Create a successful Result */
-declare function ok<T>(value: T): Ok<T>;
-/** Create a failed Result */
-declare function err<E>(error: E): Err<E>;
-/** Check if Result is Ok */
-declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
-/** Check if Result is Err */
-declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
-/**
- * Transform the success value of a Result.
- *
- * @example
- * ```typescript
- * const result = ok(5);
- * const doubled = mapResult(result, (n) => n * 2);
- * // doubled = { ok: true, value: 10 }
- * ```
- */
-declare function mapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
-/**
- * Transform the error value of a Result.
- *
- * @example
- * ```typescript
- * const result = err(new Error("oops"));
- * const mapped = mapError(result, (e) => new CustomError(e.message));
- * ```
- */
-declare function mapError<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
-/**
- * Chain Results together. If the first Result is Ok, apply the function.
- * If it's Err, propagate the error.
- *
- * @example
- * ```typescript
- * const getUser = (id: string): Result<User, Error> => { ... }
- * const getOrders = (user: User): Result<Order[], Error> => { ... }
- *
- * const result = flatMap(getUser("123"), (user) => getOrders(user));
- * ```
- */
-declare function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
-/**
- * Get the value or a default if the Result is Err.
- *
- * @example
- * ```typescript
- * const result = err(new Error("failed"));
- * const value = getOrElse(result, () => defaultCart);
- * ```
- */
-declare function getOrElse<T, E>(result: Result<T, E>, defaultFn: () => T): T;
-/**
- * Get the value or throw the error.
- * Use sparingly - defeats the purpose of Result!
- *
- * @example
- * ```typescript
- * const cart = unwrap(result); // throws if Err
- * ```
- */
-declare function unwrap<T, E>(result: Result<T, E>): T;
-/**
- * Get the value or undefined if Err.
- *
- * @example
- * ```typescript
- * const cart = toNullable(result); // Cart | undefined
- * ```
- */
-declare function toNullable<T, E>(result: Result<T, E>): T | undefined;
-/**
- * Convert a Promise that might throw into a Result.
- *
- * @example
- * ```typescript
- * const result = await fromPromise(
- *   fetch("/api/data"),
- *   (error) => new NetworkError(error.message)
- * );
- * ```
- */
-declare function fromPromise<T, E>(promise: Promise<T>, mapError: (error: unknown) => E): Promise<Result<T, E>>;
-/**
- * Convert a function that might throw into one that returns Result.
- *
- * @example
- * ```typescript
- * const safeParse = tryCatch(
- *   () => JSON.parse(input),
- *   (e) => new ParseError(e.message)
- * );
- * ```
- */
-declare function tryCatch<T, E>(fn: () => T, mapError: (error: unknown) => E): Result<T, E>;
-/**
- * Combine multiple Results. Returns Ok with array of values if all succeed,
- * or the first Err encountered.
- *
- * @example
- * ```typescript
- * const results = await Promise.all([
- *   client.cart.getSafe(),
- *   client.business.getSafe(),
- * ]);
- * const combined = combine(results);
- * // Result<[Cart, Business], CimplifyError>
- * ```
- */
-declare function combine<T, E>(results: Result<T, E>[]): Result<T[], E>;
-/**
- * Like combine, but for an object of Results.
- *
- * @example
- * ```typescript
- * const data = combineObject({
- *   cart: await client.cart.getSafe(),
- *   business: await client.business.getSafe(),
- * });
- * // Result<{ cart: Cart, business: Business }, CimplifyError>
- * ```
- */
-declare function combineObject<T extends Record<string, Result<unknown, unknown>>>(results: T): Result<{
-    [K in keyof T]: T[K] extends Result<infer V, unknown> ? V : never;
-}, T[keyof T] extends Result<unknown, infer E> ? E : never>;
-
 /**
  * Cart operations with explicit error handling via Result type.
  *
@@ -2018,17 +2034,33 @@ interface GetOrdersOptions {
     limit?: number;
     offset?: number;
 }
+/**
+ * Order queries with explicit error handling via Result type.
+ *
+ * All methods return `Result<T, CimplifyError>` - no exceptions thrown.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.orders.list({ status: "pending" });
+ *
+ * if (result.ok) {
+ *   console.log("Orders:", result.value);
+ * } else {
+ *   console.error("Failed:", result.error.code);
+ * }
+ * ```
+ */
 declare class OrderQueries {
     private client;
     constructor(client: CimplifyClient);
-    list(options?: GetOrdersOptions): Promise<Order[]>;
-    get(orderId: string): Promise<Order>;
-    getRecent(limit?: number): Promise<Order[]>;
-    getByStatus(status: OrderStatus): Promise<Order[]>;
-    cancel(orderId: string, reason?: string): Promise<Order>;
+    list(options?: GetOrdersOptions): Promise<Result<Order[], CimplifyError>>;
+    get(orderId: string): Promise<Result<Order, CimplifyError>>;
+    getRecent(limit?: number): Promise<Result<Order[], CimplifyError>>;
+    getByStatus(status: OrderStatus): Promise<Result<Order[], CimplifyError>>;
+    cancel(orderId: string, reason?: string): Promise<Result<Order, CimplifyError>>;
 }
 
-interface SuccessResult {
+interface SuccessResult$2 {
     success: boolean;
     message?: string;
 }
@@ -2040,9 +2072,9 @@ interface SuccessResult {
 declare class LinkService {
     private client;
     constructor(client: CimplifyClient);
-    requestOtp(input: RequestOtpInput): Promise<Result<SuccessResult, CimplifyError>>;
+    requestOtp(input: RequestOtpInput): Promise<Result<SuccessResult$2, CimplifyError>>;
     verifyOtp(input: VerifyOtpInput): Promise<Result<AuthResponse, CimplifyError>>;
-    logout(): Promise<Result<SuccessResult, CimplifyError>>;
+    logout(): Promise<Result<SuccessResult$2, CimplifyError>>;
     checkStatus(contact: string): Promise<Result<LinkStatusResult, CimplifyError>>;
     getLinkData(): Promise<Result<LinkData, CimplifyError>>;
     getAddresses(): Promise<Result<CustomerAddress[], CimplifyError>>;
@@ -2050,28 +2082,28 @@ declare class LinkService {
     getPreferences(): Promise<Result<CustomerLinkPreferences, CimplifyError>>;
     enroll(data: EnrollmentData): Promise<Result<LinkEnrollResult, CimplifyError>>;
     enrollAndLinkOrder(data: EnrollAndLinkOrderInput): Promise<Result<EnrollAndLinkOrderResult, CimplifyError>>;
-    updatePreferences(preferences: Partial<CustomerLinkPreferences>): Promise<Result<SuccessResult, CimplifyError>>;
+    updatePreferences(preferences: Partial<CustomerLinkPreferences>): Promise<Result<SuccessResult$2, CimplifyError>>;
     createAddress(input: CreateAddressInput): Promise<Result<CustomerAddress, CimplifyError>>;
-    updateAddress(input: UpdateAddressInput): Promise<Result<SuccessResult, CimplifyError>>;
-    deleteAddress(addressId: string): Promise<Result<SuccessResult, CimplifyError>>;
-    setDefaultAddress(addressId: string): Promise<Result<SuccessResult, CimplifyError>>;
-    trackAddressUsage(addressId: string): Promise<Result<SuccessResult, CimplifyError>>;
+    updateAddress(input: UpdateAddressInput): Promise<Result<SuccessResult$2, CimplifyError>>;
+    deleteAddress(addressId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
+    setDefaultAddress(addressId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
+    trackAddressUsage(addressId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
     createMobileMoney(input: CreateMobileMoneyInput): Promise<Result<CustomerMobileMoney, CimplifyError>>;
-    deleteMobileMoney(mobileMoneyId: string): Promise<Result<SuccessResult, CimplifyError>>;
-    setDefaultMobileMoney(mobileMoneyId: string): Promise<Result<SuccessResult, CimplifyError>>;
-    trackMobileMoneyUsage(mobileMoneyId: string): Promise<Result<SuccessResult, CimplifyError>>;
-    verifyMobileMoney(mobileMoneyId: string): Promise<Result<SuccessResult, CimplifyError>>;
+    deleteMobileMoney(mobileMoneyId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
+    setDefaultMobileMoney(mobileMoneyId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
+    trackMobileMoneyUsage(mobileMoneyId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
+    verifyMobileMoney(mobileMoneyId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
     getSessions(): Promise<Result<LinkSession[], CimplifyError>>;
     revokeSession(sessionId: string): Promise<Result<RevokeSessionResult, CimplifyError>>;
     revokeAllSessions(): Promise<Result<RevokeAllSessionsResult, CimplifyError>>;
     getAddressesRest(): Promise<Result<CustomerAddress[], CimplifyError>>;
     createAddressRest(input: CreateAddressInput): Promise<Result<CustomerAddress, CimplifyError>>;
-    deleteAddressRest(addressId: string): Promise<Result<SuccessResult, CimplifyError>>;
-    setDefaultAddressRest(addressId: string): Promise<Result<SuccessResult, CimplifyError>>;
+    deleteAddressRest(addressId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
+    setDefaultAddressRest(addressId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
     getMobileMoneyRest(): Promise<Result<CustomerMobileMoney[], CimplifyError>>;
     createMobileMoneyRest(input: CreateMobileMoneyInput): Promise<Result<CustomerMobileMoney, CimplifyError>>;
-    deleteMobileMoneyRest(mobileMoneyId: string): Promise<Result<SuccessResult, CimplifyError>>;
-    setDefaultMobileMoneyRest(mobileMoneyId: string): Promise<Result<SuccessResult, CimplifyError>>;
+    deleteMobileMoneyRest(mobileMoneyId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
+    setDefaultMobileMoneyRest(mobileMoneyId: string): Promise<Result<SuccessResult$2, CimplifyError>>;
 }
 
 interface AuthStatus {
@@ -2092,24 +2124,39 @@ interface ChangePasswordInput {
     current_password: string;
     new_password: string;
 }
+interface SuccessResult$1 {
+    success: boolean;
+}
+/**
+ * Auth service with explicit error handling via Result type.
+ *
+ * All methods return `Result<T, CimplifyError>` - no exceptions thrown.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.auth.verifyOtp("123456");
+ *
+ * if (result.ok) {
+ *   console.log("Logged in as:", result.value.customer.name);
+ * } else {
+ *   if (result.error.code === "INVALID_OTP") {
+ *     toast.error("Invalid code. Please try again.");
+ *   }
+ * }
+ * ```
+ */
 declare class AuthService {
     private client;
     constructor(client: CimplifyClient);
-    getStatus(): Promise<AuthStatus>;
-    getCurrentUser(): Promise<Customer | null>;
-    isAuthenticated(): Promise<boolean>;
-    requestOtp(contact: string, contactType?: "phone" | "email"): Promise<void>;
-    verifyOtp(code: string, contact?: string): Promise<OtpResult>;
-    logout(): Promise<{
-        success: boolean;
-    }>;
-    updateProfile(input: UpdateProfileInput): Promise<Customer>;
-    changePassword(input: ChangePasswordInput): Promise<{
-        success: boolean;
-    }>;
-    resetPassword(email: string): Promise<{
-        success: boolean;
-    }>;
+    getStatus(): Promise<Result<AuthStatus, CimplifyError>>;
+    getCurrentUser(): Promise<Result<Customer | null, CimplifyError>>;
+    isAuthenticated(): Promise<Result<boolean, CimplifyError>>;
+    requestOtp(contact: string, contactType?: "phone" | "email"): Promise<Result<void, CimplifyError>>;
+    verifyOtp(code: string, contact?: string): Promise<Result<OtpResult, CimplifyError>>;
+    logout(): Promise<Result<SuccessResult$1, CimplifyError>>;
+    updateProfile(input: UpdateProfileInput): Promise<Result<Customer, CimplifyError>>;
+    changePassword(input: ChangePasswordInput): Promise<Result<SuccessResult$1, CimplifyError>>;
+    resetPassword(email: string): Promise<Result<SuccessResult$1, CimplifyError>>;
 }
 
 type BusinessType = "eatery" | "retail" | "service" | "other" | "system" | "unset";
@@ -2270,19 +2317,35 @@ interface CategoryInfo {
     slug: string;
 }
 
+/**
+ * Business service with explicit error handling via Result type.
+ *
+ * All methods return `Result<T, CimplifyError>` - no exceptions thrown.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.business.getInfo();
+ *
+ * if (result.ok) {
+ *   console.log("Business:", result.value.name);
+ * } else {
+ *   console.error("Failed:", result.error.code);
+ * }
+ * ```
+ */
 declare class BusinessService {
     private client;
     constructor(client: CimplifyClient);
-    getInfo(): Promise<Business>;
-    getByHandle(handle: string): Promise<Business>;
-    getByDomain(domain: string): Promise<Business>;
-    getSettings(): Promise<BusinessSettings>;
-    getTheme(): Promise<Record<string, unknown>>;
-    getLocations(): Promise<Location[]>;
-    getLocation(locationId: string): Promise<Location>;
-    getHours(): Promise<BusinessHours[]>;
-    getLocationHours(locationId: string): Promise<BusinessHours[]>;
-    getBootstrap(): Promise<StorefrontBootstrap>;
+    getInfo(): Promise<Result<Business, CimplifyError>>;
+    getByHandle(handle: string): Promise<Result<Business, CimplifyError>>;
+    getByDomain(domain: string): Promise<Result<Business, CimplifyError>>;
+    getSettings(): Promise<Result<BusinessSettings, CimplifyError>>;
+    getTheme(): Promise<Result<Record<string, unknown>, CimplifyError>>;
+    getLocations(): Promise<Result<Location[], CimplifyError>>;
+    getLocation(locationId: string): Promise<Result<Location, CimplifyError>>;
+    getHours(): Promise<Result<BusinessHours[], CimplifyError>>;
+    getLocationHours(locationId: string): Promise<Result<BusinessHours[], CimplifyError>>;
+    getBootstrap(): Promise<Result<StorefrontBootstrap, CimplifyError>>;
 }
 
 type StockOwnershipType = "owned" | "consignment" | "dropship";
@@ -2373,22 +2436,38 @@ interface InventorySummary {
     total_value?: Money;
 }
 
+/**
+ * Inventory service with explicit error handling via Result type.
+ *
+ * All methods return `Result<T, CimplifyError>` - no exceptions thrown.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.inventory.isInStock("prod_123");
+ *
+ * if (result.ok) {
+ *   console.log("In stock:", result.value);
+ * } else {
+ *   console.error("Failed:", result.error.code);
+ * }
+ * ```
+ */
 declare class InventoryService {
     private client;
     constructor(client: CimplifyClient);
-    getStockLevels(): Promise<StockLevel[]>;
-    getProductStock(productId: string, locationId?: string): Promise<ProductStock>;
-    getVariantStock(variantId: string, locationId?: string): Promise<StockLevel>;
-    checkProductAvailability(productId: string, quantity: number, locationId?: string): Promise<AvailabilityResult>;
-    checkVariantAvailability(variantId: string, quantity: number, locationId?: string): Promise<AvailabilityResult>;
+    getStockLevels(): Promise<Result<StockLevel[], CimplifyError>>;
+    getProductStock(productId: string, locationId?: string): Promise<Result<ProductStock, CimplifyError>>;
+    getVariantStock(variantId: string, locationId?: string): Promise<Result<StockLevel, CimplifyError>>;
+    checkProductAvailability(productId: string, quantity: number, locationId?: string): Promise<Result<AvailabilityResult, CimplifyError>>;
+    checkVariantAvailability(variantId: string, quantity: number, locationId?: string): Promise<Result<AvailabilityResult, CimplifyError>>;
     checkMultipleAvailability(items: {
         product_id: string;
         variant_id?: string;
         quantity: number;
-    }[], locationId?: string): Promise<AvailabilityResult[]>;
-    getSummary(): Promise<InventorySummary>;
-    isInStock(productId: string, locationId?: string): Promise<boolean>;
-    getAvailableQuantity(productId: string, locationId?: string): Promise<number>;
+    }[], locationId?: string): Promise<Result<AvailabilityResult[], CimplifyError>>;
+    getSummary(): Promise<Result<InventorySummary, CimplifyError>>;
+    isInStock(productId: string, locationId?: string): Promise<Result<boolean, CimplifyError>>;
+    getAvailableQuantity(productId: string, locationId?: string): Promise<Result<number, CimplifyError>>;
 }
 
 interface ServiceAvailabilityRule {
@@ -2631,29 +2710,48 @@ interface ServiceAvailabilityResult {
     days: DayAvailability[];
 }
 
+/**
+ * Scheduling service with explicit error handling via Result type.
+ *
+ * All methods return `Result<T, CimplifyError>` - no exceptions thrown.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.scheduling.getAvailableSlots({
+ *   service_id: "svc_haircut",
+ *   date: "2024-01-15"
+ * });
+ *
+ * if (result.ok) {
+ *   console.log("Available slots:", result.value);
+ * } else {
+ *   console.error("Failed:", result.error.code);
+ * }
+ * ```
+ */
 declare class SchedulingService {
     private client;
     constructor(client: CimplifyClient);
-    getServices(): Promise<Service[]>;
+    getServices(): Promise<Result<Service[], CimplifyError>>;
     /**
      * Get a specific service by ID
      * Note: Filters from all services client-side (no single-service endpoint)
      */
-    getService(serviceId: string): Promise<Service | null>;
-    getAvailableSlots(input: GetAvailableSlotsInput): Promise<AvailableSlot[]>;
-    checkSlotAvailability(input: CheckSlotAvailabilityInput): Promise<{
+    getService(serviceId: string): Promise<Result<Service | null, CimplifyError>>;
+    getAvailableSlots(input: GetAvailableSlotsInput): Promise<Result<AvailableSlot[], CimplifyError>>;
+    checkSlotAvailability(input: CheckSlotAvailabilityInput): Promise<Result<{
         available: boolean;
         reason?: string;
-    }>;
-    getServiceAvailability(params: ServiceAvailabilityParams): Promise<ServiceAvailabilityResult>;
-    getBooking(bookingId: string): Promise<BookingWithDetails>;
-    getCustomerBookings(): Promise<Booking[]>;
-    getUpcomingBookings(): Promise<Booking[]>;
-    getPastBookings(limit?: number): Promise<Booking[]>;
-    cancelBooking(input: CancelBookingInput): Promise<Booking>;
-    rescheduleBooking(input: RescheduleBookingInput): Promise<Booking>;
-    getNextAvailableSlot(serviceId: string, fromDate?: string): Promise<AvailableSlot | null>;
-    hasAvailabilityOn(serviceId: string, date: string): Promise<boolean>;
+    }, CimplifyError>>;
+    getServiceAvailability(params: ServiceAvailabilityParams): Promise<Result<ServiceAvailabilityResult, CimplifyError>>;
+    getBooking(bookingId: string): Promise<Result<BookingWithDetails, CimplifyError>>;
+    getCustomerBookings(): Promise<Result<Booking[], CimplifyError>>;
+    getUpcomingBookings(): Promise<Result<Booking[], CimplifyError>>;
+    getPastBookings(limit?: number): Promise<Result<Booking[], CimplifyError>>;
+    cancelBooking(input: CancelBookingInput): Promise<Result<Booking, CimplifyError>>;
+    rescheduleBooking(input: RescheduleBookingInput): Promise<Result<Booking, CimplifyError>>;
+    getNextAvailableSlot(serviceId: string, fromDate?: string): Promise<Result<AvailableSlot | null, CimplifyError>>;
+    hasAvailabilityOn(serviceId: string, date: string): Promise<Result<boolean, CimplifyError>>;
 }
 
 interface LiteBootstrap {
@@ -2686,27 +2784,52 @@ interface KitchenOrderResult {
     order_number: string;
     estimated_time_minutes?: number;
 }
+interface SuccessResult {
+    success: boolean;
+}
+interface RequestBillResult {
+    success: boolean;
+    order_id: string;
+}
+/**
+ * Lite service for QR code ordering with explicit error handling via Result type.
+ *
+ * All methods return `Result<T, CimplifyError>` - no exceptions thrown.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.lite.getBootstrap();
+ *
+ * if (result.ok) {
+ *   console.log("Business:", result.value.business.name);
+ *   console.log("Table:", result.value.table?.number);
+ * } else {
+ *   console.error("Failed:", result.error.code);
+ * }
+ * ```
+ */
 declare class LiteService {
     private client;
     constructor(client: CimplifyClient);
-    getBootstrap(): Promise<LiteBootstrap>;
-    getTable(tableId: string): Promise<TableInfo>;
-    getTableByNumber(tableNumber: string, locationId?: string): Promise<TableInfo>;
-    sendToKitchen(tableId: string, items: KitchenOrderItem[]): Promise<KitchenOrderResult>;
-    callWaiter(tableId: string, reason?: string): Promise<{
-        success: boolean;
-    }>;
-    requestBill(tableId: string): Promise<{
-        success: boolean;
-        order_id: string;
-    }>;
-    getMenu(): Promise<Product[]>;
-    getMenuByCategory(categoryId: string): Promise<Product[]>;
+    getBootstrap(): Promise<Result<LiteBootstrap, CimplifyError>>;
+    getTable(tableId: string): Promise<Result<TableInfo, CimplifyError>>;
+    getTableByNumber(tableNumber: string, locationId?: string): Promise<Result<TableInfo, CimplifyError>>;
+    sendToKitchen(tableId: string, items: KitchenOrderItem[]): Promise<Result<KitchenOrderResult, CimplifyError>>;
+    callWaiter(tableId: string, reason?: string): Promise<Result<SuccessResult, CimplifyError>>;
+    requestBill(tableId: string): Promise<Result<RequestBillResult, CimplifyError>>;
+    getMenu(): Promise<Result<Product[], CimplifyError>>;
+    getMenuByCategory(categoryId: string): Promise<Result<Product[], CimplifyError>>;
 }
 
 interface CimplifyConfig {
     publicKey?: string;
     credentials?: RequestCredentials;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum retry attempts for retryable errors (default: 3) */
+    maxRetries?: number;
+    /** Base delay between retries in milliseconds (default: 1000) */
+    retryDelay?: number;
 }
 declare class CimplifyClient {
     private baseUrl;
@@ -2714,6 +2837,9 @@ declare class CimplifyClient {
     private publicKey;
     private credentials;
     private sessionToken;
+    private timeout;
+    private maxRetries;
+    private retryDelay;
     private _catalogue?;
     private _cart?;
     private _checkout?;
@@ -2732,6 +2858,11 @@ declare class CimplifyClient {
     private saveSessionToken;
     private getHeaders;
     private updateSessionFromResponse;
+    /**
+     * Resilient fetch with timeout and automatic retries for network errors.
+     * Uses exponential backoff: 1s, 2s, 4s between retries.
+     */
+    private resilientFetch;
     query<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T>;
     call<T = unknown>(method: string, args?: unknown): Promise<T>;
     get<T = unknown>(path: string): Promise<T>;