sabre-legacy-client/dist/index.js

Sabre Legacy Node.js SDK

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  ErrorInResponse: () => ErrorInResponse,
  FaultError: () => FaultError,
  SabreLegacy: () => Sabre
});
module.exports = __toCommonJS(index_exports);

// src/common/utils/get-sub-string.ts
function getSubString(strSearch, strBegin, strEnd, withEnd) {
  let strSub = "";
  const intBegin = strSearch.indexOf(strBegin);
  if (intBegin !== -1) {
    const startIndex = withEnd ? intBegin : intBegin + strBegin.length;
    const endIndex = strSearch.indexOf(strEnd, startIndex);
    if (endIndex !== -1) strSub = strSearch.substring(startIndex, endIndex + (withEnd ? strEnd.length : 0));
  }
  return strSub;
}

// package.json
var version = "0.1.10";

// src/config.ts
var defaultBaseUrl = "https://webservices.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_SOAP_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/common/helpers/binary-security-token.helper.ts
function binarySecurityToken(token) {
  return `<BinarySecurityToken EncodingType="Base64Binary" valueType="String">${token}</BinarySecurityToken>`;
}

// src/common/helpers/message-header.helper.ts
function messageHeader(payload) {
  const {
    from = "Agency",
    to = "SWS",
    conversationId: conversationId2 = "2021.01.DevStudio",
    action
  } = payload;
  return `<MessageHeader xmlns="http://www.ebxml.org/namespaces/messageHeader"><From><PartyId>${from}</PartyId></From><To><PartyId>${to}</PartyId></To><ConversationId>${conversationId2}</ConversationId><Action>${action}</Action></MessageHeader>`;
}

// src/common/helpers/security.helper.ts
function security(authorization) {
  return `<Security xmlns="http://schemas.xmlsoap.org/ws/2002/12/secext">${authorization}</Security>`;
}

// src/common/helpers/header.helper.ts
function header(payload) {
  const { action, conversationId: conversationId2, authorization } = payload;
  const binarySecurity = binarySecurityToken(authorization);
  return messageHeader({ action, conversationId: conversationId2 }) + security(binarySecurity);
}

// src/common/helpers/soap-env.helper.ts
function soapEnv(payload) {
  const { header: header2, body } = payload;
  return `<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"><SOAP-ENV:Header>${header2}</SOAP-ENV:Header><SOAP-ENV:Body>${body}</SOAP-ENV:Body></SOAP-ENV:Envelope>`;
}

// src/common/helpers/request.helper.ts
function request(payload) {
  const { action, conversationId: conversationId2, authorization, body } = payload;
  return soapEnv({
    header: header({ action, conversationId: conversationId2, authorization }),
    body
  });
}

// src/authentication/requests/ping.request.ts
function pingRequest(payload) {
  const body = '<OTA_PingRQ Version="1.0.0" xmlns="http://www.opentravel.org/OTA/2003/05"/>';
  return request({ body, action: "OTA_PingRQ" /* PING */, ...payload });
}

// src/authentication/helpers/username-token.helper.ts
function usernameToken(options2) {
  const { username, password, pcc, domain: domain2 } = options2;
  return `<UsernameToken><Username>${username}</Username><Password>${password}</Password><Organization>${pcc}</Organization><Domain>${domain2}</Domain></UsernameToken>`;
}

// src/authentication/requests/session-create.request.ts
function sessionCreateRequest(payload) {
  const { conversationId: conversationId2, authorization } = payload;
  const message = messageHeader({
    action: "SessionCreateRQ" /* SESSION_CREATE */,
    conversationId: conversationId2,
    to: "Sabre_API"
  });
  const header2 = message + security(usernameToken(authorization));
  const body = '<SessionCreateRQ returnContextID="true" Version="1.0.0" xmlns="http://www.opentravel.org/OTA/2002/11"/>';
  return soapEnv({ header: header2, body });
}

// src/authentication/requests/session-close.request.ts
function sessionCloseRequest(payload) {
  const body = '<SessionCloseRQ Version="1.0.0" xmlns="http://www.opentravel.org/OTA/2002/11"/>';
  return request({ body, action: "SessionCloseRQ" /* SESSION_CLOSE */, ...payload });
}

// src/authentication/requests/token-create.request.ts
function tokenCreateRequest(payload) {
  const { conversationId: conversationId2, authorization } = payload;
  const message = messageHeader({
    action: "TokenCreateRQ" /* TOKEN_CREATE */,
    conversationId: conversationId2,
    to: "Sabre_API"
  });
  const header2 = message + security(usernameToken(authorization));
  const body = '<TokenCreateRQ Version="1.0.0" xmlns="http://webservices.sabre.com"/>';
  return soapEnv({ header: header2, body });
}

// src/authentication/authentication..ts
var Authentication = class {
  constructor(sabre) {
    this.sabre = sabre;
  }
  /**
   * See https://developer.sabre.com/docs/soap_apis/session_management/create_session
   * @returns string
   */
  async sessionCreate() {
    this.sabre.setAction("SessionCreateRQ" /* SESSION_CREATE */);
    const xml = await this.sabre.auth(sessionCreateRequest);
    return xml;
  }
  /**
   * See https://developer.sabre.com/docs/soap_apis/session_management/close_session
   * @returns string
   */
  async sessionClose() {
    this.sabre.setAction("SessionCloseRQ" /* SESSION_CLOSE */);
    const xml = await this.sabre.post(sessionCloseRequest);
    return xml;
  }
  /**
   * See https://developer.sabre.com/docs/soap_apis/session_management/refresh_session
   * @returns string
   */
  async ping() {
    this.sabre.setAction("OTA_PingRQ" /* PING */);
    const xml = await this.sabre.post(pingRequest);
    return xml;
  }
  /**
   * See https://developer.sabre.com/docs/soap_apis/session_management/create_access_token
   * @returns string
   */
  async tokenCreate() {
    this.sabre.setAction("TokenCreateRQ" /* TOKEN_CREATE */);
    const xml = await this.sabre.auth(tokenCreateRequest);
    return xml;
  }
};

// src/currency/helpers/get-month-name-sabre.helper.ts
var ListMonth = /* @__PURE__ */ ((ListMonth2) => {
  ListMonth2[ListMonth2["JAN"] = 1] = "JAN";
  ListMonth2[ListMonth2["FEB"] = 2] = "FEB";
  ListMonth2[ListMonth2["MAR"] = 3] = "MAR";
  ListMonth2[ListMonth2["APR"] = 4] = "APR";
  ListMonth2[ListMonth2["MAY"] = 5] = "MAY";
  ListMonth2[ListMonth2["JUN"] = 6] = "JUN";
  ListMonth2[ListMonth2["JUL"] = 7] = "JUL";
  ListMonth2[ListMonth2["AUG"] = 8] = "AUG";
  ListMonth2[ListMonth2["SEP"] = 9] = "SEP";
  ListMonth2[ListMonth2["OCT"] = 10] = "OCT";
  ListMonth2[ListMonth2["NOV"] = 11] = "NOV";
  ListMonth2[ListMonth2["DEC"] = 12] = "DEC";
  return ListMonth2;
})(ListMonth || {});
var getMonthName = (month) => ListMonth[month];
var formatMonth = (month) => String(ListMonth[month]).padStart(2, "0");

// src/queue/common/utils/find-queue-line.ts
function findQueueLine(text) {
  if (!text) throw new Error("Missing text.");
  const LINE_REGEX = /(\w{4})\.(\w{4})\*(A{1}[A-Z0-9]{2})\s(\d{4})\/(\d{2}[A-Z]{3}\d{2})\s([A-Z0-9]{6})/g;
  const found = LINE_REGEX.exec(text);
  if (!found) throw new Error("Queue line not found");
  const [_, workPcc, homePcc, agent, time, date, bookingId] = found;
  return { workPcc, homePcc, agent, dateTime: `20${date.slice(5)}-${formatMonth(date.slice(2, 5))}-${date.slice(0, 2)}T${time.slice(0, 2)}:${time.slice(2)}`, bookingId };
}

// src/common/config/xml-parser.config.ts
var import_fast_xml_parser = require("fast-xml-parser");
var options = {
  textNodeName: "content",
  attributeNamePrefix: "",
  removeNSPrefix: true,
  ignoreAttributes: [/^xmlns:/, /^eb:/, /^soap-env:/, /^xmlns/, /^Version/],
  transformTagName: (tagName) => tagName[0].toLowerCase() + tagName.slice(1),
  transformAttributeName: (attributeName) => attributeName[0].toLowerCase() + attributeName.slice(1)
};
var parseXML = (() => {
  const parser = new import_fast_xml_parser.XMLParser(options);
  return (xml) => parser.parse(xml);
})();

// src/queue/common/utils/parse-xml-to-queue-access.ts
function parseXMLToQueueAccess(body) {
  const { queueAccessRS } = parseXML(body);
  return queueAccessRS;
}

// src/queue/common/utils/parse-xml-to-queue-count.ts
function parseXMLToQueueCount(body) {
  const { queueCountRS } = parseXML(body);
  return queueCountRS;
}

// src/queue/common/utils/parse-xml-to-queue-place.ts
function parseXMLToQueuePlace(body) {
  return parseXML(body).queuePlaceRS;
}

// src/queue/common/utils/parse-paragraph-to-warnings.ts
function parseParagraphToWarnings(payload) {
  const LIMIT_NOTIFICATIONS = 5;
  const WARNING_REGEX = /\d{3}\s{2}.+/g;
  return payload.text.slice(0, LIMIT_NOTIFICATIONS).filter((text) => text.match(WARNING_REGEX)).map((warningInLine) => {
    const [code, message] = warningInLine.split("  ");
    return { code, message };
  });
}

// src/queue/common/utils/parse-warnings-to-notifications.ts
function parseWarningsToNotifications(payload) {
  return payload.warnings.map((warning) => ({ queue: payload.queue, warning }));
}

// src/queue/common/utils/parse-access-rs-to-access.ts
function parseAccessResponseToAccess(context, accessResponse) {
  if (!accessResponse.line?.uniqueID?.iD) {
    throw new Error(accessResponse.applicationResults.error?.systemSpecificResults?.message || "Unknown error");
  }
  const { queueNumber: queue } = context;
  const { paragraph, line } = accessResponse;
  const warnings = parseParagraphToWarnings(paragraph);
  const notifications = parseWarningsToNotifications({ queue, warnings });
  return {
    dateTime: line.dateTime,
    agent: line.pOS.source.agentSine,
    pcc: line.pOS.source.pseudoCityCode,
    bookingId: line.uniqueID.iD,
    notifications,
    paragraph,
    queue
  };
}

// src/queue/common/utils/parse-place-rs-to-access.ts
function parsePlaceResponseToAccess(context, placeResponse) {
  if (!placeResponse.text) {
    throw new Error(placeResponse.applicationResults.error?.systemSpecificResults?.message || "Unknown error");
  }
  const { queueNumber: queue } = context;
  const warnings = parseParagraphToWarnings(placeResponse);
  const notifications = parseWarningsToNotifications({ queue, warnings });
  const { dateTime, agent, homePcc, bookingId } = findQueueLine(placeResponse.text.pop());
  return {
    dateTime,
    agent,
    pcc: homePcc,
    bookingId,
    notifications,
    paragraph: placeResponse,
    queue
  };
}

// src/queue/common/utils/parse-xml-to-queue-access-list.ts
function parseXMLToQueueAccessList(body) {
  const { queueAccessRS } = parseXML(body);
  return queueAccessRS;
}

// src/queue/common/utils/get-queue-booking-info.ts
function getQueueBookingInfo(text) {
  if (!text) throw new Error("Missing text.");
  const BOOKING_INFO_REGEX = /(\d+)\s+([A-Z0-9]{6})\s+(\w{3,})[\s|\/]+(\w{3,})\s+(\d{2}[A-Z]{3}\d{2})\s+(\d{4})\s+[1](.+)/g;
  const found = BOOKING_INFO_REGEX.exec(text);
  if (!found) throw new Error("Queue booking info not found");
  const [_, num, bookingId, pcc, agent, date, time, name] = found;
  return { num, bookingId, placeBy: `${pcc} ${agent}`, date: `20${date.slice(5)}-${formatMonth(date.slice(2, 5))}-${date.slice(0, 2)}T${time.slice(0, 2)}:${time.slice(2)}`, name };
}

// src/queue/common/utils/parse-access-list-rs-to-list.ts
function parseAccessListResponseToList(context, accessListResponse) {
  if (!accessListResponse.applicationResults?.success) {
    throw new Error(accessListResponse.applicationResults.error?.systemSpecificResults?.message || "Unknown error");
  }
  const { queueNumber: queue } = context;
  const { paragraph, line } = accessListResponse;
  return {
    lines: line ? line.map((qall) => ({
      index: qall.number,
      dateTime: qall.dateTime,
      passengerName: qall.passengerName,
      agent: qall.pOS.source.agentSine,
      pcc: qall.pOS.source.pseudoCityCode,
      bookingId: qall.uniqueID.iD
    })) : void 0,
    list: paragraph.text.slice(2, -1).map((text) => getQueueBookingInfo(text)),
    paragraph,
    queue
  };
}

// src/queue/common/helpers/queue-access.helper.ts
function queueAccess(queueInfo) {
  return `<QueueAccessRQ ReturnHostCommand="false" Version="2.1.0" xmlns="http://webservices.sabre.com/sabreXML/2011/10">${queueInfo}</QueueAccessRQ>`;
}

// src/queue/common/utils/parse-identifier-options-to-queue-identifier.ts
function parseIdentifierOptionsToQueueIdentifier(payload) {
  return {
    QueueIdentifier: {
      "$Number": payload.number,
      "$PrefatoryInstructionCode": payload.code,
      "$PseudoCityCode": payload.pcc,
      List: payload.ind ? {
        "$Ind": payload.ind,
        "$PrimaryPassenger": payload.primaryPassenger
      } : void 0
    }
  };
}

// src/queue/common/utils/builder-queue-identifier.ts
function builderQueueIdentifier(payload) {
  const QueueIdentifierObj = parseIdentifierOptionsToQueueIdentifier(payload);
  const { XMLBuilder } = require("fast-xml-parser");
  const options2 = {
    ignoreAttributes: false,
    attributeNamePrefix: "$",
    suppressBooleanAttributes: false,
    suppressEmptyNode: true
  };
  const builder = new XMLBuilder(options2);
  return builder.build(QueueIdentifierObj);
}

// src/queue/common/requests/access-list.request.ts
function accessListRequest(options2) {
  const { pcc, number, authorization, conversationId: conversationId2, primaryPassenger } = options2;
  const queueInfo = builderQueueIdentifier({ pcc, number, ind: true, primaryPassenger });
  const body = queueAccess(queueInfo);
  return request({
    body,
    authorization,
    conversationId: conversationId2,
    action: "QueueAccessLLSRQ" /* QUEUE_ACCESS */
  });
}

// src/queue/common/requests/access.request.ts
function accessRequest(options2) {
  const { pcc, number, authorization, conversationId: conversationId2 } = options2;
  const queueInfo = builderQueueIdentifier({ pcc, number });
  const body = queueAccess(queueInfo);
  return request({
    body,
    authorization,
    conversationId: conversationId2,
    action: "QueueAccessLLSRQ" /* QUEUE_ACCESS */
  });
}

// src/queue/common/helpers/queue-count.helper.ts
function queueCount(queueInfo) {
  return `<QueueCountRQ xmlns="http://webservices.sabre.com/sabreXML/2011/10" ReturnHostCommand="false" Version="2.2.1"><QueueInfo>${queueInfo}</QueueInfo></QueueCountRQ>`;
}

// src/queue/common/requests/count.request.ts
function countRequest(options2) {
  const { authorization, conversationId: conversationId2, pcc } = options2;
  const queueInfo = builderQueueIdentifier({ pcc });
  const body = queueCount(queueInfo);
  return request({
    body,
    authorization,
    conversationId: conversationId2,
    action: "QueueCountLLSRQ" /* QUEUE_COUNT */
  });
}

// src/queue/common/helpers/navigation-action.helper.ts
function navigationAction(action) {
  const queueInfo = `<Navigation Action="${action}"/>`;
  const body = queueAccess(queueInfo);
  return body;
}

// src/queue/common/requests/exit.request.ts
function exitRequest(options2) {
  const { authorization, conversationId: conversationId2 } = options2;
  const body = navigationAction("QXI" /* EXIT */);
  return request({ authorization, conversationId: conversationId2, body, action: "QueueAccessLLSRQ" /* QUEUE_ACCESS */ });
}

// src/queue/common/requests/ignore.request.ts
function ignoreRequest(options2) {
  const { authorization, conversationId: conversationId2 } = options2;
  const body = navigationAction("I" /* IGNORE */);
  return request({ authorization, conversationId: conversationId2, body, action: "QueueAccessLLSRQ" /* QUEUE_ACCESS */ });
}

// src/queue/common/helpers/queue-place.helper.ts
function queuePlace(queueInfo) {
  return `<QueuePlaceRQ ReturnHostCommand="false" Version="2.0.4" xmlns="http://webservices.sabre.com/sabreXML/2011/10"><QueueInfo>${queueInfo}</QueueInfo></QueuePlaceRQ>`;
}

// src/queue/common/requests/place.request.ts
function placeRequest(options2) {
  const { number, pcc, authorization, conversationId: conversationId2 } = options2;
  const queueInfo = builderQueueIdentifier({ number, code: "11", pcc });
  const body = queuePlace(queueInfo);
  return request({ body, authorization, conversationId: conversationId2, action: "QueuePlaceLLSRQ" /* QUEUE_PLACE */ });
}

// src/queue/common/requests/remove.request.ts
function removeRequest(options2) {
  const { authorization, conversationId: conversationId2 } = options2;
  const body = navigationAction("I" /* IGNORE */);
  return request({ authorization, conversationId: conversationId2, body, action: "QueueAccessLLSRQ" /* QUEUE_ACCESS */ });
}

// src/queue/queue.ts
var Queue = class {
  constructor(sabre) {
    this.sabre = sabre;
  }
  meta = {
    queue: ""
  };
  /**
   * List Queues
   * 
   * See https://developer.sabre.com/docs/soap_apis/management/queue/Get_Queue_Count
   * @param pcc string
   * @returns QueueCountResponse
   */
  async count(pcc) {
    if (!pcc) {
      if (typeof process !== "undefined" && process.env) {
        pcc = process.env.SABRE_ORGANIZATION;
      }
    }
    if (!pcc) throw new Error('Missing pcc. Set it in count("PCC")');
    this.sabre.setAction("QueueCountLLSRQ" /* QUEUE_COUNT */);
    const xml = await this.sabre.post((opts) => countRequest({
      pcc,
      ...opts
    }));
    return parseXMLToQueueCount(xml);
  }
  /**
   * Access queue 
   * 
   * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
   * @param payload QueueAccessOptions
   * @returns QueueAccessResponse
   */
  async access(payload) {
    if (!payload.pcc) {
      if (typeof process !== "undefined" && process.env) {
        payload.pcc = process.env.SABRE_ORGANIZATION;
      }
    }
    if (!payload.pcc) throw new Error("Missing pcc. Set it in access({ pcc, number })");
    const { number, pcc } = payload;
    this.sabre.setAction("QueueAccessLLSRS" /* QUEUE_ACCESS */);
    const xml = await this.sabre.post((opts) => accessRequest({
      number,
      pcc,
      ...opts
    }));
    this.meta.queue = number;
    const queueAccess2 = parseXMLToQueueAccess(xml);
    return parseAccessResponseToAccess({ queueNumber: this.meta.queue }, queueAccess2);
  }
  /**
   * Get PNR list from queue (Stateless)
   * 
   * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
   * @param payload QueueAccessListOptions
   * @returns QueueAccessListResponse
   */
  async accessList(payload) {
    if (!payload.pcc) {
      if (typeof process !== "undefined" && process.env) {
        payload.pcc = process.env.SABRE_ORGANIZATION;
      }
    }
    if (!payload.pcc) throw new Error("Missing pcc. Set it in access({ pcc, number })");
    const { number, pcc, primaryPassenger } = payload;
    this.sabre.setAction("QueueAccessLLSRS" /* QUEUE_ACCESS */);
    const xml = await this.sabre.post((opts) => accessListRequest({
      number,
      pcc,
      primaryPassenger,
      ...opts
    }));
    const queueAccessList = parseXMLToQueueAccessList(xml);
    return parseAccessListResponseToList({ queueNumber: number }, queueAccessList);
  }
  /**
   * Ignore PNR & Next
   * 
   * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
   * @returns QueueIgnoreResponse
   */
  async ignore() {
    this.sabre.setAction("QueueAccessLLSRS" /* QUEUE_ACCESS */);
    const xml = await this.sabre.post(ignoreRequest);
    const queueAccess2 = parseXMLToQueueAccess(xml);
    return parseAccessResponseToAccess({ queueNumber: this.meta.queue }, queueAccess2);
  }
  /**
   * Remove PNR & Next
   * 
   * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
   * @returns QueueRemoveResponse
   */
  async remove() {
    this.sabre.setAction("QueueAccessLLSRS" /* QUEUE_ACCESS */);
    const xml = await this.sabre.post(removeRequest);
    const queueAccess2 = parseXMLToQueueAccess(xml);
    return parseAccessResponseToAccess({ queueNumber: this.meta.queue }, queueAccess2);
  }
  /**
   * Ignore PNR & Exit
   * 
   * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
   * @returns QueueExitResponse
   */
  async exit() {
    this.sabre.setAction("QueueAccessLLSRS" /* QUEUE_ACCESS */);
    const xml = await this.sabre.post(exitRequest);
    const queueAccess2 = parseXMLToQueueAccess(xml);
    if (queueAccess2.applicationResults.error) {
      throw new Error(queueAccess2.applicationResults.error?.systemSpecificResults?.message);
    }
    return {
      paragraph: queueAccess2.paragraph
    };
  }
  /**
   * Queue Place "Stateful Single Queue"
   * 
   * See https://developer.sabre.com/docs/soap_apis/management/queue/Place_Queue_Message
   * @param payload QueuePlaceOptions
   * @returns QueuePlaceResponse
   */
  async place(payload) {
    if (!payload.pcc) {
      if (typeof process !== "undefined" && process.env) {
        payload.pcc = process.env.SABRE_ORGANIZATION;
      }
    }
    if (!payload.pcc) throw new Error("Missing pcc. Set it in place({ pcc, number })");
    const { number, pcc } = payload;
    this.sabre.setAction("QueuePlaceLLSRQ" /* QUEUE_PLACE */);
    const xml = await this.sabre.post((opts) => placeRequest({
      number,
      pcc,
      ...opts
    }));
    const queuePlace2 = parseXMLToQueuePlace(xml);
    return parsePlaceResponseToAccess({ queueNumber: this.meta.queue }, queuePlace2);
  }
};

// src/daily-sales/common/requests/report.request.ts
function reportRequest(options2) {
  const { pcc, date, authorization, conversationId: conversationId2 } = options2;
  const body = `<DailySalesReportRQ ReturnHostCommand="false" Version="2.0.0" xmlns="http://webservices.sabre.com/sabreXML/2011/10"><SalesReport PseudoCityCode="${pcc}" StartDate="${date}"/></DailySalesReportRQ>`;
  return request({
    body,
    action: "DailySalesReportLLSRQ" /* DAILY_SALES_REPORT */,
    authorization,
    conversationId: conversationId2
  });
}

// src/daily-sales/common/utils/parse-summary-options-to-selection-criteria.ts
function parseSummaryOptionsToSelectionCriteria(payload) {
  return {
    PseudoCityCode: payload.pcc,
    ReportDate: payload.date,
    DocumentNumber: payload.documentNumber,
    SettlementType: payload.settlementType,
    DocumentType: payload.documentType,
    Airline: payload.airline?.code || payload.airline?.number ? {
      AirlineCode: payload.airline.code,
      AirlineNumber: payload.airline.number
    } : void 0
  };
}

// src/daily-sales/common/utils/parse-summary-options-to-xml.ts
function parseSummaryOptionsToXML(payload) {
  const SelectionCriteria = parseSummaryOptionsToSelectionCriteria(payload);
  const { XMLBuilder } = require("fast-xml-parser");
  const builder = new XMLBuilder();
  return builder.build({ SelectionCriteria });
}

// src/daily-sales/common/requests/summary.request.ts
function summaryRequest(options2) {
  const { authorization, conversationId: conversationId2, ...summaryOptions } = options2;
  const selectionCriteria = parseSummaryOptionsToXML(summaryOptions);
  const body = `<DailySalesSummaryRQ version="1.2.2" xmlns="http://www.sabre.com/ns/Ticketing/AsrServices/1.0"><Header/>${selectionCriteria}</DailySalesSummaryRQ>`;
  return request({
    body,
    action: "TKT_TravelAgencyReportsRQ" /* AGENCY_REPORT */,
    authorization,
    conversationId: conversationId2
  });
}

// src/daily-sales/common/utils/parse-xml-to-daily-sales-summary.ts
function parseXMLToDailySalesSummary(payload) {
  return parseXML(payload).dailySalesSummaryRS;
}

// src/daily-sales/common/utils/parse-xml-to-daily-sales-report.ts
function parseXMLToDailySalesReport(payload) {
  return parseXML(payload).dailySalesReportRS;
}

// src/daily-sales/daily-sales.ts
var DailySales = class {
  constructor(sabre) {
    this.sabre = sabre;
  }
  /**
   * See https://developer.sabre.com/docs/soap_apis/air/fulfill/Get_Sales_Reports
   * @param payload ReportOptions
   * @returns DailySalesReportRS
   */
  async report(payload) {
    if (!payload.pcc) {
      if (typeof process !== "undefined" && process.env) {
        payload.pcc = process.env.SABRE_ORGANIZATION;
      }
    }
    if (!payload.pcc) throw new Error("Missing pcc. Set it in report({ pcc, number })");
    const { pcc, date } = payload;
    this.sabre.setAction("DailySalesReportLLSRQ" /* DAILY_SALES_REPORT */);
    const xml = await this.sabre.post((headersPayload) => reportRequest({ pcc, date, ...headersPayload }));
    return parseXMLToDailySalesReport(xml);
  }
  /**
   * See https://developer.sabre.com/docs/soap_apis/air/fulfill/display_audit_trail
   * @param payload 
   * @returns DailySalesSummaryRS
   */
  async summary(payload) {
    if (!payload.pcc) {
      if (typeof process !== "undefined" && process.env) {
        payload.pcc = process.env.SABRE_ORGANIZATION;
      }
    }
    if (!payload.pcc) throw new Error("Missing pcc. Set it in summary({ pcc, ... })");
    const { pcc } = payload;
    this.sabre.setAction("DailySalesReportLLSRQ" /* DAILY_SALES_REPORT */);
    const xml = await this.sabre.post((headersPayload) => summaryRequest({ pcc, ...payload, ...headersPayload }));
    return parseXMLToDailySalesSummary(xml);
  }
};

// src/common/utils/fault-error.ts
var FaultError = class extends Error {
  constructor(message) {
    super(message);
    this.name = "FaultError";
  }
};

// src/common/utils/error-in-response.ts
var ErrorInResponse = class extends Error {
  constructor(message) {
    super(message);
    this.name = "ErrorInResponse";
  }
};

// src/common/utils/parse-xml-to-sabre-command.ts
function parseXMLToSabreCommand(payload) {
  return parseXML(payload).sabreCommandLLSRS;
}

// src/common/helpers/sabre-command.helper.ts
function sabreCommand(command) {
  return `<SabreCommandLLSRQ xmlns="http://webservices.sabre.com/sabreXML/2011/10" ReturnHostCommand="true" Version="2.0.0"><Request Output="SCREEN"><HostCommand>${command}</HostCommand></Request></SabreCommandLLSRQ>`;
}

// src/currency/helpers/format-date-sabre.helper.ts
function formatDateSabre(date) {
  const dateSplit = date.split("-");
  const monthNumber = parseInt(dateSplit[1]);
  const numberValid = monthNumber >= 1 && monthNumber <= 12;
  if (!numberValid) {
    throw new Error("Month is not valid:" + monthNumber);
  }
  const month = monthNumber;
  const year = dateSplit[0].slice(2, 4);
  return dateSplit[2] + getMonthName(month) + year;
}

// src/currency/helpers/format-currency-command.helper.ts
function formatCurrencyCommand(options2) {
  const { from, to, date } = options2;
  const dateFormatted = formatDateSabre(date);
  const command = `DC\xA5${from}1/${to}/${dateFormatted}`;
  return command;
}

// src/currency/requests/currency.request.ts
function currencyRequest(options2) {
  const { authorization, conversationId: conversationId2 } = options2;
  const body = sabreCommand(formatCurrencyCommand(options2));
  return request({
    body,
    authorization,
    conversationId: conversationId2,
    action: "SabreCommandLLSRQ" /* SABRE_COMMAND */
  });
}

// src/currency/currency.ts
var Currency = class {
  constructor(sabre) {
    this.sabre = sabre;
  }
  /**
   * See https://developer.sabre.com/docs/soap_apis/management/utility/Send_Sabre_Command
   * Sabre equivalent command -> DC¥USD1/MXN/19MAR25
   */
  async conversion(payload) {
    this.sabre.setAction("SabreCommandLLSRQ" /* SABRE_COMMAND */);
    const { from, to, date } = payload;
    const xml = await this.sabre.post((headersPayload) => currencyRequest({ from, to, date, ...headersPayload }));
    return parseXMLToSabreCommand(xml);
  }
};

// src/sabre.ts
var Sabre = class {
  constructor(options2 = {}) {
    this.options = options2;
    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 SabreLegacy authorization. Pass it to the constructor new SabreLegacy({
        username: '773400', 
        password: 'PASSWORD_GOES_HERE',
        organization: '7TZA', // pcc
      });})`);
    }
    this.headers = new Headers({
      "User-Agent": userAgent,
      "Content-Type": 'text/xml; charset="utf-8"',
      "Content-Encoding": "deflate"
    });
    this.headersRequest = {
      conversationId,
      authorization: ""
    };
  }
  headers;
  headersRequest;
  lastReq = {};
  authentication = new Authentication(this);
  queue = new Queue(this);
  dailySales = new DailySales(this);
  currency = new Currency(this);
  setAction(action) {
    this.headers.set("SOAPAction", action);
  }
  setAuthorization(token) {
    this.headersRequest.authorization = token;
    this.headers.set("Authorization", `Bearer ${token}`);
  }
  getAuthorization() {
    return this.headersRequest.authorization;
  }
  getLastRequest() {
    return this.lastReq;
  }
  async fetchRequest(options2 = {}) {
    this.lastReq = options2;
    try {
      const response = await fetch(baseUrl, options2);
      const xml = await response.text();
      if (!response.ok) {
        const fault = getSubString(xml, "<faultstring>", "</faultstring>", false);
        throw new FaultError(fault);
      }
      const body = getSubString(xml, "<soap-env:Body>", "</soap-env:Body>", false);
      const error = getSubString(body, "<stl:Error>", "</stl:Error>", false);
      if (error) {
        const message = getSubString(error, "<stl:Message>", "</stl:Message>", false);
        throw new ErrorInResponse(message);
      }
      const action = this.headers.get("SOAPAction");
      if (action === "SessionCreateRQ" /* SESSION_CREATE */ || action === "TokenCreateRQ" /* TOKEN_CREATE */) {
        const token = getSubString(xml, '<wsse:BinarySecurityToken valueType="String" EncodingType="wsse:Base64Binary">', "</wsse:BinarySecurityToken>", false);
        this.setAuthorization(token);
      } else if (action === "SessionCloseRQ" /* SESSION_CLOSE */) {
        this.headersRequest.authorization = "";
        this.headers.delete("Authorization");
      }
      return body;
    } catch (error) {
      if (error instanceof FaultError || error instanceof ErrorInResponse) {
        throw error;
      }
      throw error instanceof Error ? error : new Error("Unknown error");
    }
  }
  async post(handlerRequest, options2 = {}) {
    if (!this.headersRequest.authorization) throw new Error('Missing authorization. Set it in setAuthorization("TOKEN")');
    const requestOptions = {
      method: "POST",
      headers: this.headers,
      body: handlerRequest(this.headersRequest),
      ...options2
    };
    return this.fetchRequest(requestOptions);
  }
  async auth(handlerRequest, options2 = {}) {
    if (!this.options.username || !this.options.password || !this.options.organization)
      throw new Error('Missing authorization. Pass it to the constructor `new LegacySabre("USERNAME", "PASSWORD", "ORGANIZATION")');
    const requestOptions = {
      method: "POST",
      headers: this.headers,
      body: handlerRequest({
        conversationId,
        authorization: {
          username: this.options.username,
          password: this.options.password,
          pcc: this.options.organization,
          domain
        }
      }),
      ...options2
    };
    return this.fetchRequest(requestOptions);
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ErrorInResponse,
  FaultError,
  SabreLegacy
});