/**
 * Block API Client Types
 *
 * Request/response types for all client-side API calls from blocks.
 */
import type { AppointmentResourceId } from "@riverbankcms/core";
/** API key auth for SDK sites (bld_live_sk_*) */
export type ApiKeyAuth = {
    type: "api-key";
    key: string;
};
/** Bearer token auth for preview mode or customer portal */
export type BearerAuth = {
    type: "bearer";
    token: string;
};
/** No auth - public endpoints only */
export type NoAuth = {
    type: "none";
};
/** Auth strategy for Block API Client */
export type BlockApiAuth = ApiKeyAuth | BearerAuth | NoAuth;
/** Configuration for creating a Block API Client */
export interface BlockApiConfig {
    /** Dashboard API URL (e.g., https://dashboard.example.com/api) */
    baseUrl: string;
    /** Auth strategy */
    auth: BlockApiAuth;
    /**
     * Optional per-scope auth overrides.
     * Useful when a single page needs multiple auth modes (e.g. preview + portal).
     */
    authOverrides?: {
        /**
         * Auth override for customer portal endpoints (`/portal/*`).
         * Portal endpoints are authenticated via a portal session token and are not stage-aware.
         */
        portal?: BlockApiAuth;
    };
    /** Site ID for site-scoped endpoints */
    siteId?: string;
    /** Include draft content (adds stage=preview param) */
    isPreview?: boolean;
}
/** API success response wrapper */
export interface ApiSuccessResponse<T> {
    success: true;
    data: T;
}
/** API error response */
export interface ApiErrorResponse {
    success: false;
    error: {
        message: string;
        code?: string;
    };
}
/** Standard API response */
export type ApiResponse<T> = ApiSuccessResponse<T> | ApiErrorResponse;
export interface FormSubmitRequest {
    formId: string;
    data: Record<string, unknown>;
    meta?: {
        honeypot?: string;
        altchaSolution?: string | null;
        referer?: string;
        userAgent?: string;
        path?: string;
    };
}
export interface FormSubmitResponse {
    success: boolean;
    submissionId?: string;
}
export type { FormField } from "../components/multi-step/DynamicFormFields";
import type { FormField } from "../components/multi-step/DynamicFormFields";
export interface FormConfigResponse {
    form: {
        id: string;
        name: string;
        slug: string;
        settingsJson?: {
            type: "booking";
            serviceId?: string;
            serviceIds?: string[];
            resourceId?: string;
            requiresApproval?: boolean;
            successMessage?: string;
        };
        schemaJson?: {
            version: string;
            fields: FormField[];
        };
        settings?: {
            type: "booking";
            serviceId?: string;
            serviceIds?: string[];
            resourceId?: string;
            requiresApproval?: boolean;
            successMessage?: string;
        };
        schema?: {
            version: string;
            fields: FormField[];
        };
    };
}
export interface BookingSubmitRequest {
    formId: string;
    serviceId: string;
    resourceId?: string | null;
    startAt: string;
    endAt: string;
    customFields: Record<string, unknown>;
    timezone: string;
    discountCode?: string;
    selectedCollectionOptionKind?: "upfront" | "deferred_manual" | "instalment_plan" | "flexible_balance";
    altchaSolution?: string | null;
    successUrl?: string;
    cancelUrl?: string;
}
export type BookingPackageSubmitRequest = Omit<BookingSubmitRequest, "altchaSolution" | "cancelUrl" | "discountCode" | "selectedCollectionOptionKind" | "successUrl"> & {
    customerPassId: string;
};
export type BookingAppointmentSummary = {
    id: string;
    status: "confirmed" | "pending" | "cancelled";
    startAt: string;
    endAt: string;
    timezone: string;
    resourceName: string | null;
};
export type BookingCustomerSummary = {
    id: string;
    email: string | null;
    name: string | null;
    phone: string | null;
};
export type BookingSubmitResponse = {
    type: "booked";
    orderId: string;
    orderNumber: string;
    appointment: BookingAppointmentSummary;
    customer: BookingCustomerSummary;
} | {
    type: "checkout_redirect";
    orderId: string;
    orderNumber: string;
    checkoutUrl: string;
    sessionId: string;
    appointment: BookingAppointmentSummary;
    customer: BookingCustomerSummary;
};
export type EligibleAppointmentPackage = {
    customerPassId: string;
    passId: string;
    passName: string;
    passDescription: string | null;
    creditsRemaining: number;
    creditsTotal: number;
    expiresAt: string | null;
};
export interface EligibleAppointmentPackagesResponse {
    packages: EligibleAppointmentPackage[];
}
export interface AppointmentBookingStatusRequest {
    siteId: string;
    sessionId: string;
}
export type AppointmentBookingStatusResponse = {
    appointmentId: string;
    appointmentStatus: "pending" | "confirmed" | "cancelled";
    resourceName: string | null;
    paymentStatus: "pending" | "completed" | "failed" | "cancelled" | "refunded" | "not_required";
};
export interface AvailableSlotsRequest {
    siteId: string;
    serviceId: string;
    startDate: string;
    endDate: string;
    timezone: string;
    resourceId?: string;
}
export interface TimeSlot {
    startAt: string;
    endAt: string;
    resourceId: AppointmentResourceId;
}
export interface AvailableSlotsResponse {
    slots: TimeSlot[];
}
export interface AvailableDatesRequest {
    siteId: string;
    serviceId: string;
    startDate: string;
    endDate: string;
    timezone: string;
    resourceId?: string;
}
export interface AvailableDatesResponse {
    dates: string[];
    hasMore: boolean;
    nextStartDate?: string;
    startDate: string;
    endDate: string;
}
export interface BookingService {
    id: string;
    title: string;
    description?: string;
    durationMinutes?: number;
    priceAmount?: number | null;
    priceCurrency?: string | null;
    paymentTerms?: import("../../blocks/shared/bookingPaymentTerms").BlockBookingPaymentTerms;
}
export interface BookingServicesRequest {
    siteId: string;
    ids?: string[];
}
export interface BookingServicesResponse {
    services: BookingService[];
}
export interface BookingServiceResponse {
    service: BookingService;
}
export interface BookingResource {
    id: string;
    label: string;
}
export interface BookingResourcesRequest {
    siteId: string;
    serviceId: string;
}
export interface BookingResourcesResponse {
    options: BookingResource[];
}
import type { PublicEvent as _PublicEvent, EventVenue as _EventVenue, PricingType as _PricingType, AccessRestriction as _AccessRestriction, PublicEventTicketType as _PublicEventTicketType, PublicEventTicketTypeAvailability as _PublicEventTicketTypeAvailability } from "../../blocks/events/shared/types";
import type { EventScheduleScope, EventSurfaceScope } from "../../blocks/events/shared/filtering";
export type PublicEvent = _PublicEvent;
export type EventVenue = _EventVenue;
export type PricingType = _PricingType;
export type AccessRestriction = _AccessRestriction;
export type PublicEventTicketType = _PublicEventTicketType;
export type PublicEventTicketTypeAvailability = _PublicEventTicketTypeAvailability;
export interface EligibilityEventTicketType {
    id: string;
    name: string;
    description: string | null;
    priceAmount: number;
    isActive: boolean;
    sortOrder: number;
    capacityMode: "limited" | "unlimited";
    capacityLimit: number | null;
    attendanceScope?: 'in_person' | 'online' | 'both';
    saleStartsAt: string | null;
    saleEndsAt: string | null;
    availability: PublicEventTicketTypeAvailability;
}
export interface PublicEventsRequest {
    siteId: string;
    from?: string;
    to?: string;
    /** Cursor: only return events after this startsAt */
    afterStartsAt?: string;
    /** Cursor: tie-breaker for events with same startsAt (occurrenceId) */
    afterId?: string;
    limit?: number;
    stage?: "preview" | "published";
    /** Filter by kind */
    kind?: "all" | "courses" | "events";
    /** Semantic event surface scope */
    eventSurface?: EventSurfaceScope;
    /** Filter by event presets (comma-separated) */
    eventPresets?: string;
    /** Filter by event schedule cadence */
    scheduleScope?: EventScheduleScope;
    /** Filter by category IDs (comma-separated) */
    categoryIds?: string;
    /** Filter by venue ID */
    venueId?: string;
    /** Filter by staff member ID */
    staffMemberId?: string;
    /** Scope results to a single series (by linked content entry ID) */
    entryId?: string;
    /** Scope results to a single series (by series ID) */
    seriesId?: string;
    /** Ensure this occurrence is included even if outside date window */
    includeOccurrenceId?: string;
    /** Response detail level for list-style blocks */
    detailLevel?: 'full' | 'listing';
}
export interface PublicEventsResponse {
    success: boolean;
    data: PublicEvent[];
}
export interface EventFilterCategory {
    id: string;
    name: string;
    identifier: string | null;
    color: string | null;
    /** Count of upcoming events in this category */
    upcomingCount: number;
}
export interface EventFilterVenue {
    id: string;
    name: string;
    /** Count of upcoming events at this venue */
    upcomingCount: number;
}
export interface EventFilterStaffMember {
    id: string;
    name: string;
    /** Count of upcoming events for this staff member */
    upcomingCount: number;
}
export interface EventFilterLabels {
    courseOption: string;
}
export interface EventFiltersResponse {
    categories: EventFilterCategory[];
    venues: EventFilterVenue[];
    staffMembers: EventFilterStaffMember[];
    labels: EventFilterLabels;
}
export type PaymentMethod = "free" | "pass" | "membership" | "stripe" | "pass_bundle" | "membership_bundle";
/**
 * Guest details for additional attendees
 */
export interface EventRegisterGuest {
    name: string;
    email?: string | null;
    phone?: string | null;
}
export interface EventRegisterRequest {
    siteId: string;
    occurrenceId: string;
    attendanceMode?: 'in_person' | 'online';
    ticketTypeId?: string;
    email: string;
    name: string;
    ticketsCount: number;
    phone?: string;
    notes?: string;
    altchaSolution?: string | null;
    stage?: "preview" | "published";
    paymentMethod?: PaymentMethod;
    customerPassId?: string;
    customerMembershipId?: string;
    /** Product ID for bundle purchases (pass or membership ID to buy) */
    bundleProductId?: string;
    claimToken?: string;
    /** Guest details when "collect all attendee details" is enabled */
    guests?: EventRegisterGuest[];
}
export type EventRegisterResponse = {
    success: boolean;
    attendeeId: string;
    status: "confirmed";
    paymentMethod: PaymentMethod;
    pendingPayment: boolean;
    passCreditsUsed?: number;
    alreadyRegistered?: boolean;
    message?: string;
} | {
    success: boolean;
    attendeeId: string;
    status: "waitlist";
    waitlistPosition: number | null;
    alreadyRegistered?: boolean;
    message?: string;
};
/** Type of checkout for event payment */
export type EventCheckoutType = "event" | "pass_bundle" | "membership_bundle";
export interface EventCheckoutRequest {
    siteId: string;
    attendeeId: string;
    /** Type of checkout: 'event' for direct payment, or bundle types */
    checkoutType?: EventCheckoutType;
    /** Product ID for bundle purchases (pass or membership ID) */
    productId?: string;
    /** Optional booking discount code (applies only to Stripe/card flows) */
    discountCode?: string;
    successUrl: string;
    cancelUrl: string;
}
export interface EventCheckoutResponse {
    checkoutUrl: string | null;
    sessionId: string | null;
    bypassed: boolean;
}
export interface EligiblePass {
    customerPassId: string;
    passName: string;
    creditsRemaining: number;
}
export interface EligibleMembership {
    customerMembershipId: string;
    membershipName: string;
}
export interface AvailablePass {
    id: string;
    name: string;
    description: string | null;
    price: number;
    currency: string;
    creditsTotal: number;
    pricePerCredit: number;
    validDays: number | null;
}
export interface AvailableMembership {
    id: string;
    name: string;
    description: string | null;
    price: number;
    currency: string;
    interval: "month" | "year";
}
export interface EligibilityCheckRequest {
    siteId: string;
    occurrenceId: string;
    attendanceMode?: 'in_person' | 'online';
    ticketTypeId?: string;
    email: string;
    ticketsCount: number;
}
export interface EligibilityCheckResponse {
    customerExists: boolean;
    eligibility: {
        isFull: boolean;
        waitlistEnabled: boolean;
        canJoinWaitlist: boolean;
        membership: EligibleMembership | null;
        passes: EligiblePass[];
        requiresPayment: boolean;
        pricingMode?: "single" | "ticket_types";
        selectedTicketTypeId?: string | null;
        ticketTypes?: EligibilityEventTicketType[];
        eventPrice: number | null;
        eventPriceCurrency: string | null;
        eventAcceptsPasses: boolean;
        eventAcceptsMemberships: boolean;
        requiresAuthForPasses: boolean;
        requiresAuthForMemberships: boolean;
        availableForPurchase: {
            passes: AvailablePass[];
            memberships: AvailableMembership[];
        };
    };
}
/** Payment status values returned by the backend */
export type PaymentStatus = "pending" | "completed" | "failed" | "not_required" | "refunded";
/** Attendee status values returned by the backend */
export type AttendeeStatus = "confirmed" | "waitlist" | "cancelled";
export interface EventRegistrationStatusRequest {
    siteId: string;
    attendeeId: string;
}
export interface EventRegistrationStatusResponse {
    paymentStatus: PaymentStatus;
    attendeeStatus: AttendeeStatus;
    waitlistPosition: number | null;
}
export type CoursePaymentMethod = "free" | "membership" | "stripe";
export interface CourseEnrollRequest {
    siteId: string;
    courseId: string;
    pricingOptionId?: string;
    email: string;
    name: string;
    phone?: string;
    formData?: Record<string, unknown>;
    altchaSolution?: string | null;
    stage?: "preview" | "published";
    paymentMethod?: Exclude<CoursePaymentMethod, "stripe">;
    customerMembershipId?: string;
    claimToken?: string;
}
interface CourseEnrollBaseResponse {
    waitlistPosition?: number | null;
    courseTitle: string;
    sessionsCount: number;
    message: string;
}
export interface CourseEnrollSuccessResponse extends CourseEnrollBaseResponse {
    status: "enrolled";
    enrollmentId: string;
    paymentMethod: CoursePaymentMethod;
    pendingPayment: boolean;
}
export interface CourseWaitlistResponse extends CourseEnrollBaseResponse {
    status: "waitlist";
    paymentMethod: "free";
    pendingPayment: false;
}
export type CourseEnrollResponse = CourseEnrollSuccessResponse | CourseWaitlistResponse;
export interface CourseEligibilityCheckRequest {
    siteId: string;
    courseId: string;
}
export interface CourseEligibilityCheckResponse {
    courseId: string;
    canEnroll: boolean;
    canJoinWaitlist: boolean;
    reason?: string;
    availableSpots: number | null;
    isFull: boolean;
    isOnWaitlist: boolean;
    waitlistEnabled: boolean;
    price: {
        cents: number | null;
        currency: string;
    };
    paymentOptions: {
        free: boolean;
        membership: boolean;
        stripe: boolean;
    };
    eligibleMemberships?: Array<{
        customerMembershipId: string;
        membershipName: string;
    }>;
}
export interface CourseCheckoutRequest {
    siteId: string;
    courseId: string;
    pricingOptionId?: string;
    email: string;
    name: string;
    phone?: string;
    formData?: Record<string, unknown>;
    altchaSolution?: string | null;
    /** Optional booking discount code (applies only to Stripe/card flows) */
    discountCode?: string;
    successUrl: string;
    cancelUrl: string;
    claimToken?: string;
}
export type WaitlistClaimSubject = {
    kind: "event_occurrence";
    occurrenceId: string;
    attendanceMode: 'in_person' | 'online';
} | {
    kind: "course";
    courseId: string;
};
export interface ResolveWaitlistClaimRequest {
    siteId: string;
    claimToken: string;
}
export interface ResolveWaitlistClaimResponse {
    subject: WaitlistClaimSubject;
    expiresAt: string;
    customer: {
        email: string;
        name: string;
        phone: string | null;
    };
    prefill: {
        email: string;
        name: string;
        phone: string | null;
        notes: string | null;
        guests: Array<{
            name: string;
            email?: string | null;
            phone: string | null;
        }>;
    };
}
export interface CourseCheckoutResponse {
    checkoutUrl: string | null;
    sessionId: string | null;
    enrollmentId: string;
    bypassed: boolean;
}
export type DiscountContext = {
    type: "event";
    eventSeriesId: string;
    eventCategoryId: string | null;
    ticketsCount?: number;
} | {
    type: "appointment";
    serviceId: string;
} | {
    type: "course";
    courseId: string;
} | {
    type: "pass";
    passId: string;
} | {
    type: "membership";
    membershipId: string;
};
export interface DiscountsAvailableRequest {
    siteId: string;
    context: DiscountContext;
    subtotalCents?: number;
}
export interface AutoAppliedDiscountPreview {
    id: string;
    code: string;
    publicLabel: string;
    description: string | null;
    discountType: "percent" | "fixed";
    discountPercent: number | null;
    discountAmountCents: number | null;
    computedAmountCents: number;
}
export interface DiscountsAvailableResponse {
    hasDiscounts: boolean;
    manualCodeEntryAllowed: boolean;
    autoAppliedDiscount: AutoAppliedDiscountPreview | null;
}
export interface CourseRegistrationStatusRequest {
    siteId: string;
    sessionId: string;
}
export interface CourseRegistrationStatusResponse {
    enrollmentId: string;
    courseId: string;
    courseTitle: string;
    status: "pending_payment" | "enrolled" | "waitlist" | "cancelled" | "completed";
    paymentMethod: CoursePaymentMethod | null;
    paymentStatus: PaymentStatus | null;
}
export interface PublicProductVariant {
    id: string;
    title: string;
    sku: string | null;
    priceCents: number;
    stockQuantity: number | null;
    soldOut: boolean;
}
export interface PublicProduct {
    id: string;
    contentEntryId: string | null;
    title: string;
    slug: string;
    path: string | null;
    status: "draft" | "active";
    priceCents: number;
    currency: string;
    productType: "physical" | "digital";
    requiresShipping: boolean;
    hasVariants: boolean;
    trackInventory: boolean;
    soldOut: boolean;
    category: {
        id: string;
        name: string;
        slug: string;
    } | null;
    summary: string | null;
    badges: string[];
    ctaLabel: string | null;
    body: unknown | null;
    gallery: Array<{
        url: string;
        alt: string | null;
    }>;
    variants: PublicProductVariant[];
}
export interface PublicProductsResponse {
    products: PublicProduct[];
}
export interface ShopCheckoutRequest {
    siteId: string;
    productType: "pass" | "membership";
    productId: string;
    customerEmail: string;
    customerName: string;
    /** Optional booking discount code (applies only to Stripe/card flows) */
    discountCode?: string;
    successUrl: string;
    cancelUrl: string;
    confirmDuplicate?: boolean;
}
export interface ShopCheckoutResponse {
    checkoutUrl: string | null;
    sessionId: string | null;
    bypassed: boolean;
}
export interface ShopDuplicateMembershipWarning {
    warning: "duplicate_membership";
    message: string;
    existingMembership: {
        id: string;
        name: string;
        expiresAt: string | null;
    };
}
export type UnifiedCheckoutItem = {
    type: "course_enrollment";
    courseId: string;
    pricingOptionId?: string;
    attendeeInfo: {
        email: string;
        name: string;
        formData?: Record<string, unknown>;
    };
} | {
    type: "product";
    productId: string;
    variantId?: string;
    quantity: number;
} | {
    type: "pass";
    passId: string;
};
export interface UnifiedCheckoutRequest {
    siteId: string;
    mode: "one_time";
    items: UnifiedCheckoutItem[];
    customer: {
        email: string;
        name: string;
    };
    discountCode?: string;
    successUrl: string;
    cancelUrl: string;
}
export type UnifiedCheckoutResponse = {
    type: "redirect";
    checkoutUrl: string;
    sessionId: string;
    orderId: string | null;
    orderNumber: string | null;
} | {
    type: "bypassed";
    orderId: string | null;
    orderNumber: string | null;
};
export interface PublicGiftCardOffer {
    id: string;
    kind: "gift_card";
    title: string;
    description: string | null;
    sortOrder: number;
    giftCard: {
        fixedDenominations: number[];
        customAmountEnabled: boolean;
        customAmountMinCents: number;
        customAmountMaxCents: number;
    };
    voucher: null;
}
export interface PublicVoucherOffer {
    id: string;
    kind: "voucher";
    title: string;
    description: string | null;
    sortOrder: number;
    giftCard: null;
    voucher: {
        purchaseAmountCents: number;
    };
}
export interface PublicGiftingOffersResponse {
    currency: string;
    giftCards: PublicGiftCardOffer[];
    vouchers: PublicVoucherOffer[];
}
export interface CreateGiftingCheckoutRequest {
    siteId: string;
    offerId: string;
    purchaserName?: string | null;
    purchaserEmail: string;
    recipientName?: string | null;
    recipientEmail: string;
    message?: string | null;
    amountCents?: number | null;
    sendOnDate?: string | null;
    successUrl: string;
    cancelUrl: string;
}
export interface CreateGiftingCheckoutResponse {
    checkoutUrl: string;
    sessionId: string;
}
export interface ClaimGiftCardRequest {
    siteId: string;
    email: string;
    token?: string | null;
    code?: string | null;
}
export interface ClaimGiftCardResponse {
    customerId: string;
    amountCents: number;
    currency: string;
}
export type { AppointmentBookingQuestionsTaskDetail, BookingQuestionsTaskDetail, BookingQuestionsAnswerValue, BookingQuestionsDocumentAnswerValue, BookingQuestionsField, BookingQuestionsFieldOption, BookingQuestionsSection, BeforeYouComeTaskSummary, CustomerProfile, CustomerOrderInstalmentPlan, CustomerOrderInstalmentPlanStatus, CustomerOrderInstalmentRow, CustomerOrderInstalmentStatus, CustomerOrder, CustomerOrderFilter, CustomerOrderItem, CustomerOrderPaymentState, CustomerOrderRefund, CustomerPass, CustomerPassCreditHistoryEntry, CustomerMembership, CustomerEventRegistration, CustomerCourseEnrollment, CustomerAppointment, EnabledModules, EventGuest, PortalCredit, PortalCreditSummary, PortalCreditTransaction, PortalDigitalProduct, PortalDigitalProductFile, } from "../../../portal/types";
import type { EventGuest as EventGuestType } from "../../../portal/types";
/**
 * Full response from GET /api/portal/me including profile and enabled modules
 */
export interface PortalMeResponse {
    profile: import("../../../portal/types").CustomerProfile;
    modules: import("../../../portal/types").EnabledModules;
}
export interface PortalMeUpdateRequest {
    name?: string;
    phone?: string | null;
}
export interface PortalEventTicket {
    ticketUrl: string;
    qrImageUrl: string;
    fallbackCode: string;
    registration: {
        id: string;
        eventTitle: string;
        seriesName: string | null;
        startsAt: string;
        endsAt: string;
        timeZone: string;
        venueName: string | null;
        venueAddress: string | null;
        ticketsCount: number;
    };
}
export interface MagicLinkRequest {
    siteId: string;
    email: string;
    /** URL to redirect to after magic link verification. Required by server. */
    redirectUrl: string;
}
export interface PortalCreditResponse {
    credit: import("../../../portal/types").PortalCredit | null;
}
export interface PortalOrdersResponse {
    orders: import("../../../portal/types").CustomerOrder[];
}
export interface PortalOrderCheckoutRequest {
    successUrl: string;
    cancelUrl: string;
    amountCents?: number;
}
export interface PortalOrderCheckoutResponse {
    checkoutUrl: string;
    sessionId: string;
}
export interface PortalDigitalProductsResponse {
    tabLabel: string;
    products: import("../../../portal/types").PortalDigitalProduct[];
}
export interface PortalDigitalProductAccessResponse {
    product: import("../../../portal/types").PortalDigitalProduct;
    guardedHref: string | null;
}
export interface PortalDigitalProductDownloadUrlResponse {
    signedUrl: string;
    filename: string;
}
export interface PortalAppointmentBookingQuestionsResponse {
    task: import("../../../portal/types").BookingQuestionsTaskDetail;
}
export interface PortalUpdateAppointmentBookingQuestionsRequest {
    answers: Record<string, unknown>;
}
export interface PortalUpdateAppointmentBookingQuestionsResponse {
    task: import("../../../portal/types").BookingQuestionsTaskDetail;
}
export interface PortalCreateAppointmentBookingQuestionsUploadUrlRequest {
    fieldId: string;
    filename: string;
    bytes: number;
}
export interface PortalCreateAppointmentBookingQuestionsUploadUrlResponse {
    uploadId: string;
    signedUrl: string;
}
export interface PortalFinalizeAppointmentBookingQuestionsUploadRequest {
    fieldId: string;
    uploadId: string;
}
export interface PortalFinalizeAppointmentBookingQuestionsUploadResponse {
    answer: import("../../../portal/types").BookingQuestionsDocumentAnswerValue;
}
export interface PortalEventBookingQuestionsResponse {
    task: import("../../../portal/types").BookingQuestionsTaskDetail;
}
export interface PortalUpdateEventBookingQuestionsRequest {
    answers: Record<string, unknown>;
}
export interface PortalUpdateEventBookingQuestionsResponse {
    task: import("../../../portal/types").BookingQuestionsTaskDetail;
}
export interface PortalCreateEventBookingQuestionsUploadUrlRequest {
    fieldId: string;
    filename: string;
    bytes: number;
}
export interface PortalCreateEventBookingQuestionsUploadUrlResponse {
    uploadId: string;
    signedUrl: string;
}
export interface PortalFinalizeEventBookingQuestionsUploadRequest {
    fieldId: string;
    uploadId: string;
}
export interface PortalFinalizeEventBookingQuestionsUploadResponse {
    answer: import("../../../portal/types").BookingQuestionsDocumentAnswerValue;
}
export interface PortalCourseBookingQuestionsResponse {
    task: import("../../../portal/types").BookingQuestionsTaskDetail;
}
export interface PortalUpdateCourseBookingQuestionsRequest {
    answers: Record<string, unknown>;
}
export interface PortalUpdateCourseBookingQuestionsResponse {
    task: import("../../../portal/types").BookingQuestionsTaskDetail;
}
export interface PortalCreateCourseBookingQuestionsUploadUrlRequest {
    fieldId: string;
    filename: string;
    bytes: number;
}
export interface PortalCreateCourseBookingQuestionsUploadUrlResponse {
    uploadId: string;
    signedUrl: string;
}
export interface PortalFinalizeCourseBookingQuestionsUploadRequest {
    fieldId: string;
    uploadId: string;
}
export interface PortalFinalizeCourseBookingQuestionsUploadResponse {
    answer: import("../../../portal/types").BookingQuestionsDocumentAnswerValue;
}
export interface UpdateEventGuestsRequest {
    guests: Array<{
        name: string;
        phone?: string | null;
    }>;
}
export interface EventGuestsResponse {
    guests: EventGuestType[];
}
export interface PortalCancelEventRegistrationRequest {
    confirmCancelWithoutRefund?: boolean;
}
export interface PortalCancelCourseEnrollmentRequest {
    confirmCancelWithoutRefund?: boolean;
}
export interface PortalRescheduleAppointmentRequest {
    startAt: string;
    endAt: string;
    resourceId: string;
}
export interface PortalRescheduleAppointmentResponse {
    appointment: {
        id: string;
        status: string;
        startAt: string;
        endAt: string;
        resourceId: string;
    };
}
export interface PortalCancelAppointmentRequest {
    confirmCancelWithoutRefund?: boolean;
}
export interface PortalCancelCourseEnrollmentResult {
    cancelled: boolean;
    refunded: boolean;
    refund?: PortalRefundInfo;
    requiresCancelWithoutRefundConfirmation?: boolean;
    message: string;
}
export interface PortalRefundInfo {
    status: "succeeded" | "failed" | "skipped";
    amountCents: number | null;
    currency: string | null;
    paymentLast4: string | null;
    stripeRefundId: string | null;
    errorMessage?: string;
    errorCode?: string;
}
export interface PortalCancelEventRegistrationResult {
    cancelled: boolean;
    refunded: boolean;
    refund?: PortalRefundInfo;
    requiresCancelWithoutRefundConfirmation?: boolean;
    message: string;
}
export interface PortalCancelAppointmentResult {
    cancelled: boolean;
    refunded: boolean;
    refund?: PortalRefundInfo;
    requiresCancelWithoutRefundConfirmation?: boolean;
    failedToRestoreCredit?: boolean;
    message: string;
}
export interface PortalTransferEventRegistrationRequest {
    toEmail: string;
    toName?: string;
}
export interface PortalTransferEventRegistrationResult {
    transferred: boolean;
    message: string;
    transferId?: string;
}
export interface PortalCancelMembershipAtPeriodEndResult {
    cancelled: boolean;
    message: string;
}
export interface NewsletterSubscribeRequest {
    email: string;
    firstName?: string;
    lastName?: string;
    name?: string;
    company?: string;
    phone?: string;
    listId: string;
    tags?: string[];
    blockId?: string;
    meta?: {
        honeypot?: string;
        altchaSolution?: string | null;
    };
}
export interface NewsletterSubscribeResponse {
    subscribed: boolean;
    requiresConfirmation?: boolean;
}
