sabre-client 0.2.4 → 0.3.0-next.1

package/dist/index.js

@@ -1,370 +1,1307 @@
-// src/air/search.ts
-var Search = class {
-  /**
-   * Bargain Finder Max v5
-   * 
-   * Bargain Finder Max (BFM), 
-   * nuestro producto de búsqueda de tarifas bajas líder en su clase, 
-   * se utiliza para buscar los itinerarios con los precios más bajos disponibles según una fecha específica.
-   * 
-   * Revalidate Itinerary v5
-   * 
-   * La API Revalidate Itinerary permite volver a consultar la disponibilidad 
-   * y el precio de una opción de itinerario específica sin tener que reservarla. 
-   * La solución revalida si la opción de itinerario es válida para la compra. 
-   * Revalidate Itinerary no admite contenido NDC.
-   * 
-   * @param sabre Sabre Client Reference
-   */
-  constructor(sabre) {
-    this.sabre = sabre;
+// src/errors/sabre-error.ts
+var SabreError = class extends Error {
+  name = "SabreError";
+  retryable;
+  constructor(message, options) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.retryable = options.retryable;
+    Object.defineProperty(this, "raw", {
+      value: options.raw,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
   }
-  /**
-   * Crear solicitud de Buscador de ofertas Max.
-   * 
-   * payload - El mensaje de solicitud de búsqueda de tarifa baja solicita opciones 
-   * de itinerario para vuelos entre pares de ciudades específicos, en fechas específicas, 
-   * para un número y tipo de pasajeros específicos. 
-   * La información opcional de la solicitud puede incluir: 
-   *  hora/ventana horaria, ciudades de conexión 
-   *  y preferencias del cliente (aerolíneas, cabina, tipo de vuelo, etc.). 
-   * La solicitud de búsqueda de tarifa baja contiene información similar a 
-   * la de una búsqueda de tarifa baja en el CRS o GDS de una aerolínea.
-   * @param payload BargainFinderMaxOptions 
-   * @returns {Promise<BargainFinderMaxResponseSuccess>}
-   */
-  async shop(payload) {
-    const path = "/v5/offers/shop";
-    return this.sabre.post(path, payload);
+  toJSON() {
+    const fields = Object.fromEntries(Object.entries(this));
+    return { ...fields, name: this.name, message: this.message };
   }
-  /**
-   * Crear solicitud de revalidación de itinerario.
-   * 
-   * payload - El mensaje de solicitud de búsqueda de tarifa baja solicita opciones
-   * de itinerario para vuelos entre pares de ciudades específicos, en fechas específicas, 
-   * para un número y tipo de pasajeros específicos. 
-   * La información opcional de la solicitud puede incluir: 
-   *  hora/ventana horaria, ciudades de conexión 
-   *  y preferencias del cliente (aerolíneas, cabina, tipo de vuelo, etc.). 
-   * La solicitud de búsqueda de tarifa baja contiene información similar a 
-   * la de una búsqueda de tarifa baja en el CRS o GDS de una aerolínea.
-   * @param payload RevalidateItineraryOptions
-   * @returns {Promise<RevalidateItineraryResponseSuccess>}
-   */
-  async revalidate(payload) {
-    const path = "/v5/shop/flights/revalidate";
-    return this.sabre.post(path, payload);
+};
+var SabreGatewayError = class extends SabreError {
+  name = "SabreGatewayError";
+  protocol;
+  status;
+  code;
+  constructor(message, options) {
+    super(message, options);
+    this.protocol = options.protocol;
+    this.status = options.status;
+    this.code = options.code;
+  }
+};
+var SabreOrchestrationError = class extends SabreError {
+  name = "SabreOrchestrationError";
+  code;
+  constructor(message, options) {
+    super(message, { ...options, retryable: options.code === "SP.PROVIDER_ERROR" });
+    this.code = options.code;
+  }
+};
+var SabreBusinessError = class extends SabreError {
+  name = "SabreBusinessError";
+  service;
+  code;
+  warnings;
+  errors;
+  constructor(message, options) {
+    super(message, { ...options, retryable: options.retryable ?? false });
+    this.service = options.service;
+    this.code = options.code;
+    this.warnings = options.warnings ?? [];
+    this.errors = options.errors ?? [];
+  }
+};
+var SabreWarning = class extends SabreError {
+  name = "SabreWarning";
+  service;
+  code;
+  constructor(message, options) {
+    super(message, { ...options, retryable: false });
+    this.service = options.service;
+    this.code = options.code;
   }
 };
 
-// src/air/ticketing.ts
-var Ticketing = class {
-  /**
-   * Enhanced Air Ticket v1.3.0
-   * 
-   * La API de boletos aéreos mejorados se utiliza para emitir uno o varios boletos aéreos 
-   * y/o EMD (documentos electrónicos varios) dentro de una sola llamada API.
-   * 
-   * @param sabre Sabre Client Reference
-   */
-  constructor(sabre) {
-    this.sabre = sabre;
+// src/air/grouped-itinerary.ts
+function denormalizeGroupedItineraryResponse(raw, service) {
+  const resolver = new Resolver(raw, service);
+  return {
+    version: raw.version,
+    messages: raw.messages ?? [],
+    ...raw.statistics === void 0 ? {} : { statistics: raw.statistics },
+    itineraryGroups: (raw.itineraryGroups ?? []).map((group) => ({
+      groupDescription: group.groupDescription,
+      itineraries: group.itineraries.map((itinerary) => resolver.itinerary(itinerary))
+    }))
+  };
+}
+var Resolver = class {
+  #service;
+  #schedules;
+  #legs;
+  #taxes;
+  #taxSummaries;
+  #obFees;
+  #fareComponents;
+  #validatingCarriers;
+  #baggageAllowances;
+  constructor(raw, service) {
+    this.#service = service;
+    this.#schedules = byId(raw.scheduleDescs);
+    this.#legs = byId(raw.legDescs);
+    this.#taxes = byId(raw.taxDescs);
+    this.#taxSummaries = byId(raw.taxSummaryDescs);
+    this.#obFees = byId(raw.obFeeDescs);
+    this.#fareComponents = byId(raw.fareComponentDescs);
+    this.#validatingCarriers = byId(raw.validatingCarrierDescs);
+    this.#baggageAllowances = byId(raw.baggageAllowanceDescs);
   }
-  /**
-   * La API de boletos aéreos mejorados (AirTicketRQ) 
-   * se utiliza para emitir boletos aéreos y documentos electrónicos varios (EMD) en una sola solicitud.
-   * 
-   * payload - Solicitud de API de boletos aéreos orquestada.
-   * @param payload EnhancedAirTicketOptions 
-   * @returns {Promise<EnhancedAirTicketResponseSuccess>}
-   */
-  async issue(payload) {
-    const path = "/v1.3.0/air/ticket";
-    return this.sabre.post(path, payload);
+  itinerary(itinerary) {
+    return {
+      ...itinerary,
+      legs: itinerary.legs.map((ref) => this.#leg(ref)),
+      pricingInformation: itinerary.pricingInformation.map((pricing) => ({
+        ...pricing,
+        fare: this.#fare(pricing.fare)
+      }))
+    };
+  }
+  #leg(ref) {
+    const leg = this.#merge(this.#legs, "legDescs", ref);
+    return { ...leg, schedules: leg.schedules.map((schedule) => this.#merge(this.#schedules, "scheduleDescs", schedule)) };
+  }
+  #fare(fare) {
+    const { validatingCarriers, ...rest } = fare;
+    return {
+      ...rest,
+      passengerInfoList: fare.passengerInfoList.map(({ passengerInfo, ...entry }) => ({
+        ...entry,
+        passengerInfo: this.#passengerInfo(passengerInfo)
+      })),
+      ...validatingCarriers === void 0 ? {} : {
+        validatingCarriers: validatingCarriers.map(
+          (ref) => this.#merge(this.#validatingCarriers, "validatingCarrierDescs", ref)
+        )
+      }
+    };
+  }
+  #passengerInfo(info) {
+    const { fareComponents, taxes, taxSummaries, obFees, baggageInformation, ...rest } = info;
+    const result = { ...rest };
+    if (fareComponents !== void 0) result.fareComponents = fareComponents.map((ref) => this.#fareComponent(ref));
+    if (taxes !== void 0) result.taxes = taxes.map((ref) => this.#merge(this.#taxes, "taxDescs", ref));
+    if (taxSummaries !== void 0) {
+      result.taxSummaries = taxSummaries.map((ref) => this.#merge(this.#taxSummaries, "taxSummaryDescs", ref));
+    }
+    if (obFees !== void 0) result.obFees = obFees.map((ref) => this.#merge(this.#obFees, "obFeeDescs", ref));
+    if (baggageInformation !== void 0) {
+      result.baggageInformation = baggageInformation.map(({ allowance, ...bag }) => ({
+        ...bag,
+        ...allowance === void 0 ? {} : { allowance: this.#merge(this.#baggageAllowances, "baggageAllowanceDescs", allowance) }
+      }));
+    }
+    return result;
+  }
+  #fareComponent(ref) {
+    const desc = this.#lookup(this.#fareComponents, "fareComponentDescs", ref.ref);
+    const { ref: _ref, segments: siteSegments, ...site } = ref;
+    const { segments: descSegments, ...descRest } = desc;
+    if (descSegments !== void 0 && siteSegments !== void 0 && descSegments.length !== siteSegments.length) {
+      throw this.#malformed(
+        `fareComponents con ${siteSegments.length} segmentos y fareComponentDescs ${ref.ref} con ${descSegments.length}`
+      );
+    }
+    const segments = mergeSegments(descSegments, siteSegments);
+    return { ...descRest, ...site, ...segments === void 0 ? {} : { segments } };
+  }
+  /** `{ ref, ...resto }` → `{ ...descriptor, ...resto }`. */
+  #merge(index, kind, ref) {
+    const { ref: id, ...site } = ref;
+    return { ...this.#lookup(index, kind, id), ...site };
+  }
+  #lookup(index, kind, id) {
+    const desc = index.get(id);
+    if (desc === void 0) throw this.#malformed(`ref ${id} sin descriptor en ${kind}`);
+    return desc;
+  }
+  #malformed(detail) {
+    return new SabreError(`${this.#service}: respuesta malformada, ${detail}`, { retryable: false });
   }
 };
+function byId(descs) {
+  return new Map((descs ?? []).map((desc) => [desc.id, desc]));
+}
+function mergeSegments(desc, site) {
+  if (desc === void 0 && site === void 0) return void 0;
+  const length = desc?.length ?? site?.length ?? 0;
+  return Array.from({ length }, (_, i) => ({
+    segment: { ...desc?.[i]?.segment, ...site?.[i]?.segment }
+  }));
+}
 
-// src/authentication/authentication.ts
-var grantType = new URLSearchParams({ "grant_type": "client_credentials" }).toString();
-var Authentication = class {
-  constructor(sabre) {
-    this.sabre = sabre;
+// src/air/itinerary-messages.ts
+function classifyItineraryMessages(body, service, catalog) {
+  const response = isObject(body) ? body.groupedItineraryResponse : void 0;
+  if (!isObject(response)) {
+    return new SabreError(`${service}: respuesta malformada, falta groupedItineraryResponse`, {
+      retryable: false,
+      raw: body
+    });
   }
-  /**
-   * OAuth Token Create REST API v2
-   * See https://developer.sabre.com/docs/rest_apis/session_management/token_create_api/v2
-   * @param payload El tipo de concesión utilizado para obtener el token. Sólo se admiten 'client_credentials'.
-   * @returns TokenResponse
-   */
-  async OAuthTokenV2(payload = grantType) {
-    const data = await this.sabre.auth(
-      "/v2/auth/token",
-      payload
+  const messages = Array.isArray(response.messages) ? response.messages : [];
+  const error = messages.find((message) => message.severity?.toLowerCase() === "error");
+  if (error === void 0) return void 0;
+  const match = findInCatalog(messages, catalog);
+  const text = match?.text ?? (typeof error.text === "string" ? error.text : "");
+  const known = match?.entry;
+  const code = known?.code ?? error.code ?? text;
+  return new SabreBusinessError(`${service}: ${text || code}`, {
+    service,
+    code,
+    retryable: known?.retryable ?? false,
+    raw: body
+  });
+}
+function findInCatalog(messages, catalog) {
+  for (const message of messages) {
+    if (typeof message.text !== "string") continue;
+    const text = message.text.toLowerCase();
+    const entry = catalog.find((candidate) => text.includes(candidate.code.toLowerCase()));
+    if (entry !== void 0) return { entry, text: message.text };
+  }
+  return void 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/air/bargain-finder-max.ts
+var BARGAIN_FINDER_MAX_SERVICE = "bargainFinderMax";
+var PATH = "/v5/offers/shop";
+var BARGAIN_FINDER_MAX_CATALOG = [
+  { code: "No Availability", retryable: false },
+  { code: "NO FLIGHT SCHEDULES FOR QUALIFIERS USED", retryable: false },
+  { code: "Connection reset by peer", retryable: true },
+  { code: "Transmission timeout", retryable: true },
+  { code: "Insufficient resources", retryable: true },
+  { code: "MAX NBR COMBINATIONS EXCEEDED", retryable: true }
+];
+async function bargainFinderMax(transport, request, options = {}) {
+  if (typeof request !== "object" || request === null || typeof request.OTA_AirLowFareSearchRQ !== "object") {
+    throw new TypeError("sabre-client: bargainFinderMax espera { OTA_AirLowFareSearchRQ: { ... } }");
+  }
+  const body = await transport.request({
+    method: "POST",
+    path: PATH,
+    service: BARGAIN_FINDER_MAX_SERVICE,
+    // POST, pero de solo lectura: se puede reintentar sin efectos duplicados.
+    idempotent: true,
+    body: request,
+    classify: classifyBargainFinderMax,
+    ...options.retry === void 0 ? {} : { retry: options.retry },
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    ...options.onRawResponse === void 0 ? {} : { operation: "air.bargainFinderMax", onRawResponse: options.onRawResponse }
+  });
+  return denormalizeGroupedItineraryResponse(body.groupedItineraryResponse, BARGAIN_FINDER_MAX_SERVICE);
+}
+function classifyBargainFinderMax(body) {
+  return classifyItineraryMessages(body, BARGAIN_FINDER_MAX_SERVICE, BARGAIN_FINDER_MAX_CATALOG);
+}
+
+// src/air/itinerary-flights.ts
+function itineraryFlights(group, itinerary) {
+  const { legDescriptions } = group.groupDescription;
+  if (legDescriptions.length !== itinerary.legs.length) {
+    throw new TypeError(
+      `sabre-client: el itinerario tiene ${itinerary.legs.length} tramos y el grupo ${legDescriptions.length}`
     );
-    this.sabre.setAuthorization(data.access_token);
-    return data;
   }
-};
+  const classes = bookingCodes(itinerary);
+  const flightCount = itinerary.legs.reduce((n, leg) => n + leg.schedules.length, 0);
+  if (classes.length !== flightCount) {
+    throw new TypeError(
+      `sabre-client: el itinerario tiene ${flightCount} vuelos y ${classes.length} clases de servicio en fareComponents`
+    );
+  }
+  let next = 0;
+  return itinerary.legs.flatMap((leg, legIndex) => {
+    const legDate = legDescriptions[legIndex].departureDate;
+    return leg.schedules.map((schedule) => {
+      const departureDate = addDays(legDate, schedule.departureDateAdjustment ?? 0);
+      return {
+        legIndex,
+        schedule,
+        departureDate,
+        arrivalDate: addDays(departureDate, schedule.arrival.dateAdjustment ?? 0),
+        bookingCode: classes[next++]
+      };
+    });
+  });
+}
+function bookingCodes(itinerary) {
+  const passenger = itinerary.pricingInformation[0]?.fare.passengerInfoList[0]?.passengerInfo;
+  return (passenger?.fareComponents ?? []).flatMap(
+    (component) => (component.segments ?? []).map(({ segment }) => {
+      if (segment.bookingCode === void 0) {
+        throw new TypeError("sabre-client: un segmento de fareComponents no trae bookingCode");
+      }
+      return segment.bookingCode;
+    })
+  );
+}
+function addDays(date, days) {
+  if (days === 0) return date;
+  const [year, month, day] = date.split("-").map(Number);
+  return new Date(Date.UTC(year, month - 1, day + days)).toISOString().slice(0, 10);
+}
 
-// src/booking-management/booking.ts
-var Booking = class {
-  /**
-   * Booking
-   * 
-   * La API de reservas está diseñada para proporcionar una vista normalizada de una reserva de Sabre combinando el PNR de Sabre y el pedido de Sabre.
-   * 
-   * @param sabre Sabre Client Reference
-   */
-  constructor(sabre) {
-    this.sabre = sabre;
+// src/air/revalidate-itinerary.ts
+var REVALIDATE_ITINERARY_SERVICE = "revalidateItinerary";
+var PATH2 = "/v5/shop/flights/revalidate";
+async function revalidateItinerary(transport, request, options = {}) {
+  if (typeof request !== "object" || request === null || typeof request.OTA_AirLowFareSearchRQ !== "object") {
+    throw new TypeError("sabre-client: revalidateItinerary espera { OTA_AirLowFareSearchRQ: { ... } }");
   }
-  /**
-   * Crea una solicitud que contiene un "Id. de confirmación" y un "apellido" del viajero para obtener información de la reserva.
-   * 
-   * payload - Contiene elementos tanto obligatorios como opcionales para realizar una solicitud de reserva.
-   * @param payload GetBookingOptions
-   * @returns {Promise<GetBookingResponseSuccess>}
-   */
-  get(payload) {
-    const path = "/v1/trip/orders/getBooking";
-    return this.sabre.post(path, payload);
+  const body = await transport.request({
+    method: "POST",
+    path: PATH2,
+    service: REVALIDATE_ITINERARY_SERVICE,
+    // POST, pero de solo lectura: no sostiene inventario, se puede reintentar.
+    idempotent: true,
+    body: request,
+    classify: classifyRevalidateItinerary,
+    ...options.retry === void 0 ? {} : { retry: options.retry },
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    ...options.onRawResponse === void 0 ? {} : { operation: "air.revalidateItinerary", onRawResponse: options.onRawResponse }
+  });
+  return denormalizeGroupedItineraryResponse(body.groupedItineraryResponse, REVALIDATE_ITINERARY_SERVICE);
+}
+var REVALIDATE_ITINERARY_CATALOG = [
+  { code: "NO COMBINABLE FARES FOR CLASS USED", retryable: false },
+  { code: "NO FARE FOR CLASS USED", retryable: false },
+  { code: "NO FLIGHT SCHEDULES FOR QUALIFIERS USED", retryable: false },
+  { code: "NO SUCH FLIGHT", retryable: false },
+  { code: "NO AVAILABILITY", retryable: false },
+  ...BARGAIN_FINDER_MAX_CATALOG.filter((entry) => entry.retryable)
+];
+function classifyRevalidateItinerary(body) {
+  return classifyItineraryMessages(body, REVALIDATE_ITINERARY_SERVICE, REVALIDATE_ITINERARY_CATALOG);
+}
+function buildRevalidateItineraryRequest(source) {
+  const { search, group, itinerary } = source;
+  const flights = itineraryFlights(group, itinerary);
+  const originDestinations = itinerary.legs.map((_leg, i) => {
+    const legFlights = flights.filter((f) => f.legIndex === i).map(flight);
+    const first = legFlights[0];
+    const last = legFlights.at(-1);
+    return {
+      Fixed: false,
+      DepartureDateTime: first.DepartureDateTime,
+      OriginLocation: { LocationCode: first.OriginLocation.LocationCode },
+      DestinationLocation: { LocationCode: last.DestinationLocation.LocationCode },
+      TPA_Extensions: { Flight: legFlights }
+    };
+  });
+  const { Version, POS, TravelerInfoSummary, TPA_Extensions } = search.OTA_AirLowFareSearchRQ;
+  return {
+    OTA_AirLowFareSearchRQ: {
+      Version,
+      POS,
+      OriginDestinationInformation: originDestinations,
+      TravelPreferences: {
+        MaxStopsQuantity: Math.max(...itinerary.legs.map((leg) => leg.schedules.length - 1)),
+        TPA_Extensions: { VerificationItinCallLogic: { Value: "L" } }
+      },
+      TravelerInfoSummary,
+      ...TPA_Extensions === void 0 ? {} : { TPA_Extensions }
+    }
+  };
+}
+function flight({ schedule, departureDate, arrivalDate, bookingCode }) {
+  const { carrier } = schedule;
+  return {
+    Type: "A",
+    Number: carrier.marketingFlightNumber,
+    DepartureDateTime: `${departureDate}T${localTime(schedule.departure.time)}`,
+    ArrivalDateTime: `${arrivalDate}T${localTime(schedule.arrival.time)}`,
+    ClassOfService: bookingCode,
+    OriginLocation: { LocationCode: schedule.departure.airport },
+    DestinationLocation: { LocationCode: schedule.arrival.airport },
+    Airline: {
+      Marketing: carrier.marketing,
+      ...carrier.operating === void 0 ? {} : { Operating: carrier.operating }
+    }
+  };
+}
+function localTime(time) {
+  return time.slice(0, 8);
+}
+
+// src/air/air.ts
+var Air = class {
+  #transport;
+  /** @internal Lo construye el cliente `Sabre`. */
+  constructor(transport) {
+    this.#transport = transport;
   }
   /**
-   * Crea una reserva aérea (NDC/ATPCO/LCC).
-   * 
-   * payload - Contiene elementos obligatorios y opcionales para realizar una solicitud de reserva.
-   * @param payload CreateBookingOptions
-   * @returns {Promise<CreateBookingResponseSuccess>}
+   * Bargain Finder Max v5: busca itinerarios de menor precio. Devuelve el
+   * `groupedItineraryResponse` con las referencias ya resueltas.
    */
-  async create(payload) {
-    const path = "/v1/trip/orders/createBooking";
-    return this.sabre.post(path, payload);
+  bargainFinderMax(request, options) {
+    return bargainFinderMax(this.#transport, request, options);
   }
   /**
-   * Crea una lista de elementos de reserva que deben cancelarse.
-   * 
-   * payload - Contiene elementos obligatorios y opcionales para cancelar la totalidad o partes de una reserva.
-   * @param payload CancelBookingOptions
-   * @returns {Promise<CancelBookingResponseSuccess>}
+   * Revalidate Itinerary v5: revalida disponibilidad y precio de un itinerario ya elegido,
+   * sin sostener inventario. El request se arma con `buildRevalidateItineraryRequest`.
    */
-  async cancel(payload) {
-    const path = "/v1/trip/orders/cancelBooking";
-    return this.sabre.post(path, payload);
+  revalidateItinerary(request, options) {
+    return revalidateItinerary(this.#transport, request, options);
   }
-  /**
-   * Crea una lista de elementos de reserva que deben modificarse.
-   * 
-   * payload - Contiene elementos obligatorios y opcionales para modificar datos no relacionados con el itinerario en la reserva existente. 
-   * @param payload ModifyBookingOptions 
-   * @returns {Promise<ModifyBookingResponseSuccess>}
-   */
-  async modify(payload) {
-    const path = "/v1/trip/orders/modifyBooking";
-    return this.sabre.post(path, payload);
+};
+
+// src/logging/redact.ts
+var REDACTED = "[REDACTED]";
+var SENSITIVE_KEYS = new Set(
+  [
+    // Credenciales
+    "clientSecret",
+    "password",
+    "username",
+    "authorization",
+    "binarySecurityToken",
+    "accessToken",
+    "refreshToken",
+    "token",
+    // Datos de pasajero
+    "travelers",
+    "passengers"
+  ].map(normalizeKey)
+);
+function normalizeKey(key) {
+  return key.replace(/[-_\s]/g, "").toLowerCase();
+}
+function isSensitiveKey(key) {
+  return SENSITIVE_KEYS.has(normalizeKey(key));
+}
+function redact(value) {
+  return redactValue(value, /* @__PURE__ */ new WeakSet());
+}
+function redactValue(value, seen) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((item) => redactValue(item, seen));
+  if (value instanceof Headers) return redactEntries(value.entries(), seen);
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Error) {
+    const json = "toJSON" in value && typeof value.toJSON === "function" ? value.toJSON() : void 0;
+    return redactValue(json ?? { name: value.name, message: value.message }, seen);
+  }
+  return redactEntries(Object.entries(value), seen);
+}
+function redactEntries(entries, seen) {
+  const out = {};
+  for (const [key, item] of entries) {
+    out[key] = isSensitiveKey(key) ? REDACTED : redactValue(item, seen);
+  }
+  return out;
+}
+
+// src/logging/logger.ts
+var EventLogger = class {
+  #logger;
+  constructor(logger) {
+    this.#logger = logger;
+  }
+  emit(level, event, context = {}) {
+    if (this.#logger === void 0) return;
+    try {
+      this.#logger[level](event, redact(context));
+    } catch {
+    }
   }
 };
 
-// src/booking-management/flight-tickets.ts
-var FlightTickets = class {
-  /**
-   * Flight Tickets
-   * 
-   * Los endpoint de Flight Tickets son un conjunto de métodos diseñados para obtener detalles de los billetes y 
-   * realizar operaciones específicas (anulación/reembolso) sobre ellos.
-   * 
-   * @param sabre Sabre Client Reference
-   */
-  constructor(sabre) {
-    this.sabre = sabre;
+// src/auth/token-request.ts
+function buildTokenRequestV3(credentials) {
+  return {
+    path: "/v3/auth/token",
+    authorization: `Basic ${base64(`${credentials.clientId}:${credentials.clientSecret}`)}`,
+    body: new URLSearchParams({
+      grant_type: "password",
+      username: credentials.username,
+      password: credentials.password
+    })
+  };
+}
+function buildTokenRequestV2(credentials) {
+  return {
+    path: "/v2/auth/token",
+    authorization: `Basic ${base64(`${base64(credentials.username)}:${base64(credentials.password)}`)}`,
+    body: new URLSearchParams({ grant_type: "client_credentials" })
+  };
+}
+function buildTokenRequest(authVersion, credentials) {
+  return authVersion === "v3" ? buildTokenRequestV3(credentials) : buildTokenRequestV2(credentials);
+}
+function base64(text) {
+  let binary = "";
+  for (const byte of new TextEncoder().encode(text)) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+// src/auth/token-store.ts
+async function tokenStoreKey(environment, authVersion, credentials) {
+  const identity = authVersion === "v3" ? `${credentials.clientId}
+${credentials.username}` : credentials.username;
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(identity));
+  const hash = [...new Uint8Array(digest).slice(0, 16)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `sabre-client:${environment}:${authVersion}:${hash}`;
+}
+function isStoredToken(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const { accessToken, obtainedAt, expiresAt } = value;
+  return typeof accessToken === "string" && accessToken !== "" && typeof obtainedAt === "number" && typeof expiresAt === "number" && Number.isFinite(obtainedAt) && expiresAt > obtainedAt;
+}
+
+// src/auth/auth-manager.ts
+var TOKEN_SERVICE = "oauthTokenCreate";
+var REFRESH_THRESHOLD_S = 3600;
+var AuthManager = class {
+  #config;
+  #transport;
+  #now;
+  #log;
+  #token;
+  #inFlight;
+  /** El último token cacheado fue rechazado con 401 (el próximo refresco es reactivo). */
+  #invalidated = false;
+  /** Token rechazado con 401: si el store todavía lo tiene, no se vuelve a usar. */
+  #rejected;
+  #store;
+  #storeKey;
+  constructor(config, transport, options = {}) {
+    this.#config = config;
+    this.#transport = transport;
+    this.#now = options.now ?? Date.now;
+    this.#log = new EventLogger(config.logger);
+    this.#store = config.tokenStore;
   }
-  /**
-   * Procesa tickets proporcionando una solicitud que contiene una lista de números de ticket que se anularán.
-   * 
-   * payload - Contiene elementos obligatorios y opcionales para anular los billetes.
-   * @param payload VoidTicketsOptions
-   * @returns {Promise<VoidTicketsResponseSuccess>}
-   */
-  async void(payload) {
-    const path = "/v1/trip/orders/voidFlightTickets";
-    return this.sabre.post(path, payload);
+  /** Token vigente; pide uno nuevo si no hay o si cruzó el umbral de refresco. */
+  async getToken() {
+    const token = this.#token;
+    if (token !== void 0 && !this.#needsRefresh(token)) return token.accessToken;
+    const reason = token !== void 0 ? "proactive" : this.#invalidated ? "reactive" : "initial";
+    return (await this.#refresh(reason)).accessToken;
   }
   /**
-   * Procesa los boletos proporcionando una solicitud que contiene una lista de números de boletos que deben reembolsarse. 
-   * Actualmente, los EMD no son compatibles.
-   * 
-   * payload - Contiene elementos obligatorios y opcionales para el reembolso de los billetes.
-   * @param payload RefundTicketsOptions
-   * @returns {Promise<RefundTicketsResponseSuccess>}
+   * Descarta `accessToken` tras un 401 de un servicio. Si el caché ya tiene otro token
+   * (otra request lo renovó), no hace nada: los 401 concurrentes comparten un refresco.
    */
-  async refund(payload) {
-    const path = "/v1/trip/orders/refundFlightTickets";
-    return this.sabre.post(path, payload);
+  invalidate(accessToken) {
+    if (this.#token?.accessToken !== accessToken) return;
+    this.#token = void 0;
+    this.#invalidated = true;
+    this.#rejected = accessToken;
+  }
+  /** Adaptador de salida para el transporte REST: `Authorization: Bearer <token>`. */
+  bearerProvider() {
+    return {
+      get: async () => `Bearer ${await this.getToken()}`,
+      invalidate: (authorization) => this.invalidate(authorization.replace(/^Bearer /, ""))
+    };
+  }
+  #needsRefresh(token) {
+    const thresholdMs = Math.min(REFRESH_THRESHOLD_S, token.expiresIn / 2) * 1e3;
+    return this.#now() >= token.obtainedAt + token.expiresIn * 1e3 - thresholdMs;
+  }
+  /** Una sola petición en vuelo: las llamadas concurrentes esperan la misma promesa. */
+  #refresh(reason) {
+    this.#inFlight ??= this.#obtain(reason).finally(() => {
+      this.#inFlight = void 0;
+    });
+    return this.#inFlight;
+  }
+  /** Token del store si sigue vigente (otro proceso pudo renovarlo); si no, uno nuevo. */
+  async #obtain(reason) {
+    const stored = await this.#readStore();
+    if (stored !== void 0 && stored.accessToken !== this.#rejected && !this.#needsRefresh(stored)) {
+      this.#token = stored;
+      this.#invalidated = false;
+      return stored;
+    }
+    const token = await this.fetchToken();
+    this.#token = token;
+    this.#invalidated = false;
+    this.#rejected = void 0;
+    this.#log.emit("info", "sabre.auth.token.refresh", {
+      authVersion: this.#config.authVersion,
+      reason,
+      expiresIn: token.expiresIn
+    });
+    await this.#writeStore(token);
+    return token;
+  }
+  async #readStore() {
+    if (this.#store === void 0) return void 0;
+    try {
+      const value = await this.#store.get(await this.#key());
+      if (!isStoredToken(value)) return void 0;
+      return {
+        accessToken: value.accessToken,
+        expiresIn: (value.expiresAt - value.obtainedAt) / 1e3,
+        obtainedAt: value.obtainedAt
+      };
+    } catch (error) {
+      this.#storeFailed("get", error);
+      return void 0;
+    }
+  }
+  async #writeStore(token) {
+    if (this.#store === void 0) return;
+    const stored = {
+      accessToken: token.accessToken,
+      obtainedAt: token.obtainedAt,
+      expiresAt: token.obtainedAt + token.expiresIn * 1e3
+    };
+    try {
+      await this.#store.set(await this.#key(), stored);
+    } catch (error) {
+      this.#storeFailed("set", error);
+    }
+  }
+  #key() {
+    const { environment, authVersion, credentials } = this.#config;
+    this.#storeKey ??= tokenStoreKey(environment, authVersion, credentials);
+    return this.#storeKey;
   }
   /**
-   * Procesa tickets proporcionando una solicitud que contiene una lista de números de ticket que se verificarán. 
-   * Actualmente, los EMD no son compatibles.
-   * 
-   * payload - Contiene elementos obligatorios y opcionales para consultar los tickets.
-   * @param payload CheckTicketsOptions
-   * @returns {Promise<CheckTicketsResponseSuccess>} CheckTicketsResponse
+   * El store nunca rompe la llamada: se sigue con el caché en memoria. Del error solo se
+   * loguea el nombre: el mensaje lo arma el store del consumidor y podría traer el token.
    */
-  async check(payload) {
-    const path = "/v1/trip/orders/checkFlightTickets";
-    return this.sabre.post(path, payload);
+  #storeFailed(operation, error) {
+    this.#log.emit("warn", "sabre.auth.token.store", {
+      authVersion: this.#config.authVersion,
+      operation,
+      errorName: error instanceof Error ? error.name : typeof error
+    });
   }
   /**
-   * Procesa la emisión de billetes y documentos varios electrónicos (EMD).
-   * Actualmente, los EMD no son compatibles.
-   * 
-   * payload - Contiene elementos obligatorios y opcionales para la emisión de billetes.
-   * @param payload FulfillTicketsOptions
-   * @returns {Promise<FulfillTicketsResponseSuccess>}
+   * Pide un token nuevo. Los errores del endpoint (`invalid_request`/`invalid_client` 401,
+   * `unauthorized` 403) salen como `SabreGatewayError` con `retryable: false`.
    */
-  async fulfill(payload) {
-    const path = "/v1/trip/orders/fulfillFlightTickets";
-    return this.sabre.post(path, payload);
+  async fetchToken() {
+    const { path, authorization, body } = buildTokenRequest(this.#config.authVersion, this.#config.credentials);
+    const response = await this.#transport.request({
+      method: "POST",
+      path,
+      service: TOKEN_SERVICE,
+      // Pedir otro token no tiene efectos duplicados: 429/5xx entran en la política genérica.
+      idempotent: true,
+      auth: false,
+      headers: { Authorization: authorization },
+      body
+    });
+    return this.#parse(response);
+  }
+  #parse(response) {
+    const accessToken = response?.access_token;
+    const expiresIn = response?.expires_in;
+    if (typeof accessToken !== "string" || accessToken === "" || typeof expiresIn !== "number" || !(expiresIn > 0)) {
+      throw new SabreGatewayError(`${TOKEN_SERVICE}: respuesta sin access_token/expires_in v\xE1lidos`, {
+        protocol: "rest",
+        status: 200,
+        retryable: false,
+        raw: response
+      });
+    }
+    return { accessToken, expiresIn, obtainedAt: this.#now() };
   }
 };
 
-// package.json
-var version = "0.2.4";
+// 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/config.ts
-var defaultBaseUrl = "https://api.platform.sabre.com";
-var defaultUserAgent = `sabre-client-node:${version}`;
-var defaultConversationId = `sabre.client.node:${version}`;
-var defaultDomain = "AA";
-var baseUrl = typeof process !== "undefined" && process.env ? process.env.SABRE_REST_URL || defaultBaseUrl : defaultBaseUrl;
-var userAgent = typeof process !== "undefined" && process.env ? process.env.SABRE_USER_AGENT || defaultUserAgent : defaultUserAgent;
-var domain = typeof process !== "undefined" && process.env ? process.env.SABRE_DOMAIN || defaultDomain : defaultDomain;
-var conversationId = typeof process !== "undefined" && process.env ? process.env.SABRE_CONVERSATION_ID || defaultConversationId : defaultConversationId;
+// src/booking/cancel-booking.ts
+var CANCEL_BOOKING_SERVICE = "cancelBooking";
+var PATH3 = "/v1/trip/orders/cancelBooking";
+var NO_ITEMS_CANCELLED = "NO_ITEMS_CANCELLED";
+var ITEM_LISTS = ["flights", "hotels", "cars", "trains", "cruises", "segments"];
+async function cancelBooking(transport, request, options = {}) {
+  validateCancelBookingRequest(request);
+  const body = await transport.request({
+    method: "POST",
+    path: PATH3,
+    service: CANCEL_BOOKING_SERVICE,
+    idempotent: false,
+    body: request,
+    classify: classifyCancelBooking,
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    ...options.onRawResponse === void 0 ? {} : { operation: "booking.cancel", onRawResponse: options.onRawResponse }
+  });
+  return toCancelBookingResponse(body);
+}
+function validateCancelBookingRequest(request) {
+  if (!isObject2(request) || !nonEmpty(request.confirmationId)) {
+    throw new TypeError("sabre-client: booking.cancel espera { confirmationId: string, ... }");
+  }
+  const lists = ITEM_LISTS.join(", ");
+  if (request.cancelAll === true) {
+    if (ITEM_LISTS.some((list) => request[list] !== void 0)) {
+      throw new TypeError(`sabre-client: booking.cancel no combina cancelAll con listas (${lists})`);
+    }
+  } else if (!ITEM_LISTS.some((list) => Array.isArray(request[list]) && request[list].length > 0)) {
+    throw new TypeError(`sabre-client: booking.cancel necesita cancelAll: true o al menos una lista (${lists})`);
+  }
+  if (request.offerItemId !== void 0 && request.flightTicketOperation !== void 0) {
+    throw new TypeError("sabre-client: booking.cancel no combina offerItemId con flightTicketOperation");
+  }
+}
+function classifyCancelBooking(body) {
+  if (!isObject2(body)) {
+    return new SabreError(`${CANCEL_BOOKING_SERVICE}: respuesta malformada, se esperaba un objeto`, {
+      retryable: false,
+      raw: body
+    });
+  }
+  const items = responseErrors(body);
+  const nothingCancelled = items.find(isNoItemsCancelled);
+  const warnings = items.filter((item) => isWarning(item) && !isNoItemsCancelled(item)).map(warningOf);
+  const fatal = items.filter((item) => !isWarning(item));
+  if (nothingCancelled !== void 0) {
+    return toBusinessError(CANCEL_BOOKING_SERVICE, nothingCancelled, { warnings, errors: fatal.map(errorOf) });
+  }
+  const [first, ...rest] = fatal;
+  if (first === void 0) return void 0;
+  return toBusinessError(CANCEL_BOOKING_SERVICE, first, { warnings, errors: rest.map(errorOf) });
+}
+function toCancelBookingResponse(body) {
+  const { errors: _errors, ...rest } = body;
+  return { ...rest, warnings: responseErrors(body).map(warningOf) };
+}
+function isNoItemsCancelled(item) {
+  return item.type === NO_ITEMS_CANCELLED;
+}
+function warningOf(item) {
+  return toWarning(CANCEL_BOOKING_SERVICE, item);
+}
+function errorOf(item) {
+  return toBusinessError(CANCEL_BOOKING_SERVICE, item);
+}
 
-// src/errors.ts
-var SabreError = class extends Error {
-  details;
-  statusCode;
-  constructor(message, statusCode, details) {
-    super(message);
-    this.name = "SabreError";
-    this.statusCode = statusCode;
-    this.details = details;
+// 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);
+  const body = await transport.request({
+    method: "POST",
+    path: PATH4,
+    service: CREATE_BOOKING_SERVICE,
+    idempotent: false,
+    body: request,
+    classify: classifyCreateBooking,
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    ...options.onRawResponse === void 0 ? {} : { operation: "booking.create", onRawResponse: options.onRawResponse }
+  });
+  return toCreateBookingResponse(body);
+}
+function validateCreateBookingRequest(request) {
+  if (typeof request !== "object" || request === null) {
+    throw new TypeError("sabre-client: booking.create espera un objeto CreateBookingRequest");
   }
-};
+  const agency = request.agency;
+  if (agency?.ticketingPolicy === "FUTURE_TICKETING" && agency.futureTicketingPolicy === void 0) {
+    throw new TypeError(
+      "sabre-client: booking.create con agency.ticketingPolicy FUTURE_TICKETING necesita agency.futureTicketingPolicy"
+    );
+  }
+}
+function classifyCreateBooking(body) {
+  if (!isObject2(body)) {
+    return new SabreError(`${CREATE_BOOKING_SERVICE}: respuesta malformada, se esperaba un objeto`, {
+      retryable: false,
+      raw: body
+    });
+  }
+  const response = body;
+  if (confirmationIdOf(response) !== void 0) return void 0;
+  if (reservationWithoutId(response)) {
+    return new SabreError(
+      `${CREATE_BOOKING_SERVICE}: Sabre indica que la reserva se cre\xF3, pero no devolvi\xF3 su confirmationId`,
+      { retryable: false, raw: body }
+    );
+  }
+  const items = responseErrors(response);
+  const fatal = items.find((item) => !isWarning(item));
+  if (fatal !== void 0) return toBusinessError(CREATE_BOOKING_SERVICE, fatal, { warnings: items.filter(isWarning).map(warningOf2) });
+  return new SabreError(`${CREATE_BOOKING_SERVICE}: respuesta malformada, sin confirmationId ni errores fatales`, {
+    retryable: false,
+    raw: body
+  });
+}
+function toCreateBookingResponse(body) {
+  const items = responseErrors(body);
+  return {
+    confirmationId: confirmationIdOf(body),
+    ...body.timestamp === void 0 ? {} : { timestamp: body.timestamp },
+    ...body.booking === void 0 ? {} : { booking: body.booking },
+    ...body.request === void 0 ? {} : { request: body.request },
+    warnings: items.filter(isWarning).map(warningOf2),
+    errors: items.filter((item) => !isWarning(item)).map((item) => toBusinessError(CREATE_BOOKING_SERVICE, item))
+  };
+}
+function confirmationIdOf(response) {
+  if (nonEmpty(response.confirmationId)) return response.confirmationId;
+  if (nonEmpty(response.booking?.bookingId)) return response.booking.bookingId;
+  const notRetrieved = responseErrors(response).find((item) => item.type === UNABLE_TO_RETRIEVE_BOOKING);
+  return notRetrieved === void 0 ? void 0 : locatorIn(notRetrieved.description);
+}
+function reservationWithoutId(response) {
+  return response.booking !== void 0 || responseErrors(response).some((item) => item.type === UNABLE_TO_RETRIEVE_BOOKING);
+}
+function locatorIn(description) {
+  if (description === void 0) return void 0;
+  return /\(([A-Z0-9]{6,})\)/.exec(description)?.[1] ?? /\b([A-Z0-9]{6,})\b/.exec(description)?.[1];
+}
+function warningOf2(item) {
+  return toWarning(CREATE_BOOKING_SERVICE, item);
+}
+
+// src/booking/get-booking.ts
+var GET_BOOKING_SERVICE = "getBooking";
+var PATH5 = "/v1/trip/orders/getBooking";
+var RETRYABLE_TYPES = /* @__PURE__ */ new Set(["INTERNAL_SERVER_TIMEOUT", "DOWNLINE_SERVICE_FAILURE"]);
+async function getBooking(transport, request, options = {}) {
+  if (!isObject2(request) || !nonEmpty(request.confirmationId)) {
+    throw new TypeError("sabre-client: booking.get espera { confirmationId: string, ... }");
+  }
+  const body = await transport.request({
+    method: "POST",
+    path: PATH5,
+    service: GET_BOOKING_SERVICE,
+    idempotent: true,
+    body: request,
+    classify: classifyGetBooking,
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    ...options.onRawResponse === void 0 ? {} : { operation: "booking.get", onRawResponse: options.onRawResponse }
+  });
+  return toGetBookingResponse(body);
+}
+function classifyGetBooking(body) {
+  if (!isObject2(body)) {
+    return new SabreError(`${GET_BOOKING_SERVICE}: respuesta malformada, se esperaba un objeto`, {
+      retryable: false,
+      raw: body
+    });
+  }
+  const response = body;
+  if (nonEmpty(response.bookingId)) return void 0;
+  const items = responseErrors(response);
+  const fatal = items.find((item) => !isWarning(item));
+  if (fatal !== void 0) return errorOf2(fatal, items.filter(isWarning).map(warningOf3));
+  return new SabreError(`${GET_BOOKING_SERVICE}: respuesta malformada, sin bookingId ni errores fatales`, {
+    retryable: false,
+    raw: body
+  });
+}
+function toGetBookingResponse(body) {
+  const items = responseErrors(body);
+  return {
+    ...body,
+    bookingId: body.bookingId,
+    warnings: items.filter(isWarning).map(warningOf3),
+    errors: items.filter((item) => !isWarning(item)).map((item) => errorOf2(item, []))
+  };
+}
+function warningOf3(item) {
+  return toWarning(GET_BOOKING_SERVICE, item);
+}
+function errorOf2(item, warnings) {
+  return toBusinessError(GET_BOOKING_SERVICE, item, { warnings, retryable: RETRYABLE_TYPES.has(item.type) });
+}
 
-// src/trip-management/reservation.ts
-var Reservation = class {
+// src/booking/booking-management.ts
+var BookingManagement = class {
+  #transport;
+  /** @internal Lo construye el cliente `Sabre`. */
+  constructor(transport) {
+    this.#transport = transport;
+  }
   /**
-   * Reservation
-   * 
-   * La API para crear un registro de nombre de pasajero es una API 
-   * orquestada que integra varias funciones y operaciones en una sola llamada.
-   * 
-   * Esta API permite crear un registro de nombre de pasajero (PNR), 
-   * incluyendo segmentos aéreos, en una sola llamada.
-   * 
-   * @param sabre Sabre Client Reference
+   * Create Booking: crea la reserva. Para un itinerario de BFM/Revalidate, `flightDetails` se
+   * arma con `buildBookingFlightDetails`.
+   *
+   * 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.
    */
-  constructor(sabre) {
-    this.sabre = sabre;
+  create(request, options) {
+    return createBooking(this.#transport, request, options);
   }
   /**
-   * Cree una reserva completa de contenido aéreo, hotel y automóvil de alquiler, todo dentro de una sola solicitud.
-   * 
-   * payload - Contiene elementos obligatorios y opcionales para realizar una solicitud de reserva.
-   * @param payload CreatePassengerNameRecordOptions
-   * @returns {Promise<CreatePassengerNameRecordResponseSuccess>}
+   * Get Booking: lee la reserva por `confirmationId`. El `Booking` va en el primer nivel de la
+   * respuesta, a diferencia de `create`. Usa `returnOnly` para pedir solo las secciones que
+   * hacen falta: además acelera la respuesta.
+   *
+   * Si la reserva existe, no lanza: los avisos y errores parciales van en `warnings` y
+   * `errors`. Si no existe o no se pudo leer (p. ej. `BOOKING_NOT_FOUND`), lanza
+   * `SabreBusinessError`. Es una lectura: se reintenta ante fallos transitorios.
    */
-  create(payload) {
-    const path = "/v2.5.0/passenger/records?mode=create";
-    return this.sabre.post(path, payload);
+  get(request, options) {
+    return getBooking(this.#transport, request, options);
+  }
+  /**
+   * Cancel Booking: cancela la reserva entera (`cancelAll: true`) o por `itemId` (p. ej. los
+   * `flights[].itemId` de `get`). Valida antes de enviar las combinaciones que Sabre rechaza y,
+   * si encuentra una, lanza `TypeError` sin llamar a la red.
+   *
+   * Nunca se reintenta automáticamente. Lanza `SabreBusinessError` si algo falló o si Sabre
+   * responde `NO_ITEMS_CANCELLED` (no se canceló nada), aunque llegue como aviso. Con
+   * `END_TRANSACTION_PROBLEM` en `warnings`, la confirmación quedó pendiente: verifica con `get`.
+   */
+  cancel(request, options) {
+    return cancelBooking(this.#transport, request, options);
   }
 };
 
-// src/sabre.ts
-var Sabre = class {
-  constructor(options = {}) {
-    this.options = options;
-    const processEnv = typeof process !== "undefined" && process.env;
-    if (!this.options.username && processEnv)
-      this.options.username = processEnv.SABRE_USERNAME;
-    if (!this.options.password && processEnv)
-      this.options.password = processEnv.SABRE_PASSWORD;
-    if (!this.options.organization && processEnv)
-      this.options.organization = processEnv.SABRE_ORGANIZATION;
-    if (!this.options.username || !this.options.password || !this.options.organization) {
-      throw new Error(`Missing Sabre authorization. Pass it to the constructor new Sabre({
-        username: '773400', 
-        password: 'PASSWORD_GOES_HERE',
-        organization: '7TZA', // pcc
-      });})`);
+// src/http/retry.ts
+var DEFAULT_RETRY = Object.freeze({ maxRetries: 3, baseDelayMs: 500 });
+var MIN_RETRY_DELAY_MS = 500;
+function retryDelay(retry, baseDelayMs, random = Math.random) {
+  return Math.max(MIN_RETRY_DELAY_MS, Math.floor(random() * baseDelayMs * 2 ** retry));
+}
+function shouldRetry(error, idempotent) {
+  return idempotent && error instanceof SabreError && error.retryable;
+}
+function validateRetryOptions(retry, where) {
+  if (retry.maxRetries !== void 0 && !(Number.isInteger(retry.maxRetries) && retry.maxRetries >= 0)) {
+    throw new TypeError(`sabre-client: ${where}.maxRetries debe ser un entero >= 0`);
+  }
+  if (retry.baseDelayMs !== void 0 && !(Number.isFinite(retry.baseDelayMs) && retry.baseDelayMs >= 0)) {
+    throw new TypeError(`sabre-client: ${where}.baseDelayMs debe ser un n\xFAmero >= 0`);
+  }
+}
+
+// src/config.ts
+var BASE_URLS = Object.freeze({
+  sandbox: "https://api.cert.platform.sabre.com",
+  production: "https://api.platform.sabre.com"
+});
+var LOGGER_METHODS = ["debug", "info", "warn", "error"];
+function fail(message) {
+  throw new TypeError(`sabre-client: ${message}`);
+}
+function isObject3(value) {
+  return typeof value === "object" && value !== null;
+}
+function requireString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") fail(`${field} es requerido y debe ser un string no vac\xEDo`);
+}
+function resolveConfig(config) {
+  if (!isObject3(config)) fail("la config debe ser un objeto");
+  const { environment } = config;
+  if (environment !== "sandbox" && environment !== "production") {
+    fail(`environment debe ser 'sandbox' o 'production' (recibido: ${JSON.stringify(environment)})`);
+  }
+  const authVersion = config.authVersion ?? "v3";
+  if (authVersion !== "v3" && authVersion !== "v2") {
+    fail(`authVersion debe ser 'v3' o 'v2' (recibido: ${JSON.stringify(authVersion)})`);
+  }
+  const { credentials } = config;
+  if (!isObject3(credentials)) fail("credentials es requerido");
+  requireString(credentials.username, "credentials.username");
+  requireString(credentials.password, "credentials.password");
+  if (authVersion === "v3") {
+    requireString(credentials.clientId, "credentials.clientId (requerido con authVersion v3)");
+    requireString(credentials.clientSecret, "credentials.clientSecret (requerido con authVersion v3)");
+  }
+  if (config.pcc !== void 0) requireString(config.pcc, "pcc");
+  const { logger } = config;
+  if (logger !== void 0) {
+    if (!isObject3(logger)) fail("logger debe ser un objeto con debug/info/warn/error");
+    for (const method of LOGGER_METHODS) {
+      if (typeof logger[method] !== "function") fail(`logger.${method} debe ser una funci\xF3n`);
     }
-    this.headers = new Headers({
-      "User-Agent": userAgent,
-      "Conversation-ID": conversationId
-    });
-    this.secret = this.getSecret();
-  }
-  headers;
-  secret;
-  authentication = new Authentication(this);
-  booking = new Booking(this);
-  flightTickets = new FlightTickets(this);
-  search = new Search(this);
-  ticketing = new Ticketing(this);
-  reservation = new Reservation(this);
-  setAuthorization(token) {
-    this.headers.set("Authorization", `Bearer ${token}`);
-    this.headers.set("Content-Type", "application/json");
-  }
-  async fetchRequest(path, options = {}) {
-    const response = await fetch(`${baseUrl}${path}`, options);
-    if (!response.ok) {
-      let errorDetails = `Request failed with status ${response.status}`;
+  }
+  if (config.retry !== void 0) {
+    if (!isObject3(config.retry)) fail("retry debe ser un objeto");
+    validateRetryOptions(config.retry, "retry");
+  }
+  const { tokenStore } = config;
+  if (tokenStore !== void 0) {
+    if (!isObject3(tokenStore) || typeof tokenStore.get !== "function" || typeof tokenStore.set !== "function") {
+      fail("tokenStore debe ser un objeto con get(key) y set(key, token)");
+    }
+  }
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") fail("no hay fetch disponible: pasa config.fetch");
+  return {
+    credentials: Object.freeze({ ...credentials }),
+    environment,
+    baseUrl: BASE_URLS[environment],
+    authVersion,
+    pcc: config.pcc,
+    logger,
+    retry: Object.freeze({ ...DEFAULT_RETRY, ...definedOnly(config.retry ?? {}) }),
+    // Enlazado al global para evitar "Illegal invocation" en algunos runtimes.
+    fetch: config.fetch ?? globalThis.fetch.bind(globalThis),
+    tokenStore
+  };
+}
+function definedOnly(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
+
+// src/http/rest-transport.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 503, 504]);
+var RestTransport = class {
+  #config;
+  #log;
+  #random;
+  #sleep;
+  #authorization;
+  constructor(config, options = {}) {
+    this.#config = config;
+    this.#log = new EventLogger(config.logger);
+    this.#authorization = options.authorization;
+    this.#random = options.random ?? Math.random;
+    this.#sleep = options.sleep ?? sleep;
+  }
+  /** Punto de enganche para `AuthManager`. */
+  setAuthorizationProvider(provider) {
+    this.#authorization = provider;
+  }
+  async request(request) {
+    if (request.retry !== void 0) validateRetryOptions(request.retry, "retry");
+    const capture = request.onRawResponse === void 0 ? void 0 : { attempts: 0 };
+    try {
+      return await this.#attempts(request, capture);
+    } finally {
+      if (capture?.last !== void 0) this.#deliverRaw(request, { ...capture.last, attempts: capture.attempts });
+    }
+  }
+  async #attempts(request, capture) {
+    const retry = { ...this.#config.retry, ...definedOnly(request.retry ?? {}) };
+    let reauthorized = false;
+    for (let attempt = 0; ; attempt++) {
+      const authorization = await this.#authorizationFor(request);
       try {
-        const jsonError = await response.json();
-        errorDetails = JSON.stringify(jsonError);
-      } catch (e) {
-        console.error(e);
-        errorDetails = response.statusText;
+        return await this.#send(request, attempt, authorization, capture);
+      } catch (error) {
+        if (authorization !== void 0 && !reauthorized && isUnauthorized(error)) {
+          reauthorized = true;
+          this.#authorization?.invalidate(authorization);
+          this.#log.emit("warn", "sabre.request.retry", {
+            service: request.service,
+            method: request.method,
+            path: request.path,
+            attempt: attempt + 1,
+            reason: "unauthorized",
+            error
+          });
+          attempt--;
+          continue;
+        }
+        if (attempt >= retry.maxRetries || !shouldRetry(error, request.idempotent)) throw error;
+        const delayMs = retryDelay(attempt, retry.baseDelayMs, this.#random);
+        this.#log.emit("warn", "sabre.request.retry", {
+          service: request.service,
+          method: request.method,
+          path: request.path,
+          attempt: attempt + 1,
+          maxRetries: retry.maxRetries,
+          delayMs,
+          error
+        });
+        await this.#sleep(delayMs, request.signal);
       }
-      throw new SabreError(
-        `Request failed with status ${response.status}`,
-        response.status,
-        errorDetails
-      );
     }
-    const data = await response.json();
-    return data;
   }
-  async post(path, entity, options = {}) {
-    const requestOptions = {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(entity),
-      ...options
-    };
-    return this.fetchRequest(path, requestOptions);
+  /** Un callback que lanza no rompe la operación: Create Booking no puede perder su localizador. */
+  #deliverRaw(request, raw) {
+    const operation = request.operation ?? request.service;
+    try {
+      request.onRawResponse?.({ operation, protocol: "rest", ...raw });
+    } catch (error) {
+      this.#log.emit("warn", "sabre.request.rawResponseHookFailed", {
+        service: request.service,
+        operation,
+        errorName: error instanceof Error ? error.name : typeof error
+      });
+    }
   }
-  async auth(path, entity, options = {}) {
-    this.headers.set("Authorization", `Basic ${this.secret}`);
-    this.headers.set("Content-Type", "application/x-www-form-urlencoded");
-    const requestOptions = {
-      method: "POST",
-      headers: this.headers,
-      body: entity,
-      ...options
+  async #authorizationFor(request) {
+    if (request.auth === false || this.#authorization === void 0) return void 0;
+    return this.#authorization.get();
+  }
+  async #send(request, attempt, authorization, capture) {
+    const url = this.#url(request);
+    const headers = new Headers({ Accept: "application/json", ...request.headers });
+    const form = request.body instanceof URLSearchParams;
+    if (request.body !== void 0 && !headers.has("Content-Type")) {
+      headers.set("Content-Type", form ? "application/x-www-form-urlencoded" : "application/json");
+    }
+    if (authorization !== void 0) headers.set("Authorization", authorization);
+    const logContext = { service: request.service, method: request.method, path: request.path, attempt };
+    this.#log.emit("debug", "sabre.request.start", logContext);
+    const startedAt = Date.now();
+    let response;
+    if (capture !== void 0) capture.attempts++;
+    try {
+      response = await this.#config.fetch(url, {
+        method: request.method,
+        headers,
+        ...request.body === void 0 ? {} : { body: form ? String(request.body) : JSON.stringify(request.body) },
+        ...request.signal === void 0 ? {} : { signal: request.signal }
+      });
+    } catch (cause) {
+      if (isAbort(cause, request.signal)) throw cause;
+      const error = new SabreGatewayError(`${request.service}: fallo de red (${describe(cause)})`, {
+        protocol: "rest",
+        retryable: true,
+        cause
+      });
+      this.#log.emit("error", "sabre.request.end", { ...logContext, durationMs: Date.now() - startedAt, error });
+      throw error;
+    }
+    const text = await response.text();
+    if (capture !== void 0) capture.last = { status: response.status, headers: response.headers, body: text };
+    const body = parseBody(text);
+    const endContext = { ...logContext, status: response.status, durationMs: Date.now() - startedAt };
+    if (!response.ok) {
+      const error = gatewayError(request.service, response.status, body);
+      this.#log.emit("error", "sabre.request.end", { ...endContext, error });
+      throw error;
+    }
+    const serviceError = request.classify?.(body, response);
+    if (serviceError !== void 0) {
+      this.#log.emit("warn", "sabre.request.end", { ...endContext, error: serviceError });
+      throw serviceError;
+    }
+    this.#log.emit("info", "sabre.request.end", endContext);
+    return body;
+  }
+  #url(request) {
+    const path = request.path.startsWith("/") ? request.path : `/${request.path}`;
+    const url = new URL(path, this.#config.baseUrl);
+    for (const [key, value] of Object.entries(request.query ?? {})) {
+      if (value !== void 0) url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+};
+function parseBody(text) {
+  if (text === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return 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 }
+  });
+}
+function extractCode(body) {
+  if (typeof body !== "object" || body === null) return void 0;
+  for (const key of ["errorCode", "error"]) {
+    const value = body[key];
+    if (typeof value === "string" && value !== "") return value;
+  }
+  return void 0;
+}
+function isUnauthorized(error) {
+  return error instanceof SabreGatewayError && error.protocol === "rest" && error.status === 401;
+}
+function isAbort(error, signal) {
+  return signal?.aborted === true || error instanceof Error && error.name === "AbortError";
+}
+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);
     };
-    return this.fetchRequest(path, requestOptions);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/sabre.ts
+var Sabre = class {
+  #config;
+  #transport;
+  /** Servicios de Air: shopping, revalidación. */
+  air;
+  /** Booking Management: creación de reservas. */
+  booking;
+  constructor(config) {
+    this.#config = resolveConfig(config);
+    this.#transport = new RestTransport(this.#config);
+    const auth = new AuthManager(this.#config, this.#transport);
+    this.#transport.setAuthorizationProvider(auth.bearerProvider());
+    this.air = new Air(this.#transport);
+    this.booking = new BookingManagement(this.#transport);
   }
-  getSecret() {
-    if (!this.options.password) throw new Error("Missing Sabre password");
-    return btoa(`${this.userID()}:${btoa(this.options.password)}`);
+  get environment() {
+    return this.#config.environment;
   }
-  userID() {
-    return btoa(`V1:${this.options.username}:${this.options.organization}:${domain}`);
+  get baseUrl() {
+    return this.#config.baseUrl;
   }
 };
+
+// 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");
+  }
+  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 }];
+  }
+  return {
+    flights,
+    flightPricing: [
+      {
+        ...priceComparisons === void 0 ? {} : { priceComparisons },
+        qualifiers: {
+          passengersPricing,
+          ...fare.validatingCarrierCode === void 0 ? {} : { validatingAirlineCode: fare.validatingCarrierCode }
+        }
+      }
+    ]
+  };
+}
+function amount(value) {
+  return String(Math.round(value * 1e3) / 1e3);
+}
+
+// src/index.ts
+var VERSION = "0.3.0";
 export {
-  Sabre
+  Sabre,
+  SabreBusinessError,
+  SabreError,
+  SabreGatewayError,
+  SabreOrchestrationError,
+  SabreWarning,
+  VERSION,
+  buildBookingFlightDetails,
+  buildRevalidateItineraryRequest
 };
 //# sourceMappingURL=index.js.map