sabre-client 0.3.0-next.1 → 0.3.0-next.2

package/dist/index.js

@@ -29,6 +29,14 @@ var SabreGatewayError = class extends SabreError {
     this.code = options.code;
   }
 };
+var SabreSessionError = class extends SabreGatewayError {
+  name = "SabreSessionError";
+  kind;
+  constructor(message, options) {
+    super(message, { ...options, protocol: "soap" });
+    this.kind = options.kind;
+  }
+};
 var SabreOrchestrationError = class extends SabreError {
   name = "SabreOrchestrationError";
   code;
@@ -248,6 +256,104 @@ function classifyBargainFinderMax(body) {
   return classifyItineraryMessages(body, BARGAIN_FINDER_MAX_SERVICE, BARGAIN_FINDER_MAX_CATALOG);
 }
 
+// src/booking/booking-errors.ts
+var WARNING = "WARNING";
+function responseErrors(response) {
+  return Array.isArray(response.errors) ? response.errors.filter(isObject2) : [];
+}
+function isWarning(item) {
+  return typeof item.category === "string" && item.category.toUpperCase() === WARNING;
+}
+function toWarning(service, item) {
+  return new SabreWarning(messageOf(service, item), { service, code: codeOf(item), raw: item });
+}
+function toBusinessError(service, item, { warnings = [], errors = [], retryable = false } = {}) {
+  return new SabreBusinessError(messageOf(service, item), {
+    service,
+    code: codeOf(item),
+    raw: item,
+    warnings,
+    errors,
+    retryable
+  });
+}
+function codeOf(item) {
+  return typeof item.type === "string" && item.type !== "" ? item.type : String(item.category);
+}
+function messageOf(service, item) {
+  const where = typeof item.fieldPath === "string" && item.fieldPath !== "" ? ` en ${item.fieldPath}` : "";
+  const description = typeof item.description === "string" && item.description !== "" ? `: ${item.description}` : "";
+  return `${service}: ${String(item.category)} ${codeOf(item)}${where}${description}`;
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value !== "";
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/air/get-seats.ts
+var GET_SEATS_BY_PAYLOAD_SERVICE = "getSeatsByPayload";
+var BY_PAYLOAD_PATH = "/v3/offers/getseats/byReservationPayload";
+var GET_SEATS_BY_PNR_LOCATOR_SERVICE = "getSeatsByPnrLocator";
+var BY_PNR_LOCATOR_PATH = "/v3/offers/getseats/byPnrLocator";
+var PAYLOAD_FIELDS = ["segments", "passengers", "returnSeatMapsOnlyForSegmentRefs"];
+async function getSeats(transport, request, options = {}) {
+  if (!isObject2(request)) {
+    throw new TypeError("sabre-client: air.getSeats espera un objeto");
+  }
+  if ("pnrLocator" in request) {
+    if (!nonEmpty(request.pnrLocator)) {
+      throw new TypeError("sabre-client: air.getSeats con pnrLocator vac\xEDo");
+    }
+    const mixed = PAYLOAD_FIELDS.filter((field) => field in request);
+    if (mixed.length > 0) {
+      throw new TypeError(`sabre-client: air.getSeats con pnrLocator no acepta ${mixed.join(", ")}`);
+    }
+    return send(transport, BY_PNR_LOCATOR_PATH, GET_SEATS_BY_PNR_LOCATOR_SERVICE, request, options);
+  }
+  if (!Array.isArray(request.segments) || !Array.isArray(request.passengers)) {
+    throw new TypeError("sabre-client: air.getSeats espera { segments: [...], passengers: [...], ... } o { pnrLocator }");
+  }
+  return send(transport, BY_PAYLOAD_PATH, GET_SEATS_BY_PAYLOAD_SERVICE, request, options);
+}
+async function send(transport, path, service, request, options) {
+  const body = await transport.request({
+    method: "POST",
+    path,
+    service,
+    idempotent: true,
+    body: request,
+    classify: (raw) => classifyGetSeats(raw, service),
+    ...options.retry === void 0 ? {} : { retry: options.retry },
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    ...options.onRawResponse === void 0 ? {} : { operation: `air.${service}`, onRawResponse: options.onRawResponse }
+  });
+  return {
+    response: body.response,
+    warnings: issues(body.warnings).map((item) => toWarning(service, item)),
+    errors: issues(body.errors).map((item) => toBusinessError(service, item))
+  };
+}
+function classifyGetSeats(body, service) {
+  if (!isObject2(body)) {
+    return new SabreError(`${service}: respuesta malformada, se esperaba un objeto`, { retryable: false, raw: body });
+  }
+  const rs = body;
+  if (isObject2(rs.response)) return void 0;
+  const [first, ...rest] = issues(rs.errors);
+  if (first !== void 0) {
+    return toBusinessError(service, first, {
+      warnings: issues(rs.warnings).map((item) => toWarning(service, item)),
+      errors: rest.map((item) => toBusinessError(service, item))
+    });
+  }
+  return new SabreError(`${service}: respuesta malformada, sin response ni errors`, { retryable: false, raw: body });
+}
+function issues(list) {
+  return Array.isArray(list) ? list.filter(isObject2) : [];
+}
+
 // src/air/itinerary-flights.ts
 function itineraryFlights(group, itinerary) {
   const { legDescriptions } = group.groupDescription;
@@ -398,6 +504,15 @@ var Air = class {
   revalidateItinerary(request, options) {
     return revalidateItinerary(this.#transport, request, options);
   }
+  /**
+   * 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, options) {
+    return getSeats(this.#transport, request, options);
+  }
 };
 
 // src/logging/redact.ts
@@ -447,6 +562,13 @@ function redactEntries(entries, seen) {
   }
   return out;
 }
+var BINARY_SECURITY_TOKEN = /(<(?:[A-Za-z_][\w.-]*:)?BinarySecurityToken(?=[\s/>])(?:[^>"']|"[^"]*"|'[^']*')*(?<!\/)>)([\s\S]*?)(<\/(?:[A-Za-z_][\w.-]*:)?BinarySecurityToken\s*>)/g;
+function redactSoapEnvelope(envelope) {
+  return envelope.replace(
+    BINARY_SECURITY_TOKEN,
+    (match, open, value, close) => value.trim() === "" ? match : `${open}${REDACTED}${close}`
+  );
+}
 
 // src/logging/logger.ts
 var EventLogger = class {
@@ -660,42 +782,6 @@ var AuthManager = class {
   }
 };
 
-// src/booking/booking-errors.ts
-var WARNING = "WARNING";
-function responseErrors(response) {
-  return Array.isArray(response.errors) ? response.errors.filter(isObject2) : [];
-}
-function isWarning(item) {
-  return typeof item.category === "string" && item.category.toUpperCase() === WARNING;
-}
-function toWarning(service, item) {
-  return new SabreWarning(messageOf(service, item), { service, code: codeOf(item), raw: item });
-}
-function toBusinessError(service, item, { warnings = [], errors = [], retryable = false } = {}) {
-  return new SabreBusinessError(messageOf(service, item), {
-    service,
-    code: codeOf(item),
-    raw: item,
-    warnings,
-    errors,
-    retryable
-  });
-}
-function codeOf(item) {
-  return typeof item.type === "string" && item.type !== "" ? item.type : String(item.category);
-}
-function messageOf(service, item) {
-  const where = typeof item.fieldPath === "string" && item.fieldPath !== "" ? ` en ${item.fieldPath}` : "";
-  const description = typeof item.description === "string" && item.description !== "" ? `: ${item.description}` : "";
-  return `${service}: ${String(item.category)} ${codeOf(item)}${where}${description}`;
-}
-function nonEmpty(value) {
-  return typeof value === "string" && value !== "";
-}
-function isObject2(value) {
-  return typeof value === "object" && value !== null;
-}
-
 // src/booking/cancel-booking.ts
 var CANCEL_BOOKING_SERVICE = "cancelBooking";
 var PATH3 = "/v1/trip/orders/cancelBooking";
@@ -763,12 +849,123 @@ function errorOf(item) {
   return toBusinessError(CANCEL_BOOKING_SERVICE, item);
 }
 
+// src/booking/flight-details.ts
+var SEAT_NUMBER = /^[0-9]+[A-Z]$/;
+var pricedSeats = /* @__PURE__ */ new WeakMap();
+function pricedSeatsOf(details) {
+  return details === void 0 ? [] : pricedSeats.get(details) ?? [];
+}
+function buildBookingFlightDetails(source) {
+  const { group, itinerary, priceComparison, seats = [], seatAvailability } = source;
+  const flights = itineraryFlights(group, itinerary).map(
+    ({ schedule, departureDate, bookingCode }) => ({
+      flightNumber: schedule.carrier.marketingFlightNumber,
+      airlineCode: schedule.carrier.marketing,
+      fromAirportCode: schedule.departure.airport,
+      toAirportCode: schedule.arrival.airport,
+      departureDate,
+      departureTime: schedule.departure.time.slice(0, 5),
+      bookingClass: bookingCode,
+      flightStatusCode: "NN"
+    })
+  );
+  const fare = itinerary.pricingInformation[0]?.fare;
+  if (fare === void 0) {
+    throw new TypeError("sabre-client: el itinerario no trae pricingInformation");
+  }
+  const passengersPricing = fare.passengerInfoList.map(
+    ({ passengerInfo }) => ({
+      passengerCode: passengerInfo.passengerType,
+      numberOfpassengers: passengerInfo.passengerNumber ?? 1
+    })
+  );
+  let priceComparisons;
+  if (priceComparison !== void 0) {
+    const total = fare.totalFare?.totalPrice;
+    if (total === void 0) {
+      throw new TypeError("sabre-client: el itinerario no trae totalFare.totalPrice para priceComparison");
+    }
+    priceComparisons = [{ desiredAmount: amount(total), ...priceComparison }];
+  }
+  const travelerCount = passengersPricing.reduce((n, p) => n + (p.numberOfpassengers ?? 1), 0);
+  const priced = [];
+  for (const selection of seats) {
+    const flight2 = flights[validSeat(selection, flights.length, travelerCount)];
+    (flight2.seats ??= []).push({ number: selection.number, travelerIndex: selection.travelerIndex });
+    const price = seatAvailability === void 0 ? void 0 : seatPrice(seatAvailability, flight2, selection.number);
+    if (price !== void 0) {
+      priced.push({
+        segmentIndex: selection.segmentIndex,
+        flight: `${flight2.airlineCode}${flight2.flightNumber}`,
+        seat: selection.number,
+        ...price
+      });
+    }
+  }
+  const details = {
+    flights,
+    flightPricing: [
+      {
+        ...priceComparisons === void 0 ? {} : { priceComparisons },
+        qualifiers: {
+          passengersPricing,
+          ...fare.validatingCarrierCode === void 0 ? {} : { validatingAirlineCode: fare.validatingCarrierCode }
+        }
+      }
+    ]
+  };
+  if (priced.length > 0) pricedSeats.set(details, priced);
+  return details;
+}
+function validSeat(selection, flightCount, travelerCount) {
+  const { segmentIndex, travelerIndex, number } = selection;
+  if (typeof number !== "string" || !SEAT_NUMBER.test(number)) {
+    throw new TypeError(`sabre-client: el asiento ${String(number)} no cumple ^[0-9]+[A-Z]$ (p. ej. 13A)`);
+  }
+  if (!Number.isInteger(segmentIndex) || segmentIndex < 1 || segmentIndex > flightCount) {
+    throw new TypeError(
+      `sabre-client: el asiento ${number} pide el vuelo ${segmentIndex}, y hay ${flightCount} (empieza en 1)`
+    );
+  }
+  if (!Number.isInteger(travelerIndex) || travelerIndex < 1 || travelerIndex > travelerCount) {
+    throw new TypeError(
+      `sabre-client: el asiento ${number} pide el viajero ${travelerIndex}, y hay ${travelerCount} (empieza en 1)`
+    );
+  }
+  return segmentIndex - 1;
+}
+function seatPrice(availability, flight2, number) {
+  const { response } = availability;
+  const segmentIds = new Set(
+    response.segments.filter(
+      (s) => s.bookingAirlineCode === flight2.airlineCode && s.bookingFlightNumber === flight2.flightNumber && s.departureAirportCode === flight2.fromAirportCode && s.departureDate === flight2.departureDate
+    ).map((s) => s.id)
+  );
+  const row = Number(number.slice(0, -1));
+  const column = number.slice(-1);
+  const seat = response.seatMaps.filter((map) => segmentIds.has(map.segmentRef)).flatMap((map) => map.cabinCompartments ?? []).flatMap((cabin) => cabin.seatRows ?? []).filter((r) => r.row === row).flatMap((r) => r.seats).find((s) => s.column === column);
+  for (const itemId of seat?.offerItemRefIds ?? []) {
+    const item = response.offerItems.find((i) => i.id === itemId);
+    const price = response.priceDefinitions?.find((p) => p.id === item?.priceDefinitionRef);
+    if (price !== void 0 && Number(price.totalPrice.amount) > 0) {
+      return { amount: String(price.totalPrice.amount), currencyCode: price.currencyCode };
+    }
+  }
+  return void 0;
+}
+function amount(value) {
+  return String(Math.round(value * 1e3) / 1e3);
+}
+
 // src/booking/create-booking.ts
 var CREATE_BOOKING_SERVICE = "createBooking";
 var PATH4 = "/v1/trip/orders/createBooking";
 var UNABLE_TO_RETRIEVE_BOOKING = "UNABLE_TO_RETRIEVE_BOOKING";
 async function createBooking(transport, request, options = {}) {
   validateCreateBookingRequest(request);
+  for (const seat of pricedSeatsOf(request.flightDetails)) {
+    transport.log.emit("warn", "sabre.booking.seat.priced", { service: CREATE_BOOKING_SERVICE, ...seat });
+  }
   const body = await transport.request({
     method: "POST",
     path: PATH4,
@@ -791,6 +988,16 @@ function validateCreateBookingRequest(request) {
       "sabre-client: booking.create con agency.ticketingPolicy FUTURE_TICKETING necesita agency.futureTicketingPolicy"
     );
   }
+  const travelers = Array.isArray(request.travelers) ? request.travelers.length : 0;
+  for (const flight2 of request.flightDetails?.flights ?? []) {
+    for (const seat of flight2.seats ?? []) {
+      if (seat.travelerIndex < 1 || seat.travelerIndex > travelers) {
+        throw new TypeError(
+          `sabre-client: booking.create con un asiento para el viajero ${seat.travelerIndex}, y travelers tiene ${travelers}`
+        );
+      }
+    }
+  }
 }
 function classifyCreateBooking(body) {
   if (!isObject2(body)) {
@@ -910,7 +1117,9 @@ var BookingManagement = class {
    * 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, options) {
     return createBooking(this.#transport, request, options);
@@ -958,12 +1167,30 @@ function validateRetryOptions(retry, where) {
     throw new TypeError(`sabre-client: ${where}.baseDelayMs debe ser un n\xFAmero >= 0`);
   }
 }
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason);
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 
 // src/config.ts
 var BASE_URLS = Object.freeze({
   sandbox: "https://api.cert.platform.sabre.com",
   production: "https://api.platform.sabre.com"
 });
+var SOAP_BASE_URLS = Object.freeze({
+  sandbox: "https://webservices.cert.platform.sabre.com",
+  production: "https://webservices.platform.sabre.com"
+});
 var LOGGER_METHODS = ["debug", "info", "warn", "error"];
 function fail(message) {
   throw new TypeError(`sabre-client: ${message}`);
@@ -1016,6 +1243,7 @@ function resolveConfig(config) {
     credentials: Object.freeze({ ...credentials }),
     environment,
     baseUrl: BASE_URLS[environment],
+    soapBaseUrl: SOAP_BASE_URLS[environment],
     authVersion,
     pcc: config.pcc,
     logger,
@@ -1044,6 +1272,10 @@ var RestTransport = class {
     this.#random = options.random ?? Math.random;
     this.#sleep = options.sleep ?? sleep;
   }
+  /** @internal Para los avisos de las operaciones que no son de una request (p. ej. asientos con precio). */
+  get log() {
+    return this.#log;
+  }
   /** Punto de enganche para `AuthManager`. */
   setAuthorizationProvider(provider) {
     this.#authorization = provider;
@@ -1177,13 +1409,17 @@ function parseBody(text) {
 }
 function gatewayError(service, status, body) {
   const code = extractCode(body);
-  return new SabreGatewayError(`${service}: HTTP ${status}${code === void 0 ? "" : ` ${code}`}`, {
-    protocol: "rest",
-    status,
-    retryable: RETRYABLE_STATUS.has(status),
-    raw: body,
-    ...code === void 0 ? {} : { code }
-  });
+  const detail = extractDescription(body);
+  return new SabreGatewayError(
+    `${service}: HTTP ${status}${code === void 0 ? "" : ` ${code}`}${detail === void 0 ? "" : `: ${detail}`}`,
+    {
+      protocol: "rest",
+      status,
+      retryable: RETRYABLE_STATUS.has(status),
+      raw: body,
+      ...code === void 0 ? {} : { code }
+    }
+  );
 }
 function extractCode(body) {
   if (typeof body !== "object" || body === null) return void 0;
@@ -1191,7 +1427,18 @@ function extractCode(body) {
     const value = body[key];
     if (typeof value === "string" && value !== "") return value;
   }
-  return void 0;
+  return firstErrorField(body, "code") ?? firstErrorField(body, "type");
+}
+function extractDescription(body) {
+  return firstErrorField(body, "descriptionText") ?? firstErrorField(body, "description");
+}
+function firstErrorField(body, key) {
+  if (typeof body !== "object" || body === null) return void 0;
+  const errors = body.errors;
+  const first = Array.isArray(errors) ? errors[0] : void 0;
+  if (typeof first !== "object" || first === null) return void 0;
+  const value = first[key];
+  return typeof value === "string" && value !== "" ? value : void 0;
 }
 function isUnauthorized(error) {
   return error instanceof SabreGatewayError && error.protocol === "rest" && error.status === 401;
@@ -1202,20 +1449,6 @@ function isAbort(error, signal) {
 function describe(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) return reject(signal.reason);
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(signal?.reason);
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
 
 // src/sabre.ts
 var Sabre = class {
@@ -1241,54 +1474,1787 @@ var Sabre = class {
   }
 };
 
-// src/booking/flight-details.ts
-function buildBookingFlightDetails(source) {
-  const { group, itinerary, priceComparison } = source;
-  const flights = itineraryFlights(group, itinerary).map(
-    ({ schedule, departureDate, bookingCode }) => ({
-      flightNumber: schedule.carrier.marketingFlightNumber,
-      airlineCode: schedule.carrier.marketing,
-      fromAirportCode: schedule.departure.airport,
-      toAirportCode: schedule.arrival.airport,
-      departureDate,
-      departureTime: schedule.departure.time.slice(0, 5),
-      bookingClass: bookingCode,
-      flightStatusCode: "NN"
-    })
-  );
-  const fare = itinerary.pricingInformation[0]?.fare;
-  if (fare === void 0) {
-    throw new TypeError("sabre-client: el itinerario no trae pricingInformation");
+// src/http/soap-transport.ts
+import { XMLParser } from "fast-xml-parser";
+var TRANSIENT_STATUS = /* @__PURE__ */ new Set([429, 500, 503, 504]);
+var BUSY_CODES = /* @__PURE__ */ new Set(["USG_CONNECTOR_IS_BUSY", "USG_IS_BUSY", "USG_SERVICE_IS_BUSY"]);
+var TRANSIENT_CODES = /* @__PURE__ */ new Set([
+  "USG_SECURITY_ICE_ERROR",
+  "USG_SERVICE_PROVIDER_ERROR",
+  "USG_NO_RESPONSE_FROM_JMSRECEIVER_IN_TIME",
+  "SC_SERVICE_UNAVAILABLE",
+  "USG_COULD_NOT_COMPLETE_REQUEST",
+  "USG_IIOP_OBJECT_NOT_EXIST",
+  "USG_IIOP_TRANSIENT_EXCEPTION",
+  "USG_MOM_SERVICE_PROVIDER_INFRASTRUCTURE_ERROR"
+]);
+var PREVIOUS_ENTRY_ACTIVE_RETRIES = 3;
+var PREVIOUS_ENTRY_ACTIVE_DELAY_MS = 1e3;
+var PREVIOUS_ENTRY_ACTIVE = /PREVIOUS ENTRY ACTIVE/i;
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@",
+  removeNSPrefix: true,
+  parseTagValue: false,
+  parseAttributeValue: false,
+  processEntities: true
+});
+var SoapTransport = class {
+  #config;
+  #log;
+  #messageId;
+  #now;
+  #random;
+  #sleep;
+  constructor(config, options = {}) {
+    this.#config = config;
+    this.#log = new EventLogger(config.logger);
+    this.#messageId = options.messageId ?? (() => globalThis.crypto.randomUUID());
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.#random = options.random ?? Math.random;
+    this.#sleep = options.sleep ?? sleep;
   }
-  const passengersPricing = fare.passengerInfoList.map(
-    ({ passengerInfo }) => ({
-      passengerCode: passengerInfo.passengerType,
-      numberOfpassengers: passengerInfo.passengerNumber ?? 1
-    })
-  );
-  let priceComparisons;
-  if (priceComparison !== void 0) {
-    const total = fare.totalFare?.totalPrice;
-    if (total === void 0) {
-      throw new TypeError("sabre-client: el itinerario no trae totalFare.totalPrice para priceComparison");
+  /** @internal Para los eventos de sesión que no son una request. */
+  get log() {
+    return this.#log;
+  }
+  async request(request) {
+    if (request.retry !== void 0) validateRetryOptions(request.retry, "retry");
+    const capture = { attempts: 0 };
+    try {
+      return await this.#attempts(request, capture);
+    } finally {
+      if (capture.last !== void 0) this.#deliverRaw(request, { ...capture.last, attempts: capture.attempts });
     }
-    priceComparisons = [{ desiredAmount: amount(total), ...priceComparison }];
   }
-  return {
-    flights,
-    flightPricing: [
-      {
-        ...priceComparisons === void 0 ? {} : { priceComparisons },
-        qualifiers: {
-          passengersPricing,
-          ...fare.validatingCarrierCode === void 0 ? {} : { validatingAirlineCode: fare.validatingCarrierCode }
+  /**
+   * Dos presupuestos separados: el backoff genérico (`retry.maxRetries`, para `USG_*_BUSY` y
+   * los transitorios) y el esquema fijo de `PREVIOUS ENTRY ACTIVE`, que no se ajusta a la config.
+   */
+  async #attempts(request, capture) {
+    const retry = { ...this.#config.retry, ...definedOnly(request.retry ?? {}) };
+    let generic = 0;
+    let previousEntryActive = 0;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await this.#send(request, attempt, capture);
+      } catch (error) {
+        const reason = retryReason(error, request.idempotent);
+        let delayMs;
+        if (reason === "previous-entry-active" && previousEntryActive < PREVIOUS_ENTRY_ACTIVE_RETRIES) {
+          previousEntryActive++;
+          delayMs = PREVIOUS_ENTRY_ACTIVE_DELAY_MS;
+        } else if ((reason === "busy" || reason === "transient") && generic < retry.maxRetries) {
+          delayMs = retryDelay(generic, retry.baseDelayMs, this.#random);
+          generic++;
+        } else {
+          throw error;
         }
+        this.#log.emit("warn", "sabre.request.retry", {
+          protocol: "soap",
+          service: request.service,
+          action: request.action,
+          attempt: attempt + 1,
+          reason,
+          delayMs,
+          error
+        });
+        await this.#sleep(delayMs, request.signal);
       }
-    ]
+    }
+  }
+  async #send(request, attempt, capture) {
+    const envelope = this.#envelope(request);
+    const logContext = { protocol: "soap", service: request.service, action: request.action, attempt };
+    this.#log.emit("debug", "sabre.request.start", logContext);
+    const startedAt = Date.now();
+    let response;
+    capture.attempts++;
+    try {
+      response = await this.#config.fetch(this.#config.soapBaseUrl, {
+        method: "POST",
+        headers: { "Content-Type": "text/xml; charset=utf-8", Accept: "text/xml" },
+        body: envelope,
+        ...request.signal === void 0 ? {} : { signal: request.signal }
+      });
+    } catch (cause) {
+      if (isAbort2(cause, request.signal)) throw cause;
+      const error = new SabreGatewayError(`${request.service}: fallo de red (${describe2(cause)})`, {
+        protocol: "soap",
+        retryable: false,
+        cause
+      });
+      this.#log.emit("error", "sabre.request.end", { ...logContext, durationMs: Date.now() - startedAt, error });
+      throw error;
+    }
+    const original = await response.text();
+    const text = redactSoapEnvelope(scrubToken(original, request.security));
+    capture.last = { status: response.status, headers: response.headers, body: text };
+    const document = parseEnvelope(text);
+    const messageId = stringAt(document?.Header, "MessageHeader", "MessageData", "MessageId");
+    const endContext = {
+      ...logContext,
+      status: response.status,
+      durationMs: Date.now() - startedAt,
+      ...messageId === void 0 ? {} : { messageId }
+    };
+    try {
+      const result = this.#classify(request, response, document, text);
+      this.#log.emit("info", "sabre.request.end", { ...endContext, warnings: result.warnings.length });
+      return {
+        ...result,
+        messageId,
+        raw: text,
+        securityToken: request.readSecurityToken === true ? readSecurityToken(original) : void 0,
+        status: response.status
+      };
+    } catch (error) {
+      const level = error instanceof SabreBusinessError ? "warn" : "error";
+      this.#log.emit(level, "sabre.request.end", { ...endContext, error });
+      throw error;
+    }
+  }
+  /** Orden de detección: fault (gateway), luego `stl:Error` (negocio), luego data. */
+  #classify(request, response, document, text) {
+    const { service } = request;
+    if (document === void 0) {
+      throw new SabreGatewayError(`${service}: HTTP ${response.status}, la respuesta no es un sobre SOAP`, {
+        protocol: "soap",
+        status: response.status,
+        retryable: false,
+        raw: text
+      });
+    }
+    const fault = asNode(document.Body.Fault);
+    if (fault !== void 0) throw faultError(service, response.status, fault, text);
+    const [payloadName, payloadValue] = firstElement(document.Body);
+    const payload = asNode(payloadValue);
+    if (payloadName === void 0 || payload === void 0) {
+      throw new SabreGatewayError(`${service}: HTTP ${response.status}, el sobre SOAP no trae payload`, {
+        protocol: "soap",
+        status: response.status,
+        retryable: false,
+        raw: text
+      });
+    }
+    if (!response.ok) {
+      throw new SabreGatewayError(`${service}: HTTP ${response.status}`, {
+        protocol: "soap",
+        status: response.status,
+        retryable: false,
+        raw: text
+      });
+    }
+    const results = asNode(payload.ApplicationResults);
+    const warnings = asArray(results?.Warning).map((node2) => {
+      const entry = resultEntry(node2);
+      return new SabreWarning(`${service}: ${entry.description}`, { service, code: entry.code, raw: text });
+    });
+    const errors = asArray(results?.Error).map((node2) => {
+      const entry = resultEntry(node2);
+      return new SabreBusinessError(`${service}: ${entry.description}`, {
+        service,
+        code: entry.code,
+        raw: text,
+        retryable: PREVIOUS_ENTRY_ACTIVE.test(entry.description)
+      });
+    });
+    const [first, ...rest] = errors;
+    if (first !== void 0) {
+      throw new SabreBusinessError(first.message, {
+        service,
+        code: first.code,
+        raw: text,
+        retryable: first.retryable,
+        warnings,
+        errors: rest
+      });
+    }
+    return { payload, payloadName, warnings };
+  }
+  #envelope(request) {
+    const timestamp = this.#now().toISOString().replace(/\.\d{3}Z$/, "Z");
+    return [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<soap-env:Envelope xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/" xmlns:eb="http://www.ebxml.org/namespaces/messageHeader">',
+      "<soap-env:Header>",
+      '<eb:MessageHeader soap-env:mustUnderstand="1" eb:version="1.0">',
+      "<eb:From><eb:PartyId/></eb:From>",
+      "<eb:To><eb:PartyId/></eb:To>",
+      `<eb:CPAId>${xmlEscape(request.cpaId)}</eb:CPAId>`,
+      `<eb:ConversationId>${xmlEscape(request.conversationId)}</eb:ConversationId>`,
+      `<eb:Service>${xmlEscape(request.action)}</eb:Service>`,
+      `<eb:Action>${xmlEscape(request.action)}</eb:Action>`,
+      "<eb:MessageData>",
+      `<eb:MessageId>mid:${xmlEscape(this.#messageId())}</eb:MessageId>`,
+      `<eb:Timestamp>${timestamp}</eb:Timestamp>`,
+      "</eb:MessageData>",
+      "</eb:MessageHeader>",
+      securityHeader(request.security),
+      "</soap-env:Header>",
+      `<soap-env:Body>${request.payload}</soap-env:Body>`,
+      "</soap-env:Envelope>"
+    ].join("");
+  }
+  /** Un callback que lanza no rompe la operación (mismo criterio que REST). */
+  #deliverRaw(request, raw) {
+    if (request.onRawResponse === void 0) return;
+    const operation = request.operation ?? request.service;
+    try {
+      request.onRawResponse({ operation, protocol: "soap", ...raw });
+    } catch (error) {
+      this.#log.emit("warn", "sabre.request.rawResponseHookFailed", {
+        service: request.service,
+        operation,
+        errorName: error instanceof Error ? error.name : typeof error
+      });
+    }
+  }
+};
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function securityHeader(security) {
+  const open = '<wsse:Security xmlns:wsse="http://schemas.xmlsoap.org/ws/2002/12/secext">';
+  if ("binarySecurityToken" in security) {
+    return `${open}<wsse:BinarySecurityToken valueType="String" EncodingType="wsse:Base64Binary">${xmlEscape(security.binarySecurityToken)}</wsse:BinarySecurityToken></wsse:Security>`;
+  }
+  const token = security.usernameToken;
+  return [
+    open,
+    "<wsse:UsernameToken>",
+    `<wsse:Username>${xmlEscape(token.username)}</wsse:Username>`,
+    `<wsse:Password>${xmlEscape(token.password)}</wsse:Password>`,
+    `<Organization>${xmlEscape(token.organization)}</Organization>`,
+    `<Domain>${xmlEscape(token.domain)}</Domain>`,
+    token.clientId === void 0 ? "" : `<ClientId>${xmlEscape(token.clientId)}</ClientId>`,
+    token.clientSecret === void 0 ? "" : `<ClientSecret>${xmlEscape(token.clientSecret)}</ClientSecret>`,
+    "</wsse:UsernameToken>",
+    "</wsse:Security>"
+  ].join("");
+}
+function scrubToken(text, security) {
+  if (!("binarySecurityToken" in security) || security.binarySecurityToken === "") return text;
+  const token = security.binarySecurityToken;
+  return text.split(token).join(REDACTED).split(xmlEscape(token)).join(REDACTED);
+}
+function parseEnvelope(text) {
+  if (text.trim() === "") return void 0;
+  let parsed;
+  try {
+    parsed = parser.parse(text);
+  } catch {
+    return void 0;
+  }
+  const envelope = asNode(asNode(parsed)?.Envelope);
+  const body = asNode(envelope?.Body);
+  if (envelope === void 0 || body === void 0) return void 0;
+  return { Header: envelope.Header, Body: body };
+}
+function readSecurityToken(original) {
+  const document = parseEnvelope(original);
+  const token = stringAt(document?.Header, "Security", "BinarySecurityToken");
+  return token === void 0 || token.trim() === "" ? void 0 : token.trim();
+}
+var USG_CODE = /\bUSG_[A-Z0-9_]+\b/;
+function faultError(service, status, fault, text) {
+  const faultcode = textOf(fault.faultcode);
+  const faultstring = textOf(fault.faultstring);
+  const haystack = [faultcode, faultstring, JSON.stringify(fault.detail ?? "")].join(" ");
+  const code = USG_CODE.exec(haystack)?.[0] ?? faultcode;
+  const detail = [faultcode, faultstring].filter((part) => part !== void 0 && part !== "").join(": ");
+  const retryable = code !== void 0 && BUSY_CODES.has(code) || PREVIOUS_ENTRY_ACTIVE.test(haystack);
+  return new SabreGatewayError(`${service}: SOAP fault${detail === "" ? "" : ` ${detail}`}`, {
+    protocol: "soap",
+    status,
+    retryable,
+    raw: text,
+    ...code === void 0 || code === "" ? {} : { code }
+  });
+}
+function resultEntry(node2) {
+  const entry = asNode(node2) ?? {};
+  const messages = [];
+  const shortTexts = [];
+  let code;
+  for (const results of asArray(entry.SystemSpecificResults)) {
+    const resultsNode = asNode(results) ?? {};
+    for (const message of asArray(resultsNode.Message)) {
+      code ??= nonEmpty2(asNode(message)?.["@code"]);
+      const value = textOf(message);
+      if (value !== void 0 && value !== "") messages.push(value);
+    }
+    for (const shortText of asArray(resultsNode.ShortText)) {
+      const value = textOf(shortText);
+      if (value !== void 0 && value !== "") shortTexts.push(value);
+    }
+  }
+  const type = nonEmpty2(entry["@type"]);
+  const description = [
+    messages.join(" / ") || type || "sin detalle",
+    ...shortTexts.filter((short) => !messages.includes(short)).map((short) => `(${short})`)
+  ].join(" ");
+  return { code: code ?? shortTexts[0] ?? type ?? "UNKNOWN", description };
+}
+function retryReason(error, idempotent) {
+  if ((error instanceof SabreBusinessError || error instanceof SabreGatewayError) && PREVIOUS_ENTRY_ACTIVE.test(error.message)) {
+    return "previous-entry-active";
+  }
+  if (!(error instanceof SabreGatewayError) || error.protocol !== "soap") return void 0;
+  if (error.code !== void 0 && BUSY_CODES.has(error.code)) return "busy";
+  if (!idempotent) return void 0;
+  if (error.code !== void 0) return TRANSIENT_CODES.has(error.code) ? "transient" : void 0;
+  if (error.status === void 0 || TRANSIENT_STATUS.has(error.status)) return "transient";
+  return void 0;
+}
+function firstElement(node2) {
+  for (const [key, value] of Object.entries(node2)) {
+    if (!key.startsWith("@") && key !== "#text") return [key, Array.isArray(value) ? value[0] : value];
+  }
+  return [void 0, void 0];
+}
+function asNode(value) {
+  if (Array.isArray(value)) return asNode(value[0]);
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function asArray(value) {
+  if (value === void 0 || value === null || value === "") return [];
+  return Array.isArray(value) ? value : [value];
+}
+function textOf(value) {
+  if (typeof value === "string") return value;
+  const node2 = asNode(value);
+  const text = node2?.["#text"];
+  return typeof text === "string" ? text : node2 === void 0 ? void 0 : "";
+}
+function stringAt(root2, ...path) {
+  let node2 = root2;
+  for (const key of path) node2 = asNode(node2)?.[key];
+  return nonEmpty2(textOf(node2));
+}
+function nonEmpty2(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function isAbort2(error, signal) {
+  return signal?.aborted === true || error instanceof Error && error.name === "AbortError";
+}
+function describe2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/session/credentials.ts
+var PCC = /^[A-Za-z0-9]{3,4}$/;
+function isPseudoCityCode(value) {
+  return typeof value === "string" && PCC.test(value);
+}
+var V2_PREFIX = "V1:";
+var FORMATS = "'V1:<user>:<PCC>:<domain>' (OAuth v2) o '<user>-<PCC>-<domain>' (OAuth v3)";
+function fail2(message) {
+  throw new TypeError(`sabre-client: ${message}`);
+}
+function parseEprUsername(username) {
+  const v2 = username.startsWith(V2_PREFIX);
+  const fields = (v2 ? username.slice(V2_PREFIX.length) : username).split(v2 ? ":" : "-");
+  if (fields.length < 3) fail2(`credentials.username debe tener el formato ${FORMATS} para abrir una sesi\xF3n SOAP`);
+  const domain = fields.pop();
+  const organization = fields.pop();
+  const user = fields.join(v2 ? ":" : "-");
+  if (user.trim() === "" || domain.trim() === "") {
+    fail2(`credentials.username debe tener el formato ${FORMATS} para abrir una sesi\xF3n SOAP`);
+  }
+  if (!PCC.test(organization)) {
+    fail2("el PCC de credentials.username debe tener 3 o 4 caracteres alfanum\xE9ricos");
+  }
+  return { username: user, organization, domain };
+}
+function resolveSessionCredentials(credentials) {
+  const { clientId, clientSecret, password } = credentials;
+  if (clientId === void 0 !== (clientSecret === void 0)) {
+    fail2("credentials.clientId y credentials.clientSecret van juntos: pasa los dos (SessionCreateRQ 2.0.0) o ninguno (1.0.0)");
+  }
+  const epr = parseEprUsername(credentials.username);
+  if (clientId === void 0 || clientSecret === void 0) return { version: "1.0.0", ...epr, password };
+  if (typeof clientId !== "string" || clientId.trim() === "") fail2("credentials.clientId debe ser un string no vac\xEDo");
+  if (typeof clientSecret !== "string" || clientSecret.trim() === "") {
+    fail2("credentials.clientSecret debe ser un string no vac\xEDo");
+  }
+  return { version: "2.0.0", ...epr, password, clientId, clientSecret };
+}
+
+// src/queue/queue-access.ts
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+
+// src/queue/queue-ref.ts
+var MIN_QUEUE_NUMBER = 0;
+var MAX_QUEUE_NUMBER = 511;
+function validateQueueRef(value, label) {
+  if (typeof value === "number") {
+    if (Number.isInteger(value) && value >= MIN_QUEUE_NUMBER && value <= MAX_QUEUE_NUMBER) return;
+    throw new TypeError(
+      `sabre-client: ${label} debe ser un n\xFAmero de cola entero de ${MIN_QUEUE_NUMBER} a ${MAX_QUEUE_NUMBER}, o { name }`
+    );
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const { name } = value;
+    if (typeof name === "string" && name.trim() !== "") return;
+    throw new TypeError(`sabre-client: ${label}.name debe ser un string no vac\xEDo`);
+  }
+  throw new TypeError(`sabre-client: ${label} debe ser un n\xFAmero de cola (0\u2013511) o { name }`);
+}
+function queueRefAttribute(queue) {
+  return typeof queue === "number" ? `Number="${queue}"` : `Name="${xmlEscape(queue.name)}"`;
+}
+function toQueueRef(value) {
+  const text = value?.trim();
+  if (text === void 0 || text === "") return void 0;
+  return /^\d+$/.test(text) ? Number(text) : { name: text };
+}
+
+// src/queue/queue-access.ts
+var QUEUE_ACCESS_SERVICE = "queueAccess";
+var NAMESPACE = "http://webservices.sabre.com/sabreXML/2011/10";
+var END_OF_DISPLAY = "END OF DISPLAY FOR REQUESTED DATA";
+var QUEUE_EMPTY = "QUEUE SELECTED WAS EMPTY";
+var OFF_QUEUE = "CANNOT DO THIS IF OFF QUEUE";
+var MAX_SELECTIONS = 8;
+var MAX_REMOVE_FROM = 3;
+var OPERATIONS = { I: "queue.ignore", QR: "queue.remove", QXI: "queue.exit" };
+function root(body) {
+  return `<QueueAccessRQ Version="2.1.1" xmlns="${NAMESPACE}">${body}</QueueAccessRQ>`;
+}
+function identifier(queue, pcc) {
+  return `<QueueIdentifier ${queueRefAttribute(queue)} PseudoCityCode="${xmlEscape(pcc)}"/>`;
+}
+function queueAccessPayload(queue, pcc, selection = []) {
+  const filters = selection.map((filter) => `<Selection Function="${xmlEscape(filter.function)}" Criteria="${xmlEscape(filter.criteria)}"/>`).join("");
+  return root(`${identifier(queue, pcc)}${filters}`);
+}
+function queueNavigationPayload(action, from = []) {
+  return root(`<Navigation Action="${action}"/>${from.map((target) => identifier(target.queue, target.pcc)).join("")}`);
+}
+function queueAccessRequest(payload, operation, options) {
+  return { service: QUEUE_ACCESS_SERVICE, action: "QueueAccessLLSRQ", payload, idempotent: false, operation, ...options };
+}
+function navigationOperation(action) {
+  return OPERATIONS[action];
+}
+var paragraphParser = new XMLParser2({
+  ignoreAttributes: true,
+  removeNSPrefix: true,
+  parseTagValue: false,
+  trimValues: false,
+  processEntities: true,
+  isArray: (name) => name === "Text"
+});
+function node(value) {
+  if (Array.isArray(value)) return node(value[0]);
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function attribute(value, name) {
+  const text = node(value)?.[`@${name}`];
+  return typeof text === "string" && text.trim() !== "" ? text.trim() : void 0;
+}
+function element(value) {
+  const text = textOf(Array.isArray(value) ? value[0] : value)?.trim();
+  return text === void 0 || text === "" ? void 0 : text;
+}
+function textLines(raw, payloadName) {
+  let parsed;
+  try {
+    parsed = paragraphParser.parse(raw);
+  } catch {
+    return [];
+  }
+  const payload = node(node(node(node(parsed)?.Envelope)?.Body)?.[payloadName]);
+  const container = payloadName === "QueueAccessRS" ? node(payload?.Paragraph) : payload;
+  return asArray(container?.Text).map((line) => typeof line === "string" ? line : textOf(line) ?? "");
+}
+function paragraphLines(raw) {
+  return textLines(raw, "QueueAccessRS");
+}
+function isEndOfDisplay(text) {
+  return text?.trim() === END_OF_DISPLAY;
+}
+function isEndOfDisplayResult(error) {
+  return resultHasText(error, END_OF_DISPLAY);
+}
+function resultHasText(error, text) {
+  const prefix = `${error.service}: `;
+  const description = error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message;
+  return description.split(/ \/ | \(|\)/).some((part) => part.trim() === text);
+}
+function queueEndError(error, service) {
+  if (!(error instanceof SabreBusinessError) || error.service !== service) return void 0;
+  const results = [error, ...error.errors];
+  if (results.some((result) => resultHasText(result, QUEUE_EMPTY))) return { reason: "empty", error };
+  if (results.some(isEndOfDisplayResult)) return { reason: "end-of-display", error };
+  return void 0;
+}
+function isOffQueueError(error) {
+  return error instanceof SabreBusinessError && [error, ...error.errors].some((result) => resultHasText(result, OFF_QUEUE));
+}
+function endStep(warnings, reason = "end-of-display") {
+  return { done: true, reason, message: reason === "empty" ? QUEUE_EMPTY : END_OF_DISPLAY, warnings };
+}
+function parseQueueStep(response) {
+  const { warnings } = response;
+  const paragraph = paragraphLines(response.raw);
+  const firstLine = paragraph.find((line) => line.trim() !== "");
+  if (isEndOfDisplay(firstLine) || warnings.some(isEndOfDisplayResult)) return endStep(warnings);
+  const fields = lineFields(response.payload.Line);
+  if (fields === void 0) {
+    throw new SabreGatewayError(`${QUEUE_ACCESS_SERVICE}: respuesta no reconocida (sin Line/UniqueID ni fin de cola)`, {
+      protocol: "soap",
+      status: response.status,
+      retryable: false,
+      raw: response.raw
+    });
+  }
+  const item = { ...fields, paragraph };
+  return { done: false, item, warnings };
+}
+function lineFields(value) {
+  const line = node(value);
+  const locator = attribute(line?.UniqueID, "ID");
+  if (line === void 0 || locator === void 0) return void 0;
+  const source = node(node(line.POS)?.Source);
+  const agentSine = attribute(source, "AgentSine");
+  const pseudoCityCode = attribute(source, "PseudoCityCode");
+  const placedAt = element(line.DateTime);
+  const primaryPassenger = element(line.PassengerName);
+  const group = element(line.Group);
+  return {
+    locator,
+    ...placedAt === void 0 ? {} : { placedAt },
+    ...agentSine === void 0 && pseudoCityCode === void 0 ? {} : {
+      placedBy: {
+        ...agentSine === void 0 ? {} : { agentSine },
+        ...pseudoCityCode === void 0 ? {} : { pseudoCityCode }
+      }
+    },
+    ...primaryPassenger === void 0 ? {} : { primaryPassenger },
+    ...group === void 0 ? {} : { group }
   };
 }
-function amount(value) {
-  return String(Math.round(value * 1e3) / 1e3);
+
+// src/queue/queue-count.ts
+var QUEUE_COUNT_SERVICE = "queueCount";
+var NAMESPACE2 = "http://webservices.sabre.com/sabreXML/2011/10";
+var TOTAL_TYPES = { MESSAGES: "messages", SPECIALS: "specials", PNRS: "pnrs" };
+function queueCountPayload(pcc) {
+  return `<QueueCountRQ Version="2.2.1" xmlns="${NAMESPACE2}"><QueueInfo><QueueIdentifier PseudoCityCode="${xmlEscape(pcc)}"/></QueueInfo></QueueCountRQ>`;
+}
+function queueCountRequest(pcc, options) {
+  return {
+    service: QUEUE_COUNT_SERVICE,
+    action: "QueueCountLLSRQ",
+    payload: queueCountPayload(pcc),
+    idempotent: true,
+    operation: "queue.count",
+    ...options
+  };
+}
+function parseHostCount(value) {
+  const match = /^[.\s]*(\d+)\s*$/.exec(value ?? "");
+  return match === null ? void 0 : Number(match[1]);
+}
+function attribute2(node2, name) {
+  const value = node2?.[`@${name}`];
+  return typeof value === "string" ? value : void 0;
+}
+function parseQueueCountResponse(response) {
+  const queues = [];
+  let countedAt;
+  for (const info of asArray(response.payload.QueueInfo)) {
+    countedAt ??= nonEmpty3(attribute2(info, "DateTime"));
+    for (const identifier2 of asArray(info.QueueIdentifier)) {
+      const number = attribute2(identifier2, "Number");
+      const queue = toQueueRef(number);
+      const count = parseHostCount(attribute2(identifier2, "Count"));
+      if (queue === void 0 || count === void 0) {
+        throw malformed(`QueueIdentifier con Number="${number ?? ""}" y Count="${attribute2(identifier2, "Count") ?? ""}"`, response);
+      }
+      queues.push({ queue, count });
+    }
+  }
+  const totals = {};
+  for (const total of asArray(response.payload.Totals)) {
+    const key = TOTAL_TYPES[(attribute2(total, "Type") ?? "").toUpperCase()];
+    if (key === void 0) continue;
+    const count = parseHostCount(attribute2(total, "Count"));
+    if (count === void 0) throw malformed(`Totals ${key} con Count="${attribute2(total, "Count") ?? ""}"`, response);
+    totals[key] = count;
+  }
+  return { queues, totals, ...countedAt === void 0 ? {} : { countedAt }, warnings: response.warnings };
+}
+function malformed(detail, response) {
+  return new SabreGatewayError(`${QUEUE_COUNT_SERVICE}: respuesta no reconocida (${detail})`, {
+    protocol: "soap",
+    status: response.status,
+    retryable: false,
+    raw: response.raw
+  });
+}
+function nonEmpty3(value) {
+  const text = value?.trim();
+  return text === void 0 || text === "" ? void 0 : text;
+}
+
+// src/queue/queue-list.ts
+var NAMESPACE3 = "http://webservices.sabre.com/sabreXML/2011/10";
+function queueListPayload(queue, pcc, primaryPassenger) {
+  const list = primaryPassenger ? '<List Ind="true" PrimaryPassenger="true"/>' : '<List Ind="true"/>';
+  return `<QueueAccessRQ Version="2.1.1" xmlns="${NAMESPACE3}"><QueueIdentifier ${queueRefAttribute(queue)} PseudoCityCode="${xmlEscape(pcc)}">${list}</QueueIdentifier></QueueAccessRQ>`;
+}
+function queueListRequest(payload, options) {
+  return {
+    service: QUEUE_ACCESS_SERVICE,
+    action: "QueueAccessLLSRQ",
+    payload,
+    idempotent: true,
+    operation: "queue.list",
+    ...options
+  };
+}
+function emptyList(warnings, paragraph = []) {
+  return { locators: [], entries: [], paragraph, warnings };
+}
+function parseQueueList(response) {
+  const { warnings } = response;
+  const paragraph = paragraphLines(response.raw);
+  const firstLine = paragraph.find((line) => line.trim() !== "");
+  if (isEndOfDisplay(firstLine) || warnings.some(isEndOfDisplayResult)) return emptyList(warnings, paragraph);
+  const entries = asArray(response.payload.Line).map((line) => {
+    const fields = lineFields(line);
+    if (fields === void 0) {
+      throw new SabreGatewayError(`${QUEUE_ACCESS_SERVICE}: respuesta no reconocida (Line sin UniqueID en la lista)`, {
+        protocol: "soap",
+        status: response.status,
+        retryable: false,
+        raw: response.raw
+      });
+    }
+    const number = attribute(line, "Number");
+    const position = number !== void 0 && /^\d+$/.test(number) ? Number(number) : void 0;
+    return { ...position === void 0 ? {} : { position }, ...fields };
+  });
+  return { locators: entries.map((entry) => entry.locator), entries, paragraph, warnings };
+}
+
+// src/queue/queue-place.ts
+var QUEUE_PLACE_SERVICE = "queuePlace";
+var NAMESPACE4 = "http://webservices.sabre.com/sabreXML/2011/10";
+var MAX_PLACE_TO = 10;
+var MAX_PLACE_LOCATORS = 6;
+var INSTRUCTION_CODE_RANGES = [
+  [0, 191],
+  [200, 254]
+];
+function isInstructionCode(value) {
+  return typeof value === "number" && Number.isInteger(value) && INSTRUCTION_CODE_RANGES.some(([min, max]) => value >= min && value <= max);
+}
+function queuePlacePayload(to, locators = []) {
+  const identifiers = to.map((target) => {
+    const pic = target.instructionCode === void 0 ? "" : ` PrefatoryInstructionCode="${target.instructionCode}"`;
+    return `<QueueIdentifier ${queueRefAttribute(target.queue)}${pic} PseudoCityCode="${xmlEscape(target.pcc)}"/>`;
+  }).join("");
+  const ids = locators.map((locator) => `<UniqueID ID="${xmlEscape(locator)}"/>`).join("");
+  return `<QueuePlaceRQ Version="2.0.4" xmlns="${NAMESPACE4}"><QueueInfo>${identifiers}${ids}</QueueInfo></QueuePlaceRQ>`;
+}
+function queuePlaceRequest(payload, options) {
+  return {
+    service: QUEUE_PLACE_SERVICE,
+    action: "QueuePlaceLLSRQ",
+    payload,
+    idempotent: false,
+    operation: "queue.place",
+    ...options
+  };
+}
+var SIGNATURE_LINE = /\s\d{4}\/\d{2}[A-Z]{3}\d{2}\s+([A-Z0-9]{6})\s+H\s*$/;
+function signatureLocator(lines) {
+  for (let index = lines.length - 1; index >= 0; index--) {
+    const match = SIGNATURE_LINE.exec(lines[index] ?? "");
+    if (match !== null) return match[1];
+  }
+  return void 0;
+}
+function isEnd(response, text) {
+  return response.warnings.some(isEndOfDisplayResult) || isEndOfDisplay(text.find((line) => line.trim() !== ""));
+}
+function parsePlaceStep(response) {
+  const text = textLines(response.raw, "QueuePlaceRS");
+  if (isEnd(response, text)) return endStep(response.warnings);
+  const locator = signatureLocator(text);
+  if (locator === void 0) {
+    throw new SabreGatewayError(`${QUEUE_PLACE_SERVICE}: respuesta no reconocida (sin l\xEDnea de firma del PNR ni fin de cola)`, {
+      protocol: "soap",
+      status: response.status,
+      retryable: false,
+      raw: response.raw
+    });
+  }
+  return { done: false, item: { locator, paragraph: text }, warnings: response.warnings };
+}
+function parsePlaceUnknown(response) {
+  const text = textLines(response.raw, "QueuePlaceRS");
+  if (isEnd(response, text) || signatureLocator(text) !== void 0) return parsePlaceStep(response);
+  return parsePlaceResult(response);
+}
+function parsePlaceResult(response) {
+  const placements = asArray(response.payload.QueueInfo).map((info) => {
+    const identifier2 = node(node(info)?.QueueIdentifier);
+    const number = attribute(identifier2, "Number");
+    const name = attribute(identifier2, "Name");
+    const queue = number !== void 0 ? toQueueRef(number) : name !== void 0 ? { name } : void 0;
+    const pcc = attribute(identifier2, "PseudoCityCode");
+    const locator = attribute(node(info)?.UniqueID, "ID");
+    const placedAt = attribute(info, "DateTime");
+    return {
+      ...queue === void 0 ? {} : { queue },
+      ...pcc === void 0 ? {} : { pcc },
+      ...locator === void 0 ? {} : { locator },
+      ...placedAt === void 0 ? {} : { placedAt }
+    };
+  });
+  return { placements, text: textLines(response.raw, "QueuePlaceRS"), warnings: response.warnings };
+}
+
+// src/queue/queue-management.ts
+function fail3(message) {
+  throw new TypeError(`sabre-client: ${message}`);
+}
+function rejectedBySabre(error) {
+  return error instanceof SabreBusinessError || error instanceof SabreGatewayError && error.code !== void 0;
+}
+var QueueManagement = class {
+  #context;
+  #state = "outside";
+  /** @internal Lo construye `SabreSession`. */
+  constructor(context) {
+    this.#context = context;
+  }
+  /**
+   * 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() {
+    return this.#state;
+  }
+  /**
+   * 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.
+   */
+  async count(request = {}, options = {}) {
+    const pcc = this.#pcc(request.pcc, "pcc");
+    const response = await this.#context.send(queueCountRequest(pcc, options));
+    return parseQueueCountResponse(response);
+  }
+  /**
+   * 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.
+   */
+  async list(request, options = {}) {
+    if (typeof request !== "object" || request === null) fail3("queue.list recibe { queue, pcc?, primaryPassenger? }");
+    validateQueueRef(request.queue, "queue");
+    const pcc = this.#pcc(request.pcc, "pcc");
+    const { primaryPassenger = false } = request;
+    if (typeof primaryPassenger !== "boolean") fail3("primaryPassenger debe ser un boolean");
+    const send2 = queueListRequest(queueListPayload(request.queue, pcc, primaryPassenger), options);
+    try {
+      return parseQueueList(await this.#context.send(send2));
+    } catch (error) {
+      const end = queueEndError(error, send2.service);
+      if (end !== void 0) return emptyList([...end.error.warnings]);
+      throw error;
+    }
+  }
+  /**
+   * 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'`.
+   */
+  async access(request, options = {}) {
+    if (this.#state === "inside") fail3("la sesi\xF3n ya est\xE1 dentro de una cola: sal con queue.exit() antes de entrar a otra");
+    if (this.#state === "unknown") fail3("no se sabe si la sesi\xF3n sigue dentro de una cola: llama a queue.exit() antes de entrar");
+    if (typeof request !== "object" || request === null) fail3("queue.access recibe { queue, pcc?, selection? }");
+    validateQueueRef(request.queue, "queue");
+    const pcc = this.#pcc(request.pcc, "pcc");
+    const selection = validateSelection(request.selection);
+    return this.#step(queueAccessRequest(queueAccessPayload(request.queue, pcc, selection), "queue.access", options));
+  }
+  /**
+   * Deja el PNR actual en la cola y pasa al siguiente (`I`). Fuera de una cola lanza `TypeError`
+   * sin red.
+   */
+  async ignore(options = {}) {
+    this.#requireQueue("ignore");
+    return this.#step(queueAccessRequest(queueNavigationPayload("I"), navigationOperation("I"), options));
+  }
+  /**
+   * 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.
+   */
+  async remove(request = {}, options = {}) {
+    this.#requireQueue("remove");
+    const from = this.#removeFrom(request.from);
+    return this.#step(queueAccessRequest(queueNavigationPayload("QR", from), navigationOperation("QR"), options));
+  }
+  /**
+   * 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'`.
+   */
+  async exit(options = {}) {
+    this.#requireQueue("exit");
+    const before = this.#state;
+    const request = queueAccessRequest(queueNavigationPayload("QXI"), navigationOperation("QXI"), options);
+    try {
+      await this.#context.send(request);
+    } catch (error) {
+      if (before === "unknown" && isOffQueueError(error)) {
+        this.#context.log.emit("info", "sabre.queue.exitTolerated", { code: error.code, error });
+        this.#state = "outside";
+        return;
+      }
+      this.#onError(error);
+      throw error;
+    }
+    this.#state = "outside";
+  }
+  /**
+   * 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.
+   */
+  async process(request, callback, options = {}) {
+    if (typeof request !== "object" || request === null) fail3("queue.process recibe { queue, pcc?, selection?, limit? }");
+    if (typeof callback !== "function") fail3("queue.process necesita un callback");
+    const { limit, ...access } = request;
+    if (limit !== void 0 && !(Number.isInteger(limit) && limit >= 1)) fail3("limit debe ser un entero mayor o igual a 1");
+    const startedOutside = this.#state === "outside";
+    let visited = 0;
+    try {
+      let step = await this.access(access, options);
+      while (!step.done) {
+        if (limit !== void 0 && visited >= limit) {
+          await this.exit(options);
+          return { visited, ended: "limit" };
+        }
+        const action = await callback(step.item);
+        visited++;
+        step = await this.#processAction(action, options);
+      }
+      return { visited, ended: step.reason };
+    } catch (error) {
+      if (startedOutside) await this.#exitQuietly(error, options);
+      throw error;
+    }
+  }
+  async #processAction(action, options) {
+    const kind = typeof action === "object" && action !== null ? action.action : void 0;
+    if (kind === "ignore") return this.ignore(options);
+    if (kind === "remove") return this.remove({}, options);
+    if (kind === "place") {
+      const step = await this.place({ to: action.to }, options);
+      if (!("done" in step)) throw new TypeError("sabre-client: queue.place no devolvi\xF3 un paso de la cola");
+      return step;
+    }
+    throw new TypeError("sabre-client: el callback de queue.process debe devolver { action: 'remove' }, { action: 'ignore' } o { action: 'place', to }");
+  }
+  /** Sale de la cola después de un error del recorrido, sin pisar ese error. */
+  async #exitQuietly(cause, options) {
+    if (this.#state === "outside" || cause instanceof SabreSessionError) return;
+    try {
+      await this.exit(options);
+    } catch (error) {
+      this.#context.log.emit("warn", "sabre.queue.exitFailed", { error });
+    }
+  }
+  async place(request, options = {}) {
+    if (typeof request !== "object" || request === null) fail3("queue.place recibe { to, locators? }");
+    const to = this.#placeTo(request.to);
+    const locators = validateLocators(request.locators);
+    if (locators.length > 0 && this.#state === "inside") {
+      fail3("queue.place con locators no se puede dentro de una cola, donde coloca el PNR actual: sal con queue.exit() antes");
+    }
+    if (locators.length > 0 && this.#state === "unknown") {
+      fail3("no se sabe si la sesi\xF3n sigue dentro de una cola: llama a queue.exit() antes de colocar por localizador");
+    }
+    if (to.some((target) => target.instructionCode === void 0)) {
+      fail3("queue.place necesita instructionCode en cada destino: Sabre lo exige, dentro y fuera de una cola");
+    }
+    const send2 = queuePlaceRequest(queuePlacePayload(to, locators), options);
+    if (this.#state === "outside") return parsePlaceResult(await this.#context.send(send2));
+    return this.#advance(send2, this.#state === "inside" ? parsePlaceStep : parsePlaceUnknown);
+  }
+  /** Manda una operación que avanza y actualiza `state` con el resultado. */
+  #step(request) {
+    return this.#advance(request, parseQueueStep);
+  }
+  /**
+   * Manda una operación que puede mover el cursor. Un `QueueStep` fija el estado: `'outside'` con
+   * el fin de cola e `'inside'` con un PNR. Cualquier otro resultado lo deja como estaba.
+   */
+  async #advance(request, parse) {
+    let result;
+    try {
+      result = parse(await this.#context.send(request));
+    } catch (error) {
+      const end = queueEndError(error, request.service);
+      if (end !== void 0) {
+        this.#state = "outside";
+        return endStep([...end.error.warnings], end.reason);
+      }
+      this.#onError(error);
+      throw error;
+    }
+    if ("done" in result) this.#state = result.done ? "outside" : "inside";
+    return result;
+  }
+  /**
+   * Qué pasa con `state` cuando una operación de cola falla. Los `TypeError` del uso exclusivo y
+   * los errores de sesión no lo tocan: no llegaron a Sabre, o la sesión ya no sirve. Dentro de una
+   * cola, cualquier otro error deja `'unknown'`. Fuera, solo lo que no es un rechazo claro de
+   * Sabre (fallo de red, cancelación, respuesta ilegible).
+   */
+  #onError(error) {
+    if (error instanceof TypeError || error instanceof SabreSessionError) return;
+    if (this.#state === "outside" && rejectedBySabre(error)) return;
+    this.#state = "unknown";
+  }
+  #placeTo(to) {
+    if (!Array.isArray(to) || to.length === 0 || to.length > MAX_PLACE_TO) {
+      fail3(`to debe ser una lista de 1 a ${MAX_PLACE_TO} colas`);
+    }
+    return to.map((target, index) => {
+      if (typeof target !== "object" || target === null) fail3(`to[${index}] debe ser { queue, pcc?, instructionCode }`);
+      const { queue, pcc, instructionCode } = target;
+      validateQueueRef(queue, `to[${index}].queue`);
+      if (instructionCode !== void 0 && !isInstructionCode(instructionCode)) {
+        fail3(`to[${index}].instructionCode debe ser un entero de 0 a 191 o de 200 a 254`);
+      }
+      return {
+        queue,
+        pcc: this.#pcc(pcc, `to[${index}].pcc`),
+        ...instructionCode === void 0 ? {} : { instructionCode }
+      };
+    });
+  }
+  #requireQueue(operation) {
+    if (this.#state === "outside") fail3(`queue.${operation} necesita estar dentro de una cola: entra con queue.access()`);
+  }
+  #pcc(value, label) {
+    if (value === void 0) return this.#context.pcc;
+    if (!isPseudoCityCode(value)) fail3(`${label} debe tener 3 o 4 caracteres alfanum\xE9ricos`);
+    return value;
+  }
+  #removeFrom(from) {
+    if (from === void 0) return [];
+    if (!Array.isArray(from) || from.length === 0 || from.length > MAX_REMOVE_FROM) {
+      fail3(`from debe ser una lista de 1 a ${MAX_REMOVE_FROM} colas`);
+    }
+    return from.map((target, index) => {
+      if (typeof target !== "object" || target === null) fail3(`from[${index}] debe ser { queue, pcc? }`);
+      const { queue, pcc } = target;
+      validateQueueRef(queue, `from[${index}].queue`);
+      return { queue, pcc: this.#pcc(pcc, `from[${index}].pcc`) };
+    });
+  }
+};
+function validateLocators(locators) {
+  if (locators === void 0) return [];
+  if (!Array.isArray(locators) || locators.length === 0 || locators.length > MAX_PLACE_LOCATORS) {
+    fail3(`locators debe ser una lista de 1 a ${MAX_PLACE_LOCATORS} localizadores`);
+  }
+  return locators.map((locator, index) => {
+    if (typeof locator !== "string" || locator.trim() === "") fail3(`locators[${index}] debe ser un string no vac\xEDo`);
+    return locator;
+  });
+}
+function validateSelection(selection) {
+  if (selection === void 0) return [];
+  if (!Array.isArray(selection)) fail3("selection debe ser una lista de { function, criteria }");
+  if (selection.length > MAX_SELECTIONS) fail3(`selection admite hasta ${MAX_SELECTIONS} filtros`);
+  return selection.map((filter, index) => {
+    const { function: fn, criteria } = typeof filter === "object" && filter !== null ? filter : {};
+    if (typeof fn !== "string" || fn.trim() === "") fail3(`selection[${index}].function debe ser un string no vac\xEDo`);
+    if (typeof criteria !== "string" || criteria.trim() === "") {
+      fail3(`selection[${index}].criteria debe ser un string no vac\xEDo`);
+    }
+    return { function: fn, criteria };
+  });
+}
+
+// src/session/session.ts
+var OTA_NAMESPACE = "http://www.opentravel.org/OTA/2002/11";
+var SWS_NAMESPACE = "http://webservices.sabre.com";
+var sessionSend = /* @__PURE__ */ Symbol("sabre-client.session.send");
+function fail4(message) {
+  throw new TypeError(`sabre-client: ${message}`);
+}
+var SESSION_ERROR_KINDS = /* @__PURE__ */ new Map([
+  ["USG_RESOURCE_UNAVAILABLE", "limit"],
+  ["USG_INVALID_SESSION", "invalid"],
+  ["USG_INVALID_SECURITY_TOKEN", "expired"],
+  ["USG_AUTHENTICATION_FAILED", "expired"],
+  ["USG_RESOURCE_BLOCKED", "blocked"]
+]);
+var OPEN_ERROR_KINDS = /* @__PURE__ */ new Set(["limit", "blocked"]);
+function toSessionError(error, allowed) {
+  if (!(error instanceof SabreGatewayError) || error instanceof SabreSessionError) return error;
+  if (error.protocol !== "soap" || error.code === void 0) return error;
+  const kind = SESSION_ERROR_KINDS.get(error.code);
+  if (kind === void 0 || allowed !== void 0 && !allowed.has(kind)) return error;
+  return new SabreSessionError(error.message, {
+    kind,
+    code: error.code,
+    retryable: error.retryable,
+    raw: error.raw,
+    cause: error.cause,
+    ...error.status === void 0 ? {} : { status: error.status }
+  });
+}
+var KEEP_ALIVE_IDLE_MS = 13 * 6e4;
+var SabreSession = class {
+  /** Queue Management: contar, recorrer y colocar en colas, dentro de esta sesión. */
+  queue;
+  #transport;
+  #pcc;
+  #conversationId;
+  #security;
+  #busy = false;
+  #closing;
+  /** El `SabreSessionError` que dejó la sesión inutilizable. */
+  #unusable;
+  /** Última vez que Sabre respondió en esta sesión (`Date.now()`). */
+  #lastActivity = Date.now();
+  #keepAliveTimer;
+  /** El ping de `keepAlive` en vuelo: las llamadas del consumidor lo esperan en vez de chocar. */
+  #keepAlivePing;
+  static {
+    installAsyncDispose(this.prototype, Symbol.asyncDispose);
+  }
+  /** @internal Se crea con `SabreLegacy.openSession()`. */
+  constructor(internal) {
+    this.#transport = internal.transport;
+    this.#pcc = internal.pcc;
+    this.#conversationId = internal.conversationId;
+    this.#security = { binarySecurityToken: internal.token };
+    this.queue = new QueueManagement({
+      send: (request) => this[sessionSend](request),
+      pcc: internal.pcc,
+      log: internal.transport.log
+    });
+    if (internal.keepAlive) this.#scheduleKeepAlive(KEEP_ALIVE_IDLE_MS);
+  }
+  /**
+   * 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() {
+    return this.#busy ? 0 : Math.max(0, Date.now() - this.#lastActivity);
+  }
+  /**
+   * 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.
+   */
+  async ping(options = {}) {
+    checkPingResponse(await this[sessionSend]({ ...pingRequest(), ...options }));
+  }
+  /**
+   * 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 = {}) {
+    if (this.#closing !== void 0) return this.#closing;
+    if (this.#busy && this.#keepAlivePing === void 0) {
+      return Promise.reject(new TypeError("sabre-client: session busy"));
+    }
+    this.#stopKeepAlive();
+    if (this.#unusable !== void 0) {
+      this.#closing = Promise.resolve();
+      return this.#closing;
+    }
+    const before = this.#keepAlivePing ?? Promise.resolve();
+    this.#closing = before.then(() => this.#sendClose(options));
+    return this.#closing;
+  }
+  /** @internal Una llamada a Sabre dentro de la sesión, con uso exclusivo. */
+  async [sessionSend](request) {
+    if (this.#keepAlivePing !== void 0 && this.#closing === void 0) await this.#keepAlivePing;
+    return this.#send(request);
+  }
+  async #send(request) {
+    if (this.#closing !== void 0) fail4("session closed");
+    if (this.#unusable !== void 0) {
+      throw new TypeError(`sabre-client: session unusable (${this.#unusable.kind})`, { cause: this.#unusable });
+    }
+    if (this.#busy) fail4("session busy");
+    this.#busy = true;
+    try {
+      const response = await this.#transport.request({ ...request, ...this.#envelopeFields() });
+      this.#touch();
+      return response;
+    } catch (error) {
+      if (reachedSabre(error)) this.#touch();
+      throw this.#markUnusable(error);
+    } finally {
+      this.#busy = false;
+    }
+  }
+  async #sendClose(options) {
+    if (this.#unusable !== void 0) return;
+    this.#busy = true;
+    try {
+      await this.#transport.request({
+        service: "sessionClose",
+        action: "SessionCloseRQ",
+        payload: `<SessionCloseRQ Version="1.0.1"><POS><Source PseudoCityCode="${xmlEscape(this.#pcc)}"/></POS></SessionCloseRQ>`,
+        ...this.#envelopeFields(),
+        // Solo se reintenta ante `USG_*_BUSY`: tras un fallo de red no se sabe si ya se cerró.
+        idempotent: false,
+        operation: "close",
+        ...options
+      });
+    } catch (error) {
+      throw this.#markUnusable(error);
+    } finally {
+      this.#busy = false;
+    }
+    this.#transport.log.emit("info", "sabre.session.close", { pseudoCityCode: this.#pcc });
+  }
+  /** Un error de sesión deja la sesión inutilizable. No se reabre sola: el cursor ya se perdió. */
+  #markUnusable(error) {
+    const mapped = toSessionError(error);
+    if (mapped instanceof SabreSessionError) {
+      this.#unusable = mapped;
+      this.#stopKeepAlive();
+    }
+    return mapped;
+  }
+  #touch() {
+    this.#lastActivity = Date.now();
+  }
+  #envelopeFields() {
+    return { cpaId: this.#pcc, conversationId: this.#conversationId, security: this.#security };
+  }
+  /**
+   * Un solo timer, que se reprograma según `idleMs`: cada respuesta de Sabre corre el ping. Si el
+   * ping falla (ya con los reintentos del transporte), se avisa con un `warn` y `keepAlive` se
+   * apaga: reintentar sin fin no tiene sentido con una sesión que vence a los 15 minutos.
+   */
+  #scheduleKeepAlive(delayMs) {
+    const timer = setTimeout(() => this.#onKeepAlive(), delayMs);
+    timer.unref?.();
+    this.#keepAliveTimer = timer;
+  }
+  #onKeepAlive() {
+    this.#keepAliveTimer = void 0;
+    if (this.#closing !== void 0 || this.#unusable !== void 0) return;
+    if (this.#busy) {
+      this.#scheduleKeepAlive(KEEP_ALIVE_IDLE_MS);
+      return;
+    }
+    const remaining = KEEP_ALIVE_IDLE_MS - this.idleMs;
+    if (remaining > 0) {
+      this.#scheduleKeepAlive(remaining);
+      return;
+    }
+    this.#keepAlivePing = this.#send(pingRequest()).then(
+      () => {
+        if (this.#closing === void 0 && this.#unusable === void 0) this.#scheduleKeepAlive(KEEP_ALIVE_IDLE_MS);
+      },
+      (error) => {
+        this.#transport.log.emit("warn", "sabre.session.keepAliveFailed", { error });
+      }
+    );
+    void this.#keepAlivePing.finally(() => {
+      this.#keepAlivePing = void 0;
+    });
+  }
+  #stopKeepAlive() {
+    if (this.#keepAliveTimer !== void 0) clearTimeout(this.#keepAliveTimer);
+    this.#keepAliveTimer = void 0;
+  }
+};
+function pingRequest() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  return {
+    service: "ping",
+    action: "OTA_PingRQ",
+    payload: `<OTA_PingRQ xmlns="${OTA_PING_NAMESPACE}" TimeStamp="${timestamp}" Version="1.0.0"><EchoData>sabre-client</EchoData></OTA_PingRQ>`,
+    idempotent: true,
+    operation: "ping"
+  };
+}
+var OTA_PING_NAMESPACE = "http://www.opentravel.org/OTA/2003/05";
+function checkPingResponse(response) {
+  const errors = asArray(response.payload.Errors)[0];
+  const error = asArray(errors?.Error)[0];
+  if (error !== void 0) {
+    const type = error["@Type"];
+    const text = textOf(error)?.trim();
+    throw new SabreGatewayError(`ping: OTA_PingRS con error${text ? `: ${text}` : ""}`, {
+      protocol: "soap",
+      status: response.status,
+      ...typeof type === "string" && type !== "" && { code: type },
+      retryable: false,
+      raw: response.raw
+    });
+  }
+  if (response.payloadName !== "OTA_PingRS" || !("Success" in response.payload)) {
+    throw new SabreGatewayError("ping: respuesta no reconocida (sin OTA_PingRS/Success)", {
+      protocol: "soap",
+      status: response.status,
+      retryable: false,
+      raw: response.raw
+    });
+  }
+}
+function reachedSabre(error) {
+  if (!(error instanceof SabreError)) return false;
+  return !(error instanceof SabreGatewayError && error.status === void 0);
+}
+function installAsyncDispose(target, symbol) {
+  if (symbol === void 0) return;
+  Object.defineProperty(target, symbol, {
+    value() {
+      return this.close();
+    },
+    configurable: true,
+    writable: true
+  });
+}
+function sessionCreatePayload(credentials) {
+  const pos = `<POS><Source PseudoCityCode="${xmlEscape(credentials.organization)}"/></POS>`;
+  return credentials.version === "2.0.0" ? `<SessionCreateRQ xmlns="${SWS_NAMESPACE}" Version="2.0.0">${pos}</SessionCreateRQ>` : `<SessionCreateRQ xmlns="${OTA_NAMESPACE}" Version="1.0.0" returnContextID="true">${pos}</SessionCreateRQ>`;
+}
+function usernameToken(credentials) {
+  const { username, password, organization, domain, clientId, clientSecret } = credentials;
+  return {
+    usernameToken: {
+      username,
+      password,
+      organization,
+      domain,
+      ...clientId === void 0 ? {} : { clientId },
+      ...clientSecret === void 0 ? {} : { clientSecret }
+    }
+  };
+}
+async function openSession(transport, credentials, options = {}) {
+  const { keepAlive = false, ...requestOptions } = options;
+  if (typeof keepAlive !== "boolean") fail4("keepAlive debe ser un boolean");
+  const conversationId = globalThis.crypto.randomUUID();
+  const request = {
+    service: "sessionCreate",
+    action: "SessionCreateRQ",
+    payload: sessionCreatePayload(credentials),
+    cpaId: credentials.organization,
+    conversationId,
+    security: usernameToken(credentials),
+    idempotent: false,
+    readSecurityToken: true,
+    operation: "openSession",
+    ...requestOptions
+  };
+  const response = await transport.request(request).catch((error) => {
+    throw toSessionError(error, OPEN_ERROR_KINDS);
+  });
+  const status = response.payload["@status"];
+  if (typeof status === "string" && status !== "Approved") {
+    throw new SabreGatewayError(`sessionCreate: SessionCreateRS con status ${status}`, {
+      protocol: "soap",
+      status: response.status,
+      retryable: false
+    });
+  }
+  if (response.securityToken === void 0) {
+    throw new SabreGatewayError("sessionCreate: la respuesta no trae BinarySecurityToken", {
+      protocol: "soap",
+      status: response.status,
+      retryable: false
+    });
+  }
+  transport.log.emit("info", "sabre.session.open", {
+    version: credentials.version,
+    pseudoCityCode: credentials.organization
+  });
+  return new SabreSession({
+    transport,
+    pcc: credentials.organization,
+    conversationId,
+    token: response.securityToken,
+    keepAlive
+  });
+}
+
+// src/sabre-legacy.ts
+var SabreLegacy = class {
+  #config;
+  /** Usuario, PCC, domain y versión de `SessionCreateRQ`, validados al crear el cliente. */
+  #session;
+  #transport;
+  /**
+   * 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) {
+    this.#config = resolveConfig(config);
+    this.#session = Object.freeze(resolveSessionCredentials(this.#config.credentials));
+    this.#transport = new SoapTransport(this.#config);
+  }
+  get environment() {
+    return this.#config.environment;
+  }
+  /** Endpoint SOAP del entorno. */
+  get baseUrl() {
+    return this.#config.soapBaseUrl;
+  }
+  /**
+   * 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 = {}) {
+    return openSession(this.#transport, this.#session, options);
+  }
+  /**
+   * 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.
+   */
+  async withSession(callback) {
+    const session = await this.openSession();
+    let result;
+    try {
+      result = await callback(session);
+    } catch (error) {
+      await this.#closeQuietly(session);
+      throw error;
+    }
+    await this.#closeQuietly(session);
+    return result;
+  }
+  async #closeQuietly(session) {
+    try {
+      await session.close();
+    } catch (error) {
+      this.#transport.log.emit("warn", "sabre.session.closeFailed", { error });
+    }
+  }
+};
+
+// src/queue/host-date.ts
+var MONTHS = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
+var DAY_MS = 864e5;
+var HALF_YEAR_DAYS = 184;
+function resolveHostDate(text, referenceDate, options = {}) {
+  const reference = referenceDay(referenceDate);
+  const direction = options.direction ?? "past";
+  if (direction !== "past" && direction !== "nearest") {
+    throw new TypeError("sabre-client: direction debe ser 'past' o 'nearest'");
+  }
+  if (typeof text !== "string") return void 0;
+  const parsed = parseHostDate(text.trim().toUpperCase());
+  if (parsed === void 0) return void 0;
+  const year = parsed.year ?? resolveYear(parsed.month, parsed.day, reference, direction);
+  if (year === void 0 || !isValidDate(year, parsed.month, parsed.day)) return void 0;
+  const date = `${pad(year, 4)}-${pad(parsed.month, 2)}-${pad(parsed.day, 2)}`;
+  return parsed.time === void 0 ? date : `${date}T${parsed.time}`;
+}
+function parseHostDate(text) {
+  let match = /^(\d{1,2})([A-Z]{3})(\d{2})?$/.exec(text);
+  if (match !== null) {
+    const month2 = MONTHS.indexOf(match[2]) + 1;
+    if (month2 === 0) return void 0;
+    return {
+      ...match[3] !== void 0 && { year: 2e3 + Number(match[3]) },
+      month: month2,
+      day: Number(match[1])
+    };
+  }
+  match = /^(?:(\d{4})-)?(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}))?$/.exec(text);
+  if (match === null) return void 0;
+  const [, year, month, day, hours, minutes] = match;
+  if (hours !== void 0 && (Number(hours) > 23 || Number(minutes) > 59)) return void 0;
+  return {
+    ...year !== void 0 && { year: Number(year) },
+    month: Number(month),
+    day: Number(day),
+    ...hours !== void 0 && { time: `${hours}:${minutes}` }
+  };
+}
+function resolveYear(month, day, reference, direction) {
+  const year = new Date(reference).getUTCFullYear();
+  if (direction === "past") {
+    for (let candidate = year; candidate >= year - 8; candidate--) {
+      if (isValidDate(candidate, month, day) && dayNumber(candidate, month, day) <= reference) return candidate;
+    }
+    return void 0;
+  }
+  let best;
+  for (const candidate of [year + 1, year, year - 1]) {
+    if (!isValidDate(candidate, month, day)) continue;
+    const distance = Math.abs(dayNumber(candidate, month, day) - reference);
+    if (best === void 0 || distance < best.distance) best = { year: candidate, distance };
+  }
+  return best !== void 0 && best.distance <= HALF_YEAR_DAYS * DAY_MS ? best.year : void 0;
+}
+function referenceDay(referenceDate) {
+  if (referenceDate instanceof Date) {
+    const time = referenceDate.getTime();
+    if (Number.isNaN(time)) throw new TypeError("sabre-client: referenceDate es un Date inv\xE1lido");
+    return time - (time % DAY_MS + DAY_MS) % DAY_MS;
+  }
+  if (typeof referenceDate === "string") {
+    const match = /^(\d{4})-(\d{2})-(\d{2})(?:T.*)?$/.exec(referenceDate.trim());
+    if (match !== null) {
+      const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];
+      if (isValidDate(year, month, day)) return dayNumber(year, month, day);
+    }
+  }
+  throw new TypeError("sabre-client: referenceDate es obligatoria, como 'YYYY-MM-DD' o un Date v\xE1lido");
+}
+function dayNumber(year, month, day) {
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getTime();
+}
+function isValidDate(year, month, day) {
+  if (month < 1 || month > 12 || day < 1) return false;
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function pad(value, length) {
+  return String(value).padStart(length, "0");
+}
+
+// src/queue/queue-paragraph.ts
+var MESSAGE = /^\s*(\d{3})\s{2,}(\S.*?)\s*$/;
+var PASSENGER_LINE = /^\s*\d+\.\d+[A-Z]/;
+var PASSENGER_SPLIT = /\s+(?=\d+\.\d+[A-Z])/;
+var PASSENGER = /^(\d+\.\d+)([^/*]+?)\s*(?:\/([^*]*?))?\s*(?:\*(.*?))?\s*$/;
+var AIR_SEGMENT = /^\s*(\d{1,2})\s+([A-Z0-9]{2})\s*(\d{1,4})([A-Z])\s+(\d{2}[A-Z]{3})\s+[A-Z0-9]\s+([A-Z]{3})([A-Z]{3})\s+([A-Z]{2})(\d{1,3})(?=\s|$)(.*)$/;
+var SEGMENT_TIMES = /^\s+(\d{3,4}[APNM]?)\s+(\d{3,4}[APNM]?)(?=\s|$)/;
+var OTHER_SEGMENT = /^\s*(\d{1,2})\s+([A-Z]{3})\s+([A-Z0-9]{2})\s+(\d{2}[A-Z]{3})\s+[A-Z0-9]\s+([A-Z]{2})(\d{1,3})(?=\s|$)/;
+var NO_ITINERARY = /^\s*NO ITIN\s*$/;
+var TICKETING_HEADER = /^\s*TKT\/TIME LIMIT\s*$/;
+var TICKETING_ENTRY = /^\s*(\d+)\.(.*?)\s*$/;
+var TICKETED = /^T-(\d{2}[A-Z]{3})?(?:-([A-Z0-9]{3,4})\*([A-Z0-9]+))?(?:\/.*)?$/;
+var ARRANGEMENT = /^(TA[WCMTX])([A-Z0-9]{3,4})?(\d{2}[A-Z]{3})?\d{0,3}\/.*$/;
+var TICKET = /^(TE|TK)\s+(\d{13})\b/;
+var RECEIVED = /^\s*RECEIVED FROM -\s?(.*?)\s*$/;
+var SIGNATURE = /^\s*([A-Z0-9]{3,4})\.(\S+)\s+(\d{2})(\d{2})\/(\d{2}[A-Z]{3}\d{2})\s+([A-Z0-9]{6})\s+H\s*$/;
+var Phase = { Messages: 0, Passengers: 1, Segments: 2, Body: 3 };
+function parseQueueParagraph(lines, options) {
+  if (!Array.isArray(lines)) throw new TypeError("sabre-client: lines debe ser un array de strings");
+  if (typeof options !== "object" || options === null) {
+    throw new TypeError("sabre-client: referenceDate es obligatoria, como 'YYYY-MM-DD' o un Date v\xE1lido");
+  }
+  const { referenceDate } = options;
+  referenceDay(referenceDate);
+  const result = { messages: [], passengers: [], segments: [], unparsed: [] };
+  const signatureIndex = lastSignatureIndex(lines);
+  let phase = Phase.Messages;
+  let inTicketing = false;
+  lines.forEach((value, index) => {
+    const line = typeof value === "string" ? value : "";
+    if (line.trim() === "") return;
+    if (index === signatureIndex) {
+      result.receivedFrom = { ...result.receivedFrom, ...parseSignature(line, referenceDate) };
+      return;
+    }
+    if (inTicketing) {
+      const entry = TICKETING_ENTRY.exec(line);
+      if (entry !== null) {
+        const parsed = parseTicketingEntry(Number(entry[1]), entry[2], referenceDate);
+        if (parsed === void 0) result.unparsed.push(line);
+        else result.ticketing.entries.push(parsed);
+        return;
+      }
+      inTicketing = false;
+    }
+    if (TICKETING_HEADER.test(line)) {
+      phase = Phase.Body;
+      inTicketing = true;
+      result.ticketing ??= { entries: [], issued: false };
+      return;
+    }
+    const received = RECEIVED.exec(line);
+    if (received !== null) {
+      phase = Phase.Body;
+      result.receivedFrom = { ...result.receivedFrom, ...received[1] !== "" && { name: received[1] } };
+      return;
+    }
+    if (phase === Phase.Messages) {
+      const message = MESSAGE.exec(line);
+      if (message !== null) {
+        result.messages.push({ instructionCode: Number(message[1]), text: message[2] });
+        return;
+      }
+    }
+    if (phase <= Phase.Passengers && PASSENGER_LINE.test(line)) {
+      const passengers = parsePassengers(line);
+      if (passengers !== void 0) {
+        phase = Phase.Passengers;
+        result.passengers.push(...passengers);
+        return;
+      }
+    }
+    if (phase <= Phase.Segments) {
+      if (NO_ITINERARY.test(line)) {
+        phase = Phase.Segments;
+        return;
+      }
+      const segment = parseSegment(line, referenceDate);
+      if (segment !== void 0) {
+        phase = Phase.Segments;
+        result.segments.push(segment);
+        return;
+      }
+    }
+    result.unparsed.push(line);
+  });
+  if (result.ticketing !== void 0) {
+    result.ticketing.issued = result.ticketing.entries.some((entry) => entry.ticketNumber !== void 0);
+  }
+  return result;
+}
+function parsePassengers(line) {
+  const passengers = [];
+  for (const part of line.trim().split(PASSENGER_SPLIT)) {
+    const match = PASSENGER.exec(part);
+    if (match === null) return void 0;
+    const [, nameNumber, surname, givenName, nameRemark] = match;
+    passengers.push({
+      nameNumber,
+      surname: surname.trim(),
+      ...givenName !== void 0 && givenName !== "" && { givenName },
+      ...nameRemark !== void 0 && nameRemark !== "" && { nameRemark },
+      text: part.slice(nameNumber.length).trim()
+    });
+  }
+  return passengers;
+}
+function parseSegment(line, referenceDate) {
+  const air = AIR_SEGMENT.exec(line);
+  if (air !== null) {
+    const [, number2, airlineCode, flightNumber, bookingClass, date2, from, to, status2, quantity2, rest] = air;
+    const times = SEGMENT_TIMES.exec(rest);
+    const departureTime = times === null ? void 0 : hostTime(times[1]);
+    const arrivalTime = times === null ? void 0 : hostTime(times[2]);
+    return {
+      kind: "air",
+      number: Number(number2),
+      ...withDate(date2, referenceDate),
+      status: status2,
+      quantity: Number(quantity2),
+      airlineCode,
+      flightNumber: Number(flightNumber),
+      bookingClass,
+      fromAirportCode: from,
+      toAirportCode: to,
+      ...departureTime !== void 0 && { departureTime },
+      ...arrivalTime !== void 0 && { arrivalTime },
+      text: line.trim()
+    };
+  }
+  const other = OTHER_SEGMENT.exec(line);
+  if (other === null) return void 0;
+  const [, number, segmentType, vendorCode, date, status, quantity] = other;
+  return {
+    kind: "other",
+    number: Number(number),
+    ...withDate(date, referenceDate),
+    status,
+    quantity: Number(quantity),
+    segmentType,
+    vendorCode,
+    text: line.trim()
+  };
+}
+function parseTicketingEntry(number, text, referenceDate) {
+  const ticketed = TICKETED.exec(text);
+  if (ticketed !== null) {
+    const [, date, pseudoCityCode, agentSine] = ticketed;
+    return {
+      number,
+      code: "T-",
+      ...date !== void 0 && withDate(date, referenceDate),
+      ...pseudoCityCode !== void 0 && { pseudoCityCode },
+      ...agentSine !== void 0 && { agentSine },
+      text
+    };
+  }
+  const arrangement = ARRANGEMENT.exec(text);
+  if (arrangement !== null) {
+    const [, code, pseudoCityCode, date] = arrangement;
+    return {
+      number,
+      code,
+      ...date !== void 0 && withDate(date, referenceDate),
+      ...pseudoCityCode !== void 0 && { pseudoCityCode },
+      text
+    };
+  }
+  const ticket = TICKET.exec(text);
+  if (ticket !== null) return { number, code: ticket[1], ticketNumber: ticket[2], text };
+  return void 0;
+}
+function lastSignatureIndex(lines) {
+  for (let index = lines.length - 1; index >= 0; index--) {
+    const line = lines[index];
+    if (typeof line === "string" && SIGNATURE.test(line)) return index;
+  }
+  return -1;
+}
+function parseSignature(line, referenceDate) {
+  const [, pseudoCityCode, sign, hours, minutes, date, locator] = SIGNATURE.exec(line);
+  const agentSine = /\*([A-Z0-9]+)$/.exec(sign)?.[1];
+  const day = Number(hours) <= 23 && Number(minutes) <= 59 ? resolveHostDate(date, referenceDate) : void 0;
+  return {
+    pseudoCityCode,
+    ...agentSine !== void 0 && { agentSine },
+    ...day !== void 0 && { receivedAt: `${day}T${hours}:${minutes}` },
+    locator
+  };
+}
+function withDate(text, referenceDate) {
+  const date = resolveHostDate(text, referenceDate, { direction: "nearest" });
+  return date === void 0 ? {} : { date };
+}
+function hostTime(text) {
+  const match = /^(\d{1,2})(\d{2})([APNM])?$/.exec(text);
+  if (match === null) return void 0;
+  let hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  const suffix = match[3];
+  if (minutes > 59) return void 0;
+  if (suffix === void 0) {
+    if (hours > 23) return void 0;
+  } else {
+    if (hours < 1 || hours > 12) return void 0;
+    if (suffix === "A" || suffix === "M") hours %= 12;
+    else if (suffix === "P") hours = hours % 12 + 12;
+    else if (hours !== 12) return void 0;
+  }
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+
+// src/air/seat-availability-request.ts
+function buildSeatAvailabilityRequest(source) {
+  const { group, itinerary, segments: only, currencyCode } = source;
+  const flights = itineraryFlights(group, itinerary);
+  const segments = flights.map(
+    ({ schedule, departureDate, arrivalDate, bookingCode }, i) => {
+      const { carrier } = schedule;
+      const operating = carrier.operating !== void 0 && (carrier.operating !== carrier.marketing || carrier.operatingFlightNumber !== void 0 && carrier.operatingFlightNumber !== carrier.marketingFlightNumber);
+      return {
+        id: segmentId(i),
+        bookingAirlineCode: carrier.marketing,
+        bookingFlightNumber: carrier.marketingFlightNumber,
+        departureAirportCode: schedule.departure.airport,
+        arrivalAirportCode: schedule.arrival.airport,
+        departureDate,
+        departureTime: schedule.departure.time.slice(0, 5),
+        arrivalDate,
+        arrivalTime: schedule.arrival.time.slice(0, 5),
+        bookingClassCode: bookingCode,
+        ...operating ? { operatingAirlineCode: carrier.operating } : {},
+        ...operating && carrier.operatingFlightNumber !== void 0 ? { operatingFlightNumber: carrier.operatingFlightNumber } : {}
+      };
+    }
+  );
+  const fare = itinerary.pricingInformation[0]?.fare;
+  if (fare === void 0) {
+    throw new TypeError("sabre-client: el itinerario no trae pricingInformation");
+  }
+  const fareComponents = /* @__PURE__ */ new Map();
+  const passengers = [];
+  for (const { passengerInfo } of fare.passengerInfoList) {
+    const fareSegmentAssociation = [];
+    let next = 0;
+    for (const component of passengerInfo.fareComponents ?? []) {
+      const fareComponentId = `FC${component.id}`;
+      if (!fareComponents.has(fareComponentId)) fareComponents.set(fareComponentId, fareComponent(fareComponentId, component));
+      for (const { segment } of component.segments ?? []) {
+        const flight2 = segments[next];
+        if (flight2 === void 0) break;
+        if (flight2.cabinCode === void 0 && segment.cabinCode !== void 0) flight2.cabinCode = segment.cabinCode;
+        fareSegmentAssociation.push({ segmentRef: flight2.id, fareComponentRef: fareComponentId });
+        next++;
+      }
+    }
+    for (let n = 0; n < (passengerInfo.passengerNumber ?? 1); n++) {
+      passengers.push({
+        id: `P${passengers.length + 1}`,
+        passengerType: passengerInfo.passengerType,
+        ...fareSegmentAssociation.length === 0 ? {} : { fareSegmentAssociation }
+      });
+    }
+  }
+  const refs = (only ?? segments.map((_s, i) => i + 1)).map((n) => {
+    if (!Number.isInteger(n) || n < 1 || n > segments.length) {
+      throw new TypeError(`sabre-client: segments pide el vuelo ${n}, y hay ${segments.length} (empieza en 1)`);
+    }
+    return segmentId(n - 1);
+  });
+  if (refs.length === 0) {
+    throw new TypeError("sabre-client: segments no puede ir vac\xEDo");
+  }
+  return {
+    returnSeatMapsOnlyForSegmentRefs: refs,
+    segments,
+    passengers,
+    ...fareComponents.size === 0 ? {} : { fareComponents: [...fareComponents.values()] },
+    ...currencyCode === void 0 ? {} : { currencyCode }
+  };
+}
+function segmentId(index) {
+  return `S${index + 1}`;
+}
+function fareComponent(fareComponentId, component) {
+  const { fareBasisCode, governingCarrier, fareType, fareTariff, fareRule, fareTypeBitmap } = component;
+  const fareDetail = definedOnly({ fareType, fareTariff, fareRule, fareTypeBitmap });
+  return {
+    fareComponentId,
+    fareBasis: fareBasisCode,
+    ...governingCarrier === void 0 ? {} : { governingCarrier },
+    ...Object.keys(fareDetail).length === 0 ? {} : { fareDetail }
+  };
 }
 
 // src/index.ts
@@ -1298,10 +3264,15 @@ export {
   SabreBusinessError,
   SabreError,
   SabreGatewayError,
+  SabreLegacy,
   SabreOrchestrationError,
+  SabreSessionError,
   SabreWarning,
   VERSION,
   buildBookingFlightDetails,
-  buildRevalidateItineraryRequest
+  buildRevalidateItineraryRequest,
+  buildSeatAvailabilityRequest,
+  parseQueueParagraph,
+  resolveHostDate
 };
 //# sourceMappingURL=index.js.map