sabre-client 0.3.0-next.1 → 0.3.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { Q as QueueRef } from './queue-ref-BDGh8FrV.js';
+
 /** Token ATK tal cual se guarda: tiempos absolutos, para que otro proceso sepa cuánto le queda. */
 interface StoredToken {
     accessToken: string;
@@ -39,7 +41,13 @@ interface SabreLogger {
 }
 type SabreLogLevel = keyof SabreLogger;
 /** Eventos estables que emite el SDK como `message`. */
-type SabreLogEvent = 'sabre.request.start' | 'sabre.request.end' | 'sabre.request.retry' | 'sabre.request.rawResponseHookFailed' | 'sabre.auth.token.refresh' | 'sabre.auth.token.store';
+type SabreLogEvent = 'sabre.request.start' | 'sabre.request.end' | 'sabre.request.retry' | 'sabre.request.rawResponseHookFailed' | 'sabre.auth.token.refresh' | 'sabre.auth.token.store' | 'sabre.booking.seat.priced' | 'sabre.session.open' | 'sabre.session.close' | 'sabre.session.closeFailed' | 'sabre.session.keepAliveFailed' | 'sabre.queue.exitTolerated' | 'sabre.queue.exitFailed';
+/** Logger interno: redacta siempre el contexto y no hace nada si no hay logger. */
+declare class EventLogger {
+    #private;
+    constructor(logger?: SabreLogger);
+    emit(level: SabreLogLevel, event: SabreLogEvent, context?: Record<string, unknown>): void;
+}
 
 type SabreEnvironment = 'sandbox' | 'production';
 type SabreAuthVersion = 'v3' | 'v2';
@@ -93,6 +101,7 @@ interface ResolvedConfig {
     credentials: Readonly<SabreCredentials | SabreCredentialsV2>;
     environment: SabreEnvironment;
     baseUrl: string;
+    soapBaseUrl: string;
     authVersion: SabreAuthVersion;
     pcc: string | undefined;
     logger: SabreLogger | undefined;
@@ -138,6 +147,24 @@ declare class SabreGatewayError extends SabreError {
     readonly code: string | undefined;
     constructor(message: string, options: SabreGatewayErrorOptions);
 }
+/**
+ * Por qué una sesión SOAP no sirve: `'limit'` (más de 50 sesiones), `'invalid'` (uso
+ * concurrente de la sesión), `'expired'` (sesión vencida) o `'blocked'` (creación de sesión
+ * bloqueada para el usuario).
+ */
+type SabreSessionErrorKind = 'limit' | 'invalid' | 'expired' | 'blocked';
+interface SabreSessionErrorOptions extends Omit<SabreGatewayErrorOptions, 'protocol'> {
+    kind: SabreSessionErrorKind;
+}
+/**
+ * Error de la sesión SOAP de `SabreLegacy`. Se distingue con `instanceof` y `kind`, sin comparar
+ * mensajes. La sesión que lo lanzó queda inutilizable: las llamadas siguientes lanzan sin red.
+ */
+declare class SabreSessionError extends SabreGatewayError {
+    name: string;
+    readonly kind: SabreSessionErrorKind;
+    constructor(message: string, options: SabreSessionErrorOptions);
+}
 interface SabreOrchestrationErrorOptions extends Omit<SabreErrorOptions, 'retryable'> {
     /** `SP.PROVIDER_ERROR` o `SP.INTERNAL_ERROR`. */
     code: string;
@@ -204,11 +231,14 @@ declare class SabreWarning extends SabreError {
 interface SabreRawResponse {
     /** Método público sin `sabre.`, p. ej. `'booking.get'` o `'air.bargainFinderMax'`. */
     operation: string;
-    protocol: 'rest';
+    protocol: 'rest' | 'soap';
     /** HTTP status del intento que se entrega. */
     status: number;
     headers: Headers;
-    /** Texto tal cual llegó, sin parsear. `''` si vino vacío. */
+    /**
+     * Texto tal cual llegó, sin parsear. `''` si vino vacío. En SOAP es el sobre completo, con
+     * una sola modificación: el valor de cada `BinarySecurityToken` va como `[REDACTED]`.
+     */
     body: string;
     /** Intentos HTTP hechos, contando los reintentos (1 si no hubo). */
     attempts: number;
@@ -271,6 +301,8 @@ interface RestTransportOptions {
 declare class RestTransport {
     #private;
     constructor(config: ResolvedConfig, options?: RestTransportOptions);
+    /** @internal Para los avisos de las operaciones que no son de una request (p. ej. asientos con precio). */
+    get log(): EventLogger;
     /** Punto de enganche para `AuthManager`. */
     setAuthorizationProvider(provider: AuthorizationProvider | undefined): void;
     request<T>(request: RestRequest): Promise<T>;
@@ -715,6 +747,309 @@ interface RequestOptions {
     retry?: Partial<RetryOptions>;
 }
 
+/** `KeyValuePair` del spec. */
+interface SeatKeyValuePair {
+    key: string;
+    value: string;
+}
+/** `LoyaltyProgramAccount` del spec. */
+interface SeatLoyaltyProgramAccount {
+    airlineCode?: string;
+    accountNumber?: string;
+    programName?: string;
+}
+/** `SegmentBase` del spec. Fechas `YYYY-MM-DD` y horas `HH:MM`, locales del aeropuerto. */
+interface SeatSegment {
+    /** Identifica el segmento dentro del mensaje (`IdType`: `^[a-zA-Z_][a-zA-Z0-9_\-.]*$`). */
+    id: string;
+    bookingAirlineCode: string;
+    bookingFlightNumber: number;
+    departureAirportCode: string;
+    arrivalAirportCode: string;
+    departureDate: string;
+    bookingClassCode: string;
+    departureTime?: string;
+    arrivalDate?: string;
+    arrivalTime?: string;
+    operatingAirlineCode?: string;
+    operatingFlightNumber?: number;
+    operatingBookingClassCode?: string;
+    cabinCode?: string;
+}
+/** `SegmentPayloadRq` del spec. */
+interface SeatSegmentPayloadRq extends SeatSegment {
+    /** Si el segmento tiene el tag `/RCRQ`. */
+    hasRecordCreateTag?: boolean;
+}
+/** `FareSegmentAssociation` del spec. */
+interface SeatFareSegmentAssociation {
+    segmentRef: string;
+    fareComponentRef: string;
+}
+/** `SpecialServiceRequest` del spec. */
+interface SeatSpecialServiceRequest {
+    codes: string[];
+    segmentRef?: string;
+}
+/** `PassengerBase` del spec. */
+interface SeatPassenger {
+    id: string;
+    passengerType?: string;
+    givenName?: string;
+    surname?: string;
+    loyaltyProgramAccounts?: SeatLoyaltyProgramAccount[];
+}
+/** `PassengerPayloadRq` del spec. */
+interface SeatPassengerPayloadRq extends SeatPassenger {
+    fareSegmentAssociation?: SeatFareSegmentAssociation[];
+    specialServiceRequests?: SeatSpecialServiceRequest[];
+    /** Pasajero con un infante sin asiento. Por defecto `false`. */
+    isAccompaniedByInfant?: boolean;
+    customAttributes?: SeatKeyValuePair[];
+}
+/** `FareDetail` del spec. */
+interface SeatFareDetail {
+    fareType?: string;
+    fareTariff?: string;
+    fareRule?: string;
+    fareIndicator?: number;
+    fareTypeBitmap?: string;
+    hasPrivateTariff?: boolean;
+}
+/** `FareComponent` del spec. */
+interface SeatFareComponent {
+    fareComponentId: string;
+    fareBasis: string;
+    governingCarrier?: string;
+    /** Número como string, p. ej. `'500.00'`. Exige `totalPriceCurrencyCode`. */
+    totalPrice?: string;
+    totalPriceCurrencyCode?: string;
+    brandCode?: string;
+    fareDetail?: SeatFareDetail;
+}
+/** `SeatAvailabilityByPayloadRq` del spec 3.0: la reserva armada a mano. */
+interface SeatAvailabilityByPayloadRq {
+    /** `id` de los segmentos para los que se piden mapas. */
+    returnSeatMapsOnlyForSegmentRefs: string[];
+    segments: SeatSegmentPayloadRq[];
+    passengers: SeatPassengerPayloadRq[];
+    returnSeatOffersOnlyForPassengerRefs?: string[];
+    fareComponents?: SeatFareComponent[];
+    /** ISO 4217. Si falta, Sabre la elige según otros factores. */
+    currencyCode?: string;
+    /** `true`: mapa de check-in; `false`: mapa de reserva. */
+    isCheckinMode?: boolean;
+    customAttributes?: SeatKeyValuePair[];
+}
+/**
+ * `SeatAvailabilityByPnrLocatorRq` del spec 3.0: un PNR ya creado. Sabre lo lee sin estado,
+ * así que no ve los cambios sin confirmar.
+ */
+interface SeatAvailabilityByPnrLocatorRq {
+    /** Localizador del PNR (`^[A-Z]{6}$`). */
+    pnrLocator: string;
+    /** IDs de segmento del PNR para los que se piden mapas. */
+    returnSeatMapsOnlyForSegmentIds?: string[];
+    /** Name reference numbers del PNR, p. ej. `'01.01'`. */
+    returnSeatOffersOnlyForPassengerNameReferenceNumbers?: string[];
+    currencyCode?: string;
+    isCheckinMode?: boolean;
+    customAttributes?: SeatKeyValuePair[];
+}
+/** Entrada de `sabre.air.getSeats`: con `pnrLocator` va a `byPnrLocator`; sin él, a `byReservationPayload`. */
+type GetSeatsRequest = SeatAvailabilityByPayloadRq | SeatAvailabilityByPnrLocatorRq;
+/** `FlightLeg` del spec. */
+interface SeatFlightLeg {
+    id: string;
+    departureAirportCode: string;
+    arrivalAirportCode: string;
+    departureScheduledDateTime?: string;
+    aircraftCode?: string;
+}
+/** `SegmentRs` del spec. */
+interface SeatSegmentRs extends SeatSegment {
+    isChangeOfGauge?: boolean;
+    flightLegs?: SeatFlightLeg[];
+}
+/** `PassengerRs` del spec. */
+type SeatPassengerRs = SeatPassenger;
+/** `TaxType` del spec. */
+interface SeatTax {
+    taxAmount?: number | string;
+    taxCode?: string;
+    description?: string;
+}
+/**
+ * `PriceBreakdown` del spec, en la moneda del `PriceDefinition`. El spec dice string, pero en
+ * producción los importes llegaron como número (`1200`, 2026-10-31): se acepta cualquiera.
+ */
+interface SeatPriceBreakdown {
+    /** Con impuestos. */
+    amount: number | string;
+    amountWithoutTaxes?: number | string;
+    taxesTotal?: number | string;
+    taxes?: SeatTax[];
+    isTaxExempt?: boolean;
+}
+/** `PriceDefinition` del spec. */
+interface SeatPriceDefinition {
+    id: string;
+    currencyCode: string;
+    totalPrice: SeatPriceBreakdown;
+    referenceBasePrice?: SeatPriceBreakdown;
+}
+/** `OfferItemDetails` del spec. */
+interface SeatOfferItemDetails {
+    serviceDefinitionRef: string;
+    /** `id` de un `PriceDefinition` del mismo mensaje: ahí está el precio del asiento. */
+    priceDefinitionRef?: string;
+    segmentRefs: string[];
+    passengerRefs: string[];
+    refundableReissuableIndicator?: 'Yes' | 'No' | 'Reuse';
+    isInterlineable?: boolean;
+    sectorPortionIndicator?: 'Sector' | 'Portion' | 'Journey';
+    feeApplicationMethod?: string;
+    purchaseByDateTime?: string;
+    annotations?: SeatKeyValuePair[];
+}
+/** `OfferItem` del spec: ítem reservable asignado a asientos. */
+interface SeatOfferItem extends SeatOfferItemDetails {
+    id: string;
+}
+/** `DisplayOnlyItem` del spec: ítem solo informativo. */
+interface SeatDisplayOnlyItem extends SeatOfferItemDetails {
+    id: string;
+    displayOnlyReason?: 'Unavailable' | 'Unable To Book' | 'Restricted' | 'Unknown';
+    displayOnlySource?: string;
+    displayOnlyReasonDetails?: SeatKeyValuePair[];
+}
+/** `ServiceDefinition` del spec. */
+interface SeatServiceDefinition {
+    id: string;
+    serviceCode?: string;
+    airlineCode?: string;
+    commercialName?: string;
+    /** Group code de ATPCO. */
+    groupCode?: string;
+    emdType?: 'Standalone' | 'Flight Coupon Associated' | 'Standalone Ticket Associated' | 'Other Than Emd' | 'Eticket';
+    emdTypeCode?: number;
+    specialServiceCode?: string;
+    reasonForIssuance?: string;
+    reasonForIssuanceCode?: string;
+    isCommissionable?: boolean;
+    isFeeGuaranteed?: boolean;
+}
+/** `SeatCharacteristic` / `RowCharacteristic` del spec (PADIS 9825). */
+interface SeatCharacteristic {
+    code: string;
+    description?: string;
+}
+/** `SeatType` del spec. El número de asiento es `row` de la fila más `column`. */
+interface Seat {
+    column: string;
+    /** PADIS 9865: `F` libre, `O` ocupado, … */
+    occupationStatusCode?: string;
+    characteristics?: SeatCharacteristic[];
+    isOperative?: boolean;
+    /** Ítems reservables (`offerItems[].id`) del asiento. */
+    offerItemRefIds?: string[];
+    /** Ítems solo informativos (`displayOnlyItems[].id`) del asiento. */
+    displayOnlyItemRefIds?: string[];
+}
+/** `SeatRow` del spec. */
+interface SeatRow {
+    row: number;
+    characteristics?: SeatCharacteristic[];
+    seats: Seat[];
+}
+/** `CabinLayoutRowPosition` del spec. */
+interface SeatCabinRowPosition {
+    firstRow: number;
+    lastRow: number;
+}
+/** `Facility` del spec. */
+interface SeatCabinFacility {
+    firstRow: number;
+    lastRow: number;
+    columnIds?: string[];
+    orientationCode: string;
+    positionCodes: string[];
+    facilityTypeCode: string;
+}
+/** `CabinLayoutType` del spec. */
+interface SeatCabinLayout {
+    columns: Array<{
+        id: string;
+        position?: string[];
+    }>;
+    rows: SeatCabinRowPosition;
+    wingRowPosition?: SeatCabinRowPosition[];
+    exitRowPosition?: SeatCabinRowPosition[];
+    seatCount?: number;
+    authorizedSeatCount?: number;
+    missingRowNumbers?: number[];
+    missingSeats?: string[];
+    facilities?: SeatCabinFacility[];
+    deckCode?: string;
+}
+/** `CabinCompartment` del spec. */
+interface SeatCabinCompartment {
+    firstRow?: number;
+    lastRow?: number;
+    columnIds?: string[];
+    cabinCode?: string;
+    cabinName?: string;
+    cabinLayout?: SeatCabinLayout;
+    seatRows?: SeatRow[];
+}
+/** `SeatMap` del spec. */
+interface SeatMap {
+    /** `id` del segmento, del request o de `segments[]` de la respuesta. */
+    segmentRef: string;
+    flightLegRef?: string;
+    cabinCompartments?: SeatCabinCompartment[];
+}
+/** `SeatAvailabilityResponse` del spec 3.0. */
+interface SeatAvailabilityResponse {
+    /** Solo lo usa `seatOffers` (NDC); por ATPCO el asiento se reserva por número. */
+    offerId?: string;
+    offerExpirationDateTime?: string;
+    segments: SeatSegmentRs[];
+    passengers: SeatPassengerRs[];
+    serviceDefinitions: SeatServiceDefinition[];
+    priceDefinitions?: SeatPriceDefinition[];
+    offerItems: SeatOfferItem[];
+    displayOnlyItems?: SeatDisplayOnlyItem[];
+    seatMaps: SeatMap[];
+}
+/** `Error` / `Warning` del spec: la misma forma que los de Booking Management. */
+interface SeatAvailabilityIssue {
+    category: string;
+    type: string;
+    description?: string;
+    fieldName?: string;
+    fieldPath?: string;
+    /** Puede traer datos del request: no se copia a los errores del SDK. */
+    fieldValue?: string;
+}
+/** `SeatAvailabilityRs` tal cual llega de Sabre. */
+interface RawSeatAvailabilityRs {
+    response?: SeatAvailabilityResponse;
+    errors?: SeatAvailabilityIssue[];
+    warnings?: SeatAvailabilityIssue[];
+}
+/**
+ * Resultado de `sabre.air.getSeats`: el `SeatAvailabilityRs` del spec con `errors[]` y
+ * `warnings[]` reemplazados por los del SDK.
+ */
+interface GetSeatsResponse {
+    response: SeatAvailabilityResponse;
+    /** `warnings[]` de Sabre. Nunca se lanzan. */
+    warnings: SabreWarning[];
+    /** `errors[]` que llegaron junto con un `response`: el mapa existe, pero puede faltar algo. */
+    errors: SabreBusinessError[];
+}
+
 /** Body de Revalidate Itinerary v5: el mismo `OTA_AirLowFareSearchRQ` que BFM, con los vuelos fijados. */
 interface RevalidateItineraryRequest {
     OTA_AirLowFareSearchRQ: OtaAirLowFareSearchRq;
@@ -754,6 +1089,13 @@ declare class Air {
      * sin sostener inventario. El request se arma con `buildRevalidateItineraryRequest`.
      */
     revalidateItinerary(request: RevalidateItineraryRequest, options?: RequestOptions): Promise<RevalidateItineraryResponse>;
+    /**
+     * Get Seats v3: mapa de asientos con disponibilidad y precio. Sin `pnrLocator` va a
+     * `byReservationPayload`, armado con `buildSeatAvailabilityRequest`; con `pnrLocator`, a
+     * `byPnrLocator`. Un `pnrLocator` vacío o mezclado con `segments`, `passengers` o
+     * `returnSeatMapsOnlyForSegmentRefs` lanza `TypeError` sin llamar a la red.
+     */
+    getSeats(request: GetSeatsRequest, options?: RequestOptions): Promise<GetSeatsResponse>;
 }
 
 /** Elemento de `errors[]` tal cual lo manda Sabre (`Error` del spec; los avisos comparten forma). */
@@ -1143,7 +1485,9 @@ declare class BookingManagement {
      * Nunca se reintenta automáticamente. Si la reserva se crea con avisos o errores no fatales,
      * no lanza: los devuelve en `warnings` y `errors`. Si no se crea, lanza `SabreBusinessError`.
      * Con `agency.ticketingPolicy: 'FUTURE_TICKETING'` y sin `agency.futureTicketingPolicy`, lanza
-     * `TypeError` sin llamar a la red: Sabre lo rechaza seguro.
+     * `TypeError` sin llamar a la red: Sabre lo rechaza seguro. Lo mismo con un asiento cuyo
+     * `travelerIndex` no está en `travelers`. Un asiento con precio en Get Seats (ver
+     * `buildBookingFlightDetails`) solo emite `sabre.booking.seat.priced` en `warn`.
      */
     create(request: CreateBookingRequest, options?: CreateBookingOptions): Promise<CreateBookingResponse>;
     /**
@@ -1179,6 +1523,667 @@ declare class Sabre {
     get baseUrl(): string;
 }
 
+/** Credencial del header `wsse:Security`. */
+type SoapSecurity = 
+/** Token de sesión (ATH) o stateless (ATK). */
+{
+    binarySecurityToken: string;
+}
+/** Credenciales de `SessionCreateRQ`. `clientId` y `clientSecret` solo van en la 2.0.0. */
+ | {
+    usernameToken: {
+        username: string;
+        password: string;
+        organization: string;
+        domain: string;
+        clientId?: string;
+        clientSecret?: string;
+    };
+};
+interface SoapRequest {
+    /** Nombre del servicio para errores y logs, p. ej. `'queueAccess'`. */
+    service: string;
+    /** `eb:Service` y `eb:Action`, p. ej. `'QueueAccessLLSRQ'`. */
+    action: string;
+    /** Payload del `soap-env:Body`, ya armado y escapado (ver `xmlEscape`). */
+    payload: string;
+    /** `eb:CPAId`: el PCC. */
+    cpaId: string;
+    /** `eb:ConversationId` de la sesión. */
+    conversationId: string;
+    security: SoapSecurity;
+    /**
+     * Si la operación se puede repetir sin efectos (`count`, `list`, `ping`). Las que mueven el
+     * cursor de una cola van en `false`: nunca se reintentan ante un fallo de red.
+     */
+    idempotent: boolean;
+    retry?: Partial<RetryOptions>;
+    /** `true` para devolver el `BinarySecurityToken` de la respuesta (solo `SessionCreateRQ`). */
+    readSecurityToken?: boolean;
+    signal?: AbortSignal;
+    /** Método público sin `legacy.`, p. ej. `'queue.access'`. Lo recibe `onRawResponse`. */
+    operation?: string;
+    onRawResponse?: SabreRawResponseCallback;
+}
+interface SoapResponse {
+    /** Elemento hijo del `Body` (p. ej. `QueueAccessRS`), parseado y sin prefijos de namespace. */
+    payload: Record<string, unknown>;
+    /** Nombre local de ese elemento, p. ej. `'QueueAccessRS'`. */
+    payloadName: string;
+    /** Los `stl:Warning` de `stl:ApplicationResults`. */
+    warnings: SabreWarning[];
+    /** `eb:MessageId` de la respuesta, el dato que pide soporte de Sabre. */
+    messageId: string | undefined;
+    /** El sobre redactado, como `raw` de los errores que arme la operación al leer el payload. */
+    raw: string;
+    /** El `BinarySecurityToken` del header, solo con `readSecurityToken`. */
+    securityToken: string | undefined;
+    status: number;
+}
+interface SoapTransportOptions {
+    /** Solo para tests: id del `eb:MessageId`. */
+    messageId?: () => string;
+    /** Solo para tests: reloj del `eb:Timestamp`. */
+    now?: () => Date;
+    /** Solo para tests: fuente de aleatoriedad del jitter. */
+    random?: () => number;
+    /** Solo para tests: espera entre reintentos. */
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+declare class SoapTransport {
+    #private;
+    constructor(config: ResolvedConfig, options?: SoapTransportOptions);
+    /** @internal Para los eventos de sesión que no son una request. */
+    get log(): EventLogger;
+    request(request: SoapRequest): Promise<SoapResponse>;
+}
+
+/** Por qué terminó la cola: el fin de cola de siempre o una cola vacía al entrar. */
+type QueueEndReason = 'end-of-display' | 'empty';
+/**
+ * Un filtro al entrar a una cola: un calificador de host, p. ej. `{ function: 'AL', criteria: 'DL' }`
+ * (solo los PNR de esa aerolínea). Las reglas de combinación las valida Sabre.
+ */
+interface QueueSelection {
+    function: string;
+    criteria: string;
+}
+interface QueueAccessRequest {
+    queue: QueueRef;
+    /** PCC de la cola. Por defecto, el de la sesión. */
+    pcc?: string;
+    /** Hasta 8 filtros. Con selección, la cola abre solo los PNR que cumplen el criterio. */
+    selection?: readonly QueueSelection[];
+}
+/** Una cola de la que `remove` saca el PNR actual. */
+interface QueueRemoveTarget {
+    queue: QueueRef;
+    /** Por defecto, el PCC de la sesión. */
+    pcc?: string;
+}
+interface QueueRemoveRequest {
+    /** De 1 a 3 colas de las que sacar el PNR actual a la vez. Sin `from`, sale de la cola en curso. */
+    from?: readonly QueueRemoveTarget[];
+}
+type QueueAccessOptions = RequestOptions;
+type QueueNavigationOptions = RequestOptions;
+/** El PNR en el que quedó parada la cola. */
+interface QueueItem {
+    /** Localizador: `Line/UniqueID@ID`. */
+    locator: string;
+    /**
+     * `Line/DateTime`, tal cual llegó: con año en las respuestas reales (`"2024-05-15T13:24"`), sin
+     * año en el design (`"12-21T07:00"`). Se toma como la colocación en la cola, pero en producción
+     * el de `list` y el de `access` no coinciden para un mismo PNR (#96): el de `list` es siempre
+     * posterior, y ninguna fuente dice qué fecha es cada uno. Se devuelve tal cual.
+     */
+    placedAt?: string;
+    /** `Line/POS/Source`: quién colocó el PNR. `agentSine` puede ser `SABRE`. */
+    placedBy?: {
+        agentSine?: string;
+        pseudoCityCode?: string;
+    };
+    /** `Line/PassengerName`. Las respuestas reales de entrar a una cola no lo traen. */
+    primaryPassenger?: string;
+    /** `Line/Group`. Las respuestas reales de entrar a una cola no lo traen. */
+    group?: string;
+    /**
+     * `Paragraph/Text`: el PNR en formato de host, línea por línea y tal cual, con su sangría. Las
+     * líneas vacías llegan como `""`. Se interpreta con `parseQueueParagraph`.
+     */
+    paragraph: readonly string[];
+}
+/**
+ * Resultado de una operación que avanza en la cola. El fin de cola es un resultado, no un error:
+ * `END OF DISPLAY FOR REQUESTED DATA` llega como `{ done: true }`, también al entrar a una cola
+ * vacía, y deja la sesión fuera de la cola.
+ */
+type QueueStep = {
+    done: false;
+    item: QueueItem;
+    warnings: SabreWarning[];
+} | {
+    done: true;
+    reason: QueueEndReason;
+    message: string;
+    warnings: SabreWarning[];
+};
+
+interface QueueCountRequest {
+    /** PCC cuyas colas se cuentan. Por defecto, el de la sesión. */
+    pcc?: string;
+}
+type QueueCountOptions = RequestOptions;
+/** Una cola con mensajes o PNR. */
+interface QueueCount {
+    queue: QueueRef;
+    count: number;
+}
+interface QueueCountResponse {
+    /** Las colas que trae la respuesta, en el orden de Sabre. Sabre no lista las vacías. */
+    queues: QueueCount[];
+    /**
+     * Los `Totals` por `Type`: `MESSAGES`, `SPECIALS` y `PNRS`. Si Sabre no manda alguno, queda en
+     * `undefined`.
+     */
+    totals: {
+        messages?: number;
+        specials?: number;
+        pnrs?: number;
+    };
+    /**
+     * `QueueInfo@DateTime` tal cual llegó, sin año (`"06-25T09:46"`): la hora del host al contar.
+     * Es un hecho pasado, así que el año se resuelve hacia atrás desde una fecha de referencia.
+     */
+    countedAt?: string;
+    /** Los `stl:Warning` de la respuesta. No lanzan. */
+    warnings: SabreWarning[];
+}
+
+interface QueueListRequest {
+    queue: QueueRef;
+    /** PCC de la cola. Por defecto, el de la sesión. */
+    pcc?: string;
+    /** `true` para pedir también el pasajero principal de cada PNR (`Q/…/LN`). */
+    primaryPassenger?: boolean;
+}
+type QueueListOptions = RequestOptions;
+/** Un PNR de la lista: los campos de su `Line`. */
+interface QueueListEntry extends Omit<QueueItem, 'paragraph'> {
+    /** `Line@Number`: la posición en la lista. */
+    position?: number;
+}
+interface QueueListResponse {
+    /** Los localizadores, en el orden de la cola. */
+    locators: string[];
+    /** Un elemento por PNR, en el mismo orden que `locators`. */
+    entries: QueueListEntry[];
+    /** `Paragraph/Text` tal cual: empieza con la cabecera `QUEUE LIST FOR <PCC>  QUEUE <n>`. */
+    paragraph: string[];
+    warnings: SabreWarning[];
+}
+
+/** Una cola de destino. */
+interface QueuePlaceTarget {
+    queue: QueueRef;
+    /** Por defecto, el PCC de la sesión. */
+    pcc?: string;
+    /**
+     * Código PIC (`PrefatoryInstructionCode`): 0–191 o 200–254. **Obligatorio**, aunque el design
+     * 2.0.4 lo da como opcional: sin PIC, producción rechaza el place con `INSTRUCTION NUMBER NOT IN
+     * RANGE` fuera de una cola y con `NEED INSTRUCTION NUMBER` dentro (#97). Sin valor por defecto.
+     */
+    instructionCode: number;
+}
+interface QueuePlaceRequest {
+    /** De 1 a 10 colas de destino. */
+    to: readonly QueuePlaceTarget[];
+    /**
+     * Hasta 6 localizadores a colocar, sin tenerlos en el AAA. Solo fuera de una cola: dentro,
+     * `place` coloca el PNR actual.
+     */
+    locators?: readonly string[];
+}
+type QueuePlaceOptions = RequestOptions;
+/** Una colocación que confirma Sabre (`QueueInfo`). */
+interface QueuePlacement {
+    queue?: QueueRef;
+    pcc?: string;
+    locator?: string;
+    /** `QueueInfo@DateTime` tal cual, sin año (`"12-21T12:00"`). */
+    placedAt?: string;
+}
+/** Lo que devuelve `place` fuera de una cola: no avanza nada. */
+interface QueuePlaceResult {
+    /** Las colocaciones de `QueueInfo`, si Sabre las manda. */
+    placements: QueuePlacement[];
+    /** Las líneas `Text`, tal cual (p. ej. `"OK 1030 NMIUTF"`). */
+    text: string[];
+    warnings: SabreWarning[];
+}
+/**
+ * Lo que devuelve `place`: un `QueueStep` dentro de una cola, y un `QueuePlaceResult` fuera. Se
+ * distinguen con `'done' in result`. Con `locators`, el tipo ya es `QueuePlaceResult`.
+ */
+type QueuePlaceResponse = QueueStep | QueuePlaceResult;
+
+/**
+ * Dónde está la sesión respecto de las colas: `'outside'`, `'inside'` (hay un PNR de una cola en
+ * el AAA) o `'unknown'` (una operación falló dentro de una cola, o un `access` falló sin respuesta
+ * de Sabre, y no se sabe si Sabre dejó la sesión adentro). De `'unknown'` se sale con `exit()`.
+ */
+type QueueState = 'outside' | 'inside' | 'unknown';
+/** Qué hacer con un PNR en `queue.process`. */
+type QueueProcessAction = {
+    action: 'remove';
+} | {
+    action: 'ignore';
+} | {
+    action: 'place';
+    to: readonly QueuePlaceTarget[];
+};
+interface QueueProcessRequest extends QueueAccessRequest {
+    /** Cuántos PNR visitar como máximo. Al llegar, sale con `QXI`. Sin tope por defecto. */
+    limit?: number;
+}
+interface QueueProcessResult {
+    /** Cuántos PNR se pasaron al callback. */
+    visited: number;
+    /** Por qué terminó: el fin de cola, una cola vacía al entrar, o `limit`. */
+    ended: QueueEndReason | 'limit';
+}
+/** @internal Lo que la sesión le presta al módulo de colas. */
+interface QueueContext {
+    /** Una llamada a Sabre dentro de la sesión, con uso exclusivo. */
+    send(request: SessionRequest): Promise<SoapResponse>;
+    /** PCC de la sesión: el default de cada operación. */
+    pcc: string;
+    log: EventLogger;
+}
+declare class QueueManagement {
+    #private;
+    /** @internal Lo construye `SabreSession`. */
+    constructor(context: QueueContext);
+    /**
+     * Si la sesión está dentro de una cola. Lo lleva el SDK: `access` con un PNR la deja en
+     * `'inside'`, y el fin de cola o `exit()`, en `'outside'`.
+     */
+    get state(): QueueState;
+    /**
+     * Get Queue Count (`QueueCountLLSRQ` 2.2.1): cuántos mensajes o PNR hay en cada cola del PCC,
+     * más los totales. Cada `queue` de la respuesta se puede pasar tal cual a las demás operaciones
+     * de cola.
+     *
+     * Se puede llamar dentro o fuera de una cola, y no cambia `state`. Es una lectura: se reintenta
+     * ante fallos transitorios. Un PCC que no tiene 3 o 4 caracteres alfanuméricos lanza
+     * `TypeError` sin red.
+     */
+    count(request?: QueueCountRequest, options?: QueueCountOptions): Promise<QueueCountResponse>;
+    /**
+     * La lista de localizadores de una cola (`QueueAccessLLSRQ` con `List`), sin recorrerla. Con
+     * `primaryPassenger: true`, cada entrada trae también el pasajero principal. Una cola vacía da
+     * una lista vacía.
+     *
+     * No cambia `state`. Es una lectura: se reintenta ante fallos transitorios. Lanza `TypeError`
+     * sin red si `queue` o `pcc` no son válidos, o si `primaryPassenger` no es un boolean.
+     */
+    list(request: QueueListRequest, options?: QueueListOptions): Promise<QueueListResponse>;
+    /**
+     * Access Queue (`QueueAccessLLSRQ` 2.1.1): entra a una cola y devuelve su primer PNR. Una cola
+     * vacía, o sin PNR que cumplan `selection`, devuelve `{ done: true }` y la sesión sigue afuera.
+     *
+     * Lanza `TypeError` sin red si la sesión ya está dentro de una cola (o en `'unknown'`: hay que
+     * llamar a `exit()` primero), si `queue` no es de 0 a 511 o `{ name }`, o con más de 8 filtros.
+     * Mueve el cursor: nunca se reintenta ante un fallo de red, y ese fallo deja `state` en
+     * `'unknown'`.
+     */
+    access(request: QueueAccessRequest, options?: QueueAccessOptions): Promise<QueueStep>;
+    /**
+     * Deja el PNR actual en la cola y pasa al siguiente (`I`). Fuera de una cola lanza `TypeError`
+     * sin red.
+     */
+    ignore(options?: QueueNavigationOptions): Promise<QueueStep>;
+    /**
+     * Saca el PNR actual de la cola y pasa al siguiente (`QR`). Con `from` (de 1 a 3 colas), lo saca
+     * de esas colas a la vez. Fuera de una cola lanza `TypeError` sin red.
+     */
+    remove(request?: QueueRemoveRequest, options?: QueueNavigationOptions): Promise<QueueStep>;
+    /**
+     * Sale de la cola sin cerrar la transacción (`QXI`) y deja `state` en `'outside'`. Fuera de una
+     * cola lanza `TypeError` sin red. En `'unknown'` manda `QXI` igual y, si Sabre lo rechaza con
+     * `CANNOT DO THIS IF OFF QUEUE` (la sesión ya no estaba en una cola), lo da por bueno. Cualquier
+     * otro error lanza y deja `'unknown'`.
+     */
+    exit(options?: QueueNavigationOptions): Promise<void>;
+    /**
+     * Recorre una cola: entra con `access`, llama a `callback` con cada PNR, ejecuta la acción que
+     * devuelve (`remove`, `ignore` o `place`) y termina en el fin de cola. No hace nada que no se
+     * pueda hacer con las primitivas.
+     *
+     * - Con `limit`, después de visitar esa cantidad de PNR sale con `QXI`. No tiene tope por
+     *   defecto: con una cola anómala que nunca llega al fin, el recorrido no termina. Conviene
+     *   pasarlo.
+     * - Si el callback lanza, o devuelve una acción inválida, sale con `QXI` y propaga el error. No
+     *   lo convierte en `ignore`: para seguir de largo, el callback atrapa su error y devuelve
+     *   `{ action: 'ignore' }`.
+     * - Si una operación falla, sale con `QXI` (tolerando que la sesión ya no esté en la cola) y
+     *   propaga el error. Con un `SabreSessionError` no intenta salir: la sesión ya no sirve.
+     *
+     * `options` se aplica a cada llamada a Sabre del recorrido.
+     */
+    process(request: QueueProcessRequest, callback: (item: QueueItem) => QueueProcessAction | Promise<QueueProcessAction>, options?: QueueNavigationOptions): Promise<QueueProcessResult>;
+    /**
+     * Place Queue Message (`QueuePlaceLLSRQ` 2.0.4): coloca un PNR en 1 a 10 colas.
+     *
+     * - **Dentro de una cola**, coloca el PNR actual y devuelve un `QueueStep` con el siguiente,
+     *   como `ignore` y `remove`. El PNR se mueve: sale de la cola en curso (producción, #97). El localizador sale de la línea de firma del PNR; `placedAt` y
+     *   `placedBy` quedan en `undefined`. Con `locators` lanza `TypeError` sin red: para colocar
+     *   otros PNR, primero `exit()`.
+     * - **Fuera de una cola**, coloca los `locators` (hasta 6) o el PNR del AAA, no avanza nada y
+     *   devuelve `{ placements, text, warnings }`.
+     *
+     * Cada destino necesita `instructionCode` (0–191 o 200–254), sin valor por defecto: sin él
+     * lanza `TypeError` sin red, porque Sabre lo exige dentro y fuera de una cola. Nunca se
+     * reintenta ante un fallo de red. Errores como `BAD PNR LOCATOR` o `NEED RECEIVED FROM FIELD`
+     * salen como `SabreBusinessError` (`service: 'queuePlace'`).
+     */
+    place(request: QueuePlaceRequest & {
+        locators: readonly string[];
+    }, options?: QueuePlaceOptions): Promise<QueuePlaceResult>;
+    place(request: QueuePlaceRequest, options?: QueuePlaceOptions): Promise<QueuePlaceResponse>;
+}
+
+/** Lo que una operación pide al transporte. La sesión agrega `CPAId`, `ConversationId` y el token. */
+type SessionRequest = Omit<SoapRequest, 'cpaId' | 'conversationId' | 'security'>;
+/**
+ * Método interno por el que las operaciones de la sesión (cola, ping) llaman a Sabre. Va con un
+ * símbolo que no se exporta del paquete para no sumar superficie pública.
+ */
+declare const sessionSend: unique symbol;
+/** Opciones de `openSession`. */
+interface OpenSessionOptions extends RequestOptions {
+    /**
+     * Manda `OTA_PingRQ` cuando la sesión lleva 13 minutos inactiva, antes del vencimiento de los
+     * 15. Apagado por defecto: en runtimes serverless o edge un timer no sobrevive entre
+     * invocaciones. Ahí conviene `withSession` por recorrido, o un `ping()` antes de reutilizar.
+     */
+    keepAlive?: boolean;
+}
+/**
+ * Una sesión SOAP abierta con `SessionCreateRQ`. Es exclusiva: Sabre no admite llamadas
+ * concurrentes en la misma sesión (`USG_INVALID_SESSION`), así que una segunda llamada mientras
+ * otra está en vuelo lanza `TypeError` sin llamar a la red. Se cierra con `close()`, o sola si
+ * se abrió con `withSession`.
+ */
+declare class SabreSession {
+    #private;
+    /** Queue Management: contar, recorrer y colocar en colas, dentro de esta sesión. */
+    readonly queue: QueueManagement;
+    /** @internal Se crea con `SabreLegacy.openSession()`. */
+    constructor(internal: {
+        transport: SoapTransport;
+        pcc: string;
+        conversationId: string;
+        token: string;
+        keepAlive: boolean;
+    });
+    /**
+     * Milisegundos desde la última respuesta de Sabre en esta sesión; `0` mientras hay una llamada
+     * en vuelo. Sabre cierra la sesión a los 15 minutos de inactividad.
+     */
+    get idleMs(): number;
+    /**
+     * Manda `OTA_PingRQ`, que reinicia el contador de inactividad sin tocar el AAA. Durante un
+     * recorrido de cola no hace falta: cada operación ya lo reinicia.
+     */
+    ping(options?: RequestOptions): Promise<void>;
+    /**
+     * Cierra la sesión con `SessionCloseRQ`: Sabre descarta el AAA e invalida el token. Es
+     * idempotente: las llamadas siguientes devuelven la misma promesa, sin volver a la red. Si el
+     * cierre falla, la sesión queda cerrada igual del lado del SDK; la de Sabre vence sola a los
+     * 15 minutos. Una sesión inutilizable (ver `SabreSessionError`) se cierra sin red: Sabre ya no
+     * la reconoce.
+     */
+    close(options?: RequestOptions): Promise<void>;
+    /** @internal Una llamada a Sabre dentro de la sesión, con uso exclusivo. */
+    [sessionSend](request: SessionRequest): Promise<SoapResponse>;
+}
+
+declare class SabreLegacy {
+    #private;
+    /**
+     * Recibe la misma config que `Sabre`. Usuario, PCC y domain de la sesión salen de
+     * `credentials.username` (`V1:<user>:<PCC>:<domain>` o `<user>-<PCC>-<domain>`), y la versión
+     * de `SessionCreateRQ` de las credenciales: 2.0.0 con `clientId` y `clientSecret`, 1.0.0 sin
+     * ellos. Una config inválida lanza `TypeError` aquí, sin llamar a la red.
+     */
+    constructor(config: SabreConfig);
+    get environment(): SabreEnvironment;
+    /** Endpoint SOAP del entorno. */
+    get baseUrl(): string;
+    /**
+     * Abre una sesión SOAP. Quien la abre la cierra: `try { … } finally { await session.close() }`.
+     * Para el caso común, `withSession` la cierra sola. Con `keepAlive: true`, manda un ping a los
+     * 13 minutos de inactividad.
+     */
+    openSession(options?: OpenSessionOptions): Promise<SabreSession>;
+    /**
+     * Abre una sesión, se la presta al callback y la cierra en un `finally`. Devuelve lo mismo que
+     * el callback y propaga su error. Si el cierre falla, emite `sabre.session.closeFailed` en
+     * `warn` y no pisa el resultado ni el error del callback.
+     */
+    withSession<T>(callback: (session: SabreSession) => Promise<T>): Promise<T>;
+}
+
+/**
+ * Cómo se elige el año cuando el texto no lo trae:
+ *
+ * - `'past'`: la fecha más reciente que no sea posterior a `referenceDate` (el mismo día cuenta).
+ *   Es la regla de los hechos que ya pasaron: la línea de recibido, `placedAt` y `countedAt`.
+ * - `'nearest'`: la fecha más cercana a `referenceDate`, hacia adelante o hacia atrás, dentro de
+ *   ±6 meses. Es la regla de los segmentos y del plazo de ticketing (`T-`, `TAW`). Con un empate
+ *   gana la fecha futura.
+ */
+type HostDateDirection = 'past' | 'nearest';
+interface ResolveHostDateOptions {
+    /** Regla del año. Por defecto `'past'`, la de `placedAt` y `countedAt`. */
+    direction?: HostDateDirection;
+}
+/**
+ * Convierte una fecha de host en un string ISO sin zona horaria: `'YYYY-MM-DD'`, o
+ * `'YYYY-MM-DDTHH:mm'` si el texto trae hora.
+ *
+ * Formatos que reconoce (sin distinguir mayúsculas, sin espacios a los costados):
+ *
+ * - `06SEP` y `06SEP26`, como en los segmentos, el ticketing y la línea de recibido;
+ * - `12-21` y `12-21T07:00`, como el `DateTime` de `QueueCountRS`;
+ * - `2024-05-15` y `2024-05-15T13:24`, como el `DateTime` de una línea de cola real.
+ *
+ * Si el texto trae año, se usa ese (un año de dos dígitos es del 2000 en adelante). Si no, el año
+ * se resuelve contra `referenceDate` con la regla de `options.direction`.
+ *
+ * `referenceDate` es un `'YYYY-MM-DD'` (puede seguir una hora, que no se usa) o un `Date`, del que
+ * se toma el día en UTC. Conviene pasar el día en el calendario del PCC: la regla compara días, y
+ * con zonas distintas la referencia puede quedar un día corrida.
+ *
+ * Devuelve `undefined` si el texto no tiene un formato reconocido, si la fecha no existe
+ * (`2026-02-29`, `31APR`) o si no hay un año que cumpla la regla (un `29FEB` sin un año bisiesto a
+ * menos de 6 meses, con `'nearest'`). Lanza `TypeError` si `referenceDate` no es válida.
+ */
+declare function resolveHostDate(text: string, referenceDate: Date | string, options?: ResolveHostDateOptions): string | undefined;
+
+interface QueueParagraphOptions {
+    /**
+     * Fecha contra la que se resuelve el año de las fechas sin año: un `'YYYY-MM-DD'` o un `Date`
+     * (se toma el día en UTC). Es obligatoria. Ver `resolveHostDate`.
+     */
+    referenceDate: Date | string;
+}
+/** Aviso de cola del principio del párrafo: el código PIC y su descripción (`011  SEE REMARKS`). */
+interface QueueParagraphMessage {
+    instructionCode: number;
+    text: string;
+}
+/** Un nombre del PNR (`1.1TEST/SWS*FSG`). */
+interface QueueParagraphPassenger {
+    /** Número de nombre, tal cual: `'1.1'`. */
+    nameNumber: string;
+    surname: string;
+    givenName?: string;
+    /** Lo que sigue al `*` del nombre. */
+    nameRemark?: string;
+    /** El nombre como llegó, sin el número: `'TEST/SWS*FSG'`. */
+    text: string;
+}
+interface QueueParagraphSegmentBase {
+    /** Número de segmento en el PNR. */
+    number: number;
+    /** Fecha ISO (`'2026-05-22'`), con el año resuelto con la regla `'nearest'`. */
+    date?: string;
+    /** Estado del segmento: `HK`, `HX`, `UN`, `GK`… */
+    status: string;
+    /** Cantidad que acompaña al estado (`HK1` → `1`). */
+    quantity: number;
+    /** La línea como llegó, sin espacios a los costados. */
+    text: string;
+}
+/** Un segmento aéreo: ` 1 DL2151E 20MAR 5 MIALGA HK1  0700  1003  /DCDL*HTDHAT /E`. */
+interface QueueParagraphAirSegment extends QueueParagraphSegmentBase {
+    kind: 'air';
+    airlineCode: string;
+    flightNumber: number;
+    bookingClass: string;
+    fromAirportCode: string;
+    toAirportCode: string;
+    /** Hora local de salida, en 24 horas (`'07:00'`). */
+    departureTime?: string;
+    /** Hora local de llegada, en 24 horas. Puede ser de otro día: el host no siempre lo marca. */
+    arrivalTime?: string;
+}
+/** Un segmento no aéreo con fecha: `2  CAR ZE 22APR Q GK1  DFW/24APR/…`. */
+interface QueueParagraphOtherSegment extends QueueParagraphSegmentBase {
+    kind: 'other';
+    /** Tipo de segmento del host: `CAR`, `OTH`… */
+    segmentType: string;
+    vendorCode: string;
+}
+type QueueParagraphSegment = QueueParagraphAirSegment | QueueParagraphOtherSegment;
+/** Una entrada del campo de ticketing (`TKT/TIME LIMIT`). */
+interface QueueParagraphTicketingEntry {
+    /** Número de la entrada: `1` en `1.T-13MAY-X6R3*N18`. */
+    number: number;
+    /** `'T-'`, `'TAW'` (o `TAC`, `TAM`, `TAT`, `TAX`), o `'TE'`/`'TK'` para una línea de boleto. */
+    code: string;
+    /** Fecha ISO de la entrada, con el año resuelto con la regla `'nearest'`. */
+    date?: string;
+    pseudoCityCode?: string;
+    agentSine?: string;
+    /** Número de boleto de una línea `TE` o `TK`. */
+    ticketNumber?: string;
+    /** La entrada como llegó, sin el número: `'T-13MAY-X6R3*N18'`. */
+    text: string;
+}
+interface QueueParagraphTicketing {
+    entries: QueueParagraphTicketingEntry[];
+    /** `true` si alguna entrada es una línea de boleto (`TE` o `TK`, con número). */
+    issued: boolean;
+}
+/**
+ * La línea `RECEIVED FROM - …` y la línea de firma del PNR
+ * (`<PCC>.<PCC>*<agente> HHMM/DDMMMYY <localizador> H`). La firma es la de la última modificación.
+ */
+interface QueueParagraphReceivedFrom {
+    /** Lo que sigue a `RECEIVED FROM - `. */
+    name?: string;
+    /** El primer PCC de la firma. */
+    pseudoCityCode?: string;
+    /** La firma del agente, lo que sigue al `*`. */
+    agentSine?: string;
+    /** Fecha y hora de la firma, `'YYYY-MM-DDTHH:mm'`. Sin año, se resuelve hacia atrás. */
+    receivedAt?: string;
+    locator?: string;
+}
+interface QueueParagraph {
+    messages: QueueParagraphMessage[];
+    passengers: QueueParagraphPassenger[];
+    segments: QueueParagraphSegment[];
+    /** El campo de ticketing, si el párrafo trae la sección `TKT/TIME LIMIT`. */
+    ticketing?: QueueParagraphTicketing;
+    /** La línea de recibido y la firma, si llega alguna de las dos. */
+    receivedFrom?: QueueParagraphReceivedFrom;
+    /** Las líneas que no se reconocieron, tal cual y en orden. Las líneas vacías no se incluyen. */
+    unparsed: string[];
+}
+/**
+ * Lee un párrafo de cola (`QueueItem.paragraph`) y extrae las secciones estándar de un PNR en
+ * formato de host: los avisos de cola, los nombres, los segmentos con su estado, el campo de
+ * ticketing y la línea de recibido con la firma.
+ *
+ * **Es best-effort**: el formato de host no tiene contrato. Una línea que no reconoce va a
+ * `unparsed` y nunca lanza por el contenido del párrafo. Solo lanza `TypeError` si `lines` no es
+ * un array o si `referenceDate` falta o no es válida.
+ *
+ * **No extrae** los plazos escritos en texto libre por la aerolínea (`ADTK BY`, `BEFORE` en
+ * remarks, SSR u OSI): su formato lo pone cada aerolínea. Esas líneas van a `unparsed`.
+ *
+ * Las fechas salen como strings ISO sin zona horaria. Los segmentos y el ticketing toman la fecha
+ * más cercana a `referenceDate` dentro de ±6 meses, y la firma se resuelve hacia atrás.
+ *
+ * **Versionado**: que una línea pase de `unparsed` a un campo nuevo es un cambio minor. Que cambie
+ * la forma de un campo existente es major.
+ */
+declare function parseQueueParagraph(lines: readonly string[], options: QueueParagraphOptions): QueueParagraph;
+
+interface SeatAvailabilityRequestSource {
+    /** Grupo del itinerario: aporta la fecha de cada tramo. */
+    group: ItineraryGroup;
+    /** Itinerario elegido, idealmente el devuelto por Revalidate Itinerary. */
+    itinerary: Itinerary;
+    /**
+     * Números de los vuelos para los que se piden mapas, empezando en 1, igual que `segmentIndex`
+     * de `buildBookingFlightDetails` (`1` es `S1`). Por defecto, todos.
+     */
+    segments?: number[];
+    /** ISO 4217 para los precios de los asientos. Si falta, Sabre la elige. */
+    currencyCode?: string;
+}
+/**
+ * Arma el request de `sabre.air.getSeats` por payload para un itinerario ya revalidado.
+ *
+ * - `segments[]`: un segmento por vuelo, en el orden del itinerario, con `id` `S1`, `S2`, …
+ *   (`IdType` exige empezar por letra). Vuelo, fechas y clase con las mismas reglas que
+ *   `buildBookingFlightDetails`; horas en `HH:MM`. Si el operador o su número de vuelo difieren
+ *   del comercializador, van en `operatingAirlineCode` / `operatingFlightNumber`.
+ * - `fareComponents[]`: uno por componente de tarifa (`FC` + su `id` en BFM), con `fareBasis`,
+ *   `governingCarrier` y `fareDetail`. `brandCode` no se manda: el itinerario no lo trae.
+ * - `passengers[]`: `P1`, `P2`, … en el orden de `passengerInfoList`, repetidos según
+ *   `passengerNumber`. Coinciden con `travelerIndex` de Create Booking si `travelers[]` va en
+ *   el mismo orden. `fareSegmentAssociation` une cada segmento con su componente de tarifa.
+ */
+declare function buildSeatAvailabilityRequest(source: SeatAvailabilityRequestSource): SeatAvailabilityByPayloadRq;
+
+/** Asiento elegido para un vuelo del itinerario. */
+interface BookingSeatSelection {
+    /**
+     * Número del vuelo en el itinerario, empezando en 1 (`1` es `flights[0]`). Misma base que
+     * `travelerIndex`, para no confundirlos.
+     */
+    segmentIndex: number;
+    /** Número del viajero en `travelers[]` de Create Booking, empezando en 1 (lo fija el spec). */
+    travelerIndex: number;
+    /** Fila y columna, p. ej. `13A`. */
+    number: string;
+}
+/** Asiento elegido que tiene precio en Get Seats. Sin datos del pasajero. */
+interface PricedSeat {
+    /** Empieza en 1, como en `BookingSeatSelection`. */
+    segmentIndex: number;
+    /** Vuelo comercializador, p. ej. `AA1234`. */
+    flight: string;
+    seat: string;
+    amount: string;
+    currencyCode: string;
+}
 interface BookingFlightDetailsSource {
     /** Grupo del itinerario: aporta la fecha de cada tramo. */
     group: ItineraryGroup;
@@ -1189,6 +2194,16 @@ interface BookingFlightDetailsSource {
      * tiene campo de moneda: se supone la del pricing (la del PCC, salvo `currencyPricing`).
      */
     priceComparison?: Omit<PriceComparison, 'desiredAmount'>;
+    /**
+     * Asientos por número, para `flights[segmentIndex - 1].seats[]` (camino ATPCO; `seatOffers` es
+     * solo NDC). Conviene elegir asientos sin cargo: no se sabe qué hace Sabre con uno cobrable.
+     */
+    seats?: BookingSeatSelection[];
+    /**
+     * Respuesta de `sabre.air.getSeats` para el mismo itinerario. Si un asiento elegido tiene
+     * precio ahí, `booking.create` emite `sabre.booking.seat.priced` (`warn`) y reserva igual.
+     */
+    seatAvailability?: GetSeatsResponse;
 }
 /**
  * Arma `flightDetails` para reservar por el camino ATPCO un itinerario ya revalidado.
@@ -1198,9 +2213,12 @@ interface BookingFlightDetailsSource {
  *   `isMarriageGroup` no se manda: no hay fuente para él.
  * - `flightPricing[0].qualifiers`: `passengersPricing` desde `passengerInfoList` y
  *   `validatingAirlineCode` desde `validatingCarrierCode` de la primera cotización.
+ * - `seats`: se validan sin llamar a Sabre (`number` con el patrón del spec, vuelo y viajero
+ *   existentes, los dos índices empiezan en 1) y se agregan a `flights[segmentIndex - 1].seats[]`.
+ *   Sin `seats`, nada cambia.
  */
 declare function buildBookingFlightDetails(source: BookingFlightDetailsSource): FlightDetails;
 
 declare const VERSION = "0.3.0";
 
-export { Air, type BaggageAllowanceDesc, type BaggageInformation, type BargainFinderMaxRequest, type BargainFinderMaxResponse, type BookContactInformation, type BookGenericSeat, type BookSeat, type BookTraveler, type Booking, type BookingAgency, type BookingFlightDetailsSource, type BookingItemReference, BookingManagement, type BookingResponseError, type BookingSource, type BrandedFare, type CancelBookingErrorPolicy, type CancelBookingNotification, type CancelBookingOptions, type CancelBookingRequest, type CancelBookingResponse, type CancelSegmentReference, type CreateBookingErrorPolicy, type CreateBookingOptions, type CreateBookingRequest, type CreateBookingResponse, type CreateBookingResponseError, type CurrencyConversion, type Fare, type FareComponent, type FareComponentDesc, type FareComponentDescSegment, type FareComponentSegment, type FareComponentSegmentDetail, type FareMessage, type FlightDetails, type FlightStatusCode, type FlightTicketOperation, type FlightToBook, type GetBookingExtraFeatures, type GetBookingOptions, type GetBookingRequest, type GetBookingResponse, type GetBookingReturnOnly, type GroupedItineraryResponse, type Itinerary, type ItineraryGroup, type ItineraryMessage, type Leg, type LegDesc, type LegDescription, type LegSchedule, type LegScheduleRef, type LowFareSearchFlight, type LowFareSearchLocation, type LowFareSearchOriginDestination, type LowFareSearchPassengerTypeQuantity, type LowFareSearchRequestorId, type LowFareSearchSource, type LowFareSearchTpaExtensions, type LowFareSearchTravelPreferences, type LowFareSearchTravelerInfoSummary, type ObFeeDesc, type OtaAirLowFareSearchRq, type PassengerInfo, type PassengerPricing, type PassengerTotalFare, type PaymentMethod, type PriceComparison, type PriceComparisonType, type PricingDetails, type PricingInformation, type PricingQualifiers, type Ref, type RefundDocumentsType, type RequestOptions, type RetryOptions, type RevalidateItineraryRequest, type RevalidateItineraryRequestSource, type RevalidateItineraryResponse, Sabre, type SabreAuthVersion, SabreBusinessError, type SabreBusinessErrorOptions, type SabreConfig, type SabreConfigV2, type SabreConfigV3, type SabreCredentials, type SabreCredentialsV2, type SabreEnvironment, SabreError, type SabreErrorOptions, SabreGatewayError, type SabreGatewayErrorOptions, type SabreLogEvent, type SabreLogLevel, type SabreLogger, SabreOrchestrationError, type SabreOrchestrationErrorOptions, type SabreProtocol, type SabreRawResponse, type SabreRawResponseCallback, type SabreServiceErrorOptions, type SabreTokenStore, SabreWarning, type ScheduleCarrier, type ScheduleDesc, type ScheduleEndpoint, type ScheduleEquipment, type SeatAreaPreference, type SpecificFare, type StoredToken, type TaxDesc, type TaxSummaryDesc, type TicketingPolicy, type TotalFare, type TravelerPhone, type TravelerTitle, VERSION, type ValidatingCarrierDesc, buildBookingFlightDetails, buildRevalidateItineraryRequest };
+export { Air, type BaggageAllowanceDesc, type BaggageInformation, type BargainFinderMaxRequest, type BargainFinderMaxResponse, type BookContactInformation, type BookGenericSeat, type BookSeat, type BookTraveler, type Booking, type BookingAgency, type BookingFlightDetailsSource, type BookingItemReference, BookingManagement, type BookingResponseError, type BookingSeatSelection, type BookingSource, type BrandedFare, type CancelBookingErrorPolicy, type CancelBookingNotification, type CancelBookingOptions, type CancelBookingRequest, type CancelBookingResponse, type CancelSegmentReference, type CreateBookingErrorPolicy, type CreateBookingOptions, type CreateBookingRequest, type CreateBookingResponse, type CreateBookingResponseError, type CurrencyConversion, type Fare, type FareComponent, type FareComponentDesc, type FareComponentDescSegment, type FareComponentSegment, type FareComponentSegmentDetail, type FareMessage, type FlightDetails, type FlightStatusCode, type FlightTicketOperation, type FlightToBook, type GetBookingExtraFeatures, type GetBookingOptions, type GetBookingRequest, type GetBookingResponse, type GetBookingReturnOnly, type GetSeatsRequest, type GetSeatsResponse, type GroupedItineraryResponse, type HostDateDirection, type Itinerary, type ItineraryGroup, type ItineraryMessage, type Leg, type LegDesc, type LegDescription, type LegSchedule, type LegScheduleRef, type LowFareSearchFlight, type LowFareSearchLocation, type LowFareSearchOriginDestination, type LowFareSearchPassengerTypeQuantity, type LowFareSearchRequestorId, type LowFareSearchSource, type LowFareSearchTpaExtensions, type LowFareSearchTravelPreferences, type LowFareSearchTravelerInfoSummary, type ObFeeDesc, type OpenSessionOptions, type OtaAirLowFareSearchRq, type PassengerInfo, type PassengerPricing, type PassengerTotalFare, type PaymentMethod, type PriceComparison, type PriceComparisonType, type PricedSeat, type PricingDetails, type PricingInformation, type PricingQualifiers, type QueueAccessOptions, type QueueAccessRequest, type QueueCount, type QueueCountOptions, type QueueCountRequest, type QueueCountResponse, type QueueEndReason, type QueueItem, type QueueListEntry, type QueueListOptions, type QueueListRequest, type QueueListResponse, QueueManagement, type QueueNavigationOptions, type QueueParagraph, type QueueParagraphAirSegment, type QueueParagraphMessage, type QueueParagraphOptions, type QueueParagraphOtherSegment, type QueueParagraphPassenger, type QueueParagraphReceivedFrom, type QueueParagraphSegment, type QueueParagraphTicketing, type QueueParagraphTicketingEntry, type QueuePlaceOptions, type QueuePlaceRequest, type QueuePlaceResponse, type QueuePlaceResult, type QueuePlaceTarget, type QueuePlacement, type QueueProcessAction, type QueueProcessRequest, type QueueProcessResult, QueueRef, type QueueRemoveRequest, type QueueRemoveTarget, type QueueSelection, type QueueState, type QueueStep, type RawSeatAvailabilityRs, type Ref, type RefundDocumentsType, type RequestOptions, type ResolveHostDateOptions, type RetryOptions, type RevalidateItineraryRequest, type RevalidateItineraryRequestSource, type RevalidateItineraryResponse, Sabre, type SabreAuthVersion, SabreBusinessError, type SabreBusinessErrorOptions, type SabreConfig, type SabreConfigV2, type SabreConfigV3, type SabreCredentials, type SabreCredentialsV2, type SabreEnvironment, SabreError, type SabreErrorOptions, SabreGatewayError, type SabreGatewayErrorOptions, SabreLegacy, type SabreLogEvent, type SabreLogLevel, type SabreLogger, SabreOrchestrationError, type SabreOrchestrationErrorOptions, type SabreProtocol, type SabreRawResponse, type SabreRawResponseCallback, type SabreServiceErrorOptions, SabreSession, SabreSessionError, type SabreSessionErrorKind, type SabreSessionErrorOptions, type SabreTokenStore, SabreWarning, type ScheduleCarrier, type ScheduleDesc, type ScheduleEndpoint, type ScheduleEquipment, type Seat, type SeatAreaPreference, type SeatAvailabilityByPayloadRq, type SeatAvailabilityByPnrLocatorRq, type SeatAvailabilityIssue, type SeatAvailabilityRequestSource, type SeatAvailabilityResponse, type SeatCabinCompartment, type SeatCabinFacility, type SeatCabinLayout, type SeatCabinRowPosition, type SeatCharacteristic, type SeatDisplayOnlyItem, type SeatFareComponent, type SeatFareDetail, type SeatFareSegmentAssociation, type SeatFlightLeg, type SeatKeyValuePair, type SeatLoyaltyProgramAccount, type SeatMap, type SeatOfferItem, type SeatOfferItemDetails, type SeatPassenger, type SeatPassengerPayloadRq, type SeatPassengerRs, type SeatPriceBreakdown, type SeatPriceDefinition, type SeatRow, type SeatSegment, type SeatSegmentPayloadRq, type SeatSegmentRs, type SeatServiceDefinition, type SeatSpecialServiceRequest, type SeatTax, type SpecificFare, type StoredToken, type TaxDesc, type TaxSummaryDesc, type TicketingPolicy, type TotalFare, type TravelerPhone, type TravelerTitle, VERSION, type ValidatingCarrierDesc, buildBookingFlightDetails, buildRevalidateItineraryRequest, buildSeatAvailabilityRequest, parseQueueParagraph, resolveHostDate };