@theelena/sdk 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,901 @@
+import { bo as ElenaHttpClient, bp as ElenaFetch, bq as ElenaClientOptions, E as ElenaKeyRequestOptions, W as ElenaClientContextV1, b as ElenaKeyPageQuery, V as ElenaClientCatalogV1, X as ElenaClientProductResponseV1, T as ElenaClientAssetResponseV1, j as ElenaKeyTransportOptions } from './key-transport.d-Bopgxw9r.js';
+export { S as ElenaAgentTransportError, U as ElenaClientAssetV1, Y as ElenaClientProductV1, br as ElenaHttpMethod, Z as ElenaKeyTransportErrorCode, a0 as ElenaPublicConnectionV1, bs as ElenaRequestOptions } from './key-transport.d-Bopgxw9r.js';
+import { z } from 'zod';
+
+type TicketEstado = 'emitido' | 'usado' | 'anulado';
+interface EventTicketType {
+    id: string;
+    nombre: string;
+    precio: string | null;
+    requiereDni: boolean;
+    ventana: {
+        inicio: string | null;
+        fin: string | null;
+    } | null;
+    cupo: number | null;
+    disponibles: number | null;
+    agotado: boolean;
+}
+/** Wire shape of GET /api/v1/public/events/detail. */
+interface EventDetail {
+    evento: {
+        nombre: string;
+        imageUrl: string | null;
+        imageId: string | null;
+        slug: string;
+        estado: 'publicado' | 'abierto';
+        fechaOperativa: string;
+        inicia: string;
+        termina: string | null;
+        timezone: string;
+        capacidad: number | null;
+    };
+    tipos: EventTicketType[];
+}
+interface TicketEmissionInput {
+    restaurantSlug: string;
+    eventSlug: string;
+    titular: {
+        nombre: string;
+        dni?: string | null;
+        celular: string;
+    };
+    acompanantes: number;
+    ref?: string | null;
+    ticketTypeId?: string;
+}
+interface EmittedTicket {
+    id: string;
+    token: string;
+    holderName: string;
+    status: TicketEstado;
+    ticketTypeName?: string;
+}
+interface TicketEmissionResult {
+    partyId: string;
+    alreadyRegistered: boolean;
+    tickets: EmittedTicket[];
+}
+/** Wire shape of GET /api/v1/public/tickets/:token. */
+interface TicketStatus {
+    qr: string;
+    estado: TicketEstado;
+    titular: {
+        nombre: string;
+        dni: string | null;
+        celular: string;
+    };
+    tipo: {
+        nombre: string | null;
+        precio: string | null;
+    };
+    evento: {
+        nombre: string | null;
+        slug: string | null;
+        estado: string | null;
+        fechaOperativa: string | null;
+        inicia: string | null;
+        timezone: string | null;
+    };
+}
+
+/**
+ * Hero Carousel Types
+ * Shared types for hero slide management
+ */
+interface HeroSlide {
+    id: string;
+    restaurantId: string;
+    imageId: string;
+    imageUrl?: string;
+    title: string;
+    description: string | null;
+    linkUrl: string | null;
+    linkLabel: string | null;
+    /**
+     * Linked event ("noche") destination; mutually exclusive with `linkUrl`
+     * (the backend enforces the exclusivity on create and on merged PATCHes).
+     */
+    eventId: string | null;
+    /**
+     * Resolved linked event at read time — never a stored slug/URL. Staff
+     * reads always include it (even when the event is hidden, with
+     * `isPublic: false`); public reads exclude the whole slide when the
+     * linked event is not publicly visible.
+     */
+    event: HeroSlideEvent | null;
+    order: number;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Lifecycle of an Elena event ("noche"); mirrors the backend `event_status` enum. */
+type HeroSlideEventStatus = 'borrador' | 'publicado' | 'abierto' | 'cerrado';
+/**
+ * Event destination resolved from the current event record. Staff panels use
+ * `isPublic: false` to explain why a linked slide is hidden from the public
+ * catalog without losing its configuration.
+ */
+interface HeroSlideEvent {
+    id: string;
+    slug: string;
+    name: string;
+    status: HeroSlideEventStatus;
+    isPublic: boolean;
+}
+
+/**
+ * Public domain contracts for Catalog Access Experiences.
+ *
+ * A single catalog can be published through several configurable access
+ * points. Each access point stores an experience policy (personal vs
+ * shared-device kiosk), a placement, allowed order types and interaction
+ * rules, and produces a stable, non-guessable public URL. These contracts are
+ * shared by the Elena backend, staff app and public web so the wire shape has
+ * one source of truth.
+ */
+/** Interface + session policy applied to a catalog access point. */
+type CatalogExperience = 'personal' | 'shared_device';
+/** Where the access point is physically/logically used. */
+type CatalogPlacement = 'remote' | 'counter' | 'table';
+/**
+ * Order types an access point may allow. Mirrors the existing order `tipo`
+ * enum; access experiences never introduce new order types.
+ */
+type CatalogOrderType = 'para_llevar' | 'en_mesa' | 'reserva';
+/** Session timing policy for shared-device (kiosk) experiences. */
+interface CatalogAccessSessionConfig {
+    /** Seconds of inactivity before an unconfirmed kiosk session resets. */
+    idleTimeoutSeconds: number;
+    /** Seconds the confirmation screen stays before returning to welcome. */
+    confirmationTimeoutSeconds: number;
+}
+/**
+ * Public resolution of an access point. The server derives the experience from
+ * the resolved route; the client never sends a free-form experience value.
+ */
+interface CatalogAccessResolution {
+    accessPointId: string;
+    name: string;
+    experience: CatalogExperience;
+    placement: CatalogPlacement;
+    allowedOrderTypes: CatalogOrderType[];
+    tableId: string | null;
+    tableNumber: string | null;
+    chat: {
+        enabled: boolean;
+    };
+    session: CatalogAccessSessionConfig | null;
+    /** URL of the canonical personal catalog (for the kiosk welcome QR). */
+    personalCatalogUrl: string;
+}
+
+/** A tenant-configured fixed charge that can apply to one or more order types. */
+interface OrderChargeDefinition {
+    id: string;
+    version: number;
+    name: string;
+    unitAmount: string;
+    applicableOrderTypes: CatalogOrderType[];
+    enabled: boolean;
+}
+/** A client selection that identifies a configured charge without asserting pricing. */
+interface OrderChargeSelection {
+    definitionId: string;
+    definitionVersion: number;
+    quantity: number;
+}
+/** A frozen charge snapshot persisted with an order or sale. */
+interface AppliedOrderCharge {
+    definitionId: string;
+    definitionVersion: number;
+    name: string;
+    unitAmount: string;
+    quantity: number;
+    total: string;
+}
+
+interface BusinessStatus {
+    isOpen: boolean;
+    nextOpeningTime: string | null;
+    isPaused: boolean;
+}
+interface BusinessContact {
+    phone: string | null;
+    address: string | null;
+    email: string | null;
+}
+interface BusinessSocial {
+    facebook: string | null;
+    instagram: string | null;
+    twitter: string | null;
+}
+type BusinessSchedule = Record<string, {
+    abierto: boolean;
+    apertura: string;
+    cierre: string;
+}>;
+interface BusinessPaymentMethodDetail {
+    methodType: 'efectivo' | 'yape' | 'plin' | 'transferencia' | 'tarjeta';
+    accountNumber: string | null;
+    accountHolder: string | null;
+    qrUrl: string | null;
+}
+interface BusinessTicketTypeSummary {
+    id: string;
+    name: string;
+    price: string | null;
+    entryWindow: {
+        start: string | null;
+        end: string | null;
+    } | null;
+    available: boolean;
+}
+interface BusinessEventSummary {
+    id: string;
+    slug: string;
+    name: string;
+    imageUrl: string | null;
+    operationalDate: string;
+    startsAt: string;
+    endsAt: string | null;
+    timezone: string;
+    ticketTypes: BusinessTicketTypeSummary[];
+}
+/** Wire shape of GET /api/v1/public/catalog/:slug. */
+interface BusinessInfo {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    logoUrl: string | null;
+    status: BusinessStatus;
+    contact: BusinessContact;
+    social: BusinessSocial;
+    schedule: BusinessSchedule | null;
+    estimatedPreparationTime: number;
+    paymentMethods: string[];
+    paymentMethodDetails: BusinessPaymentMethodDetail[];
+    sunatAvailable: boolean;
+    tableManagementActive: boolean;
+    country: string;
+    currency: string;
+    currencySymbol: string;
+    preferences: {
+        heroCarouselEnabled?: boolean;
+        catalogChatEnabled?: boolean;
+    };
+    orderCharges: OrderChargeDefinition[];
+    businessType: 'restaurante' | 'discoteca' | null;
+    capabilities: {
+        catalogEvents: boolean;
+    };
+    events: BusinessEventSummary[];
+}
+interface BusinessCategory {
+    id: string;
+    name: string;
+    description: string | null;
+    parentId: string | null;
+    order: number;
+    imageUrl: string | null;
+    imageVariants: Partial<Record<'thumb' | 'card' | 'detail' | 'optimized', string>> | null;
+}
+interface CustomizationOption {
+    id: string;
+    name: string;
+    additionalPrice: string;
+    order: number;
+}
+interface CustomizationGroup {
+    id: string;
+    name: string;
+    required: boolean;
+    minSelections: number;
+    maxSelections: number;
+    minimum: number;
+    maximum: number;
+    order: number;
+    options: CustomizationOption[];
+}
+interface BusinessProduct {
+    id: string;
+    categoryId: string | null;
+    name: string;
+    description: string | null;
+    type: 'menu' | 'inventario';
+    basePrice: string;
+    imageUrl: string | null;
+    imageVariants: Partial<Record<'thumb' | 'card' | 'detail' | 'optimized', string>> | null;
+    available: boolean;
+    preparationTime: number | null;
+    servingSize: string | null;
+    spiceLevel: number | null;
+    isVegetarian: boolean | null;
+    isVegan: boolean | null;
+    isGlutenFree: boolean | null;
+    isSpicy: boolean | null;
+    customizationGroups: CustomizationGroup[];
+}
+/** Wire shape of GET /api/v1/public/catalog/:slug/menu. */
+interface CatalogMenu {
+    categories: BusinessCategory[];
+    products: BusinessProduct[];
+}
+interface MenuQuery {
+    search?: string;
+}
+interface BusinessTable {
+    id: string;
+    number: string;
+    description?: string;
+    status: string;
+}
+
+declare const CustomerOrderStatusSchema: z.ZodEnum<{
+    recibido: "recibido";
+    aprobado: "aprobado";
+    en_preparacion: "en_preparacion";
+    listo: "listo";
+    completado: "completado";
+    rechazado: "rechazado";
+}>;
+type CustomerOrderStatus = z.infer<typeof CustomerOrderStatusSchema>;
+
+/** Wire contract for an item submitted through the public catalog order endpoint. */
+interface PublicCatalogOrderItem {
+    productId: string;
+    cantidad: number;
+    unitPrice: string;
+    specialNotes?: string;
+    extras?: Array<{
+        groupName: string;
+        optionName: string;
+        additionalPrice: string;
+    }>;
+}
+/** Optional customer identity accepted by the public catalog endpoint. */
+interface PublicCatalogOrderCustomer {
+    name?: string;
+    phone?: string;
+    whatsappOptIn?: boolean;
+}
+/** Reservation fields required by the public catalog reservation flow. */
+interface PublicCatalogOrderReservation {
+    name: string;
+    phone: string;
+    arrivalDate: string;
+    arrivalTime: string;
+    peopleCount: number;
+    preferredTable?: string;
+    tableId?: string;
+    whatsappOptIn?: boolean;
+}
+type PublicCatalogOrderReceipt = {
+    type: 'simple';
+} | {
+    type: 'boleta_sunat' | 'factura_sunat';
+    documentType?: 'dni' | 'ruc';
+    documentNumber?: string;
+    businessName?: string;
+    address?: string;
+};
+interface PublicCatalogOrderBase {
+    items: PublicCatalogOrderItem[];
+    /** Signed lead token from a WhatsApp/catalog-sharing link. */
+    leadToken?: string;
+    idempotencyKey?: string;
+    charges?: OrderChargeSelection[];
+    generalNotes?: string;
+    preferredPaymentMethod?: string;
+    sessionId?: string;
+    receipt?: PublicCatalogOrderReceipt;
+}
+/**
+ * Public catalog create-order payload. The discriminator mirrors the backend's
+ * existing `tipo` wire contract and prevents incompatible flow fields.
+ */
+type PublicCatalogOrderPayload = (PublicCatalogOrderBase & {
+    tipo: Extract<CatalogOrderType, 'para_llevar'>;
+    customer?: PublicCatalogOrderCustomer;
+}) | (PublicCatalogOrderBase & {
+    tipo: Extract<CatalogOrderType, 'en_mesa'>;
+    customer?: PublicCatalogOrderCustomer;
+    tableNumber?: string;
+    tableId?: string;
+}) | (PublicCatalogOrderBase & {
+    tipo: Extract<CatalogOrderType, 'reserva'>;
+    customer?: PublicCatalogOrderCustomer;
+    reservation: PublicCatalogOrderReservation;
+});
+
+/** Whether the restaurant collects the delivery fee or the customer pays it separately. */
+type DeliveryPaymentMode = 'business' | 'courier';
+/** Frozen operational data, independent from a payment or an operating expense. */
+interface AppliedDelivery {
+    amount: string;
+    paymentMode: DeliveryPaymentMode;
+    costTrackingEnabled: boolean;
+    cost: string | null;
+}
+/** Customer-facing delivery information must never contain internal costs. */
+type PublicDelivery = Pick<AppliedDelivery, 'amount' | 'paymentMode'>;
+
+type CreateOrderInput = PublicCatalogOrderPayload;
+interface CreateOrderOptions {
+    /** Used only when the body has no non-empty idempotencyKey. Reuse for retries. */
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+interface OrderCreationResult {
+    orderId: string;
+    orderNumber: string;
+    trackingToken: string;
+    estimatedTime?: number;
+    whatsappSent?: boolean;
+    message?: string;
+    subtotal?: string;
+    charges?: AppliedOrderCharge[];
+    chargesTotal?: string;
+    total?: string;
+    currency?: string;
+    currencySymbol?: string;
+}
+/** Wire shape of GET .../orders/:orderId and GET .../tracking/:trackingToken. */
+interface PublicOrderDetail {
+    orderId: string;
+    restaurantName: string;
+    orderNumber: string;
+    orderName?: string | null;
+    status: CustomerOrderStatus;
+    statusLabel: string;
+    orderType: string;
+    items: Array<{
+        name: string;
+        quantity: number;
+        subtotal: string;
+        notes: string | null;
+        extras: Array<{
+            groupName: string;
+            optionName: string;
+        }>;
+    }>;
+    itemCount: number;
+    subtotal: string;
+    charges: AppliedOrderCharge[];
+    chargesTotal: string;
+    delivery?: PublicDelivery | null;
+    total: string;
+    payment?: {
+        preferredMethod: string | null;
+        status: 'pending_payment' | 'under_review' | 'paid' | 'rejected';
+        amount: string;
+        instructions: {
+            methodType: BusinessPaymentMethodDetail['methodType'];
+            accountNumber: string | null;
+            accountHolder: string | null;
+            qrUrl: string | null;
+        } | null;
+        claim: {
+            id: string;
+            status: 'pending' | 'confirmed' | 'rejected';
+            referenceNumber: string;
+            hasProofImage: boolean;
+            proofImageUrl: string | null;
+            rejectionReason: string | null;
+            createdAt: string;
+        } | null;
+    };
+    currency: string;
+    currencySymbol: string;
+    receipt: {
+        type: string;
+        documentType: 'dni' | 'ruc' | null;
+        documentNumber: string | null;
+        url: string | null;
+    } | null;
+    customerSteps?: CustomerOrderStatus[];
+    rejectionReason: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PaymentClaimInput {
+    referenceNumber: string;
+    proofImage?: Blob;
+}
+interface PaymentClaimResult {
+    id: string;
+    status: 'pending' | 'confirmed' | 'rejected';
+    referenceNumber: string;
+    hasProofImage: boolean;
+    createdAt: string;
+}
+
+declare class AccessResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    resolve(publicKey: string): Promise<CatalogAccessResolution>;
+    createOrder(publicKey: string, input: CreateOrderInput, options?: CreateOrderOptions): Promise<OrderCreationResult>;
+}
+declare class OrdersResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    create(input: CreateOrderInput, options?: CreateOrderOptions): Promise<OrderCreationResult>;
+    getById(orderId: string): Promise<PublicOrderDetail>;
+    getTracking(trackingToken: string): Promise<PublicOrderDetail>;
+    submitPaymentClaim(trackingToken: string, input: PaymentClaimInput): Promise<PaymentClaimResult>;
+}
+
+declare class CatalogResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    getInfo(): Promise<BusinessInfo>;
+    getMenu(query?: MenuQuery): Promise<CatalogMenu>;
+    listHeroSlides(): Promise<HeroSlide[]>;
+}
+declare class TablesResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    listAvailable(): Promise<BusinessTable[]>;
+    get(tableId: string): Promise<BusinessTable>;
+}
+
+interface ElenaApiErrorDetails {
+    status: number;
+    code?: string;
+    details?: unknown;
+    retryAfter?: string;
+}
+/** Backend HTTP failure. Preserves status, business code and raw payload. */
+declare class ElenaApiError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    readonly retryAfter?: string;
+    constructor(message: string, details: ElenaApiErrorDetails);
+}
+/** Transport failure before any HTTP response (DNS, refused, TLS). */
+declare class ElenaNetworkError extends Error {
+    constructor(message?: string);
+}
+/** Configured timeout elapsed before the complete response body was consumed. */
+declare class ElenaTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+/** Caller-provided AbortSignal fired before completion. */
+declare class ElenaRequestAbortedError extends Error {
+    constructor(message?: string);
+}
+/** Unusable API response: a redirect or a successful body that is not JSON. */
+declare class ElenaResponseError extends Error {
+    readonly status: number;
+    readonly bodyText?: string;
+    constructor(message: string, details: {
+        status: number;
+        bodyText?: string;
+    });
+}
+type ElenaCheckoutValidationCode = 'PRODUCT_NOT_FOUND' | 'PRODUCT_UNAVAILABLE' | 'INVALID_QUANTITY' | 'UNKNOWN_GROUP' | 'UNKNOWN_OPTION' | 'DUPLICATE_OPTION' | 'REQUIRED_OPTIONS' | 'MIN_SELECTIONS' | 'MAX_SELECTIONS' | 'AMBIGUOUS_SELECTION';
+/** Local catalog-snapshot validation only; the backend remains authoritative. */
+declare class ElenaCheckoutValidationError extends Error {
+    readonly code: ElenaCheckoutValidationCode;
+    /** Selection path, e.g. selections[0].quantity or selections[0].selectedOptions. */
+    readonly field: string;
+    constructor(message: string, details: {
+        code: ElenaCheckoutValidationCode;
+        field: string;
+    });
+}
+
+interface JourneyParticipant {
+    name: string;
+    phone: string;
+    whatsappOptIn: boolean;
+}
+interface JourneySnapshot<TState = unknown> {
+    id: string;
+    capability: string;
+    status: string;
+    state: TState;
+    version: number;
+    lastActivityAt: string;
+    expiresAt: string;
+}
+interface ContinuationExchangeResult<TState = unknown> {
+    accessToken: string;
+    sessionId: string;
+    participant: JourneyParticipant;
+    journey: JourneySnapshot<TState>;
+}
+interface JourneyStateResult<TState = unknown> {
+    journey: JourneySnapshot<TState>;
+}
+interface JourneyEventInput {
+    eventId: string;
+    expectedVersion: number;
+    event: unknown;
+}
+interface JourneyConfirmInput {
+    eventId: string;
+    expectedVersion: number;
+    fingerprint: string;
+}
+interface JourneyOrderResult {
+    orderId: string;
+    orderNumber: string;
+    trackingToken: string;
+}
+interface JourneyConfirmationResult<TState = unknown> {
+    status: 'completed';
+    journey: JourneySnapshot<TState>;
+    order: JourneyOrderResult;
+}
+interface JourneyActionRequired<TState = unknown> {
+    status: 'action_required';
+    journey: JourneySnapshot<TState>;
+}
+interface JourneyConflictDetails<TState = unknown> {
+    journey: JourneySnapshot<TState>;
+}
+
+interface RealtimeConnection {
+    url: string;
+}
+interface ChatConnection {
+    apiUrl: string;
+    businessSlug: string;
+    visitorId?: string;
+}
+declare class RealtimeResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    /** SSE stream URL. EventSource-compatible: identity travels in query, not headers. */
+    getConnection(visitorId?: string): RealtimeConnection;
+}
+declare class ChatResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    /** Connection descriptor for the existing Tari chat runtime. No HTTP call. */
+    getConnection(): ChatConnection;
+}
+declare class ContinuationsResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    exchange<TState = unknown>(token: string): Promise<ContinuationExchangeResult<TState>>;
+}
+declare class JourneyConflictError<TState = unknown> extends ElenaApiError {
+    readonly journey: JourneySnapshot<TState>;
+    constructor(journey: JourneySnapshot<TState>);
+}
+declare class JourneyResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    getState<TState = unknown>(): Promise<JourneyStateResult<TState>>;
+    dispatch<TState = unknown, TData extends Record<string, unknown> = Record<string, unknown>>(input: JourneyEventInput): Promise<TData & {
+        journey: JourneySnapshot<TState>;
+    }>;
+    confirm<TState = unknown>(input: JourneyConfirmInput): Promise<JourneyConfirmationResult<TState> | JourneyActionRequired<TState>>;
+    private static withConflict;
+}
+
+type LiveSessionStatus = 'browsing' | 'cart' | 'checkout' | 'submitted' | 'abandoned';
+type LiveSessionOrderType = 'para_llevar' | 'en_mesa' | 'reserva';
+interface LiveSessionItem {
+    productId: string;
+    name: string;
+    quantity: number;
+    subtotal: number;
+    notes?: string;
+    extras?: Array<{
+        groupName: string;
+        optionName: string;
+        price: number;
+    }>;
+}
+interface LiveSessionInput {
+    sessionId: string;
+    publicKey?: string;
+    status: LiveSessionStatus;
+    orderType?: LiveSessionOrderType;
+    tableNumber?: string;
+    tableId?: string;
+    tableName?: string;
+    notes?: string;
+    itemCount: number;
+    total: number;
+    items: LiveSessionItem[];
+    lastAction: string;
+}
+interface LiveSessionResult {
+    status: 'ok';
+}
+interface LiveSessionBeacon {
+    url: string;
+    body: Blob;
+}
+
+/** Wire shape of GET /api/v1/public/catalog/:slug/sales/:receiptToken. */
+interface SaleReceipt {
+    restaurantName: string;
+    receiptNumber: string;
+    orderName?: string | null;
+    status: 'completado';
+    items: Array<{
+        name: string;
+        quantity: number;
+        subtotal: string;
+        notes: string | null;
+        extras: Array<{
+            groupName: string;
+            optionName: string;
+        }>;
+    }>;
+    itemCount: number;
+    subtotal: string;
+    charges: AppliedOrderCharge[];
+    chargesTotal: string;
+    delivery?: PublicDelivery | null;
+    total: string;
+    currency: string;
+    currencySymbol: string;
+    paymentMethod: string;
+    receipt: {
+        type: string;
+        documentType: 'dni' | 'ruc' | null;
+        documentNumber: string | null;
+        url: string | null;
+        downloadStatus: 'available' | 'pending' | 'unavailable';
+    } | null;
+    createdAt: string;
+}
+
+declare class ReceiptsResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    get(receiptToken: string): Promise<SaleReceipt>;
+    /** PDF endpoint answers 302; callers open/download the URL, never JSON-fetch it. */
+    getPdfUrl(receiptToken: string): string;
+}
+declare class PresenceResource {
+    private readonly http;
+    private readonly businessSlug;
+    constructor(http: ElenaHttpClient, businessSlug: string);
+    report(input: LiveSessionInput, options?: {
+        signal?: AbortSignal;
+    }): Promise<LiveSessionResult>;
+    /** Beacon payload for pagehide/unload, where fetch cannot be awaited. */
+    getBeaconRequest(input: LiveSessionInput): LiveSessionBeacon;
+}
+
+/**
+ * Business-scoped public surface. The slug selects the business once;
+ * resources own the endpoints. Backend wire names (restaurantSlug) stay
+ * inside the SDK: consumers speak business everywhere.
+ */
+declare class BusinessScope {
+    private readonly http;
+    readonly slug: string;
+    readonly catalog: CatalogResource;
+    readonly tables: TablesResource;
+    readonly access: AccessResource;
+    readonly orders: OrdersResource;
+    readonly receipts: ReceiptsResource;
+    readonly presence: PresenceResource;
+    readonly continuations: ContinuationsResource;
+    readonly realtime: RealtimeResource;
+    readonly chat: ChatResource;
+    private readonly eventsResource;
+    private readonly ticketsResource;
+    constructor(http: ElenaHttpClient, slug: string);
+    getInfo(): Promise<BusinessInfo>;
+    getEvent(eventSlug: string): Promise<EventDetail>;
+    emitTickets(input: Omit<TicketEmissionInput, 'restaurantSlug'>): Promise<TicketEmissionResult>;
+}
+
+declare class EventsResource {
+    private readonly http;
+    constructor(http: ElenaHttpClient);
+    get(businessSlug: string, eventSlug: string): Promise<EventDetail>;
+}
+declare class TicketsResource {
+    private readonly http;
+    constructor(http: ElenaHttpClient);
+    emit(input: TicketEmissionInput): Promise<TicketEmissionResult>;
+    getStatus(token: string): Promise<TicketStatus>;
+}
+declare class AssetsResource {
+    private readonly http;
+    constructor(http: ElenaHttpClient);
+    /** Render endpoint serves binary content; callers use the URL, never JSON-fetch it. */
+    getRenderUrl(assetId: string): string;
+}
+
+interface ElenaPublicClient {
+    business(slug: string): BusinessScope;
+    readonly tickets: TicketsResource;
+    readonly assets: AssetsResource;
+}
+declare function createElenaPublicClient(options: ElenaClientOptions): ElenaPublicClient;
+interface ElenaJourneyClientOptions {
+    baseUrl: string;
+    businessSlug: string;
+    accessToken: string;
+    fetch?: ElenaFetch;
+    timeoutMs?: number;
+}
+interface ElenaJourneyClient {
+    readonly businessSlug: string;
+    readonly journeys: JourneyResource;
+}
+declare function createElenaJourneyClient(options: ElenaJourneyClientOptions): ElenaJourneyClient;
+
+/** Product/option IDs from one public catalog snapshot; no caller-supplied prices. */
+interface OrderItemSelection {
+    productId: string;
+    quantity: number;
+    selectedOptions?: readonly {
+        groupId: string;
+        optionId: string;
+    }[];
+    notes?: string;
+}
+/**
+ * Build the public order wire items without changing the snapshot or selections.
+ * Prices remain decimal strings: unitPrice is the base price, extras are separate.
+ * This is early snapshot validation, not a quote, reservation or server guarantee.
+ */
+declare function buildOrderItems(menu: CatalogMenu, selections: readonly OrderItemSelection[]): PublicCatalogOrderItem[];
+
+interface ElenaClientKeyClientOptions extends ElenaKeyTransportOptions {
+    clientKey: string;
+}
+interface ElenaClientKeyClient {
+    context: {
+        get(options?: ElenaKeyRequestOptions): Promise<ElenaClientContextV1>;
+    };
+    catalog: {
+        list(query?: ElenaKeyPageQuery, options?: ElenaKeyRequestOptions): Promise<ElenaClientCatalogV1>;
+        getProduct(id: string, options?: ElenaKeyRequestOptions): Promise<ElenaClientProductResponseV1>;
+    };
+    assets: {
+        get(id: string, options?: ElenaKeyRequestOptions): Promise<ElenaClientAssetResponseV1>;
+    };
+}
+/** Published menu only. This client never accepts an agent secret or bearer token. */
+declare function createElenaClientKeyClient(options: ElenaClientKeyClientOptions): ElenaClientKeyClient;
+
+/** The explicit origin is pinned: discovery cannot redirect credentials to another API. */
+declare function discoverElenaPublicConnection(options: ElenaKeyTransportOptions, slug: string, requestOptions?: ElenaKeyRequestOptions): Promise<{
+    version: "1";
+    apiOrigin: string;
+    clientKey: string;
+    publication: {
+        revision: number;
+        expiresAt: string;
+    };
+    context: {
+        version: "1";
+        restaurant: {
+            id: string;
+            name: string;
+            slug: string;
+            currency: "PEN";
+        };
+        capabilities: {
+            menu: true;
+            assets: true;
+        };
+    };
+}>;
+
+export { AccessResource, type AppliedOrderCharge, AssetsResource, type BusinessCategory, type BusinessEventSummary, type BusinessInfo, type BusinessPaymentMethodDetail, type BusinessProduct, type BusinessSchedule, BusinessScope, type BusinessSocial, type BusinessStatus, type BusinessTable, type BusinessTicketTypeSummary, type CatalogMenu, CatalogResource, type ChatConnection, ChatResource, type ContinuationExchangeResult, ContinuationsResource, type CreateOrderInput, type CreateOrderOptions, type CustomerOrderStatus, type CustomizationGroup, type CustomizationOption, ElenaApiError, type ElenaApiErrorDetails, type ElenaCheckoutValidationCode, ElenaCheckoutValidationError, ElenaClientAssetResponseV1, ElenaClientCatalogV1, ElenaClientContextV1, type ElenaClientKeyClient, type ElenaClientKeyClientOptions, ElenaClientOptions, ElenaClientProductResponseV1, ElenaFetch, ElenaHttpClient, type ElenaJourneyClient, type ElenaJourneyClientOptions, ElenaKeyPageQuery, ElenaKeyRequestOptions, ElenaKeyTransportOptions, ElenaNetworkError, type ElenaPublicClient, ElenaRequestAbortedError, ElenaResponseError, ElenaTimeoutError, type EmittedTicket, type EventDetail, type EventTicketType, EventsResource, type HeroSlide, type JourneyActionRequired, type JourneyConfirmInput, type JourneyConfirmationResult, type JourneyConflictDetails, JourneyConflictError, type JourneyEventInput, type JourneyOrderResult, type JourneyParticipant, JourneyResource, type JourneySnapshot, type JourneyStateResult, type LiveSessionBeacon, type LiveSessionInput, type LiveSessionOrderType, type LiveSessionResult, type LiveSessionStatus, type MenuQuery, type OrderChargeDefinition, type OrderCreationResult, type OrderItemSelection, OrdersResource, type PaymentClaimInput, type PaymentClaimResult, PresenceResource, type PublicCatalogOrderItem, type PublicCatalogOrderPayload, type PublicOrderDetail, type RealtimeConnection, RealtimeResource, ReceiptsResource, type SaleReceipt, TablesResource, type TicketEmissionInput, type TicketEmissionResult, type TicketEstado, type TicketStatus, TicketsResource, buildOrderItems, createElenaClientKeyClient, createElenaJourneyClient, createElenaPublicClient, discoverElenaPublicConnection };