import { T as CimplifyError, Q as Category, aX as Product, f as AddOnWithOptions, aO as Pagination, b9 as ProductWithDetails, b7 as ProductVariant, bA as VariantAxis, bB as VariantAxisSelection, A as AddOn, U as Collection, E as BundleSummary, s as Bundle, a1 as Composite, $ as ComponentSelectionInput, a6 as CompositePriceResult, S as ChosenPrice, b4 as ProductTaxonomy, bt as TaxonomyWithChildren, av as EligiblePlansQuery, a$ as ProductBillingPlan, b5 as ProductTimeProfile, a_ as ProductAvailabilityNow, ah as Deal, b0 as ProductDealInfo, an as DiscountValidation, bq as TagsResponse, ac as CustomAttributeDefinition, ad as CustomAttributeValue, ba as PropertyFacet, bs as TaxonomyAttributeTemplate, aH as KnowledgeArticle, bu as UICart, J as CartItem, O as CartSummary, g as AddToCartInput, L as CartMutationResult, bz as UpdateCartItemInput, am as DiscountDetails, aM as Money, ab as CurrencyCode, aI as LineConfiguration, bG as VariantDetails, bH as VariantDetailsDTO, a as AddOnDetails, d as AddOnOptionDetails, b as AddOnGroupDetails, z as BundleSelectionData, a8 as CompositeSelectionData, ae as CustomerInputValue, bg as SchedulingMode, at as DurationUnit, bk as Subscription, bo as SubscriptionWithDetails } from './product-DXhjLQ_w.js';
import { a as AuthorizationType, c as PaymentMethod, I as InitializePaymentResult, S as SubmitAuthorizationInput, i as PaymentStatusResponse } from './payment-nH9OCUg2.js';

interface RequestContext {
    method: "GET" | "POST" | "PATCH" | "DELETE";
    path: string;
    url: string;
    body?: unknown;
    startTime: number;
}
interface RequestStartEvent extends RequestContext {
}
interface RequestSuccessEvent extends RequestContext {
    status: number;
    durationMs: number;
}
interface RequestErrorEvent extends RequestContext {
    error: Error;
    status?: number;
    durationMs: number;
    retryCount: number;
    retryable: boolean;
}
interface RetryEvent extends RequestContext {
    attempt: number;
    delayMs: number;
    error: Error;
}
interface SessionChangeEvent {
    previousToken: string | null;
    newToken: string | null;
    source: "response" | "manual" | "clear";
}
interface ObservabilityHooks {
    onRequestStart?: (event: RequestStartEvent) => void;
    onRequestSuccess?: (event: RequestSuccessEvent) => void;
    onRequestError?: (event: RequestErrorEvent) => void;
    onRetry?: (event: RetryEvent) => void;
    onSessionChange?: (event: SessionChangeEvent) => void;
}

interface MutationErrorEvent {
    service: string;
    operation: string;
    error: CimplifyError;
    opId?: string;
    idempotencyKey?: string;
}
interface OutboxEntrySnapshot {
    id: string;
    idempotencyKey: string;
    service: string;
    operation: string;
    attemptCount: number;
}
interface OutboxReplayEvent {
    entry: OutboxEntrySnapshot;
}
interface OutboxReplayErrorEvent {
    entry: OutboxEntrySnapshot;
    error: CimplifyError;
}
interface OutboxFullEvent {
    service: string;
    operation: string;
    idempotencyKey: string;
}
interface ClientEventMap {
    "mutation:error": MutationErrorEvent;
    "outbox:replay-success": OutboxReplayEvent;
    "outbox:replay-error": OutboxReplayErrorEvent;
    "outbox:dead-letter": OutboxReplayEvent;
    "outbox:full": OutboxFullEvent;
}
type ClientEventName = keyof ClientEventMap;
type ClientEventListener<K extends ClientEventName> = (payload: ClientEventMap[K]) => void;
interface ClientEvents {
    on<K extends ClientEventName>(name: K, listener: ClientEventListener<K>): () => void;
    off<K extends ClientEventName>(name: K, listener: ClientEventListener<K>): void;
    emit<K extends ClientEventName>(name: K, payload: ClientEventMap[K]): void;
}

interface CatalogueResult<T> {
    items: T[];
    is_complete: boolean;
    total_available?: number;
    pagination?: Pagination;
}
interface CatalogueSnapshot {
    categories: Category[];
    products: Product[];
    add_ons: AddOnWithOptions[];
    is_complete: boolean;
    total_available?: number;
    pagination?: Pagination;
}

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;
}
declare function ok<T>(value: T): Ok<T>;
declare function err<E>(error: E): Err<E>;
declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
declare function mapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
declare function mapError<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
declare function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
declare function getOrElse<T, E>(result: Result<T, E>, defaultFn: () => T): T;
declare function unwrap<T, E>(result: Result<T, E>): T;
declare function toNullable<T, E>(result: Result<T, E>): T | undefined;
declare function fromPromise<T, E>(promise: Promise<T>, mapError: (error: unknown) => E): Promise<Result<T, E>>;
declare function tryCatch<T, E>(fn: () => T, mapError: (error: unknown) => E): Result<T, E>;
declare function combine<T, E>(results: Result<T, E>[]): Result<T[], E>;
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 IdempotencyOption$9 {
    idempotencyKey?: string;
}
interface GetProductsOptions {
    category?: string;
    taxonomy?: string;
    search?: string;
    page?: number;
    limit?: number;
    offset?: number;
    cursor?: string;
    tags?: string[];
    featured?: boolean;
    in_stock?: boolean;
    min_price?: number;
    max_price?: number;
    sort_by?: "name" | "price" | "created_at" | "updated_at";
    sort_order?: "asc" | "desc";
    /** Property filters — e.g. { material: "Cotton", size: "M,L" }. Values are comma-separated for multi-value. */
    properties?: Record<string, string>;
}
interface QuoteCompositeSelectionInput {
    component_id: string;
    quantity: number;
    variant_id?: string;
    add_on_option_id?: string;
}
interface QuoteBundleSelectionInput {
    component_id: string;
    quantity: number;
    variant_id?: string;
}
interface FetchQuoteInput {
    product_id: string;
    variant_id?: string;
    location_id?: string;
    quantity?: number;
    add_on_option_ids?: string[];
    bundle_selections?: QuoteBundleSelectionInput[];
    composite_selections?: QuoteCompositeSelectionInput[];
}
interface RefreshQuoteInput {
    quote_id: string;
    product_id?: string;
    variant_id?: string;
    location_id?: string;
    quantity?: number;
    add_on_option_ids?: string[];
    bundle_selections?: QuoteBundleSelectionInput[];
    composite_selections?: QuoteCompositeSelectionInput[];
}
type QuoteStatus = "pending" | "used" | "expired";
interface QuoteDynamicBuckets {
    intent?: string;
    demand?: string;
    inventory?: string;
    competition?: string;
}
interface QuoteUiMessage {
    code: string;
    level: "info" | "warn" | "error" | string;
    text: string;
    countdown_seconds?: number;
}
type RequestSource = "web" | "qr_code" | "order_taker" | "ucp_a2a";
interface PriceQuote {
    quote_id: string;
    business_id: string;
    product_id: string;
    variant_id?: string;
    location_id?: string;
    source: RequestSource;
    customer_id?: string;
    customer_segment_id?: string;
    storefront_id?: string;
    attribution_id?: string;
    quantity: number;
    currency?: string;
    snapshot_id?: string;
    snapshot_markup_version?: string;
    snapshot_tax_version?: string;
    item_price_info: ChosenPrice;
    variant_price_info?: ChosenPrice;
    final_price_info: ChosenPrice;
    add_on_option_ids: string[];
    bundle_selections?: QuoteBundleSelectionInput[];
    add_ons_price_info?: ChosenPrice;
    quoted_total_price_info?: ChosenPrice;
    composite_selections?: QuoteCompositeSelectionInput[];
    dynamic_buckets: QuoteDynamicBuckets;
    ui_messages: QuoteUiMessage[];
    created_at: string;
    expires_at: string;
    next_change_at?: string;
    status: QuoteStatus;
}
interface RefreshQuoteResult {
    previous_quote_id: string;
    quote: PriceQuote;
}
declare class CatalogueQueries {
    private client;
    constructor(client: CimplifyClient);
    getCatalogue(opts?: ReadRequestOptions): Promise<Result<CatalogueSnapshot, CimplifyError>>;
    getProducts(options?: GetProductsOptions, opts?: ReadRequestOptions): Promise<Result<CatalogueResult<Product>, CimplifyError>>;
    getProduct(id: string, opts?: ReadRequestOptions): Promise<Result<ProductWithDetails, CimplifyError>>;
    getProductBySlug(slug: string, opts?: ReadRequestOptions): Promise<Result<ProductWithDetails, CimplifyError>>;
    getVariants(productId: string): Promise<Result<ProductVariant[], CimplifyError>>;
    getVariantAxes(productId: string): Promise<Result<VariantAxis[], CimplifyError>>;
    getVariantByAxisSelections(productId: string, selections: VariantAxisSelection): Promise<Result<ProductVariant | null, CimplifyError>>;
    getVariantById(productId: string, variantId: string): Promise<Result<ProductVariant, CimplifyError>>;
    getAddOns(productId: string, opts?: ReadRequestOptions): Promise<Result<AddOn[], CimplifyError>>;
    getCategories(opts?: ReadRequestOptions): Promise<Result<Category[], CimplifyError>>;
    getCategory(id: string, opts?: ReadRequestOptions): Promise<Result<Category, CimplifyError>>;
    getCategoryBySlug(slug: string, opts?: ReadRequestOptions): Promise<Result<Category, CimplifyError>>;
    getCategoryProducts(categoryId: string, options?: {
        limit?: number;
        offset?: number;
    }, opts?: ReadRequestOptions): Promise<Result<Product[], CimplifyError>>;
    getCollections(opts?: ReadRequestOptions): Promise<Result<Collection[], CimplifyError>>;
    getCollection(id: string, opts?: ReadRequestOptions): Promise<Result<Collection, CimplifyError>>;
    getCollectionBySlug(slug: string, opts?: ReadRequestOptions): Promise<Result<Collection, CimplifyError>>;
    getCollectionProducts(collectionId: string, options?: {
        limit?: number;
        offset?: number;
    }, opts?: ReadRequestOptions): Promise<Result<Product[], CimplifyError>>;
    searchCollections(query: string, limit?: number): Promise<Result<Collection[], CimplifyError>>;
    getBundles(): Promise<Result<BundleSummary[], CimplifyError>>;
    getBundle(id: string): Promise<Result<Bundle, CimplifyError>>;
    getBundleBySlug(slug: string): Promise<Result<Bundle, CimplifyError>>;
    searchBundles(query: string, limit?: number): Promise<Result<Bundle[], CimplifyError>>;
    getComposites(options?: {
        limit?: number;
    }): Promise<Result<Composite[], CimplifyError>>;
    getComposite(id: string): Promise<Result<Composite, CimplifyError>>;
    getCompositeByProduct(productId: string): Promise<Result<Composite, CimplifyError>>;
    calculateCompositePrice(compositeId: string, selections: ComponentSelectionInput[], locationId?: string): Promise<Result<CompositePriceResult, CimplifyError>>;
    fetchQuote(input: FetchQuoteInput, opts?: IdempotencyOption$9): Promise<Result<PriceQuote, CimplifyError>>;
    getQuote(quoteId: string): Promise<Result<PriceQuote, CimplifyError>>;
    refreshQuote(input: RefreshQuoteInput): Promise<Result<RefreshQuoteResult, CimplifyError>>;
    getTaxonomies(parentId?: string): Promise<Result<ProductTaxonomy[], CimplifyError>>;
    getTaxonomy(id: string): Promise<Result<TaxonomyWithChildren, CimplifyError>>;
    getTaxonomyPath(id: string): Promise<Result<ProductTaxonomy[], CimplifyError>>;
    searchTaxonomies(query: string, limit?: number): Promise<Result<ProductTaxonomy[], CimplifyError>>;
    getEligibleBillingPlans(productId: string, query?: EligiblePlansQuery): Promise<Result<ProductBillingPlan[], CimplifyError>>;
    getProductSchedules(productId: string): Promise<Result<ProductTimeProfile[], CimplifyError>>;
    checkProductAvailableNow(productId: string, locationId: string): Promise<Result<ProductAvailabilityNow, CimplifyError>>;
    getDeals(locationId?: string): Promise<Result<Deal[], CimplifyError>>;
    getProductsOnSale(): Promise<Result<ProductDealInfo[], CimplifyError>>;
    getProductDeals(productId: string): Promise<Result<Deal[], CimplifyError>>;
    getCategoryDeals(categoryId: string): Promise<Result<Deal[], CimplifyError>>;
    getCollectionDeals(collectionId: string): Promise<Result<Deal[], CimplifyError>>;
    validateDiscountCode(code: string, orderSubtotal: string, locationId?: string): Promise<Result<DiscountValidation, CimplifyError>>;
    search(query: string, options?: Omit<GetProductsOptions, "search">, opts?: ReadRequestOptions): Promise<Result<Product[], CimplifyError>>;
    searchProducts(query: string, options?: Omit<GetProductsOptions, "search">, opts?: ReadRequestOptions): Promise<Result<Product[], CimplifyError>>;
    getMenu(options?: {
        category?: string;
        limit?: number;
    }): Promise<Result<Product[], CimplifyError>>;
    getMenuCategory(categoryId: string): Promise<Result<Product[], CimplifyError>>;
    getMenuItem(itemId: string): Promise<Result<ProductWithDetails, CimplifyError>>;
    getTags(options?: {
        tag_group?: string;
        search?: string;
        min_usage?: number;
        limit?: number;
        offset?: number;
    }): Promise<Result<TagsResponse, CimplifyError>>;
    getAttributeDefinitions(namespace?: string): Promise<Result<CustomAttributeDefinition[], CimplifyError>>;
    getProductAttributes(productId: string): Promise<Result<CustomAttributeValue[], CimplifyError>>;
    getCategoryAttributes(categoryId: string): Promise<Result<CustomAttributeValue[], CimplifyError>>;
    getCollectionAttributes(collectionId: string): Promise<Result<CustomAttributeValue[], CimplifyError>>;
    getPropertyFacets(options?: {
        category_id?: string;
        product_type?: string;
    }): Promise<Result<PropertyFacet[], CimplifyError>>;
    getTaxonomyAttributes(taxonomyId: string): Promise<Result<TaxonomyAttributeTemplate[], CimplifyError>>;
    searchKnowledge(query: string, limit?: number): Promise<Result<KnowledgeArticle[], CimplifyError>>;
    getKnowledgeArticles(): Promise<Result<KnowledgeArticle[], CimplifyError>>;
}

interface IdempotencyOption$8 {
    idempotencyKey?: string;
}
interface ReorderResult {
    added: {
        item_id: string;
    }[];
    failed: {
        item_id: string;
        error: CimplifyError;
    }[];
}
declare class CartOperations {
    private client;
    constructor(client: CimplifyClient);
    get(): Promise<Result<UICart, CimplifyError>>;
    getItems(): Promise<Result<CartItem[], CimplifyError>>;
    getCount(): Promise<Result<number, CimplifyError>>;
    getTotal(): Promise<Result<string, CimplifyError>>;
    getSummary(): Promise<Result<CartSummary, CimplifyError>>;
    addItem(input: AddToCartInput, opts?: IdempotencyOption$8): Promise<Result<CartMutationResult, CimplifyError>>;
    updateItem(cartItemId: string, updates: UpdateCartItemInput): Promise<Result<CartMutationResult, CimplifyError>>;
    updateQuantity(cartItemId: string, quantity: number): Promise<Result<CartMutationResult, CimplifyError>>;
    removeItem(cartItemId: string): Promise<Result<CartMutationResult, CimplifyError>>;
    clear(): Promise<Result<CartMutationResult, CimplifyError>>;
    applyCoupon(code: string, opts?: IdempotencyOption$8): Promise<Result<CartMutationResult, CimplifyError>>;
    removeCoupon(): Promise<Result<CartMutationResult, CimplifyError>>;
    reorderFromOrder(orderId: string): Promise<Result<ReorderResult, CimplifyError>>;
    isEmpty(): Promise<Result<boolean, CimplifyError>>;
    hasItem(productId: string, variantId?: string): Promise<Result<boolean, CimplifyError>>;
    findItem(productId: string, variantId?: string): Promise<Result<CartItem | undefined, CimplifyError>>;
}

type OrderStatus = "pending" | "created" | "confirmed" | "in_preparation" | "ready_to_serve" | "partially_served" | "served" | "delivered" | "picked_up" | "completed" | "cancelled" | "refunded";
type PaymentState = "not_paid" | "partially_paid" | "paid" | "partially_refunded" | "refunded";
type OrderChannel = "qr" | "taker" | "staff" | "web" | "dashboard" | "tap" | "chat";
type LineType = "product" | "service" | "bundle" | "composite" | "digital";
type OrderLineState = "pending" | "in_preparation" | "checked_out" | "ready" | "served" | "completed" | {
    partially_served: {
        served_quantity: number;
    };
} | {
    cancelled: {
        reason?: string;
    };
};
interface OrderLineStatus {
    state: OrderLineState;
    quantity_ordered: number;
    quantity_prepared: number;
    quantity_served: number;
    last_modified: string;
    modified_by: string;
}
type FulfillmentType = "booking" | "shipment" | "order" | "digital";
type FulfillmentStatus = "pending" | "in_progress" | "completed" | "cancelled";
interface FulfillmentLink {
    fulfillment_type: FulfillmentType;
    fulfillment_id: string;
}
interface OrderFulfillmentSummary {
    total_items: number;
    pending_items: number;
    in_progress_items: number;
    completed_items: number;
    cancelled_items: number;
    all_complete: boolean;
    any_in_progress: boolean;
}
type FeeBearerType = "customer" | "business" | "split";
interface AmountToPay {
    customer_pays: Money;
    business_receives: Money;
    cimplify_receives: Money;
    provider_receives: Money;
    fee_bearer: FeeBearerType;
}
interface LineItem {
    id: string;
    order_id: string;
    product_id: string;
    line_key: string;
    quantity: number;
    configuration: LineConfiguration;
    price: Money;
    add_ons_price: Money;
    price_info: ChosenPrice;
    item_discount_amount: Money;
    discount_details?: DiscountDetails;
    created_at: string;
    updated_at: string;
    line_state: OrderLineStatus;
    metadata?: Record<string, unknown>;
    fulfillment_type?: FulfillmentType;
    fulfillment_id?: string;
}
interface Order {
    id: string;
    business_id: string;
    channel: OrderChannel;
    status: OrderStatus;
    payment_state: PaymentState;
    order_type: string;
    placed_by?: string;
    user_friendly_id: string;
    customer_id?: string;
    customer_name?: string;
    customer_email?: string;
    customer_phone?: string;
    customer_notes?: string[];
    discount_code?: string;
    applied_discount_ids: string[];
    applied_discount_codes: string[];
    discount_details?: DiscountDetails;
    delivery_address?: string;
    delivery_fee: Money;
    delivery_fee_details?: DeliveryFeeDetails;
    tracking_token?: string;
    tracking_link?: string;
    pickup_time?: string;
    created_at: string;
    updated_at: string;
    delivered_at?: string;
    fulfilled_at?: string;
    confirmed_at?: string;
    served_at?: string;
    completed_at?: string;
    cancelled_at?: string;
    table_number?: string;
    room_number?: string;
    resource_id?: string;
    location_id?: string;
    was_placed_by_staff: boolean;
    modified_by_staff: boolean;
    delivery_required: boolean;
    customer_will_pick_up: boolean;
    total_price: Money;
    subtotal: Money;
    total_discount: Money;
    service_charge?: Money;
    tax?: Money;
    price_info: ChosenPrice;
    currency: CurrencyCode;
    bill_token?: string;
    order_group_id?: string;
    subscription_id?: string;
    paid_via_group: boolean;
    amount_to_pay: AmountToPay;
    served_by?: string;
    metadata?: Record<string, unknown>;
    requires_scheduling: boolean;
    all_items_scheduled: boolean;
    earliest_service_time?: string;
    latest_service_time?: string;
    deposit_required: boolean;
    deposit_amount: Money;
    balance_due: Money;
    deposit_due_date?: string;
    final_payment_due_date?: string;
    payment_terms_id?: string;
    price_list_id?: string;
    approval_status?: string;
    version: number;
    total_quantity: number;
    items: LineItem[];
    computed_payment_status?: string;
    is_service_only?: boolean;
    source_proposal_id?: string;
}
interface OrderHistory {
    id: string;
    order_id: string;
    modified_by: string;
    modification_type: string;
    modification_details: string;
    modified_at: string;
    metadata?: Record<string, unknown>;
}
type OrderGroupStatus = "open" | "in_progress" | "ready_to_pay" | "split" | "partially_paid" | "paid" | "closed";
type OrderGroupPaymentState = "not_paid" | "partially_paid" | "fully_paid" | "partially_refunded" | "refunded";
type OrderGroupPaymentStatus = "pending" | "processing" | "completed" | "failed" | "refunded" | "cancelled" | "requires_action" | "disputed";
interface OrderGroup {
    id: string;
    business_id: string;
    location_id: string;
    table_number: string;
    created_at: string;
    updated_at: string;
    status: OrderGroupStatus;
    is_split: boolean;
    is_closed: boolean;
    total_amount?: Money;
    paid_amount?: Money;
    payment_status: OrderGroupPaymentState;
    split_method?: string;
    max_orders?: number;
    currency?: CurrencyCode;
    amount_to_pay: AmountToPay;
    metadata?: Record<string, unknown>;
}
interface OrderGroupPayment {
    id: string;
    order_group_id: string;
    order_id?: string;
    amount: Money;
    payment_method: string;
    status: OrderGroupPaymentStatus;
    created_at: string;
    updated_at: string;
    metadata?: Record<string, unknown>;
}
interface OrderSplitDetail {
    order_id: string;
    amount: Money;
    paid_amount?: Money;
    remaining_amount?: Money;
}
interface OrderGroupPaymentSummary {
    total_amount: Money;
    paid_amount: Money;
    remaining_amount: Money;
    split_details?: OrderSplitDetail[];
}
interface OrderGroupDetails {
    order_group: OrderGroup;
    orders: Order[];
    total: Money;
    payments: OrderGroupPayment[];
    payment_summary: OrderGroupPaymentSummary;
}
interface OrderPaymentEvent {
    id: string;
    order_id: string;
    amount: Money;
    reference: string;
    created_at: string;
    event_type: string;
    provider?: string;
    metadata?: Record<string, unknown>;
}
interface OrderFilter {
    location_id?: string;
    table_number?: string;
    order_type?: string;
    status?: string;
    from?: string;
    to?: string;
    search?: string;
    limit?: number;
    offset?: number;
}
interface CheckoutInput {
    customer_name?: string;
    customer_email?: string;
    customer_phone?: string;
    delivery_address?: string;
    order_type?: string;
    notes?: string;
    table_number?: string;
    room_number?: string;
}
interface UpdateOrderStatusInput {
    status: OrderStatus;
    notes?: string;
}
interface CancelOrderInput {
    reason?: string;
}
interface RefundOrderInput {
    amount?: Money;
    reason?: string;
}
type ServiceStatus = "awaiting_scheduling" | "scheduled" | "deposit_paid" | "confirmed" | "in_progress" | "checked_in" | "checked_out" | "overstay" | "completed" | "rescheduled" | "no_show" | "cancelled";
type StaffRole = "primary" | "assistant" | "specialist" | "supervisor";
type ReminderMethod = "sms" | "email" | "push" | "call" | "whatsapp";
interface CustomerServicePreferences {
    preferred_staff_ids: string[];
    avoid_staff_ids: string[];
    room_type?: string;
    accessibility_needs: string[];
    temperature_preference?: string;
    music_preference?: string;
    special_requests?: string;
    previous_service_history: string[];
}
interface BufferTimes {
    before_minutes: number;
    after_minutes: number;
    travel_time_minutes?: number;
    setup_time_minutes?: number;
    cleanup_time_minutes?: number;
}
interface ReminderSettings {
    send_24h_reminder: boolean;
    send_2h_reminder: boolean;
    send_30min_reminder: boolean;
    reminder_phone?: string;
    reminder_email?: string;
    reminder_method: ReminderMethod;
    custom_reminder_message?: string;
}
interface CancellationPolicy {
    cancellation_window_minutes: number;
    no_show_deadline_minutes?: number;
    cancellation_notice_days?: number;
    no_show_fee: Money;
    partial_refund_percentage: number;
    max_free_reschedules: number;
    reschedule_fee: Money;
    early_termination_fee?: Money;
    pro_rata_refund: boolean;
}
interface ServiceNotes {
    preparation_notes?: string;
    staff_notes?: string;
    internal_notes?: string;
    customer_history: string[];
    allergies_warnings: string[];
}
interface PricingOverrides {
    custom_duration_minutes?: number;
    price_adjustment?: Money;
    discount_reason?: string;
    surge_pricing_multiplier?: Money;
    loyalty_discount?: Money;
    package_deal_reference?: string;
}
interface SchedulingMetadata {
    customer_preferences?: CustomerServicePreferences;
    buffer_times?: BufferTimes;
    reminder_settings?: ReminderSettings;
    cancellation_policy?: CancellationPolicy;
    service_notes?: ServiceNotes;
    pricing_overrides?: PricingOverrides;
}
interface StaffAssignment {
    staff_id: string;
    role: StaffRole;
    assigned_at: string;
    notes?: string;
}
interface ResourceAssignment {
    resource_id: string;
    quantity: number;
    assigned_at: string;
    notes?: string;
}
interface SchedulingResult {
    confirmation_code: string;
    assigned_staff: StaffAssignment[];
    assigned_resources: ResourceAssignment[];
    deposit_required: boolean;
    deposit_amount?: Money;
    total_duration_minutes: number;
}
interface DepositResult {
    order_confirmed: boolean;
    balance_due: Money;
    final_payment_due?: string;
    confirmation_sent: boolean;
}
interface ServiceScheduleRequest {
    line_item_id: string;
    start_time: string;
    end_time: string;
    preferred_staff_ids?: string[];
    resource_requirements?: string[];
    customer_notes?: string;
}
interface StaffScheduleItem {
    line_item_id: string;
    order_id: string;
    customer_name: string;
    service_name: string;
    start_time: string;
    end_time: string;
    confirmation_code: string;
    service_status: ServiceStatus;
    notes?: string;
}
interface LocationBooking {
    line_item_id: string;
    order_id: string;
    customer_name: string;
    service_name: string;
    start_time: string;
    end_time: string;
    assigned_staff: string[];
    assigned_resources: string[];
    service_status: ServiceStatus;
}
type ProviderResolutionSource = "zone" | "hint" | "fallback" | "best_price";
interface DeliveryFeeDetails {
    zone_id: string;
    zone_name: string;
    provider: string;
    provider_resolved_from: ProviderResolutionSource;
    /** Named rate this fee was priced under, if any. */
    rate_id?: string;
    rate_name?: string;
    distance_km: Money;
    base_fee: Money;
    per_km_fee: Money;
    surge_multiplier: Money;
    calculated_fee: Money;
    currency: string;
    free_delivery_applied?: boolean;
}
type RelationType = "upsell" | "cross_sell";
interface RelatedProduct {
    id: string;
    business_id: string;
    source_product_id: string;
    target_product_id: string;
    relation_type: RelationType;
    is_enabled: boolean;
    display_order: number;
    created_at: string;
    updated_at: string;
    metadata?: Record<string, unknown>;
}
interface RelatedCandidate {
    product_id: string;
    relation_type: RelationType;
    source: string;
    score: number;
    is_enabled: boolean;
    display_order: number;
}
interface RelatedProductsEnrichment {
    upsells: RelatedCandidate[];
    cross_sells: RelatedCandidate[];
}

declare const CHECKOUT_MODE: {
    readonly LINK: "link";
    readonly GUEST: "guest";
};
declare const ORDER_TYPE: {
    readonly DELIVERY: "delivery";
    readonly PICKUP: "pickup";
    readonly DINE_IN: "dine-in";
    readonly WALK_IN: "walk-in";
};
declare const PAYMENT_METHOD: {
    readonly MOBILE_MONEY: "mobile_money";
    readonly CARD: "card";
};
declare const CHECKOUT_STEP: {
    readonly AUTHENTICATION: "authentication";
    readonly ORDER_DETAILS: "order_details";
    readonly PAYMENT_METHOD: "payment_method";
    readonly PAYMENT: "payment";
    readonly CONFIRMATION: "confirmation";
};
declare const PAYMENT_STATE: {
    readonly INITIAL: "initial";
    readonly PREPARING: "preparing";
    readonly PROCESSING: "processing";
    readonly VERIFYING: "verifying";
    readonly AWAITING_AUTHORIZATION: "awaiting_authorization";
    readonly SUCCESS: "success";
    readonly ERROR: "error";
    readonly TIMEOUT: "timeout";
};
declare const PICKUP_TIME_TYPE: {
    readonly ASAP: "asap";
    readonly SCHEDULED: "scheduled";
};
declare const MOBILE_MONEY_PROVIDER: {
    readonly MTN: "mtn";
    readonly VODAFONE: "vodafone";
    readonly TELECEL: "telecel";
    readonly AIRTEL: "airtel";
    readonly AIRTELTIGO: "airteltigo";
    readonly MPESA: "mpesa";
};
declare const AUTHORIZATION_TYPE: {
    readonly OTP: "otp";
    readonly PIN: "pin";
    readonly PHONE: "phone";
    readonly BIRTHDAY: "birthday";
    readonly ADDRESS: "address";
};
declare const DEVICE_TYPE: {
    readonly MOBILE: "mobile";
    readonly DESKTOP: "desktop";
    readonly TABLET: "tablet";
    readonly UNKNOWN: "unknown";
};
declare const CONTACT_TYPE: {
    readonly PHONE: "phone";
    readonly EMAIL: "email";
};
declare const LINK_QUERY: {
    readonly DATA: "link.data";
    readonly ADDRESSES: "link.addresses";
    readonly MOBILE_MONEY: "link.mobile_money";
    readonly PREFERENCES: "link.preferences";
    readonly SESSIONS: "link.sessions";
};
declare const LINK_MUTATION: {
    readonly CHECK_STATUS: "link.check_status";
    readonly ENROLL: "link.enroll";
    readonly ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order";
    readonly UPDATE_PREFERENCES: "link.update_preferences";
    readonly CREATE_ADDRESS: "link.create_address";
    readonly UPDATE_ADDRESS: "link.update_address";
    readonly DELETE_ADDRESS: "link.delete_address";
    readonly SET_DEFAULT_ADDRESS: "link.set_default_address";
    readonly TRACK_ADDRESS_USAGE: "link.track_address_usage";
    readonly CREATE_MOBILE_MONEY: "link.create_mobile_money";
    readonly DELETE_MOBILE_MONEY: "link.delete_mobile_money";
    readonly SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money";
    readonly TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage";
    readonly VERIFY_MOBILE_MONEY: "link.verify_mobile_money";
    readonly REVOKE_SESSION: "link.revoke_session";
    readonly REVOKE_ALL_SESSIONS: "link.revoke_all_sessions";
};
declare const AUTH_MUTATION: {
    readonly REQUEST_OTP: "auth.request_otp";
    readonly VERIFY_OTP: "auth.verify_otp";
};
declare const CHECKOUT_MUTATION: {
    readonly PROCESS: "checkout.process";
};
declare const PAYMENT_MUTATION: {
    readonly SUBMIT_AUTHORIZATION: "payment.submit_authorization";
    readonly CHECK_STATUS: "order.poll_payment_status";
};
declare const ORDER_MUTATION: {
    readonly UPDATE_CUSTOMER: "order.update_order_customer";
};
declare const DEFAULT_CURRENCY = "GHS";
declare const DEFAULT_COUNTRY = "GHA";

type MobileMoneyProvider = (typeof MOBILE_MONEY_PROVIDER)[keyof typeof MOBILE_MONEY_PROVIDER];
interface Customer {
    id: string;
    email: string | null;
    phone: string | null;
    name: string;
    delivery_address: string | null;
    created_at: string;
    updated_at: string;
    metadata?: Record<string, unknown> | null;
    account_id?: string | null;
}
interface CustomerAddress {
    id: string;
    customer_id: string;
    label: string;
    street_address: string;
    apartment: string | null;
    city: string;
    region: string;
    postal_code: string | null;
    country: string | null;
    delivery_instructions: string | null;
    phone_for_delivery: string | null;
    latitude: number | null;
    longitude: number | null;
    is_default: boolean | null;
    usage_count: number | null;
    last_used_at: string | null;
    created_at: string;
    updated_at: string;
}
interface CustomerMobileMoney {
    id: string;
    customer_id: string;
    phone_number: string;
    provider: string;
    label: string;
    is_verified: boolean | null;
    verification_date: string | null;
    is_default: boolean | null;
    usage_count: number | null;
    last_used_at: string | null;
    success_rate: number | null;
    created_at: string;
    updated_at: string;
}
interface CustomerLinkPreferences {
    customer_id: string;
    is_link_enabled: boolean | null;
    enrolled_at: string | null;
    enrollment_business_id: string | null;
    preferred_order_type: string | null;
    default_address_id: string | null;
    default_mobile_money_id: string | null;
    remember_me: boolean | null;
    session_duration_days: number | null;
    two_factor_enabled: boolean | null;
    notify_on_order: boolean | null;
    notify_on_payment: boolean | null;
    created_at: string;
    updated_at: string;
}
interface LinkData {
    customer: Customer;
    addresses: CustomerAddress[];
    mobile_money: CustomerMobileMoney[];
    preferences: CustomerLinkPreferences;
    default_address: CustomerAddress | null;
    default_mobile_money: CustomerMobileMoney | null;
}
interface CreateAddressInput {
    label?: string;
    street_address: string;
    apartment?: string;
    city: string;
    region?: string;
    postal_code?: string;
    country?: string;
}
interface UpdateAddressInput {
    address_id: string;
    label?: string;
    street_address?: string;
    apartment?: string;
    city?: string;
    region?: string;
    postal_code?: string;
    country?: string;
}
interface CreateMobileMoneyInput {
    phone_number: string;
    provider: MobileMoneyProvider;
    label?: string;
}
interface EnrollmentData {
    contact: string;
    name?: string;
}
interface AddressData {
    label: string;
    street_address: string;
    apartment?: string;
    city: string;
    region: string;
    delivery_instructions?: string;
    phone_for_delivery?: string;
}
interface MobileMoneyData {
    phone_number: string;
    provider: string;
    label: string;
}
interface EnrollAndLinkOrderInput {
    order_id: string;
    business_id: string;
    address?: AddressData;
    mobile_money?: MobileMoneyData;
    order_type?: string;
}
interface LinkStatusResult {
    is_link_customer: boolean;
}
interface LinkEnrollResult {
    success: boolean;
    customer_id: string;
    contact?: string;
    enrolled_at?: string;
    preferences?: CustomerLinkPreferences;
}
interface EnrollAndLinkOrderResult {
    success: boolean;
    customer_id: string;
    order_id: string;
    enrollment_result: unknown;
    linked_at: string;
}
type DeviceType = (typeof DEVICE_TYPE)[keyof typeof DEVICE_TYPE];
interface LinkSession {
    id: string;
    device_name: string | null;
    device_type: DeviceType | null;
    ip_address: string | null;
    last_used_at: string | null;
    created_at: string;
    is_current: boolean;
}
interface RevokeSessionResult {
    success: boolean;
    session_id: string;
    message: string;
}
interface RevokeAllSessionsResult {
    success: boolean;
    revoked_count: number;
    message: string;
}
type ContactType = (typeof CONTACT_TYPE)[keyof typeof CONTACT_TYPE];
interface RequestOtpInput {
    contact: string;
    contact_type: ContactType;
}
interface VerifyOtpInput {
    contact: string;
    contact_type: ContactType;
    otp_code: string;
}
interface AuthResponse {
    success: boolean;
    session_token: string | null;
    refresh_token?: string | null;
    account_id?: string | null;
    customer_id: string | null;
    name?: string | null;
    email?: string | null;
    phone?: string | null;
    message: string;
}

type CheckoutMode = (typeof CHECKOUT_MODE)[keyof typeof CHECKOUT_MODE];
type CheckoutOrderType = (typeof ORDER_TYPE)[keyof typeof ORDER_TYPE];
type CheckoutPaymentMethod = (typeof PAYMENT_METHOD)[keyof typeof PAYMENT_METHOD];
type CheckoutStep = (typeof CHECKOUT_STEP)[keyof typeof CHECKOUT_STEP];
type PickupTimeType = (typeof PICKUP_TIME_TYPE)[keyof typeof PICKUP_TIME_TYPE];
interface PickupTime {
    type: PickupTimeType;
    scheduled_time?: string;
}
interface CheckoutAddressInfo {
    street_address?: string;
    apartment?: string;
    city?: string;
    region?: string;
    postal_code?: string;
    country?: string;
    delivery_instructions?: string;
    phone_for_delivery?: string;
    latitude?: number;
    longitude?: number;
    pickup_time?: string;
    guest_count?: number;
    seating_time?: string;
    seating_requests?: string;
}
interface MobileMoneyDetails {
    phone_number: string;
    provider: MobileMoneyProvider;
    provider_other?: string;
}
interface CheckoutCustomerInfo {
    name: string;
    email: string;
    phone: string;
    notes?: string;
    save_details: boolean;
}
interface CheckoutFormData {
    cart_id: string;
    location_id?: string;
    customer: CheckoutCustomerInfo;
    order_type: CheckoutOrderType;
    address_info: CheckoutAddressInfo;
    /** Named delivery rate the customer selected (from `delivery.getOptions`).
     * Selection only — the fee is always recomputed server-side. Omit for the
     * merchant's default option. */
    delivery_rate_id?: string;
    payment_method: string;
    mobile_money_details?: MobileMoneyDetails;
    special_instructions?: string;
    link_address_id?: string;
    link_payment_method_id?: string;
    idempotency_key?: string;
    metadata?: Record<string, unknown>;
    pay_currency?: CurrencyCode;
    fx_quote_id?: string;
    /** Apply the shopper's available store credit (capped at the amount owed) as a
     * fee-exempt tender before charging the rail. */
    use_store_credit?: boolean;
    /** Store-credit voucher / gift code to claim into the wallet and apply to this
     * order. Presenting a code implies applying store credit. */
    voucher_code?: string;
}
type NextAction = {
    type: "none";
} | {
    type: "card_popup";
    provider: string;
    client_secret: string;
    public_key: string;
} | {
    type: "redirect";
    authorization_url: string;
} | {
    type: "authorization";
    authorization_type: AuthorizationType;
    display_text?: string;
} | {
    type: "poll";
};
interface CheckoutResult {
    order_id: string;
    order_number: string;
    bill_token?: string;
    payment_reference?: string;
    payment_status: string;
    requires_authorization: boolean;
    authorization_type?: AuthorizationType;
    authorization_url?: string;
    display_text?: string;
    provider?: string;
    client_secret?: string;
    public_key?: string;
    next_action?: NextAction;
    fx?: {
        base_currency: CurrencyCode;
        base_amount: Money;
        pay_currency: CurrencyCode;
        pay_amount: Money;
        rate: number;
        quote_id: string;
    };
}
type CheckoutStatus = "preparing" | "recovering" | "processing" | "awaiting_authorization" | "polling" | "finalizing" | "success" | "failed";
interface CheckoutStatusContext {
    display_text?: string;
    authorization_type?: "otp" | "pin" | "phone" | "birthday" | "address";
    poll_attempt?: number;
    max_poll_attempts?: number;
    order_id?: string;
    order_number?: string;
    provider?: string;
}
interface ProcessCheckoutOptions {
    cart_id: string;
    order_type: "delivery" | "pickup" | "dine_in";
    location_id?: string;
    notes?: string;
    scheduled_time?: string;
    tip_amount?: number;
    enroll_in_link?: boolean;
    pay_currency?: CurrencyCode;
    timeout_ms?: number;
    on_status_change?: (status: CheckoutStatus, context: CheckoutStatusContext) => void;
}
interface ProcessCheckoutResult {
    success: boolean;
    order?: {
        id: string;
        order_number: string;
        status: string;
        total: string;
        currency: CurrencyCode;
    };
    error?: {
        code: string;
        message: string;
        recoverable: boolean;
        docs_url?: string;
        suggestion?: string;
    };
    enrolled_in_link?: boolean;
}
interface ProcessAndResolveOptions {
    enroll_in_link?: boolean;
    allow_popups?: boolean;
    poll_interval_ms?: number;
    max_poll_attempts?: number;
    on_status_change?: (status: CheckoutStatus, context: CheckoutStatusContext) => void;
    on_authorization_required?: (type: "otp" | "pin" | "phone" | "birthday" | "address", submit: (code: string) => Promise<void>) => void | Promise<void>;
    return_url?: string;
    signal?: AbortSignal;
}
type AbortablePromise<T> = Promise<T> & {
    abort: () => void;
};

declare class CheckoutService {
    private client;
    constructor(client: CimplifyClient);
    private orderTokenParam;
    process(data: CheckoutFormData): Promise<Result<CheckoutResult, CimplifyError>>;
    initializePayment(_orderId: string, _method: PaymentMethod): Promise<Result<InitializePaymentResult, CimplifyError>>;
    submitAuthorization(input: SubmitAuthorizationInput): Promise<Result<CheckoutResult, CimplifyError>>;
    pollPaymentStatus(orderId: string): Promise<Result<PaymentStatusResponse, CimplifyError>>;
    updateOrderCustomer(orderId: string, customer: CheckoutCustomerInfo): Promise<Result<Order, CimplifyError>>;
    verifyPayment(orderId: string): Promise<Result<Order, CimplifyError>>;
    processAndResolve(data: CheckoutFormData & ProcessAndResolveOptions): Promise<Result<ProcessCheckoutResult, CimplifyError>>;
}

interface BusinessDetailsDTO {
    name: string;
    logo_url?: string;
    contact_email?: string;
    contact_phone?: string;
}
interface OrderCustomerInfo {
    id?: string;
    name?: string;
    email?: string;
    phone?: string;
    notes?: string[];
    delivery_address?: string;
    delivery_required: boolean;
    will_pick_up: boolean;
    pickup_time?: string;
}
interface OrderLocationInfo {
    id?: string;
    name?: string;
    table_number?: string;
    room_number?: string;
}
interface PaymentInfoDTO {
    state: PaymentState;
    computed_status?: string;
    currency: string;
    amount_to_pay: AmountToPay;
    paid_via_group: boolean;
}
interface FulfillmentSummaryDTO {
    fulfillment_type: FulfillmentType;
    fulfillment_id: string;
    status?: string;
    digital_type?: string;
    delivery_method?: string;
    delivered_at?: string;
    usage_summary?: string;
    identifier?: string;
}
interface EnrichedOrderItem {
    id: string;
    product_id: string;
    product_name?: string;
    product_description?: string;
    image_url?: string;
    line_key: string;
    quantity: number;
    line_type: LineType;
    variant_id?: string;
    variant_details?: VariantDetails;
    variant_info?: VariantDetailsDTO;
    add_on_option_ids: string[];
    add_on_ids: string[];
    add_on_details: AddOnDetails;
    add_on_options: AddOnOptionDetails[];
    add_ons: AddOnGroupDetails[];
    bundle_selections?: BundleSelectionData;
    composite_selections?: CompositeSelectionData;
    fulfillment?: FulfillmentSummaryDTO;
    customer_inputs: CustomerInputValue[];
    scheduled_start?: string;
    scheduled_end?: string;
    confirmation_code?: string;
    primary_staff_id?: string;
    base_price: Money;
    add_ons_price: Money;
    total_price: Money;
    item_discount_amount: Money;
    price_info: ChosenPrice;
    discount_details: DiscountDetails;
    line_state: OrderLineStatus;
    created_at: string;
    updated_at: string;
    metadata?: Record<string, unknown>;
}
interface OrderPricingView {
    total_price: Money;
    subtotal: Money;
    total_discount: Money;
    service_charge?: Money;
    tax?: Money;
    price_info: ChosenPrice;
}
interface OrderTimestampsDTO {
    created_at: string;
    updated_at: string;
    confirmed_at?: string;
    fulfilled_at?: string;
    delivered_at?: string;
    served_at?: string;
    completed_at?: string;
    cancelled_at?: string;
}
interface OrderStaffInfo {
    placed_by?: string;
    was_placed_by_staff: boolean;
    modified_by_staff: boolean;
    served_by?: string;
}
interface OrderDiscountInfo {
    discount_code?: string;
    applied_discount_ids: string[];
    applied_discount_codes: string[];
    discount_details: DiscountDetails;
}
interface GroupOrderInfo {
    group_order_id: string;
    is_closed: boolean;
}
/**
 * The order shape the storefront order endpoint (`/api/v1/orders/:id`) returns:
 * names, images, resolved variants/add-ons, bundle/composite selections,
 * customer inputs, scheduling and digital fulfillment all resolved server-side.
 */
interface EnrichedOrder {
    id: string;
    user_friendly_id: string;
    business_id: string;
    order_type: string;
    channel: OrderChannel;
    status: OrderStatus;
    bill_token?: string;
    tracking_token?: string;
    tracking_link?: string;
    business_details?: BusinessDetailsDTO;
    customer: OrderCustomerInfo;
    location: OrderLocationInfo;
    payment: PaymentInfoDTO;
    items: EnrichedOrderItem[];
    pricing: OrderPricingView;
    timestamps: OrderTimestampsDTO;
    staff: OrderStaffInfo;
    discounts: OrderDiscountInfo;
    group_order_info?: GroupOrderInfo;
    metadata?: Record<string, unknown>;
}

interface IdempotencyOption$7 {
    idempotencyKey?: string;
}
interface GetOrdersOptions {
    status?: OrderStatus;
    limit?: number;
    offset?: number;
}
declare class OrderQueries {
    private client;
    constructor(client: CimplifyClient);
    private orderTokenParam;
    list(options?: GetOrdersOptions): Promise<Result<Order[], CimplifyError>>;
    get(orderId: string): Promise<Result<Order, CimplifyError>>;
    /**
     * Same endpoint as `get`, typed as the enriched display contract
     * (product names, images, resolved selections, customer inputs, scheduling,
     * fulfillment). Feed the result through `toAccountOrderView`.
     */
    getDetail(orderId: string): Promise<Result<EnrichedOrder, CimplifyError>>;
    getRecent(limit?: number): Promise<Result<Order[], CimplifyError>>;
    getByStatus(status: OrderStatus): Promise<Result<Order[], CimplifyError>>;
    cancel(orderId: string, reason?: string, opts?: IdempotencyOption$7): Promise<Result<Order, CimplifyError>>;
}

interface StoreCreditBalance {
    /** Available balance (a Money string — use `parsePrice` before arithmetic). */
    balance: Money;
    currency: CurrencyCode;
}
/** Reads the signed-in shopper's store-credit balance for the current storefront. */
declare class StoreCreditQueries {
    private client;
    constructor(client: CimplifyClient);
    /**
     * The shopper's available store-credit balance, in the business's default
     * currency. Requires a signed-in customer; returns an error otherwise.
     */
    balance(): Promise<Result<StoreCreditBalance, CimplifyError>>;
}

interface GetLinkOrdersOptions {
    status?: OrderStatus;
    limit?: number;
    offset?: number;
    /**
     * Per-merchant scope. When set, only orders placed with this business
     * are returned. Pass it from SDK-rendered account pages on a merchant
     * storefront; omit for the cross-merchant view on link.cimplify.io.
     */
    businessId?: string;
}
interface GetLinkOrderOptions {
    /**
     * Per-merchant scope. When set, the order must belong to this business
     * or the request 404s. Used by merchant account pages to prevent
     * cross-merchant enumeration.
     */
    businessId?: string;
}
interface IdempotencyOption$6 {
    idempotencyKey?: string;
}
interface SuccessResult {
    success: boolean;
    message?: string;
    action?: string;
    expires_in?: number;
    is_new_account?: boolean;
}
/**
 * Cimplify Link client.
 *
 * Customer-scoped, cross-business surface — saved addresses, saved mobile
 * money, link preferences, sessions. Routed through the SDK's separate
 * `linkApiUrl` transport (default: `https://api.cimplify.io`), not the
 * per-business storefront API.
 *
 * Wire conventions:
 * - Updates use `POST /resource/:id` with a partial body (not PUT/PATCH).
 *   Both create and update share the same verb; payload completeness
 *   distinguishes them. This matches the production Rust handlers.
 * - Mobile-money `provider` is a plain string. User-facing provider
 *   values include `"mtn"`, `"vodafone"`, `"telecel"`, `"airtel"`,
 *   `"airteltigo"`, and `"mpesa"` (defined in {@link MobileMoneyProvider}).
 *   The backend's `normalize_mobile_money_provider` accepts legacy
 *   spellings and maps them to provider-specific processor codes.
 * - Address inputs use the wire shape (`street_address` / `apartment` /
 *   `region`) — same field names you read off the response. There is no
 *   translation layer.
 */
declare class LinkService {
    private client;
    constructor(client: CimplifyClient);
    requestOtp(input: RequestOtpInput, opts?: IdempotencyOption$6): Promise<Result<SuccessResult, CimplifyError>>;
    verifyOtp(input: VerifyOtpInput, opts?: IdempotencyOption$6): Promise<Result<AuthResponse, CimplifyError>>;
    refreshSession(sessionToken?: string, opts?: IdempotencyOption$6): Promise<Result<AuthResponse, CimplifyError>>;
    logout(): Promise<Result<SuccessResult, CimplifyError>>;
    checkStatus(contact: string): Promise<Result<LinkStatusResult, CimplifyError>>;
    getLinkData(): Promise<Result<LinkData, CimplifyError>>;
    getAddresses(): Promise<Result<CustomerAddress[], CimplifyError>>;
    getMobileMoney(): Promise<Result<CustomerMobileMoney[], CimplifyError>>;
    getPreferences(): Promise<Result<CustomerLinkPreferences, CimplifyError>>;
    updateProfile(input: {
        name?: string;
        email?: string;
        phone?: string;
    }): Promise<Result<Customer, CimplifyError>>;
    getOrders(options?: GetLinkOrdersOptions): Promise<Result<Order[], CimplifyError>>;
    getOrder(orderId: string, options?: GetLinkOrderOptions): Promise<Result<Order, CimplifyError>>;
    enroll(data: EnrollmentData, opts?: IdempotencyOption$6): Promise<Result<LinkEnrollResult, CimplifyError>>;
    enrollAndLinkOrder(data: EnrollAndLinkOrderInput, opts?: IdempotencyOption$6): Promise<Result<EnrollAndLinkOrderResult, CimplifyError>>;
    updatePreferences(preferences: Partial<CustomerLinkPreferences>): Promise<Result<SuccessResult, CimplifyError>>;
    createAddress(input: CreateAddressInput, opts?: IdempotencyOption$6): 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>>;
    createMobileMoney(input: CreateMobileMoneyInput, opts?: IdempotencyOption$6): 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, opts?: IdempotencyOption$6): Promise<Result<SuccessResult, CimplifyError>>;
    getSessions(): Promise<Result<LinkSession[], CimplifyError>>;
    revokeSession(sessionId: string): Promise<Result<RevokeSessionResult, CimplifyError>>;
    revokeAllSessions(): Promise<Result<RevokeAllSessionsResult, CimplifyError>>;
}

interface IdempotencyOption$5 {
    idempotencyKey?: string;
}
interface AuthStatus {
    is_authenticated: boolean;
    customer?: Customer;
    session_expires_at?: string;
}
interface OtpResult {
    message: string;
    account_id: string;
    customer: Customer;
    session_token: string;
    refresh_token: string;
}
interface RequestOtpResult {
    message: string;
    expires_in: number;
    is_new_account: boolean;
}
interface UpdateProfileInput {
    name?: string;
    email?: string;
    phone?: string;
}
interface LogoutResult {
    message: string;
    action: "discard_token" | string;
}
interface UpdateProfileResult {
    success: boolean;
    message: string;
}
declare class AuthService {
    private client;
    constructor(client: CimplifyClient);
    getStatus(): Promise<Result<AuthStatus, CimplifyError>>;
    getCurrentUser(): Promise<Result<Customer | null, CimplifyError>>;
    isAuthenticated(): Promise<Result<boolean, CimplifyError>>;
    requestOtp(contact: string, contactType?: "phone" | "email", opts?: IdempotencyOption$5): Promise<Result<RequestOtpResult, CimplifyError>>;
    verifyOtp(code: string, contact?: string, opts?: IdempotencyOption$5): Promise<Result<OtpResult, CimplifyError>>;
    logout(): Promise<Result<LogoutResult, CimplifyError>>;
    updateProfile(input: UpdateProfileInput): Promise<Result<UpdateProfileResult, CimplifyError>>;
}

type BusinessType = "eatery" | "retail" | "service" | "other" | "system" | "unset";
interface BusinessPreferences {
    [key: string]: unknown;
}
interface Business {
    id: string;
    name: string;
    handle: string;
    business_type: BusinessType;
    email: string;
    default_currency: CurrencyCode;
    default_phone?: string;
    default_address?: string;
    default_offers_table_service: boolean;
    default_accepts_online_orders: boolean;
    image?: string;
    status: string;
    created_at: string;
    updated_at: string;
    subscription_id?: string;
    owner_id?: string;
    created_by: string;
    preferences: BusinessPreferences;
    is_online_only: boolean;
    enabled_payment_types: string[];
    default_location_settings: Record<string, unknown>;
    country_code?: string;
    timezone?: string;
    metadata?: Record<string, unknown>;
}
interface LocationTaxBehavior {
    is_tax_inclusive: boolean;
    tax_rate: Money;
}
interface LocationTaxOverrides {
    [productId: string]: {
        tax_rate: Money;
        is_exempt: boolean;
    };
}
interface Location {
    id: string;
    business_id: string;
    name: string;
    location?: string;
    phone?: string;
    address?: string;
    service_charge_rate?: number;
    currency: CurrencyCode;
    capacity: number;
    status: string;
    enabled_payment_types?: string[];
    offers_table_service: boolean;
    accepts_online_orders: boolean;
    created_at: string;
    updated_at: string;
    preferences?: Record<string, unknown>;
    metadata?: Record<string, unknown>;
    country_code: string;
    timezone: string;
    tax_behavior?: LocationTaxBehavior;
    tax_overrides?: LocationTaxOverrides;
}
interface TimeRange {
    start: string;
    end: string;
}
type TimeRanges = TimeRange[];
interface LocationTimeProfile {
    id: string;
    business_id: string;
    location_id: string;
    day: string;
    is_open: boolean;
    hours: TimeRanges;
    created_at: string;
    updated_at: string;
    metadata?: Record<string, unknown>;
}
interface Table {
    id: string;
    business_id: string;
    location_id: string;
    table_number: string;
    capacity: number;
    occupied: boolean;
    created_at: string;
    updated_at: string;
    metadata?: Record<string, unknown>;
}
interface Room {
    id: string;
    business_id: string;
    location_id: string;
    name: string;
    capacity: number;
    status: string;
    floor?: string;
    created_at: string;
    updated_at: string;
    metadata?: Record<string, unknown>;
}
interface ServiceCharge {
    percentage?: Money;
    is_mandatory?: boolean;
    description?: string;
    applies_to_parties_of?: number;
    minimum_amount?: Money;
    maximum_amount?: Money;
}
interface StorefrontBootstrap {
    business: Business;
    locations: Location[];
    default_location_id?: string;
    categories: CategoryInfo[];
}
interface BusinessWithLocations extends Business {
    locations: Location[];
    default_location?: Location;
}
interface LocationWithDetails extends Location {
    time_profiles: LocationTimeProfile[];
    tables: Table[];
    rooms: Room[];
    is_open_now: boolean;
    next_open_time?: string;
}
interface BusinessSettings {
    accept_online_orders: boolean;
    accept_reservations: boolean;
    require_customer_account: boolean;
    enable_tips: boolean;
    enable_loyalty: boolean;
    minimum_order_amount?: string;
    delivery_fee?: string;
    free_delivery_threshold?: string;
    tax_rate?: number;
    tax_inclusive: boolean;
}
interface BusinessHours {
    business_id: string;
    location_id?: string;
    day_of_week: number;
    open_time: string;
    close_time: string;
    is_closed: boolean;
}
interface CategoryInfo {
    id: string;
    name: string;
    slug: string;
}

declare class BusinessService {
    private client;
    constructor(client: CimplifyClient);
    getInfo(opts?: ReadRequestOptions): Promise<Result<Business, CimplifyError>>;
    getByHandle(handle: string, opts?: ReadRequestOptions): Promise<Result<Business, CimplifyError>>;
    getByDomain(domain: string, opts?: ReadRequestOptions): Promise<Result<Business, CimplifyError>>;
    getSettings(opts?: ReadRequestOptions): Promise<Result<BusinessSettings, CimplifyError>>;
    getLocations(opts?: ReadRequestOptions): Promise<Result<Location[], CimplifyError>>;
    getLocation(locationId: string, opts?: ReadRequestOptions): Promise<Result<Location, CimplifyError>>;
    getHours(opts?: ReadRequestOptions): Promise<Result<BusinessHours[], CimplifyError>>;
    getLocationHours(locationId: string, opts?: ReadRequestOptions): Promise<Result<BusinessHours[], CimplifyError>>;
    getBootstrap(opts?: ReadRequestOptions): Promise<Result<StorefrontBootstrap, CimplifyError>>;
}

type StockStatus = "in_stock" | "low_stock" | "out_of_stock";
interface StockLevel {
    product_id: string;
    variant_id?: string;
    location_id?: string;
    /** Absent when the backend cannot compute a real count for this product/location. */
    available_quantity?: number;
    status: StockStatus;
    last_updated: string;
}
interface AvailabilityResult {
    product_id: string;
    variant_id?: string;
    is_available: boolean;
    available_quantity: number;
    requested_quantity: number;
    shortfall?: number;
}

declare class InventoryService {
    private client;
    constructor(client: CimplifyClient);
    private withQuery;
    getProductStock(productId: string, locationId?: string): Promise<Result<StockLevel, 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<Result<AvailabilityResult[], CimplifyError>>;
    isInStock(productId: string, locationId?: string): Promise<Result<boolean, CimplifyError>>;
    getAvailableQuantity(productId: string, locationId?: string): Promise<Result<number | undefined, CimplifyError>>;
}

interface Service {
    id: string;
    name: string;
    description?: string;
    price?: Money;
    scheduling_mode?: SchedulingMode;
    duration_value?: number;
    duration_minutes: number;
    duration_unit?: DurationUnit;
    image_url?: string | null;
    category_id?: string | null;
    is_available: boolean;
    business_id?: string;
    product_id?: string;
    buffer_before_minutes?: number;
    buffer_after_minutes?: number;
    max_participants?: number;
    currency?: string;
    requires_staff?: boolean;
    is_active?: boolean;
    metadata?: Record<string, unknown>;
}
interface Staff {
    id: string;
    business_id?: string;
    name: string;
    email?: string;
    phone?: string;
    avatar_url?: string;
    bio?: string;
    is_active?: boolean;
    services?: string[];
}
interface TimeSlot {
    start_time: string;
    end_time: string;
    is_available?: boolean;
    staff_id?: string;
    staff_name?: string;
    remaining_capacity?: number;
}
interface SlotResourceInfo {
    resource_id: string;
    name: string;
    resource_type: string;
}
interface SlotStaffInfo {
    staff_id: string;
    name: string;
}
interface AvailableSlot extends TimeSlot {
    price?: Money;
    duration_minutes?: number;
    available_staff?: SlotStaffInfo[];
    available_resources?: SlotResourceInfo[];
    capacity_available?: number;
}
interface DayAvailability {
    date: string;
    slots: TimeSlot[];
    has_availability: boolean;
}
type BookingStatus = "booked" | "assigned" | "pending" | "confirmed" | "in_progress" | "checked_in" | "checked_out" | "overstay" | "completed" | "cancelled" | "no_show" | string;
interface Booking {
    id: string;
    service_name: string;
    start_time: string;
    end_time: string;
    status: BookingStatus;
    confirmation_code?: string;
    total_amount?: Money;
    participant_count: number;
    staff_name?: string | null;
    notes?: unknown;
    business_id?: string;
    order_id?: string;
    line_item_id?: string;
    service_id?: string;
    customer_id?: string;
    customer_name?: string;
    customer_phone?: string;
    staff_id?: string;
    location_id?: string;
    location_name?: string;
    duration_minutes?: number;
    cancellation_reason?: string;
    cancelled_at?: string;
    created_at?: string;
    updated_at?: string;
}
interface BookingWithDetails extends Booking {
    service?: Service;
    staff?: Staff;
}
interface CustomerBookingServiceItem {
    service_id: string;
    scheduled_start?: string | null;
    scheduled_end?: string | null;
    confirmation_code?: string | null;
    status?: string | null;
}
interface CustomerBooking {
    order_id: string;
    service_items: CustomerBookingServiceItem[];
    status: BookingStatus;
    created_at: string;
    total_price: Money;
}
interface GetAvailableSlotsInput {
    service_id: string;
    date: string;
    participant_count?: number;
    variant_id?: string;
}
interface CheckSlotAvailabilityInput {
    service_id: string;
    slot_time: string;
    duration_minutes?: number;
    participant_count?: number;
}
interface CheckSlotAvailabilityResult {
    available: boolean;
    reason?: string;
    service_id?: string;
    start_time?: string;
    duration_minutes?: number;
    participant_count?: number;
}
interface RescheduleBookingInput {
    order_id: string;
    line_item_id: string;
    new_start_time: string;
    new_end_time: string;
    new_staff_id?: string;
    reason?: string;
    reschedule_type?: "customer" | "business" | "system";
}
interface CancelBookingInput {
    booking_id: string;
    reason?: string;
}
interface CancelBookingResult {
    message: string;
}
type BookingModificationType = "reschedule" | "extend" | "shorten" | "early_checkout";
interface RescheduleBookingResult {
    success: boolean;
    booking_id: string;
    old_time: {
        start: string;
        end: string;
    };
    new_time: {
        start: string;
        end: string;
    };
    staff_changed: boolean;
    old_staff_id?: string | null;
    new_staff_id?: string | null;
    fee_charged?: string;
}
interface ServiceAvailabilityParams {
    service_id: string;
    start_date: string;
    end_date: string;
    location_id?: string;
    participant_count?: number;
    variant_id?: string;
}
interface ServiceAvailabilityResult {
    service_id: string;
    location_id: string;
    scheduling_mode: SchedulingMode;
    duration_unit: string;
    duration_value: number;
    start_date: string;
    end_date: string;
    participant_count: number;
    availability: DayAvailability[];
}
interface RescheduleHistoryRecord {
    id: string;
    booking_id: string;
    order_id: string;
    order_item_id?: string | null;
    old_start_time: string;
    old_end_time: string;
    new_start_time: string;
    new_end_time: string;
    old_staff_id?: string | null;
    new_staff_id?: string | null;
    reason?: string | null;
    rescheduled_by: string;
    rescheduled_at: string;
    modification_type: BookingModificationType;
    reschedule_type: "customer" | "business" | "system";
    fee_applied: string | number;
    metadata?: Record<string, unknown> | null;
}

interface IdempotencyOption$4 {
    idempotencyKey?: string;
}
declare class SchedulingService {
    private client;
    constructor(client: CimplifyClient);
    getServices(): Promise<Result<Service[], CimplifyError>>;
    getService(serviceId: string): Promise<Result<Service | null, CimplifyError>>;
    getAvailableSlots(input: GetAvailableSlotsInput): Promise<Result<AvailableSlot[], CimplifyError>>;
    checkSlotAvailability(input: CheckSlotAvailabilityInput): Promise<Result<CheckSlotAvailabilityResult, CimplifyError>>;
    getServiceAvailability(params: ServiceAvailabilityParams): Promise<Result<ServiceAvailabilityResult, CimplifyError>>;
    getBooking(bookingId: string): Promise<Result<BookingWithDetails, CimplifyError>>;
    getCustomerBookings(customerId?: string): Promise<Result<CustomerBooking[], CimplifyError>>;
    getUpcomingBookings(): Promise<Result<CustomerBooking[], CimplifyError>>;
    getPastBookings(limit?: number): Promise<Result<CustomerBooking[], CimplifyError>>;
    cancelBooking(input: CancelBookingInput, opts?: IdempotencyOption$4): Promise<Result<CancelBookingResult, CimplifyError>>;
    rescheduleBooking(input: RescheduleBookingInput, opts?: IdempotencyOption$4): Promise<Result<RescheduleBookingResult, CimplifyError>>;
    getNextAvailableSlot(serviceId: string, fromDate?: string): Promise<Result<AvailableSlot | null, CimplifyError>>;
    hasAvailabilityOn(serviceId: string, date: string): Promise<Result<boolean, CimplifyError>>;
}

interface LiteBootstrapBusiness {
    id: string;
    name: string;
    handle: string;
    logo?: string | null;
    currency?: string | null;
    is_open: boolean;
}
interface LiteBootstrapCategory {
    id: string;
    name: string;
    slug?: string | null;
}
interface LiteBootstrapLocation {
    id: string;
}
interface LiteBootstrap {
    business: LiteBootstrapBusiness;
    categories: LiteBootstrapCategory[];
    location?: LiteBootstrapLocation | null;
}
interface LiteTable {
    id: string;
    name: string;
    location_id?: string | null;
}
interface LiteTableResponse {
    table: LiteTable;
    tab: Record<string, unknown> | null;
}
type TableInfo = LiteTableResponse;
declare class LiteService {
    private client;
    constructor(client: CimplifyClient);
    getBootstrap(): Promise<Result<LiteBootstrap, CimplifyError>>;
    getTable(tableId: string): Promise<Result<LiteTableResponse, CimplifyError>>;
    getMenu(): Promise<Result<Product[], CimplifyError>>;
    getMenuByCategory(categoryId: string): Promise<Result<Product[], CimplifyError>>;
}

interface FxQuoteRequest {
    from: CurrencyCode;
    to: CurrencyCode;
    amount: Money;
}
interface FxQuote {
    id: string;
    base_currency: CurrencyCode;
    pay_currency: CurrencyCode;
    rate: number;
    inverse_rate: number;
    base_amount: Money;
    converted_amount: Money;
    quoted_at: string;
    valid_until: string;
}
interface FxRateResponse {
    from: CurrencyCode;
    to: CurrencyCode;
    rate: number;
    inverse_rate: number;
    quoted_at: string;
    valid_until: string;
}

interface IdempotencyOption$3 {
    idempotencyKey?: string;
}
declare class FxService {
    private client;
    constructor(client: CimplifyClient);
    getRate(from: CurrencyCode, to: CurrencyCode): Promise<Result<FxRateResponse, CimplifyError>>;
    lockQuote(request: FxQuoteRequest, opts?: IdempotencyOption$3): Promise<Result<FxQuote, CimplifyError>>;
}

interface TrackProductViewOptions {
    productName?: string;
    categoryId?: string;
    price?: string;
    pagePath?: string;
}
interface TrackCategoryViewOptions {
    categoryName?: string;
    pagePath?: string;
}
interface SessionMessage {
    code: string;
    level: "info" | "promotion" | "urgency" | "suggestion" | string;
    text: string;
    metadata?: Record<string, unknown>;
    dismissible: boolean;
}
interface SessionActivityData {
    viewed_products: Array<{
        product_id: string;
        product_name?: string;
        category_id?: string;
        price?: string;
        view_count: number;
        first_viewed_at: string;
        last_viewed_at: string;
    }>;
    viewed_categories: Array<{
        category_id: string;
        category_name?: string;
        view_count: number;
        last_viewed_at: string;
    }>;
    total_product_views: number;
    unique_products_viewed: number;
    total_searches: number;
    total_cart_adds: number;
    total_cart_removes: number;
}
interface ActivityStateResponse {
    activity: SessionActivityData | null;
    intent: string;
    messages: SessionMessage[];
    incentive: {
        template_id: string;
        agent_id: string;
    } | null;
}
interface ActivityRecommendation {
    product: Product;
    reason: string;
}
interface ActivityRecommendationsResponse {
    recommendations: ActivityRecommendation[];
    intent: string;
    incentive: {
        template_id: string;
        agent_id: string;
    } | null;
}
interface DismissMessageResponse {
    dismissed: string;
    messages: SessionMessage[];
}
declare class ActivityService {
    private client;
    constructor(client: CimplifyClient);
    /**
     * Record session start (landing, referrer, UTM, device). Fire-and-forget,
     * at most once per tab session; called automatically by the track* methods.
     */
    startSession(): void;
    private buildSessionPayload;
    trackProductView(productId: string, options?: TrackProductViewOptions): void;
    trackCategoryView(categoryId: string, options?: TrackCategoryViewOptions): void;
    getState(): Promise<Result<ActivityStateResponse, CimplifyError>>;
    getRecommendations(options?: {
        location_id?: string;
        limit?: number;
    }): Promise<Result<ActivityRecommendationsResponse, CimplifyError>>;
    dismissMessage(code: string): Promise<Result<DismissMessageResponse, CimplifyError>>;
    private sendEvents;
}

interface IdempotencyOption$2 {
    idempotencyKey?: string;
}
declare class SubscriptionService {
    private client;
    constructor(client: CimplifyClient);
    list(): Promise<Result<Subscription[], CimplifyError>>;
    get(id: string): Promise<Result<SubscriptionWithDetails, CimplifyError>>;
    cancel(id: string, reason?: string, opts?: IdempotencyOption$2): Promise<Result<{
        success: boolean;
    }, CimplifyError>>;
    pause(id: string): Promise<Result<{
        success: boolean;
    }, CimplifyError>>;
    resume(id: string): Promise<Result<{
        success: boolean;
    }, CimplifyError>>;
    skipNextRenewal(id: string, opts?: IdempotencyOption$2): Promise<Result<{
        success: boolean;
    }, CimplifyError>>;
}

interface IdempotencyOption$1 {
    idempotencyKey?: string;
}
interface UploadInitResponse {
    upload_id: string;
    upload_url: string;
    expires_in_secs: number;
}
interface UploadResult {
    id: string;
    url: string;
    filename: string;
    content_type: string;
    size_bytes: number;
}
declare class UploadService {
    private client;
    constructor(client: CimplifyClient);
    init(filename: string, contentType: string, sizeBytes: number, opts?: IdempotencyOption$1): Promise<Result<UploadInitResponse, CimplifyError>>;
    confirm(uploadId: string): Promise<Result<UploadResult, CimplifyError>>;
    upload(file: File): Promise<Result<UploadResult, CimplifyError>>;
}

interface AutocompletePrediction {
    description: string;
    place_id: string;
}
interface AutocompleteResponse {
    predictions: AutocompletePrediction[];
}
interface PlaceDetailsResponse {
    formatted_address: string;
    street_address?: string;
    apartment?: string;
    city?: string;
    region?: string;
    postal_code?: string;
    country?: string;
    latitude: number;
    longitude: number;
    place_id: string;
}
declare class PlacesService {
    private client;
    constructor(client: CimplifyClient);
    autocomplete(input: string, sessionToken?: string): Promise<Result<AutocompleteResponse, CimplifyError>>;
    details(placeId: string, sessionToken?: string): Promise<Result<PlaceDetailsResponse, CimplifyError>>;
}

interface DeliveryFeeResponse {
    serviceable: boolean;
    fee: Money | null;
    currency: string | null;
    details: DeliveryFeeDetails | null;
}
/** One entry on the delivery menu for a dropoff — a merchant-named rate
 * ("Standard", "Express", "Outside Accra") priced for that address, or the
 * synthesized default when the business has no named rates (`rate_id: null`). */
interface DeliveryOption {
    rate_id: string | null;
    name: string;
    description?: string;
    fee: Money;
    currency: string;
    free_delivery_applied: boolean;
    /** Order value at/above this makes the option free — render "Free over X". */
    free_over_amount?: Money;
    eta_min_minutes?: number;
    eta_max_minutes?: number;
    /** The option charged when the shopper makes no explicit selection. */
    is_default: boolean;
    details: DeliveryFeeDetails;
}
interface DeliveryOptionsResponse {
    serviceable: boolean;
    options: DeliveryOption[];
    message?: string;
}
interface GetDeliveryOptionsParams {
    country?: string;
    /** Cart goods total — drives free-over thresholds and zone minimums. */
    orderValue?: Money;
}
declare class DeliveryService {
    private client;
    constructor(client: CimplifyClient);
    getFee(dropoffLat: number, dropoffLng: number, country?: string): Promise<Result<DeliveryFeeResponse, CimplifyError>>;
    /** The full delivery menu for an address. Pass the selected option's
     * `rate_id` as `delivery_rate_id` when processing checkout. */
    getOptions(dropoffLat: number, dropoffLng: number, opts?: GetDeliveryOptionsParams): Promise<Result<DeliveryOptionsResponse, CimplifyError>>;
}

type SenderType = "customer" | "agent" | "system" | "bot";
type ContentType = "text" | "image" | "video" | "audio" | "document" | "interactive";
interface ChatMessage {
    id: string;
    sender_type: SenderType;
    content: string;
    content_type: ContentType;
    attachments: ChatAttachment[];
    metadata: Record<string, unknown>;
    created_at: string;
}
interface ChatAttachment {
    url: string;
    mime_type: string | null;
    filename: string | null;
}
interface ChatConversation {
    id: string;
    status: "open" | "assigned" | "waiting" | "resolved" | "closed";
    ai_enabled: boolean;
    message_count: number;
    created_at: string;
    last_message_at: string | null;
}
interface ChatConversationResponse {
    conversation: ChatConversation;
    messages: ChatMessage[];
}
interface ChatWidgetStarter {
    icon?: string;
    text: string;
}

interface IdempotencyOption {
    idempotencyKey?: string;
}
declare class SupportService {
    private client;
    constructor(client: CimplifyClient);
    /** Open (or resume) the customer's widget conversation. */
    openConversation(opts?: IdempotencyOption): Promise<Result<ChatConversationResponse, CimplifyError>>;
    /** Send a message in the active conversation. */
    sendMessage(content: string, opts?: IdempotencyOption): Promise<Result<ChatMessage, CimplifyError>>;
    /** Poll for new messages since the given cursor. */
    getMessages(options?: {
        after?: string;
        limit?: number;
    }): Promise<Result<ChatMessage[], CimplifyError>>;
}

type OrderType = "delivery" | "pickup" | "dine_in";
declare const ELEMENT_TYPES: {
    readonly AUTH: "auth";
    readonly ADDRESS: "address";
    readonly PAYMENT: "payment";
    readonly CHECKOUT: "checkout";
    readonly ACCOUNT: "account";
};
type ElementType = (typeof ELEMENT_TYPES)[keyof typeof ELEMENT_TYPES];
declare const MESSAGE_TYPES: {
    readonly INIT: "init";
    readonly SET_TOKEN: "set_token";
    readonly SET_CART: "set_cart";
    readonly GET_DATA: "get_data";
    readonly NAVIGATE: "navigate";
    readonly REFRESH_TOKEN: "refresh_token";
    readonly LOGOUT: "logout";
    readonly PROCESS_CHECKOUT: "process_checkout";
    readonly ABORT_CHECKOUT: "abort_checkout";
    readonly READY: "ready";
    readonly HEIGHT_CHANGE: "height_change";
    readonly ERROR: "error";
    readonly ADDRESS_CHANGED: "address_changed";
    readonly ADDRESS_SELECTED: "address_selected";
    readonly PAYMENT_METHOD_SELECTED: "payment_method_selected";
    readonly LOGOUT_COMPLETE: "logout_complete";
    readonly AUTH_REQUESTED: "auth_requested";
    readonly CONTACT_PROVIDED: "contact_provided";
    readonly CHECKOUT_STATUS: "checkout_status";
    readonly CHECKOUT_COMPLETE: "checkout_complete";
    readonly ORDER_TYPE_CHANGED: "order_type_changed";
    readonly REQUEST_SUBMIT: "request_submit";
};
interface ElementsOptions {
    linkUrl?: string;
    appearance?: ElementAppearance;
    auth?: ElementsAuthOptions;
}
interface ElementsAuthOptions {
    clientId?: string;
    redirectUri?: string;
    callbackUri?: string;
    scope?: string;
    issuer?: string;
    authUrl?: string;
}
interface ElementAppearance {
    theme?: "light" | "dark";
    variables?: {
        primaryColor?: string;
        fontFamily?: string;
        borderRadius?: string;
    };
}
interface ElementOptions {
    mode?: "shipping" | "billing";
    prefillEmail?: string;
    amount?: number;
    currency?: CurrencyCode;
    orderTypes?: OrderType[];
    defaultOrderType?: OrderType;
    submitLabel?: string;
}
interface AddressInfo {
    id?: string;
    latitude?: number;
    longitude?: number;
    street_address: string;
    apartment?: string;
    city: string;
    region: string;
    postal_code?: string;
    country?: string;
    delivery_instructions?: string;
    phone_for_delivery?: string;
}
interface PaymentMethodInfo {
    id?: string;
    type: "mobile_money" | "card" | "cash";
    provider?: string;
    last_four?: string;
    phone_number?: string;
    label?: string;
}
interface AuthenticatedCustomer {
    name: string;
    email: string | null;
    phone: string | null;
}
type ElementsCustomerInfo = {
    name: string;
    email: string | null;
    phone: string | null;
} | null;
declare const ELEMENTS_AUTH_CONTACT_TYPES: {
    readonly EMAIL: "email";
    readonly PHONE: "phone";
};
type ElementsAuthContactType = (typeof ELEMENTS_AUTH_CONTACT_TYPES)[keyof typeof ELEMENTS_AUTH_CONTACT_TYPES];
declare const ELEMENTS_AUTH_PROMPTS: {
    readonly LOGIN: "login";
};
type ElementsAuthPrompt = (typeof ELEMENTS_AUTH_PROMPTS)[keyof typeof ELEMENTS_AUTH_PROMPTS];
declare const ELEMENTS_AUTH_MODES: {
    readonly CHECKOUT: "checkout";
    readonly DEFAULT: "default";
};
type ElementsAuthMode = (typeof ELEMENTS_AUTH_MODES)[keyof typeof ELEMENTS_AUTH_MODES];
interface AuthenticatedData {
    accountId: string;
    customerId: string;
    token: string;
    customer: AuthenticatedCustomer;
}
interface ElementsCheckoutData {
    cart_id: string;
    order_type?: "delivery" | "pickup" | "dine_in";
    location_id?: string;
    scheduled_time?: string;
    tip_amount?: number;
    notes?: string;
}
interface ElementsCheckoutResult {
    success: boolean;
    order?: {
        id: string;
        status: string;
        total: string;
    };
    error?: {
        code: string;
        message: string;
    };
}
interface CheckoutCartItem {
    name: string;
    quantity: number;
    unit_price: string;
    total_price: string;
    image_url?: string;
    line_type: "simple" | "service" | "bundle" | "composite" | "digital";
    variant_name?: string;
    scheduled_start?: string;
    scheduled_end?: string;
    selections?: {
        name: string;
        quantity: number;
        variant_name?: string;
    }[];
    add_ons?: {
        name: string;
        price: string;
    }[];
    special_instructions?: string;
}
interface CheckoutCartData {
    items: CheckoutCartItem[];
    subtotal: string;
    tax_amount: string;
    total_discounts: string;
    service_charge: string;
    total: string;
    currency: string;
    /** Tax is baked into the prices (e.g. Ghana VAT), so `tax_amount` is already
     *  inside `subtotal`/`total`. Checkout labels it "included" rather than
     *  summing it onto the total. */
    tax_inclusive: boolean;
    /** Deposit due now when the cart has deposit-eligible service items, so the
     *  checkout can offer "pay deposit now, balance later". Absent/0 otherwise. */
    deposit_required?: boolean;
    deposit_amount?: string;
    requires_delivery?: boolean;
}
type ParentToIframeMessage = {
    type: typeof MESSAGE_TYPES.INIT;
    businessId: string;
    publicKey: string;
    prefillEmail?: string;
    appearance?: ElementAppearance;
    orderTypes?: OrderType[];
    defaultOrderType?: OrderType;
    renderSubmitButton?: boolean;
    submitLabel?: string;
    token?: string;
    merchantName?: string;
} | {
    type: typeof MESSAGE_TYPES.SET_TOKEN;
    token: string;
} | {
    type: typeof MESSAGE_TYPES.NAVIGATE;
    path: string;
} | {
    type: typeof MESSAGE_TYPES.SET_CART;
    cart: CheckoutCartData;
} | {
    type: typeof MESSAGE_TYPES.GET_DATA;
} | {
    type: typeof MESSAGE_TYPES.REFRESH_TOKEN;
} | {
    type: typeof MESSAGE_TYPES.LOGOUT;
} | {
    type: typeof MESSAGE_TYPES.PROCESS_CHECKOUT;
    cart_id: string;
    order_type?: OrderType;
    location_id?: string;
    notes?: string;
    scheduled_time?: string;
    tip_amount?: number;
    pay_currency?: CurrencyCode;
    enroll_in_link?: boolean;
    address?: AddressInfo;
    customer?: ElementsCustomerInfo;
    account_id?: string;
    customer_id?: string;
} | {
    type: typeof MESSAGE_TYPES.ABORT_CHECKOUT;
};
type IframeToParentMessage = {
    type: typeof MESSAGE_TYPES.READY;
    height: number;
} | {
    type: typeof MESSAGE_TYPES.HEIGHT_CHANGE;
    height: number;
} | {
    type: typeof MESSAGE_TYPES.CONTACT_PROVIDED;
    contact: string;
    contactType: ElementsAuthContactType;
} | {
    type: typeof MESSAGE_TYPES.ERROR;
    code: string;
    message: string;
} | {
    type: typeof MESSAGE_TYPES.ADDRESS_CHANGED;
    address: AddressInfo;
    saveToLink: boolean;
} | {
    type: typeof MESSAGE_TYPES.ADDRESS_SELECTED;
    address: AddressInfo;
} | {
    type: typeof MESSAGE_TYPES.PAYMENT_METHOD_SELECTED;
    method: PaymentMethodInfo;
    saveToLink: boolean;
} | {
    type: typeof MESSAGE_TYPES.LOGOUT_COMPLETE;
} | {
    type: typeof MESSAGE_TYPES.AUTH_REQUESTED;
    loginHint?: string;
    contactType?: ElementsAuthContactType;
    mode?: ElementsAuthMode;
    prompt?: ElementsAuthPrompt;
} | {
    type: typeof MESSAGE_TYPES.CHECKOUT_STATUS;
    status: CheckoutStatus;
    context: CheckoutStatusContext;
} | {
    type: typeof MESSAGE_TYPES.CHECKOUT_COMPLETE;
    success: boolean;
    order?: {
        id: string;
        order_number: string;
        status: string;
        total: string;
        currency: CurrencyCode;
    };
    error?: {
        code: string;
        message: string;
        recoverable: boolean;
    };
    enrolled_in_link?: boolean;
} | {
    type: typeof MESSAGE_TYPES.ORDER_TYPE_CHANGED;
    orderType: OrderType;
} | {
    type: typeof MESSAGE_TYPES.REQUEST_SUBMIT;
};
declare const EVENT_TYPES: {
    readonly READY: "ready";
    readonly AUTHENTICATED: "authenticated";
    readonly ERROR: "error";
    readonly CHANGE: "change";
    readonly BLUR: "blur";
    readonly FOCUS: "focus";
    readonly ORDER_TYPE_CHANGED: "order_type_changed";
    readonly REQUEST_SUBMIT: "request_submit";
};
type ElementEventType = (typeof EVENT_TYPES)[keyof typeof EVENT_TYPES];
type ElementEventHandler<T = unknown> = (data: T) => void;

declare class CimplifyElements {
    private client;
    private businessId;
    private linkUrl;
    private options;
    private elements;
    private accessToken;
    private accountId;
    private customerId;
    private customerData;
    private addressData;
    private paymentData;
    private checkoutInProgress;
    private authInProgress;
    private activeCheckoutAbort;
    private boundHandleMessage;
    private businessIdResolvePromise;
    private debug;
    constructor(client: CimplifyClient, businessId?: string, options?: ElementsOptions);
    create(type: ElementType, options?: ElementOptions): CimplifyElement;
    getElement(type: ElementType): CimplifyElement | undefined;
    _removeElement(type: ElementType, instance: CimplifyElement): void;
    destroy(): void;
    submitCheckout(data: ElementsCheckoutData): Promise<ElementsCheckoutResult>;
    processCheckout(options: ProcessCheckoutOptions): AbortablePromise<ProcessCheckoutResult>;
    isAuthenticated(): boolean;
    getAccessToken(): string | null;
    getPublicKey(): string;
    getBusinessId(): string | null;
    resolveBusinessId(): Promise<string | null>;
    getAppearance(): ElementsOptions["appearance"];
    private hydrateCustomerData;
    private sourceElementFor;
    private applyAccessToken;
    private broadcastAccessToken;
    private startEmbeddedAuth;
    private handleMessage;
    _setAddressData(data: AddressInfo): void;
    _setPaymentData(data: PaymentMethodInfo): void;
    _setGuestContact(contact: string, contactType: "email" | "phone"): void;
}
declare class CimplifyElement {
    private type;
    private businessId;
    private linkUrl;
    private options;
    private parent;
    private nonce;
    private iframe;
    private container;
    private mounted;
    private ready;
    private pendingMessages;
    private pendingInit;
    private eventHandlers;
    private resolvers;
    private boundHandleMessage;
    private listening;
    constructor(type: ElementType, businessId: string | null, linkUrl: string, options: ElementOptions, parent: CimplifyElements);
    mount(container: string | HTMLElement): void;
    destroy(): void;
    on(event: ElementEventType, handler: ElementEventHandler): void;
    off(event: ElementEventType, handler: ElementEventHandler): void;
    getData(): Promise<unknown>;
    setCart(cart: CheckoutCartData): void;
    sendMessage(message: ParentToIframeMessage): void;
    private flushPending;
    getContentWindow(): Window | null;
    isMounted(): boolean;
    _acceptsMessageEvent(event: MessageEvent, message: IframeToParentMessage): boolean;
    _emitAuthenticated(data: AuthenticatedData): void;
    _emitError(error: {
        code: string;
        message: string;
    }): void;
    private createIframe;
    private handleMessage;
    private emit;
    private resolveData;
}
declare function createElements(client: CimplifyClient, businessId?: string, options?: ElementsOptions): CimplifyElements;

interface RequestOptions {
    idempotencyKey?: string;
    headers?: Record<string, string>;
}
/**
 * Per-call cache hints for server-side reads. Forwarded as `next: { revalidate, tags }`
 * on the underlying fetch — Next.js's data cache reads them; in non-Next runtimes
 * they're inert. Maps 1:1 onto Next 16's documented fetch caching API:
 * https://nextjs.org/docs/app/api-reference/functions/fetch#optionsnextrevalidate
 *
 * Use the `tags` builders from `@cimplify/sdk/server` so invalidation stays consistent
 * with the `revalidate*` helpers.
 */
interface CacheOptions {
    /** Seconds before the cache entry is considered stale. `false` = cache indefinitely. */
    revalidate?: number | false;
    /** Cache tags for on-demand invalidation via `revalidateTag(tag)`. */
    tags?: readonly string[];
}
interface ReadRequestOptions {
    cacheOptions?: CacheOptions;
}
interface CimplifyConfig {
    publicKey?: string;
    credentials?: RequestCredentials;
    baseUrl?: string;
    linkApiUrl?: string;
    suppressPublicKeyWarning?: boolean;
    timeout?: number;
    maxRetries?: number;
    retryDelay?: number;
    hooks?: ObservabilityHooks;
    /**
     * Custom fetch implementation. Defaults to global `fetch`. Override for
     * tests (in-process mock), service-worker contexts, or instrumented
     * fetch wrappers. Signature matches the global `fetch` exactly.
     */
    fetch?: typeof fetch;
}
declare class CimplifyClient {
    private baseUrl;
    private linkApiUrl;
    private publicKey;
    private credentials;
    private accessToken;
    private sessionToken;
    private timeout;
    private maxRetries;
    private retryDelay;
    private hooks;
    private fetchImpl;
    private context;
    private businessId;
    private businessIdResolvePromise;
    private inflightRequests;
    /**
     * App-level event channel. Subscribe to surface mutation rollbacks, outbox
     * activity, and dead-letter notifications to consumer code (toasts,
     * Sentry, analytics, etc.). The SDK emits but never auto-consumes — the
     * consumer decides how to react.
     */
    readonly events: ClientEvents;
    private buildUrl;
    private _catalogue?;
    private _cart?;
    private _checkout?;
    private _orders?;
    private _storeCredit?;
    private _subscriptions?;
    private _uploads?;
    private _places?;
    private _link?;
    private _auth?;
    private _business?;
    private _inventory?;
    private _scheduling?;
    private _lite?;
    private _fx?;
    private _activity?;
    private _delivery?;
    private _support?;
    constructor(config?: CimplifyConfig);
    getAccessToken(): string | null;
    getPublicKey(): string;
    getBaseUrl(): string;
    getLinkApiUrl(): string;
    getCredentialsMode(): RequestCredentials;
    isTestMode(): boolean;
    setAccessToken(token: string | null): void;
    clearSession(): void;
    setOrderToken(orderId: string, token: string): void;
    getOrderToken(orderId: string): string | null;
    clearOrderTokens(): void;
    setLocationId(locationId: string | null): void;
    getLocationId(): string | null;
    setBusinessId(businessId: string): void;
    getBusinessId(): string | null;
    resolveBusinessId(): Promise<string>;
    private authedFetch;
    private loadSessionToken;
    private saveSessionToken;
    private captureSessionToken;
    private getHeaders;
    private resilientFetch;
    private getDedupeKey;
    private deduplicatedRequest;
    get<T = unknown>(path: string, opts?: ReadRequestOptions): Promise<T>;
    post<T = unknown>(path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
    patch<T = unknown>(path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
    delete<T = unknown>(path: string, opts?: RequestOptions): Promise<T>;
    linkGet<T = unknown>(path: string, opts?: ReadRequestOptions): Promise<T>;
    linkPost<T = unknown>(path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
    linkDelete<T = unknown>(path: string, opts?: RequestOptions): Promise<T>;
    private handleRestResponse;
    get catalogue(): CatalogueQueries;
    get cart(): CartOperations;
    get checkout(): CheckoutService;
    get orders(): OrderQueries;
    get storeCredit(): StoreCreditQueries;
    get subscriptions(): SubscriptionService;
    get uploads(): UploadService;
    get places(): PlacesService;
    get link(): LinkService;
    get auth(): AuthService;
    get business(): BusinessService;
    get inventory(): InventoryService;
    get scheduling(): SchedulingService;
    get lite(): LiteService;
    get fx(): FxService;
    get activity(): ActivityService;
    get delivery(): DeliveryService;
    get support(): SupportService;
    buildWsUrl(path: string): string;
    elements(businessId?: string, options?: ElementsOptions): CimplifyElements;
}
declare function createCimplifyClient(config?: CimplifyConfig): CimplifyClient;

export { type CheckoutAddressInfo as $, AUTHORIZATION_TYPE as A, type Booking as B, BusinessService as C, type BusinessSettings as D, type BusinessType as E, type BusinessWithLocations as F, CHECKOUT_MODE as G, CHECKOUT_MUTATION as H, CHECKOUT_STEP as I, CONTACT_TYPE as J, type CacheOptions as K, type CancelBookingInput as L, type CancelBookingResult as M, type CancelOrderInput as N, type CancellationPolicy as O, CartOperations as P, CatalogueQueries as Q, type CatalogueResult as R, type CatalogueSnapshot as S, type CategoryInfo as T, type ChatAttachment as U, type ChatConversation as V, type ChatConversationResponse as W, type ChatMessage as X, type ChatWidgetStarter as Y, type CheckSlotAvailabilityInput as Z, type CheckSlotAvailabilityResult as _, AUTH_MUTATION as a, type Err as a$, type CheckoutCartData as a0, type CheckoutCartItem as a1, type CheckoutCustomerInfo as a2, type CheckoutFormData as a3, type CheckoutInput as a4, type CheckoutMode as a5, type CheckoutOrderType as a6, type CheckoutPaymentMethod as a7, type CheckoutResult as a8, CheckoutService as a9, DeliveryService as aA, type DepositResult as aB, type DeviceType as aC, type DismissMessageResponse as aD, ELEMENTS_AUTH_CONTACT_TYPES as aE, ELEMENTS_AUTH_MODES as aF, ELEMENTS_AUTH_PROMPTS as aG, ELEMENT_TYPES as aH, EVENT_TYPES as aI, type ElementAppearance as aJ, type ElementEventHandler as aK, type ElementEventType as aL, type ElementOptions as aM, type ElementType as aN, type ElementsAuthContactType as aO, type ElementsAuthMode as aP, type ElementsAuthOptions as aQ, type ElementsAuthPrompt as aR, type ElementsCheckoutData as aS, type ElementsCheckoutResult as aT, type ElementsCustomerInfo as aU, type ElementsOptions as aV, type EnrichedOrder as aW, type EnrichedOrderItem as aX, type EnrollAndLinkOrderInput as aY, type EnrollAndLinkOrderResult as aZ, type EnrollmentData as a_, type CheckoutStatus as aa, type CheckoutStatusContext as ab, type CheckoutStep as ac, CimplifyClient as ad, type CimplifyConfig as ae, CimplifyElement as af, CimplifyElements as ag, type ContactType as ah, type ContentType as ai, type CreateAddressInput as aj, type CreateMobileMoneyInput as ak, type Customer as al, type CustomerAddress as am, type CustomerBooking as an, type CustomerBookingServiceItem as ao, type CustomerLinkPreferences as ap, type CustomerMobileMoney as aq, type CustomerServicePreferences as ar, DEFAULT_COUNTRY as as, DEFAULT_CURRENCY as at, DEVICE_TYPE as au, type DayAvailability as av, type DeliveryFeeDetails as aw, type DeliveryFeeResponse as ax, type DeliveryOption as ay, type DeliveryOptionsResponse as az, type AbortablePromise as b, OrderQueries as b$, type FeeBearerType as b0, type FetchQuoteInput as b1, type FulfillmentLink as b2, type FulfillmentStatus as b3, type FulfillmentSummaryDTO as b4, type FulfillmentType as b5, type FxQuote as b6, type FxQuoteRequest as b7, type FxRateResponse as b8, FxService as b9, type MobileMoneyData as bA, type MobileMoneyDetails as bB, type MobileMoneyProvider as bC, type NextAction as bD, ORDER_MUTATION as bE, ORDER_TYPE as bF, type ObservabilityHooks as bG, type Ok as bH, type Order as bI, type OrderChannel as bJ, type OrderCustomerInfo as bK, type OrderDiscountInfo as bL, type OrderFilter as bM, type OrderFulfillmentSummary as bN, type OrderGroup as bO, type OrderGroupDetails as bP, type OrderGroupPayment as bQ, type OrderGroupPaymentState as bR, type OrderGroupPaymentStatus as bS, type OrderGroupPaymentSummary as bT, type OrderGroupStatus as bU, type OrderHistory as bV, type OrderLineState as bW, type OrderLineStatus as bX, type OrderLocationInfo as bY, type OrderPaymentEvent as bZ, type OrderPricingView as b_, type GetAvailableSlotsInput as ba, type GetDeliveryOptionsParams as bb, type GetOrdersOptions as bc, type GetProductsOptions as bd, type GroupOrderInfo as be, type IframeToParentMessage as bf, InventoryService as bg, LINK_MUTATION as bh, LINK_QUERY as bi, type LineItem as bj, type LineType as bk, type LinkData as bl, type LinkEnrollResult as bm, LinkService as bn, type LinkSession as bo, type LinkStatusResult as bp, type LiteBootstrap as bq, LiteService as br, type Location as bs, type LocationBooking as bt, type LocationTaxBehavior as bu, type LocationTaxOverrides as bv, type LocationTimeProfile as bw, type LocationWithDetails as bx, MESSAGE_TYPES as by, MOBILE_MONEY_PROVIDER as bz, type ActivityRecommendation as c, type ServiceCharge as c$, type OrderSplitDetail as c0, type OrderStaffInfo as c1, type OrderStatus as c2, type OrderTimestampsDTO as c3, type OrderType as c4, type OtpResult as c5, PAYMENT_METHOD as c6, PAYMENT_MUTATION as c7, PAYMENT_STATE as c8, PICKUP_TIME_TYPE as c9, type RelationType as cA, type ReminderMethod as cB, type ReminderSettings as cC, type ReorderResult as cD, type RequestContext as cE, type RequestErrorEvent as cF, type RequestOptions as cG, type RequestOtpInput as cH, type RequestSource as cI, type RequestStartEvent as cJ, type RequestSuccessEvent as cK, type RescheduleBookingInput as cL, type RescheduleBookingResult as cM, type RescheduleHistoryRecord as cN, type ResourceAssignment as cO, type Result as cP, type RetryEvent as cQ, type RevokeAllSessionsResult as cR, type RevokeSessionResult as cS, type Room as cT, type SchedulingMetadata as cU, type SchedulingResult as cV, SchedulingService as cW, type SenderType as cX, type Service as cY, type ServiceAvailabilityParams as cZ, type ServiceAvailabilityResult as c_, type ParentToIframeMessage as ca, type PaymentInfoDTO as cb, type PaymentMethodInfo as cc, type PaymentState as cd, type PickupTime as ce, type PickupTimeType as cf, type PlaceDetailsResponse as cg, PlacesService as ch, type PriceQuote as ci, type PricingOverrides as cj, type ProcessAndResolveOptions as ck, type ProcessCheckoutOptions as cl, type ProcessCheckoutResult as cm, type ProviderResolutionSource as cn, type QuoteBundleSelectionInput as co, type QuoteCompositeSelectionInput as cp, type QuoteDynamicBuckets as cq, type QuoteStatus as cr, type QuoteUiMessage as cs, type ReadRequestOptions as ct, type RefreshQuoteInput as cu, type RefreshQuoteResult as cv, type RefundOrderInput as cw, type RelatedCandidate as cx, type RelatedProduct as cy, type RelatedProductsEnrichment as cz, type ActivityRecommendationsResponse as d, type ServiceNotes as d0, type ServiceScheduleRequest as d1, type ServiceStatus as d2, type SessionActivityData as d3, type SessionChangeEvent as d4, type SessionMessage as d5, type SlotResourceInfo as d6, type SlotStaffInfo as d7, type Staff as d8, type StaffAssignment as d9, createCimplifyClient as dA, createElements as dB, err as dC, flatMap as dD, fromPromise as dE, getOrElse as dF, isErr as dG, isOk as dH, mapError as dI, mapResult as dJ, ok as dK, toNullable as dL, tryCatch as dM, unwrap as dN, type StaffRole as da, type StaffScheduleItem as db, type StockLevel as dc, type StockStatus as dd, type StoreCreditBalance as de, StoreCreditQueries as df, type StorefrontBootstrap as dg, SubscriptionService as dh, SupportService as di, type Table as dj, type TableInfo as dk, type TimeRange as dl, type TimeRanges as dm, type TimeSlot as dn, type TrackCategoryViewOptions as dp, type TrackProductViewOptions as dq, type UpdateAddressInput as dr, type UpdateOrderStatusInput as ds, type UpdateProfileInput as dt, type UploadInitResponse as du, type UploadResult as dv, UploadService as dw, type VerifyOtpInput as dx, combine as dy, combineObject as dz, ActivityService as e, type ActivityStateResponse as f, type AddressData as g, type AddressInfo as h, type AmountToPay as i, type AuthResponse as j, AuthService as k, type AuthStatus as l, type AuthenticatedCustomer as m, type AuthenticatedData as n, type AutocompletePrediction as o, type AutocompleteResponse as p, type AvailabilityResult as q, type AvailableSlot as r, type BookingModificationType as s, type BookingStatus as t, type BookingWithDetails as u, type BufferTimes as v, type Business as w, type BusinessDetailsDTO as x, type BusinessHours as y, type BusinessPreferences as z };
