sabre-client 0.4.1 → 0.5.1

package/dist/reservation-history-BKRFlxpA.d.ts

@@ -0,0 +1,792 @@
+interface RetryOptions {
+    /** Reintentos después de la primera llamada (3 → hasta 4 llamadas en total). */
+    maxRetries: number;
+    /** Delay base del backoff exponencial, en milisegundos. */
+    baseDelayMs: number;
+}
+
+interface SabreErrorOptions {
+    /** Si la política de reintentos puede volver a intentar la operación. */
+    retryable: boolean;
+    /** Fragmento de la respuesta original sin transformar (JSON parseado o nodo XML). */
+    raw?: unknown;
+    cause?: unknown;
+}
+/**
+ * Base de todos los errores del SDK.
+ *
+ * `raw` puede contener credenciales o datos de pasajero: no es enumerable, así que
+ * no aparece en `JSON.stringify`, spreads ni serializadores de logs, pero sigue
+ * accesible como `error.raw` para debugging. No lo vuelques a un logger sin sanitizar.
+ */
+declare class SabreError extends Error {
+    name: string;
+    readonly retryable: boolean;
+    readonly raw: unknown;
+    constructor(message: string, options: SabreErrorOptions);
+    toJSON(): Record<string, unknown>;
+}
+type SabreProtocol = 'rest' | 'soap';
+interface SabreGatewayErrorOptions extends SabreErrorOptions {
+    protocol: SabreProtocol;
+    /** HTTP status de la respuesta, si la hubo. */
+    status?: number;
+    /** Código tal cual lo devuelve el gateway (`ERR.2SG.*`, `USG_*`), si viene en el body. */
+    code?: string;
+}
+/** Error de transporte/gateway (`ERR.2SG.*` + HTTP status en REST, `USG_*` en SOAP). */
+declare class SabreGatewayError extends SabreError {
+    name: string;
+    readonly protocol: SabreProtocol;
+    readonly status: number | undefined;
+    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;
+}
+/**
+ * Error de servicio orquestado (`SP.*`), viaja dentro de una respuesta 200.
+ * `SP.PROVIDER_ERROR` es reintentable; `SP.INTERNAL_ERROR` (y cualquier otro) no.
+ */
+declare class SabreOrchestrationError extends SabreError {
+    name: string;
+    readonly code: string;
+    constructor(message: string, options: SabreOrchestrationErrorOptions);
+}
+interface SabreServiceErrorOptions extends Omit<SabreErrorOptions, 'retryable'> {
+    /** Servicio que originó el error, p. ej. `'createBooking'`. */
+    service: string;
+    /** Código tal cual lo documenta Sabre, sin normalizar. */
+    code: string;
+}
+interface SabreBusinessErrorOptions extends SabreServiceErrorOptions {
+    /**
+     * Solo para códigos que Sabre documenta como temporales en un servicio de lectura
+     * (p. ej. `Transmission timeout` de Bargain Finder Max). Por defecto `false`.
+     * La política de reintentos igual exige que la operación sea idempotente.
+     */
+    retryable?: boolean;
+    /** Avisos que llegaron junto con el error (p. ej. `category: WARNING` de Create Booking). */
+    warnings?: readonly SabreWarning[];
+    /**
+     * Otros errores que llegaron junto con este (p. ej. la causa real detrás de
+     * `NO_ITEMS_CANCELLED` en Cancel Booking).
+     */
+    errors?: readonly SabreBusinessError[];
+}
+/**
+ * Error del catálogo propio de un servicio. No es reintentable, salvo los códigos
+ * temporales de servicios de lectura que se marcan con `retryable: true`.
+ */
+declare class SabreBusinessError extends SabreError {
+    name: string;
+    readonly service: string;
+    readonly code: string;
+    readonly warnings: readonly SabreWarning[];
+    readonly errors: readonly SabreBusinessError[];
+    constructor(message: string, options: SabreBusinessErrorOptions);
+}
+/**
+ * Advertencia de un servicio (p. ej. `category: WARNING` de Create Booking, soft errors
+ * de End Transaction): no es un fallo fatal. Nunca se reintenta automáticamente.
+ */
+declare class SabreWarning extends SabreError {
+    name: string;
+    readonly service: string;
+    readonly code: string;
+    constructor(message: string, options: SabreServiceErrorOptions);
+}
+
+/**
+ * Respuesta tal cual llegó de Sabre, para guardarla junto al resultado tipado.
+ *
+ * ⚠️ El `body` trae datos de pasajeros (PII). El SDK nunca lo envía al logger; quien usa
+ * `onRawResponse` responde por dónde lo guarda.
+ */
+interface SabreRawResponse {
+    /** Método público sin `sabre.`, p. ej. `'booking.get'` o `'air.bargainFinderMax'`. */
+    operation: string;
+    protocol: 'rest' | 'soap';
+    /** HTTP status del intento que se entrega. */
+    status: number;
+    headers: Headers;
+    /**
+     * 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;
+}
+/**
+ * Se llama una sola vez por operación, con la respuesta del último intento HTTP, antes de
+ * devolver o de lanzar: también si termina en `SabreBusinessError` o `SabreGatewayError`. No
+ * se llama si ningún intento tuvo respuesta HTTP, ni con las llamadas de token.
+ *
+ * Es síncrono y su retorno se ignora. Si lanza, el SDK lo atrapa, emite
+ * `sabre.request.rawResponseHookFailed` al logger (sin el body) y la operación sigue.
+ */
+type SabreRawResponseCallback = (raw: SabreRawResponse) => void;
+
+/**
+ * Lo que el SDK mandó por la red en el último intento de una operación.
+ *
+ * ⚠️ El `body` y la `url` traen datos de pasajeros (PII): localizadores, nombres, contactos. El
+ * SDK nunca los envía al logger; quien usa `onRawRequest` responde por dónde los guarda.
+ */
+interface SabreRawRequest {
+    /** El mismo valor que en `onRawResponse`, p. ej. `'booking.get'` o `'queue.access'`. */
+    operation: string;
+    protocol: 'rest' | 'soap';
+    /** `'GET'`, `'POST'`… En SOAP, siempre `'POST'`. */
+    method: string;
+    /** URL completa, con query string. */
+    url: string;
+    /** Los headers que se mandaron, sin `Authorization` (se quita el header entero). */
+    headers: Headers;
+    /**
+     * El texto que se mandó, o `undefined` si el request no llevaba body. En REST va tal cual. En
+     * SOAP es el sobre completo, con una sola modificación: el valor de cada `BinarySecurityToken`
+     * va como `[REDACTED]`.
+     */
+    body: string | undefined;
+    /** Intentos que llegaron a llamar a `fetch`, contando los reintentos (1 si no hubo). */
+    attempts: number;
+}
+/**
+ * Se llama una sola vez por operación, con el último intento que se mandó, antes de devolver o de
+ * lanzar y antes que `onRawResponse`. A diferencia de este, se llama también si ningún intento tuvo
+ * respuesta HTTP (fallo de red, `AbortError`). No se llama si la operación lanza antes de mandar
+ * nada, ni con las llamadas de auth: el token de OAuth y `SessionCreateRQ` (`openSession`), que
+ * llevan credenciales, y `SessionCloseRQ` (`close`).
+ *
+ * Es síncrono y su retorno se ignora. Si lanza, el SDK lo atrapa, emite
+ * `sabre.request.rawRequestHookFailed` al logger (sin el body) y la operación sigue.
+ */
+type SabreRawRequestCallback = (raw: SabreRawRequest) => void;
+
+interface ScheduleEndpoint {
+    airport: string;
+    city?: string;
+    /** Visto en sandbox para aeropuertos de EE. UU. */
+    state?: string;
+    country?: string;
+    /** Hora local con offset, p. ej. `17:10:00+02:00`. */
+    time: string;
+    terminal?: string;
+    /** Días que se suman a la fecha de salida del vuelo. Visto en sandbox (`arrival`). */
+    dateAdjustment?: number;
+}
+interface ScheduleEquipment {
+    code: string;
+    typeForFirstLeg?: string;
+    typeForLastLeg?: string;
+}
+interface ScheduleCarrier {
+    marketing: string;
+    marketingFlightNumber: number;
+    operating?: string;
+    operatingFlightNumber?: number;
+    alliances?: string;
+    equipment?: ScheduleEquipment;
+    /**
+     * Nombre del operador en un código compartido, tal cual (p. ej. `"/AVIANCA"`). No está en el
+     * spec. Se observó en BFM y Revalidate en CERT, también cuando `operating` y
+     * `operatingFlightNumber` coinciden con el comercializador (AM101 TRC→MEX, operado por
+     * `"AEROLITORAL DBA AEROMEXICO CONNECT"`, 2026-11-05).
+     */
+    codeShared?: string;
+}
+/** Vuelo/segmento operado (`scheduleDescs[]`). */
+interface ScheduleDesc {
+    id: number;
+    /** Visto en sandbox, p. ej. `"7"`; significado sin confirmar. */
+    dotRating?: string;
+    frequency?: string;
+    stopCount?: number;
+    eTicketable?: boolean;
+    totalMilesFlown?: number;
+    /** Minutos. */
+    elapsedTime?: number;
+    departure: ScheduleEndpoint;
+    arrival: ScheduleEndpoint;
+    carrier: ScheduleCarrier;
+}
+/** Tramo lógico (`legDescs[]`): agrupa schedules por `ref`. */
+interface LegDesc {
+    id: number;
+    /** Minutos. */
+    elapsedTime?: number;
+    schedules: LegScheduleRef[];
+}
+/**
+ * Schedule dentro de un tramo. `departureDateAdjustment`: días que se suman a la fecha del
+ * tramo para la salida de este vuelo (conexión al día siguiente). Visto en sandbox, sin
+ * documentar en los ejemplos de Sabre.
+ */
+interface LegScheduleRef extends Ref {
+    departureDateAdjustment?: number;
+}
+/** Impuesto individual (`taxDescs[]`). */
+interface TaxDesc {
+    id: number;
+    code: string;
+    amount: number;
+    currency: string;
+    description?: string;
+    publishedAmount?: number;
+    publishedCurrency?: string;
+    station?: string;
+    country?: string;
+    /** Visto en sandbox. */
+    taxReissue?: {
+        refundable?: boolean;
+    };
+}
+/** Resumen de impuestos por código (`taxSummaryDescs[]`). Misma forma que `TaxDesc`. */
+type TaxSummaryDesc = TaxDesc;
+/** Cargo adicional (`obFeeDescs[]`). Significado exacto de "OB" sin confirmar. */
+interface ObFeeDesc {
+    id: number;
+    amount: number;
+    currency: string;
+}
+interface FareComponentDescSegment {
+    segment: {
+        stopover?: boolean;
+    };
+}
+/** Componente de tarifa (`fareComponentDescs[]`). */
+interface FareComponentDesc {
+    id: number;
+    governingCarrier?: string;
+    fareAmount?: number;
+    fareCurrency?: string;
+    fareBasisCode: string;
+    farePassengerType?: string;
+    publishedFareAmount?: number;
+    publishedFareCurrency?: string;
+    /** `FROM` / `TO`. */
+    directionality?: string;
+    applicablePricingCategories?: string;
+    vendorCode?: string;
+    fareTypeBitmap?: string;
+    fareType?: string;
+    fareTariff?: string;
+    fareRule?: string;
+    cabinCode?: string;
+    segments?: FareComponentDescSegment[];
+    ticketDesignator?: string;
+    mileageSurcharge?: number;
+    mileage?: boolean;
+    oneWayFare?: boolean;
+    negotiatedFare?: boolean;
+    privateFare?: boolean;
+    notValidAfter?: string;
+    /** Distinto de `directionality`; significado sin confirmar. */
+    direction?: string;
+}
+/** Aerolínea validadora (`validatingCarrierDescs[]`). */
+interface ValidatingCarrierDesc {
+    id: number;
+    settlementMethod?: string;
+    newVcxProcess?: boolean;
+    default?: {
+        code: string;
+    };
+}
+/** Franquicia de equipaje (`baggageAllowanceDescs[]`). */
+interface BaggageAllowanceDesc {
+    id: number;
+    pieceCount?: number;
+}
+/** Referencia a un descriptor por su `id`. */
+interface Ref {
+    ref: number;
+}
+interface ItineraryMessage {
+    severity: string;
+    type: string;
+    code: string;
+    text: string;
+}
+interface LegDescription {
+    departureDate: string;
+    departureLocation: string;
+    arrivalLocation: string;
+}
+interface CurrencyConversion {
+    from: string;
+    to: string;
+    exchangeRateUsed: number;
+}
+interface PassengerTotalFare {
+    totalFare: number;
+    totalTaxAmount?: number;
+    currency: string;
+    baseFareAmount?: number;
+    baseFareCurrency?: string;
+    equivalentAmount?: number;
+    equivalentCurrency?: string;
+    constructionAmount?: number;
+    constructionCurrency?: string;
+    exchangeRateOne?: number;
+    commissionPercentage?: number;
+    commissionAmount?: number;
+    cat35CommissionPercentage?: number;
+    cat35CommissionAmount?: number;
+    cat35MarkupAmount?: number;
+    commissionAmountInEquivalent?: number;
+    commissionSource?: string;
+}
+interface TotalFare {
+    totalPrice: number;
+    totalTaxAmount?: number;
+    currency: string;
+    baseFareAmount?: number;
+    baseFareCurrency?: string;
+    constructionAmount?: number;
+    constructionCurrency?: string;
+    equivalentAmount?: number;
+    equivalentCurrency?: string;
+}
+/** Disponibilidad del segmento dentro de un componente de tarifa. */
+interface FareComponentSegmentDetail {
+    bookingCode?: string;
+    cabinCode?: string;
+    mealCode?: string;
+    seatsAvailable?: number;
+    availabilityBreak?: boolean;
+    fareBreakPoint?: boolean;
+}
+interface FareMessage {
+    type: string;
+    code: string;
+    /** Visto en sandbox de Revalidate. */
+    carrier?: string;
+    info: string;
+}
+interface RawFareComponent extends Ref {
+    beginAirport?: string;
+    endAirport?: string;
+    segments?: Array<{
+        segment: FareComponentSegmentDetail;
+    }>;
+}
+interface RawBaggageInformation {
+    provisionType?: string;
+    airlineCode?: string;
+    /** Índices de segmento, no referencias a descriptores. */
+    segments?: Array<{
+        id: number;
+    }>;
+    allowance?: Ref;
+}
+interface RawPassengerInfo {
+    passengerType: string;
+    passengerNumber?: number;
+    nonRefundable?: boolean;
+    fareComponents?: RawFareComponent[];
+    taxes?: Ref[];
+    taxSummaries?: Ref[];
+    obFees?: Ref[];
+    currencyConversion?: CurrencyConversion;
+    passengerTotalFare?: PassengerTotalFare;
+    baggageInformation?: RawBaggageInformation[];
+    fareMessages?: FareMessage[];
+    fareCalcLine?: {
+        info: string;
+    };
+}
+interface RawFare {
+    mandatoryInd?: boolean;
+    validatingCarrierCode?: string;
+    vita?: boolean;
+    eTicketable?: boolean;
+    lastTicketDate?: string;
+    lastTicketTime?: string;
+    governingCarriers?: string;
+    passengerInfoList: Array<{
+        passengerInfo: RawPassengerInfo;
+    }>;
+    totalFare?: TotalFare;
+    validatingCarriers?: Ref[];
+}
+interface RawPricingInformation {
+    pricingSubsource?: string;
+    /** P. ej. `ATPCO`. Visto en Revalidate y en sandbox de BFM. */
+    distributionModel?: string;
+    fare: RawFare;
+}
+interface RawItinerary {
+    id: number;
+    pricingSource?: string;
+    /** Visto solo en Revalidate Itinerary. */
+    currentItinerary?: boolean;
+    /** Visto en sandbox de BFM; significado sin confirmar. */
+    diversitySwapper?: {
+        weighedPrice?: number;
+    };
+    legs: Ref[];
+    pricingInformation: RawPricingInformation[];
+}
+/** Tramo con sus schedules resueltos. */
+interface Leg extends Omit<LegDesc, 'schedules'> {
+    schedules: LegSchedule[];
+}
+/** Schedule resuelto, con lo que la referencia del tramo agrega. */
+type LegSchedule = ScheduleDesc & Omit<LegScheduleRef, 'ref'>;
+/** Segmento de un componente de tarifa: lo del descriptor más la disponibilidad del itinerario. */
+interface FareComponentSegment {
+    segment: FareComponentDescSegment['segment'] & FareComponentSegmentDetail;
+}
+/** Componente de tarifa resuelto: descriptor + datos propios del itinerario. */
+interface FareComponent extends Omit<FareComponentDesc, 'segments'> {
+    beginAirport?: string;
+    endAirport?: string;
+    segments?: FareComponentSegment[];
+}
+interface BaggageInformation extends Omit<RawBaggageInformation, 'allowance'> {
+    allowance?: BaggageAllowanceDesc;
+}
+interface PassengerInfo extends Omit<RawPassengerInfo, 'fareComponents' | 'taxes' | 'taxSummaries' | 'obFees' | 'baggageInformation'> {
+    fareComponents?: FareComponent[];
+    taxes?: TaxDesc[];
+    taxSummaries?: TaxSummaryDesc[];
+    obFees?: ObFeeDesc[];
+    baggageInformation?: BaggageInformation[];
+}
+interface Fare extends Omit<RawFare, 'passengerInfoList' | 'validatingCarriers'> {
+    passengerInfoList: Array<{
+        passengerInfo: PassengerInfo;
+    }>;
+    validatingCarriers?: ValidatingCarrierDesc[];
+}
+interface PricingInformation extends Omit<RawPricingInformation, 'fare'> {
+    fare: Fare;
+}
+interface Itinerary extends Omit<RawItinerary, 'legs' | 'pricingInformation'> {
+    legs: Leg[];
+    pricingInformation: PricingInformation[];
+}
+interface ItineraryGroup {
+    groupDescription: {
+        legDescriptions: LegDescription[];
+    };
+    itineraries: Itinerary[];
+}
+/**
+ * `groupedItineraryResponse` con cada `ref` resuelto al objeto completo. Los arrays de
+ * descriptores (`scheduleDescs`, `legDescs`, …) ya no se exponen: su contenido vive
+ * dentro de cada itinerario.
+ */
+interface GroupedItineraryResponse {
+    version: string;
+    messages: ItineraryMessage[];
+    statistics?: {
+        itineraryCount: number;
+    };
+    itineraryGroups: ItineraryGroup[];
+}
+
+interface LowFareSearchLocation {
+    LocationCode: string;
+    [key: string]: unknown;
+}
+interface LowFareSearchRequestorId {
+    Type: string;
+    ID: string;
+    CompanyName: {
+        Code: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface LowFareSearchSource {
+    /** PCC desde el que se busca. El SDK no lo inyecta. */
+    PseudoCityCode: string;
+    RequestorID: LowFareSearchRequestorId;
+    [key: string]: unknown;
+}
+/** Vuelo exacto a revalidar (`OriginDestinationInformation[].TPA_Extensions.Flight[]`). */
+interface LowFareSearchFlight {
+    /** `"A"` en el ejemplo de Sabre; significado sin confirmar. */
+    Type: string;
+    Number: number;
+    /** Fecha y hora local sin offset. */
+    DepartureDateTime: string;
+    ArrivalDateTime: string;
+    ClassOfService: string;
+    OriginLocation: LowFareSearchLocation;
+    DestinationLocation: LowFareSearchLocation;
+    Airline: {
+        Marketing: string;
+        Operating?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface LowFareSearchOriginDestination {
+    /** Fecha y hora local sin offset, p. ej. `2026-09-11T20:00:00`. */
+    DepartureDateTime: string;
+    OriginLocation: LowFareSearchLocation;
+    DestinationLocation: LowFareSearchLocation;
+    /** Solo Revalidate Itinerary. `false` en el ejemplo de Sabre; efecto de `true` sin confirmar. */
+    Fixed?: boolean;
+    TPA_Extensions?: {
+        /** Solo Revalidate Itinerary: fija los vuelos exactos del tramo. */
+        Flight?: LowFareSearchFlight[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface LowFareSearchTravelPreferences {
+    /** `0` = solo directos. */
+    MaxStopsQuantity?: number;
+    /** Filtro por aerolínea. */
+    VendorPref?: Array<{
+        Code: string;
+        [key: string]: unknown;
+    }>;
+    TPA_Extensions?: {
+        /** Solo Revalidate Itinerary. `"L"` en el ejemplo de Sabre; significado sin confirmar. */
+        VerificationItinCallLogic?: {
+            Value: string;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface LowFareSearchPassengerTypeQuantity {
+    /** Tipo de pasajero, p. ej. `ADT`. */
+    Code: string;
+    Quantity: number;
+    [key: string]: unknown;
+}
+interface LowFareSearchTravelerInfoSummary {
+    AirTravelerAvail: Array<{
+        PassengerTypeQuantity: LowFareSearchPassengerTypeQuantity[];
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+interface LowFareSearchTpaExtensions {
+    IntelliSellTransaction?: {
+        /** Propietario de Sabre, p. ej. `50ITINS`; significado exacto sin confirmar. */
+        RequestType: {
+            Name: string;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/** Contenido de `OTA_AirLowFareSearchRQ`. */
+interface OtaAirLowFareSearchRq {
+    /** `"5"`. El SDK no lo completa. */
+    Version: string;
+    POS: {
+        Source: LowFareSearchSource[];
+        [key: string]: unknown;
+    };
+    OriginDestinationInformation: LowFareSearchOriginDestination[];
+    TravelPreferences?: LowFareSearchTravelPreferences;
+    TravelerInfoSummary: LowFareSearchTravelerInfoSummary;
+    TPA_Extensions?: LowFareSearchTpaExtensions;
+    [key: string]: unknown;
+}
+
+/** Body de Bargain Finder Max v5, tal cual lo documenta Sabre. */
+interface BargainFinderMaxRequest {
+    OTA_AirLowFareSearchRQ: OtaAirLowFareSearchRq;
+}
+/** `groupedItineraryResponse` con las referencias ya resueltas. */
+type BargainFinderMaxResponse = GroupedItineraryResponse;
+interface RequestOptions {
+    signal?: AbortSignal;
+    /** Respuesta cruda del último intento HTTP. El body trae PII: ver `SabreRawResponse`. */
+    onRawResponse?: SabreRawResponseCallback;
+    /** Request crudo del último intento que se mandó, sin `Authorization`. Trae PII: ver `SabreRawRequest`. */
+    onRawRequest?: SabreRawRequestCallback;
+    /** Pisa los reintentos del cliente solo para esta request. */
+    retry?: Partial<RetryOptions>;
+}
+
+/**
+ * Una cola (ADR-028). Hay tres clases, y viajan por dos atributos distintos de `QueueIdentifier`:
+ * - **numérica**, de 0 a 511: `400` → `Number="400"`;
+ * - **alfabética**, una o dos letras mayúsculas: `'S'` → `Number="S"`. La `S` es la cola de
+ *   **mensajes** del PCC (cuenta lo mismo que `Totals Type="MESSAGES"`): no tiene PNR y no se puede
+ *   listar;
+ * - **con nombre** (tablas QN y QNB): `{ name: 'HOTELS' }` → `Name="HOTELS"`.
+ *
+ * Lo que devuelve `queue.count` se pasa tal cual a las demás operaciones. Las colas 0–49 son del
+ * sistema: el SDK no las restringe.
+ */
+type QueueRef = number | string | {
+    name: string;
+};
+/** La cola de mensajes del PCC: no tiene PNR y Sabre no la lista (`INVALID ENTRY`). */
+declare const MESSAGE_QUEUE = "S";
+/** Si la cola es la de mensajes (`'S'`). */
+declare function isMessageQueue(queue: QueueRef): boolean;
+
+interface QueueActivityRequest {
+    /** PCC cuyas colas se analizan. Por defecto, el de la sesión. */
+    pcc?: string;
+}
+type QueueActivityOptions = RequestOptions;
+/**
+ * Los ocho contadores de Get Queue Activity, con los nombres de Sabre. La pantalla `QA` del host los
+ * muestra en columnas (`ON Q`, `REMOVD`, …). Ninguna fuente dice desde cuándo cuentan (Q-097): el
+ * SDK los devuelve sin interpretar.
+ */
+interface QueueActivityCounters {
+    /** `NumMessages`: los mensajes o PNR que están hoy en la cola (`ON Q`). */
+    numMessages: number;
+    /** `Ended`: los terminados en la cola. */
+    ended: number;
+    /** `Ignored`: los ignorados (`I`). */
+    ignored: number;
+    /** `Moved`: los movidos a otra cola. */
+    moved: number;
+    /** `Removed`: los sacados de la cola (`QR`). */
+    removed: number;
+    /** `Transferred`: los transferidos. */
+    transferred: number;
+    /** `LeftMessageToContact`: con un mensaje dejado al contacto. */
+    leftMessageToContact: number;
+    /** `UnableToReach`: los que no se pudo contactar. */
+    unableToReach: number;
+}
+/** Los contadores de una cola. Sabre lista también colas vacías con contadores. */
+interface QueueActivity extends QueueActivityCounters {
+    /** La cola, como en `count`: `400`, `'S'` o `{ name }`. Se pasa tal cual a las demás operaciones. */
+    queue: QueueRef;
+}
+interface QueueActivityResponse {
+    /** Las colas que trae la respuesta, en el orden de Sabre. */
+    queues: QueueActivity[];
+    /** `Totals`: los ocho contadores sumados para el PCC. Sin `Totals`, `undefined`. */
+    totals?: QueueActivityCounters;
+    /**
+     * `QueueInfo@DateTime` tal cual llegó, sin año (`"11-06T11:33"`): la hora del host al analizar.
+     * Es un hecho pasado, así que el año se resuelve hacia atrás, como `countedAt`.
+     */
+    analyzedAt?: string;
+    /** Los `stl:Warning` de la respuesta. No lanzan. */
+    warnings: SabreWarning[];
+    /** `eb:Timestamp` de la respuesta de Sabre, en ISO 8601 UTC. Falta si Sabre no lo manda. */
+    respondedAt?: string;
+}
+
+type ReservationHistoryOptions = RequestOptions;
+/**
+ * Un elemento con su acción y su texto: `GeneralInfo` o `RemarkInfo/Remark`. Sabre no publica el
+ * catálogo de `action`. En CERT llegaron `A4S` (SSR), `A7` (ticketing), `A9` (teléfono), `AN`
+ * (nombre), `APE` (email) y `ADT`. La `A` inicial es un alta y la `X`, una baja.
+ */
+interface ReservationHistoryText {
+    action: string;
+    /** `Text`, tal cual. Puede traer datos del pasajero. */
+    text: string;
+}
+/** Un `FlightSegment` del historial, tal como estaba en esa transacción. */
+interface ReservationHistoryFlightSegment {
+    /** `@Action`: `AS` (alta) o `XS` (baja), según las respuestas y el design. */
+    action: string;
+    /** `@Status` en ese momento (`HK`, `HKNN`, `UN`…). */
+    status?: string;
+    /** `MarketingAirline@Code`. */
+    marketingAirline?: string;
+    /** `@FlightNumber`. */
+    flightNumber?: string;
+    /** `@ResBookDesigCode`: la clase. */
+    bookingClass?: string;
+    /** `OriginLocation@LocationCode`. */
+    origin?: string;
+    /** `DestinationLocation@LocationCode`. */
+    destination?: string;
+    /** `@DepartureDateTime` tal cual, sin año (`"12-19T13:10"`). Se resuelve con `resolveHostDate`. */
+    departureDateTime?: string;
+    /** `@ArrivalDateTime` tal cual, sin año. */
+    arrivalDateTime?: string;
+    /** `@NumberInParty`. */
+    numberInParty?: number;
+    /** `SupplierRef@ID`: el localizador de la aerolínea (`DCAA*DVDMYA`). */
+    supplierRef?: string;
+}
+/** Una `AccountingInfo` del historial: la línea de contabilidad, sin sus importes. */
+interface ReservationHistoryAccounting {
+    /** `@Action` (`HK` en el design). */
+    action?: string;
+    /** `@Type`: `R` reembolso, `G` cambio con reembolso, `E` cambio par, `A` cobro adicional, `L` descuento, `B` bulk. */
+    type?: string;
+    /** `@LinkCode`. */
+    linkCode?: string;
+}
+/**
+ * Una transacción del historial (`HistoricalInfo`): quién la firmó, cuándo y desde qué PCC
+ * (`ItineraryRef/Source`), y los elementos que cambió. Lo que el SDK no tipa (asientos, autos,
+ * hoteles, tren, seguros, facturas, importes) queda en la respuesta cruda (`onRawResponse`).
+ */
+interface ReservationHistoryTransaction {
+    /** `@RPH`: el número de la firma de la transacción (`HSTSIG`). */
+    rph?: number;
+    /** `Source@CreateDateTime`, tal cual: con año y sin zona (`"2026-11-04T17:15"`). */
+    createdAt?: string;
+    /** `Source@CreationAgent`: el sine del agente que firmó. */
+    agent?: string;
+    /** `Source@CreationAgentDutyCode`. */
+    agentDutyCode?: string;
+    /** `Source@CreationAgentFunctionCode`. */
+    agentFunctionCode?: string;
+    /** `Source@PseudoCityCode`: el PCC de la firma del agente. */
+    pcc?: string;
+    /**
+     * `Source@AAA_PseudoCityCode`: el PCC del AAA del agente. El sample lo escribe
+     * `AAAPseudoCityCode`, sin guion bajo; el SDK lee los dos.
+     */
+    aaaPcc?: string;
+    /** `Source@ReceivedFrom`: el campo de recibido de la transacción. */
+    receivedFrom?: string;
+    /** `ItineraryInfo/ReservationItems/Item/FlightSegment`, en orden. */
+    flightSegments: ReservationHistoryFlightSegment[];
+    /** `GeneralInfo`, en orden: SSR, ticketing, teléfonos, nombres, emails… como texto. */
+    generalInfo: ReservationHistoryText[];
+    /** `RemarkInfo/Remark`, en orden. */
+    remarks: ReservationHistoryText[];
+    /** `AccountingInfo`, en orden. */
+    accounting: ReservationHistoryAccounting[];
+}
+interface ReservationHistoryResponse {
+    /** Las transacciones (`HistoricalInfo`), en el orden de Sabre. */
+    transactions: ReservationHistoryTransaction[];
+    /** Los `stl:Warning` de la respuesta. No lanzan. */
+    warnings: SabreWarning[];
+    /** `eb:Timestamp` de la respuesta de Sabre, en ISO 8601 UTC. Falta si Sabre no lo manda. */
+    respondedAt?: string;
+}
+
+export { type PricingInformation as $, type LegDesc as A, type BargainFinderMaxRequest as B, type CurrencyConversion as C, type LegDescription as D, type LegSchedule as E, type Fare as F, type GroupedItineraryResponse as G, type LegScheduleRef as H, type ItineraryGroup as I, type LowFareSearchFlight as J, type LowFareSearchLocation as K, type Leg as L, type LowFareSearchOriginDestination as M, type LowFareSearchPassengerTypeQuantity as N, type OtaAirLowFareSearchRq as O, type LowFareSearchRequestorId as P, type QueueRef as Q, type ReservationHistoryTransaction as R, SabreError as S, type LowFareSearchSource as T, type LowFareSearchTpaExtensions as U, type LowFareSearchTravelPreferences as V, type LowFareSearchTravelerInfoSummary as W, MESSAGE_QUEUE as X, type ObFeeDesc as Y, type PassengerInfo as Z, type PassengerTotalFare as _, type QueueActivityCounters as a, type QueueActivity as a0, type Ref as a1, type SabreBusinessErrorOptions as a2, type SabreErrorOptions as a3, SabreGatewayError as a4, type SabreGatewayErrorOptions as a5, SabreOrchestrationError as a6, type SabreOrchestrationErrorOptions as a7, type SabreProtocol as a8, type SabreRawRequest as a9, type SabreRawResponse as aa, type SabreServiceErrorOptions as ab, SabreSessionError as ac, type SabreSessionErrorKind as ad, type SabreSessionErrorOptions as ae, type ScheduleCarrier as af, type ScheduleDesc as ag, type ScheduleEndpoint as ah, type ScheduleEquipment as ai, type TaxDesc as aj, type TaxSummaryDesc as ak, type TotalFare as al, type ValidatingCarrierDesc as am, isMessageQueue as an, type ReservationHistoryFlightSegment as b, type ReservationHistoryText as c, type ReservationHistoryAccounting as d, type RetryOptions as e, type SabreRawResponseCallback as f, type SabreRawRequestCallback as g, SabreWarning as h, SabreBusinessError as i, type Itinerary as j, type RequestOptions as k, type BargainFinderMaxResponse as l, type QueueActivityRequest as m, type QueueActivityOptions as n, type QueueActivityResponse as o, type ReservationHistoryOptions as p, type ReservationHistoryResponse as q, type BaggageAllowanceDesc as r, type BaggageInformation as s, type FareComponent as t, type FareComponentDesc as u, type FareComponentDescSegment as v, type FareComponentSegment as w, type FareComponentSegmentDetail as x, type FareMessage as y, type ItineraryMessage as z };