import type { ProductListItem, Product, ShopCategory, ShopBrand, ShopCollection, ShippingMethod, PaymentMethodOption, CreateOrderRequest, ShopOrder, ShopOrderPaymentStatus, ShopOffer, ShopOfferListParams } from "./types/shop.js";
import type { ApiEvent, EventRegistrationSubmission, EventRegistrationResult, EventRegistration, EventRegistrationAccess, EventPaymentMethod, EventPaymentSessionRequest, EventPaymentSession, EventCommandOptions, EventPaymentStatus } from "./types/event.js";
import type { BookingService, TimeSlot, Booking, BookingDetail, BookingConfig, ResourceItem, CreateBookingRequest, BookingListParams, UpdateBookingInput } from "./types/booking.js";
import type { Member, CardSettings, PaymentMethod, PublicMembershipTier } from "./types/member.js";
import type { PromotionValidationRequest, PromotionValidationResponse } from "./types/promotion.js";
import type { Invoice, InvoiceDetail } from "./types/invoice.js";
import type { DocumentSigningData, DocumentSignaturePayload, DocumentSignatureResult } from "./types/document.js";
import type { SurveyPublicView, SurveyResponseResult, SurveyResponseSubmission } from "./types/survey.js";
import type { CmsPage, CmsPageSummary } from "./types/cms.js";
import type { BlogPost, BlogPostListItem } from "./types/blog.js";
import type { ProductReview, ReviewSummary, CreateReviewRequest, ReviewContext } from "./types/review.js";
import type { ServicePackageOrder } from "./types/service-package.js";
import type { ContactEnquirySubmission, ContactEnquiryResult } from "./types/contact.js";
import type { TutorCourseSummary, TutorCourseDetail, TutorCourseEnrollmentResult, TutorCourseMyEnrollment, TutorCoursePaymentInput, TutorCoursePaymentSession, TutorCoursePaymentStatusResult, TutorCourseLeaveRequest, TutorCourseLeaveRequestInput, TutorCourseTransferRequest, TutorCourseTransferRequestInput } from "./types/tutor-course.js";
import type { ApiGiftOffer, ApiGiftOfferList, ApiRewardRedemption, ApiRewardRedemptionList, RedemptionStatus } from "./types/gift.js";
import { AuthClient } from "./auth.js";
import { SupportClient } from "./support.js";
export interface FavCRMConfig {
    baseUrl: string;
    companyId: string;
    onUnauthorized?: () => void;
    fetch?: typeof globalThis.fetch;
    /**
     * Per-request timeout in milliseconds. Defaults to 30 000 ms.
     * Set to 0 to disable. Applied to every `request()`, `requestRaw()`,
     * and `fetchRaw()` call via an internally-managed AbortController that
     * is merged with any caller-supplied signal.
     */
    timeoutMs?: number;
}
export interface CustomerAiChatInput {
    message: string;
    conversationId?: string;
}
export interface CustomerAiToolCallStatus {
    id: string;
    name: string;
    status: "running" | "completed" | "failed";
    summary?: string;
}
export interface CustomerAiUsage {
    promptTokens?: number;
    completionTokens?: number;
}
export interface CustomerAiStreamHandlers {
    onMessageStart?: (event: {
        conversationId: string;
    }) => void;
    onContentDelta?: (event: {
        content: string;
    }) => void;
    onToolCallStart?: (event: {
        toolCall: CustomerAiToolCallStatus;
    }) => void;
    onToolCallResult?: (event: {
        toolCall: CustomerAiToolCallStatus;
    }) => void;
    onMessageEnd?: (event: {
        conversationId: string;
        usage?: CustomerAiUsage;
    }) => void;
    onError?: (event: {
        message: string;
    }) => void;
}
export interface CustomerAiConversation {
    id: string;
    title?: string | null;
    type?: string | null;
    createdAt?: string;
    updatedAt?: string;
    messages?: Array<{
        id?: string;
        role: string;
        content: string | null;
        toolCalls?: unknown;
        createdAt?: string;
    }>;
}
export declare class FavCRMError extends Error {
    status: number;
    code?: string;
    constructor(status: number, message: string, code?: string);
}
type HttpMethod = "GET" | "POST" | "PATCH" | "DELETE";
interface RequestOptions {
    body?: unknown;
    params?: Record<string, string>;
    idempotencyKey?: string;
}
export declare class FavCRM {
    private config;
    private jwt;
    private readonly base;
    readonly shop: ShopClient;
    readonly bookings: BookingsClient;
    readonly events: EventsClient;
    readonly tutorCourses: TutorCoursesClient;
    readonly members: MembersClient;
    readonly payments: PaymentsClient;
    readonly promotions: PromotionsClient;
    readonly invoices: InvoicesClient;
    readonly documents: DocumentsClient;
    readonly cms: CmsClient;
    readonly blog: BlogClient;
    readonly packages: PackagesClient;
    readonly tiers: TiersClient;
    readonly contact: ContactClient;
    readonly auth: AuthClient;
    readonly walletPasses: WalletPassesClient;
    readonly gifts: GiftsClient;
    readonly surveys: SurveysClient;
    readonly ai: CustomerAiClient;
    readonly support: SupportClient;
    constructor(config: FavCRMConfig);
    get companyId(): string;
    setToken(jwt: string): void;
    clearToken(): void;
    /** @internal — used by WalletPassesClient for binary downloads */
    fetchRaw(path: string, opts?: {
        params?: Record<string, string>;
    }): Promise<Response>;
    /** @internal — used by sub-clients */
    request<T>(method: HttpMethod, path: string, opts?: RequestOptions): Promise<T>;
    private _requestOnce;
    /** @internal — used by CustomerAiClient for SSE streams */
    requestRaw(method: HttpMethod, path: string, opts?: RequestOptions): Promise<Response>;
}
declare class CustomerAiClient {
    private sdk;
    constructor(sdk: FavCRM);
    chat(input: CustomerAiChatInput): Promise<unknown>;
    streamChat(input: CustomerAiChatInput, handlers: CustomerAiStreamHandlers): Promise<void>;
    listConversations(): Promise<CustomerAiConversation[]>;
    getConversation(id: string): Promise<CustomerAiConversation>;
    deleteConversation(id: string): Promise<{
        deleted: boolean;
    }>;
}
export interface ProductListParams {
    category_slug?: string;
    category_id?: number;
    brand_slug?: string;
    collection_slug?: string;
    search?: string;
    sort?: 'name' | 'price_asc' | 'price_desc' | 'newest';
    featured?: boolean;
    page?: number;
    limit?: number;
}
export interface CategoryListParams {
    featured?: boolean;
}
declare class ShopClient {
    private sdk;
    constructor(sdk: FavCRM);
    listProducts(params?: ProductListParams): Promise<ProductListItem[]>;
    getProduct(slug: string): Promise<Product>;
    getRelatedProducts(slug: string, limit?: number): Promise<ProductListItem[]>;
    listCategories(params?: CategoryListParams): Promise<ShopCategory[]>;
    listBrands(): Promise<ShopBrand[]>;
    getBrand(slug: string): Promise<ShopBrand>;
    listCollections(): Promise<ShopCollection[]>;
    getCollection(slug: string): Promise<ShopCollection>;
    listShippingMethods(orderAmount?: number): Promise<ShippingMethod[]>;
    listPaymentMethods(): Promise<PaymentMethodOption[]>;
    listOffers(params?: ShopOfferListParams): Promise<ShopOffer[]>;
    createOrder(data: CreateOrderRequest): Promise<ShopOrder>;
    listOrders(): Promise<ShopOrder[]>;
    getOrder(orderUuid: string): Promise<ShopOrder>;
    getOrderPaymentStatus(orderUuid: string): Promise<ShopOrderPaymentStatus>;
    listProductReviews(slug: string): Promise<{
        reviews: ProductReview[];
        summary: ReviewSummary;
    }>;
    getReviewContext(token: string): Promise<ReviewContext>;
    submitProductReview(data: CreateReviewRequest): Promise<ProductReview>;
}
export interface TimeSlotsParams {
    date: string;
    createQuotes?: boolean;
    accountId?: string;
    staffId?: string;
    resourceId?: string;
}
export interface TimeSlotsResponse {
    slots: TimeSlot[];
    bookingConfig?: BookingConfig;
}
export interface StaffMember {
    memberId: string;
    memberName: string;
}
declare class BookingsClient {
    private sdk;
    constructor(sdk: FavCRM);
    listServices(): Promise<BookingService[]>;
    getService(serviceId: string): Promise<BookingService>;
    getStaff(serviceId: string): Promise<StaffMember[]>;
    getResources(serviceId: string): Promise<ResourceItem[]>;
    getTimeSlots(serviceId: string, params: TimeSlotsParams): Promise<TimeSlotsResponse>;
    create(data: CreateBookingRequest): Promise<Booking>;
    createGuest(data: CreateBookingRequest): Promise<Booking>;
    list(params?: BookingListParams): Promise<Booking[]>;
    get(bookingId: string): Promise<BookingDetail>;
    getAccessQr(bookingId: string): Promise<{
        qrContent: string;
        expiresAt: string;
        bookingId: string;
    }>;
    cancel(bookingId: string, reason?: string): Promise<BookingDetail>;
    reschedule(bookingId: string, data: UpdateBookingInput): Promise<BookingDetail>;
}
declare class EventsClient {
    private sdk;
    constructor(sdk: FavCRM);
    list(): Promise<ApiEvent[]>;
    get(slug: string): Promise<ApiEvent>;
    register(data: EventRegistrationSubmission, options?: EventCommandOptions): Promise<EventRegistrationResult>;
    listRegistrations(): Promise<EventRegistration[]>;
    createPaymentIntent(registrationId: string): Promise<PaymentIntentResponse>;
    listPaymentMethods(): Promise<EventPaymentMethod[]>;
    createPaymentSession(registrationId: string, data: EventPaymentSessionRequest, options?: EventCommandOptions): Promise<EventPaymentSession>;
    getPaymentStatus(registrationId: string, transactionId?: string): Promise<EventPaymentStatus>;
    /**
     * Create a payment intent and guarantee a Stripe `publishableKey`.
     *
     * `createPaymentIntent` may omit `publishableKey` depending on the
     * merchant's gateway configuration. This helper falls back to
     * `payments.getGateway()` so the caller always has the key needed to
     * mount Stripe Elements client-side.
     */
    startPayment(registrationId: string): Promise<PaymentIntentResponse & {
        publishableKey: string;
    }>;
    getAccess(registrationId: string): Promise<EventRegistrationAccess>;
    cancelRegistration(eventId: string, registrationId: string): Promise<{
        cancelled: boolean;
    }>;
}
declare class TutorCoursesClient {
    private sdk;
    constructor(sdk: FavCRM);
    list(): Promise<TutorCourseSummary[]>;
    get(courseId: string): Promise<TutorCourseDetail>;
    enroll(courseId: string, data: {
        sectionId: string;
    }): Promise<TutorCourseEnrollmentResult>;
    listMyEnrollments(): Promise<TutorCourseMyEnrollment[]>;
    createPayment(enrollmentId: string, data: TutorCoursePaymentInput): Promise<TutorCoursePaymentSession>;
    getPaymentStatus(enrollmentId: string, transactionId?: string): Promise<TutorCoursePaymentStatusResult>;
    listLeaveRequests(enrollmentId: string): Promise<TutorCourseLeaveRequest[]>;
    requestLeave(enrollmentId: string, data: TutorCourseLeaveRequestInput): Promise<TutorCourseLeaveRequest>;
    cancelLeave(enrollmentId: string, requestId: string): Promise<TutorCourseLeaveRequest>;
    listTransferRequests(enrollmentId: string): Promise<TutorCourseTransferRequest[]>;
    requestTransfer(enrollmentId: string, data: TutorCourseTransferRequestInput): Promise<TutorCourseTransferRequest>;
    cancelTransfer(enrollmentId: string, requestId: string): Promise<TutorCourseTransferRequest>;
}
declare class MembersClient {
    private sdk;
    constructor(sdk: FavCRM);
    getProfile(): Promise<Member>;
    updateProfile(data: Partial<Member>): Promise<Member>;
    getCardSettings(): Promise<CardSettings>;
    listPaymentMethods(): Promise<PaymentMethod[]>;
    addPaymentMethod(token: string): Promise<PaymentMethod>;
    deletePaymentMethod(methodId: string): Promise<void>;
    setDefaultPaymentMethod(methodId: string): Promise<void>;
    enroll(tierId: string): Promise<{
        membershipId: string;
    }>;
    enrollPaid(tierId: string, paymentIntentId: string): Promise<{
        membershipId: string;
    }>;
}
declare class TiersClient {
    private sdk;
    constructor(sdk: FavCRM);
    list(): Promise<PublicMembershipTier[]>;
}
export interface PaymentGateway {
    publishableKey: string;
    gateway: string;
}
export interface PaymentIntentRequest {
    amount: number;
    currency: string;
    bookingId?: string;
    tierId?: string;
}
export interface PaymentIntentResponse {
    clientSecret: string;
    paymentIntentId: string;
    publishableKey?: string;
    stripeAccount?: string;
}
declare class PaymentsClient {
    private sdk;
    constructor(sdk: FavCRM);
    getGateway(): Promise<PaymentGateway>;
    createIntent(data: PaymentIntentRequest): Promise<PaymentIntentResponse>;
    getCreditBalance(): Promise<{
        credits: string;
        currency: string;
    }>;
}
declare class PromotionsClient {
    private sdk;
    constructor(sdk: FavCRM);
    validate(data: PromotionValidationRequest): Promise<PromotionValidationResponse>;
}
declare class InvoicesClient {
    private sdk;
    constructor(sdk: FavCRM);
    list(): Promise<Invoice[]>;
    get(id: string): Promise<InvoiceDetail>;
}
declare class DocumentsClient {
    private sdk;
    constructor(sdk: FavCRM);
    getSigningToken(token: string): Promise<DocumentSigningData>;
    sign(token: string, data: DocumentSignaturePayload): Promise<DocumentSignatureResult>;
}
declare class SurveysClient {
    private sdk;
    constructor(sdk: FavCRM);
    get(slug: string): Promise<SurveyPublicView>;
    getByToken(token: string): Promise<SurveyPublicView>;
    submit(surveyId: string, data: SurveyResponseSubmission): Promise<SurveyResponseResult>;
    submitByToken(token: string, data: SurveyResponseSubmission): Promise<SurveyResponseResult>;
}
declare class CmsClient {
    private sdk;
    constructor(sdk: FavCRM);
    listPages(): Promise<CmsPageSummary[]>;
    getPage(slug: string): Promise<CmsPage>;
}
export interface BlogListParams {
    type?: string;
    category?: string;
    categoryId?: string;
    search?: string;
    sort?: "createdAt" | "updatedAt" | "publishedAt" | "title" | "sortOrder";
    order?: "asc" | "desc";
    page?: number;
    limit?: number;
}
export interface PaginatedResult<T> {
    items: T[];
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
        hasNext: boolean;
        hasPrev: boolean;
    };
}
declare class PackagesClient {
    private sdk;
    constructor(sdk: FavCRM);
    listMyOrders(): Promise<ServicePackageOrder[]>;
    getApplicable(serviceId: string): Promise<ServicePackageOrder[]>;
}
declare class BlogClient {
    private sdk;
    constructor(sdk: FavCRM);
    list(params?: BlogListParams): Promise<PaginatedResult<BlogPostListItem>>;
    getBySlug(slug: string): Promise<BlogPost>;
}
declare class ContactClient {
    private sdk;
    constructor(sdk: FavCRM);
    submit(data: ContactEnquirySubmission): Promise<ContactEnquiryResult>;
}
export interface WalletPassStatus {
    apple: {
        serialNumber: string;
        version: number;
        r2Key: string | null;
        createdAt: string;
        updatedAt: string;
    } | null;
    google: {
        objectId: string | null;
        saveUrl: string | null;
        createdAt: string;
        updatedAt: string;
    } | null;
}
declare class WalletPassesClient {
    private sdk;
    constructor(sdk: FavCRM);
    getStatus(): Promise<WalletPassStatus>;
    generate(type: "apple" | "google"): Promise<{
        queued: boolean;
    }>;
    downloadAppleBlob(): Promise<Blob>;
    getGoogleSaveUrl(): Promise<{
        saveUrl: string | null;
    }>;
}
declare class GiftsClient {
    private sdk;
    constructor(sdk: FavCRM);
    listMyRedemptions(opts?: {
        status?: RedemptionStatus | Lowercase<RedemptionStatus>;
        limit?: number;
        offset?: number;
    }): Promise<ApiRewardRedemptionList>;
    getRedemption(id: string): Promise<ApiRewardRedemption>;
    fulfill(id: string): Promise<ApiRewardRedemption>;
    listOffers(opts?: {
        limit?: number;
        offset?: number;
    }): Promise<ApiGiftOfferList>;
    getOffer(id: string): Promise<ApiGiftOffer>;
    redeemOffer(id: string): Promise<ApiRewardRedemption>;
    claimByCode(code: string): Promise<ApiRewardRedemption>;
}
export {};
//# sourceMappingURL=client.d.ts.map