@veladent/booking-widget 0.0.0-stage → 1.0.4-dev.9

package/types/booking/core/src/client.d.ts

@@ -0,0 +1,21 @@
+import type { BookingClientOptions, BookingConfig, BookingResult, BookingSlot, CreateBookingInput, GetSlotsInput, RequestBookingVerificationInput, RequestBookingVerificationResult, VerifyBookingCodeInput, VerifyBookingCodeResult } from "./types.js";
+export declare class BookingApiError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export interface BookingClient {
+    cancelPayment?(sessionId: string): Promise<Omit<BookingResult, "status"> & {
+        status: "pending" | "confirmed" | "expired";
+    }>;
+    createRequest(input: CreateBookingInput): Promise<BookingResult>;
+    getConfig(signal?: AbortSignal): Promise<BookingConfig>;
+    getPaymentStatus?(sessionId: string): Promise<Omit<BookingResult, "status"> & {
+        status: "pending" | "confirmed" | "expired";
+    }>;
+    getSlots(input: GetSlotsInput): Promise<BookingSlot[]>;
+    requestVerification(input: RequestBookingVerificationInput): Promise<RequestBookingVerificationResult>;
+    verificationStorageKey?: string;
+    verifyCode(input: VerifyBookingCodeInput): Promise<VerifyBookingCodeResult>;
+}
+export declare function createBookingClient(options: BookingClientOptions): BookingClient;

package/types/booking/core/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./client.js";
+export * from "./locale.js";
+export * from "./timezone.js";
+export * from "./types.js";
+export * from "./validation.js";

package/types/booking/core/src/locale.d.ts

@@ -0,0 +1,113 @@
+import type { BookingLocale } from "./types.js";
+export type BookingDirection = "ltr" | "rtl";
+export interface BookingCopy {
+    addressLine1: string;
+    anyPractitioner: string;
+    anyPractitionerDescription: string;
+    appointmentSummary: string;
+    appointmentTitle: string;
+    back: string;
+    balance: string;
+    bookAgain: string;
+    bookingDisabled: string;
+    bookingFailed: string;
+    bookingUnavailableDescription: string;
+    bookingUnavailableTitle: string;
+    callPractice: string;
+    cancelPayment: string;
+    checkingPayment: string;
+    checkPayment: string;
+    chooseAnotherDate: string;
+    chooseDate: string;
+    chooseDateTime: string;
+    chooseDoctor: string;
+    chooseService: string;
+    chooseTime: string;
+    chooseTreatment: string;
+    clinic: string;
+    close: string;
+    codeExpired: string;
+    codeExpiresIn: string;
+    confirmationDescription: string;
+    confirmCode: string;
+    confirmed: string;
+    contactPractice: string;
+    contactSite: string;
+    continue: string;
+    dateOfBirth: string;
+    deposit: string;
+    email: string;
+    existingPatient: string;
+    existingPatientDescription: string;
+    findPatientRecord: string;
+    firstName: string;
+    fullName: string;
+    gender: string;
+    genderOptions: {
+        female: string;
+        male: string;
+        other: string;
+        preferNotToSay: string;
+    };
+    genderPlaceholder: string;
+    goBackAndEdit: string;
+    identityUnavailable: string;
+    identityUnavailableDescription: string;
+    invalidInput: string;
+    lastName: string;
+    loadingSlots: string;
+    loginTitle: string;
+    marketingOptIn: string;
+    newPatient: string;
+    newPatientDescription: string;
+    noDoctors: string;
+    noMatchingServices: string;
+    noServices: string;
+    noSlots: string;
+    noTreatments: string;
+    otpCode: string;
+    otpDescription: string;
+    otpSent: string;
+    patientDetails: string;
+    patientDetailsRequired: string;
+    patientNoMatch: string;
+    patientNoMatchDescription: string;
+    paymentAtPractice: string;
+    paymentExpired: string;
+    paymentPending: string;
+    paymentReceived: string;
+    paymentStatusUnavailable: string;
+    payWithStripe: string;
+    pendingConfirmation: string;
+    phone: string;
+    phoneCountry: string;
+    phoneCountryCodeHint: string;
+    postcode: string;
+    practitionerDescription: string;
+    preparingPayment: string;
+    price: string;
+    registeredQuestion: string;
+    requestCode: string;
+    resendCode: string;
+    resendCodeIn: string;
+    retry: string;
+    reviewPayment: string;
+    searchServices: string;
+    selectDateFirst: string;
+    serviceDescription: string;
+    slotsLoadFailed: string;
+    somethingElse: string;
+    submit: string;
+    submitting: string;
+    title: string;
+    titleLabel: string;
+    titlePlaceholder: string;
+    total: string;
+    treatmentDescription: string;
+    verificationReminders: string;
+    verifyPhone: string;
+    yourDetails: string;
+}
+export declare function resolveLocale(locale?: BookingLocale): string;
+export declare function getLocaleDirection(locale?: BookingLocale): BookingDirection;
+export declare function getBookingCopy(locale?: BookingLocale): BookingCopy;

package/types/booking/core/src/timezone.d.ts

@@ -0,0 +1,10 @@
+import type { BookingLocale } from "./types.js";
+export interface FormatDateTimeOptions {
+    locale?: BookingLocale;
+    timeZone: string;
+}
+export declare function formatBookingDateTime(value: Date | string, options: FormatDateTimeOptions): string;
+export declare function formatBookingDate(value: Date | string, options: FormatDateTimeOptions): string;
+export declare function formatBookingTime(value: Date | string, options: FormatDateTimeOptions): string;
+export declare function getDateKeyInTimeZone(value: Date | string, timeZone: string): string;
+export declare function addCalendarDays(dateKey: string, days: number): string;

package/types/booking/core/src/types.d.ts

@@ -0,0 +1,135 @@
+export type BookingLocale = string;
+export interface BookingTheme {
+    accentColor?: string;
+    colorMode?: "dark" | "light";
+    radius?: string;
+}
+export interface BookingDoctor {
+    avatarUrl?: string | null;
+    displayName: string;
+    id: string;
+    specialty?: string | null;
+}
+export interface BookingService {
+    description?: string | null;
+    id: string;
+    name: string;
+}
+export interface BookingTreatment {
+    currencyCode: string;
+    currencySymbol?: string | null;
+    deposit?: number | null;
+    description?: string | null;
+    durationMinutes: number;
+    id: string;
+    name: string;
+    price: number;
+    serviceId: string;
+}
+export interface BookingConfig {
+    doctors: BookingDoctor[];
+    enabled: boolean;
+    locale: BookingLocale;
+    services: BookingService[];
+    siteAddress?: string | null;
+    siteLogoUrl?: string | null;
+    siteName?: string | null;
+    sitePhone?: string | null;
+    theme?: BookingTheme | null;
+    timeZone: string;
+    treatments: BookingTreatment[];
+}
+export interface BookingSlot {
+    available: boolean;
+    doctorId: string;
+    doctorName?: string | null;
+    end: string;
+    id: string;
+    start: string;
+}
+export interface BookingContact {
+    address?: string;
+    email: string;
+    firstName?: string;
+    fullName: string;
+    lastName?: string;
+    marketingOptIn?: boolean;
+    phone: string;
+    postalCode?: string;
+    title?: string;
+}
+export interface PatientDetails {
+    dateOfBirth: string;
+    gender: string;
+}
+export interface CreateBookingInput {
+    bookingMode: "existing" | "new";
+    checkoutRequestId?: string;
+    contact: BookingContact;
+    doctorId: string;
+    end: string;
+    patientDetails: PatientDetails;
+    start: string;
+    treatmentId: string;
+    verificationCode: string;
+}
+export interface RequestBookingVerificationInput {
+    bookingMode?: "existing" | "new";
+    identity?: {
+        firstName: string;
+        lastName: string;
+        dateOfBirth: string;
+    };
+    phone: string;
+}
+export interface RequestBookingVerificationResult {
+    cooldownSeconds: number;
+    expiresInSeconds: number;
+    is_patient_found?: boolean;
+}
+export interface VerifyBookingCodeInput {
+    bookingMode?: "existing" | "new";
+    code: string;
+    identity?: {
+        firstName: string;
+        lastName: string;
+        dateOfBirth: string;
+    };
+    phone: string;
+}
+export interface VerifyBookingCodeResult {
+    patientMatched?: boolean;
+    sessionExpiresInSeconds?: number;
+    sessionToken?: string;
+    verified: boolean;
+}
+export interface BookingResult {
+    checkout?: {
+        sessionId: string;
+        url: string;
+        amount: number;
+        price: number;
+        currency: string;
+    };
+    payment?: {
+        price: number;
+        currency: string;
+    };
+    scheduledEnd: string;
+    scheduledStart: string;
+    status: "pending" | "confirmed";
+    treatmentName?: string;
+}
+export interface GetSlotsInput {
+    date: string;
+    doctorId?: string;
+    fromDate?: string;
+    signal?: AbortSignal;
+    toDate?: string;
+    treatmentId: string;
+}
+export interface BookingClientOptions {
+    baseUrl: string;
+    fetcher?: typeof fetch;
+    publishableKey: string;
+}

package/types/booking/core/src/validation.d.ts

@@ -0,0 +1,9 @@
+import type { BookingContact, PatientDetails } from "./types.js";
+export declare function normalizeEmail(value: string): string;
+export declare function normalizePhone(value: string): string;
+export declare function isLikelyE164(value: string): boolean;
+export declare function validateContact(contact: BookingContact): string | null;
+export declare function validateExistingPhone(phone: string): string | null;
+export declare function validateVerificationCode(code: string): string | null;
+export declare function isValidPastDateOfBirth(value: string): boolean;
+export declare function validatePatientDetails(details?: PatientDetails): string | null;

package/types/booking/react/src/booking-context.d.ts

@@ -0,0 +1,70 @@
+import { type BookingClient, type BookingConfig, type BookingContact, type BookingLocale, type BookingResult, type BookingSlot, type BookingTheme, getBookingCopy, type PatientDetails } from "@veladent/booking-core";
+import { type ReactNode } from "react";
+export type BookingStep = "loading" | "gate" | "existingPhone" | "existingRecord" | "patientNoMatch" | "identityUnavailable" | "service" | "treatment" | "doctor" | "date" | "summary" | "details" | "otp" | "payment" | "success" | "error";
+export type BookingMode = "existing" | "new";
+export interface BookingState {
+    bookingMode: BookingMode | null;
+    config: BookingConfig | null;
+    contact: BookingContact;
+    copy: ReturnType<typeof getBookingCopy>;
+    direction: "ltr" | "rtl";
+    error: string | null;
+    isCheckingPayment: boolean;
+    isLoading: boolean;
+    locale: string;
+    needsPatientDetails: boolean;
+    otpCode: string;
+    patientDetails: PatientDetails;
+    resendCooldownSeconds: number;
+    result: BookingResult | null;
+    selectedDate: string;
+    selectedDoctorId: string | null;
+    selectedServiceId: string | null;
+    selectedSlot: BookingSlot | null;
+    selectedTreatmentId: string | null;
+    slots: BookingSlot[];
+    slotsError: string | null;
+    step: BookingStep;
+    timeZone: string;
+    verificationCode: string;
+    verificationExpiresInSeconds: number;
+    verificationSent: boolean;
+}
+export interface BookingActions {
+    cancelPayment(): Promise<void>;
+    checkPayment(): Promise<void>;
+    chooseDate(date: string): void;
+    chooseDoctor(doctorId: string): void;
+    chooseMode(mode: BookingMode): void;
+    chooseService(serviceId: string): void;
+    chooseSlot(slot: BookingSlot): void;
+    chooseTreatment(treatmentId: string): void;
+    continueDoctor(): void;
+    continueTreatment(): void;
+    findPatientRecord(): Promise<void>;
+    goBack(): void;
+    reload(): Promise<void>;
+    requestVerification(): Promise<void>;
+    setOtpCode(code: string): void;
+    setStep(step: BookingStep): void;
+    startPayment(): void;
+    submit(): Promise<void>;
+    updateContact(fields: Partial<BookingContact>): void;
+    updatePatientDetails(fields: Partial<PatientDetails>): void;
+    verifyCode(): Promise<void>;
+}
+export interface BookingContextValue {
+    actions: BookingActions;
+    state: BookingState;
+    theme: BookingTheme;
+}
+export interface BookingProviderProps {
+    children?: ReactNode;
+    client: BookingClient;
+    locale?: BookingLocale;
+    onComplete?: (result: BookingResult) => void;
+    theme?: BookingTheme;
+    timeZone?: string;
+}
+export declare function BookingProvider({ client, locale: localeProp, timeZone: timeZoneProp, theme, onComplete, children, }: BookingProviderProps): import("react").JSX.Element;
+export declare function useVeladantBooking(): BookingContextValue;

package/types/booking/react/src/booking-parts-context.d.ts

@@ -0,0 +1,7 @@
+import type { BookingClassNames, BookingComponents } from "./component-types.js";
+export interface BookingPartsContextValue {
+    classNames?: BookingClassNames;
+    components: BookingComponents;
+}
+export declare const BookingPartsContext: import("react").Context<BookingPartsContextValue | null>;
+export declare function useBookingParts(): BookingPartsContextValue;

package/types/booking/react/src/booking-parts.d.ts

@@ -0,0 +1,148 @@
+import { type ComponentPropsWithRef } from "react";
+import { type BookingWidgetProps } from "./booking-widget.js";
+import type { BookingClassNames } from "./component-types.js";
+type DivProps = ComponentPropsWithRef<"div">;
+export interface BookingStepProps extends Omit<DivProps, "children"> {
+    classNames?: BookingClassNames;
+}
+export interface BookingStepsProps extends DivProps {
+    classNames?: BookingClassNames;
+}
+export declare function BookingRoot({ children, ...props }: BookingWidgetProps): import("react").JSX.Element;
+export declare function BookingHeader({ children, className, ...props }: ComponentPropsWithRef<"header">): import("react").JSX.Element;
+export declare function BookingBranding({ children, className, ...props }: DivProps): import("react").JSX.Element | null;
+export declare function BookingNavigation({ className, ...props }: DivProps): import("react").JSX.Element;
+export declare function BookingTitle({ children, className, ...props }: ComponentPropsWithRef<"h2">): import("react").JSX.Element;
+export declare function BookingDescription({ children, className, ...props }: ComponentPropsWithRef<"p">): import("react").JSX.Element | null;
+export declare function BookingBackButton({ children, className, onClick, disabled, ...props }: ComponentPropsWithRef<"button">): import("react").JSX.Element | null;
+export declare function BookingProgress({ children, className, ...props }: DivProps): import("react").JSX.Element | null;
+export declare function BookingProgressIndicator({ className, style, ...props }: DivProps): import("react").JSX.Element;
+export declare function BookingContent({ children, className, ...props }: DivProps): import("react").JSX.Element;
+export declare const BookingGateStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingExistingPhoneStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingExistingRecordStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingPatientNoMatchStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingIdentityUnavailableStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingServiceStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingTreatmentStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingDoctorStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingDateStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingSummary: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingDetailsStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingOtpStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export declare const BookingPaymentStep: {
+    ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+    displayName: string;
+};
+export interface BookingLoadingProps extends DivProps {
+    spinnerClassName?: string;
+}
+export declare function BookingLoading({ className, spinnerClassName, ...props }: BookingLoadingProps): import("react").JSX.Element | null;
+export declare function BookingSuccess({ className, ...props }: DivProps): import("react").JSX.Element | null;
+export declare function BookingError({ className, ...props }: DivProps): import("react").JSX.Element | null;
+export declare function BookingSteps({ children, className, classNames, ...props }: BookingStepsProps): import("react").JSX.Element;
+export declare const Booking: {
+    BackButton: typeof BookingBackButton;
+    Branding: typeof BookingBranding;
+    Content: typeof BookingContent;
+    DateStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Description: typeof BookingDescription;
+    DetailsStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    DoctorStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Error: typeof BookingError;
+    ExistingPhoneStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    ExistingRecordStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    GateStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Header: typeof BookingHeader;
+    IdentityUnavailableStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Loading: typeof BookingLoading;
+    Navigation: typeof BookingNavigation;
+    OtpStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    PatientNoMatchStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    PaymentStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Progress: typeof BookingProgress;
+    ProgressIndicator: typeof BookingProgressIndicator;
+    Root: typeof BookingRoot;
+    ServiceStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Steps: typeof BookingSteps;
+    Success: typeof BookingSuccess;
+    Summary: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Title: typeof BookingTitle;
+    TreatmentStep: {
+        ({ className, classNames, ...props }: BookingStepProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+};
+export {};

package/types/booking/react/src/booking-widget.d.ts

@@ -0,0 +1,19 @@
+import { type BookingClient, type BookingLocale, type BookingResult, type BookingTheme } from "@veladent/booking-core";
+import { type ComponentPropsWithRef, type ReactNode } from "react";
+import type { BookingClassNames, BookingComponentOverrides, BookingComponents } from "./component-types.js";
+
+export declare const defaultBookingComponents: BookingComponents;
+export interface BookingWidgetProps extends Omit<ComponentPropsWithRef<"section">, "children"> {
+    baseUrl?: string;
+    children?: ReactNode;
+    className?: string;
+    classNames?: BookingClassNames;
+    client?: BookingClient;
+    components?: BookingComponentOverrides;
+    locale?: BookingLocale;
+    onComplete?: (result: BookingResult) => void;
+    publishableKey?: string;
+    theme?: BookingTheme;
+    timeZone?: string;
+}
+export declare function BookingWidget({ client, baseUrl, publishableKey, locale, timeZone, theme, className, classNames, components, onComplete, children, ...rootProps }: BookingWidgetProps): import("react").JSX.Element;

package/types/booking/react/src/component-types.d.ts

@@ -0,0 +1,33 @@
+import type { ComponentType } from "react";
+import type { BookingStep } from "./booking-context.js";
+export type BookingPart = "root" | "header" | "body" | "loading" | "loadingSpinner" | "step" | "branding" | "gate" | "serviceList" | "service" | "treatmentList" | "treatment" | "doctorList" | "doctor" | "date" | "slotList" | "slot" | "summary" | "details" | "otp" | "form" | "input" | "button" | "hint" | "actions" | "error" | "success" | "payment" | "phone" | "phoneCountry";
+export type BookingClassNames = Partial<Record<BookingPart, string>>;
+export interface BookingStepComponentProps {
+    classNames?: BookingClassNames;
+}
+export interface StepHeaderProps {
+    backLabel: string;
+    className?: string;
+    direction: "ltr" | "rtl";
+    hideBack?: boolean;
+    onBack: () => void;
+    step: BookingStep;
+    title: string;
+}
+export interface BookingComponents {
+    DateStep: ComponentType<BookingStepComponentProps>;
+    DetailsStep: ComponentType<BookingStepComponentProps>;
+    DoctorStep: ComponentType<BookingStepComponentProps>;
+    ExistingPhoneStep: ComponentType<BookingStepComponentProps>;
+    ExistingRecordStep: ComponentType<BookingStepComponentProps>;
+    GateStep: ComponentType<BookingStepComponentProps>;
+    IdentityUnavailableStep: ComponentType<BookingStepComponentProps>;
+    OtpStep: ComponentType<BookingStepComponentProps>;
+    PatientNoMatchStep: ComponentType<BookingStepComponentProps>;
+    PaymentStep: ComponentType<BookingStepComponentProps>;
+    ServiceStep: ComponentType<BookingStepComponentProps>;
+    StepHeader: ComponentType<StepHeaderProps>;
+    SummaryModal: ComponentType<BookingStepComponentProps>;
+    TreatmentStep: ComponentType<BookingStepComponentProps>;
+}
+export type BookingComponentOverrides = Partial<BookingComponents>;

package/types/booking/react/src/components/card-arrow.d.ts

@@ -0,0 +1,4 @@
+export interface CardArrowProps {
+    className?: string;
+}
+export declare function CardArrow({ className }: CardArrowProps): import("react").JSX.Element;

package/types/booking/react/src/components/date-step.d.ts

@@ -0,0 +1,2 @@
+import type { BookingStepComponentProps } from "../component-types.js";
+export declare function DateStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;

package/types/booking/react/src/components/details-step.d.ts

@@ -0,0 +1,2 @@
+import type { BookingStepComponentProps } from "../component-types.js";
+export declare function DetailsStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;

package/types/booking/react/src/components/doctor-step.d.ts

@@ -0,0 +1,2 @@
+import type { BookingStepComponentProps } from "../component-types.js";
+export declare function DoctorStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;

package/types/booking/react/src/components/existing-phone-step.d.ts

@@ -0,0 +1,2 @@
+import type { BookingStepComponentProps } from "../component-types.js";
+export declare function ExistingPhoneStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;

package/types/booking/react/src/components/existing-record-step.d.ts

@@ -0,0 +1,4 @@
+import type { BookingStepComponentProps } from "../component-types.js";
+export declare function ExistingRecordStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;
+export declare function IdentityUnavailableStep({ classNames, }: BookingStepComponentProps): import("react").JSX.Element;
+export declare function PatientNoMatchStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;

package/types/booking/react/src/components/gate-step.d.ts

@@ -0,0 +1,2 @@
+import type { BookingStepComponentProps } from "../component-types.js";
+export declare function GateStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;

package/types/booking/react/src/components/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./card-arrow.js";
+export * from "./date-step.js";
+export * from "./details-step.js";
+export * from "./doctor-step.js";
+export * from "./existing-phone-step.js";
+export * from "./existing-record-step.js";
+export * from "./gate-step.js";
+export * from "./option-card.js";
+export * from "./otp-step.js";
+export * from "./payment-step.js";
+export * from "./phone-input.js";
+export * from "./service-step.js";
+export * from "./step-header.js";
+export * from "./summary-modal.js";
+export * from "./treatment-step.js";

package/types/booking/react/src/components/option-card.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+export interface OptionCardProps {
+    children: ReactNode;
+    className?: string;
+    onClick: () => void;
+    selected?: boolean;
+}
+export declare function OptionCard({ children, className, onClick, selected, }: OptionCardProps): import("react").JSX.Element;

package/types/booking/react/src/components/otp-step.d.ts

@@ -0,0 +1,2 @@
+import type { BookingStepComponentProps } from "../component-types.js";
+export declare function OtpStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;

package/types/booking/react/src/components/payment-step.d.ts

@@ -0,0 +1,2 @@
+import type { BookingStepComponentProps } from "../component-types.js";
+export declare function PaymentStep({ classNames }: BookingStepComponentProps): import("react").JSX.Element;

package/types/booking/react/src/components/phone-input.d.ts

@@ -0,0 +1,16 @@
+import type { BookingTheme } from "@veladent/booking-core";
+import { type CountryCode } from "libphonenumber-js";
+import type { BookingClassNames } from "../component-types.js";
+export interface PhoneInputProps {
+    classNames?: BookingClassNames;
+    countryLabel: string;
+    defaultCountry?: CountryCode;
+    isDisabled?: boolean;
+    isRequired?: boolean;
+    label: string;
+    locale?: string;
+    onChange: (phone: string) => void;
+    theme?: BookingTheme;
+    value: string;
+}
+export declare function PhoneInput({ value, onChange, label, countryLabel, locale, defaultCountry, isDisabled, isRequired, classNames, theme, }: PhoneInputProps): import("react").JSX.Element;