sabre-legacy-client/dist/index.d.ts

Sabre Legacy Node.js SDK

declare enum ActionsRQ {
    SESSION_CREATE = "SessionCreateRQ",
    SESSION_CLOSE = "SessionCloseRQ",
    TOKEN_CREATE = "TokenCreateRQ",
    QUEUE_COUNT = "QueueCountLLSRQ",
    QUEUE_ACCESS = "QueueAccessLLSRQ",
    QUEUE_PLACE = "QueuePlaceLLSRQ",
    AGENCY_REPORT = "TKT_TravelAgencyReportsRQ",
    DAILY_SALES_REPORT = "DailySalesReportLLSRQ",
    PING = "OTA_PingRQ",
    ENCODE_DECODE = "EncodeDecodeLLSRQ",
    SABRE_COMMAND = "SabreCommandLLSRQ",
    READ_PROFILE = "EPS_EXT_ProfileReadRQ"
}
declare enum ActionsRS {
    SESSION_CLOSE = "SessionCloseRS",
    QUEUE_ACCESS = "QueueAccessLLSRS"
}

type Actions = ActionsRQ | ActionsRS;
interface SabreOptions {
    token?: string;
    username?: string;
    password?: string;
    organization?: string;
}
interface FetchRequestOptions {
    method: 'POST';
    headers: Headers;
    body: string;
}

interface PostOptions {
    query?: {
        [key: string]: unknown;
    };
}

interface HeadersRequestOptions {
    authorization: string;
    conversationId: string;
}

declare class Authentication {
    private readonly sabre;
    constructor(sabre: Sabre);
    /**
     * See https://developer.sabre.com/docs/soap_apis/session_management/create_session
     * @returns string
     */
    sessionCreate(): Promise<string>;
    /**
     * See https://developer.sabre.com/docs/soap_apis/session_management/close_session
     * @returns string
     */
    sessionClose(): Promise<string>;
    /**
     * See https://developer.sabre.com/docs/soap_apis/session_management/refresh_session
     * @returns string
     */
    ping(): Promise<string>;
    /**
     * See https://developer.sabre.com/docs/soap_apis/session_management/create_access_token
     * @returns string
     */
    tokenCreate(): Promise<string>;
}

interface BookingText {
    text: string[];
}

interface ApplicationResults {
    success: {
        systemSpecificResults?: {
            hostCommad?: {
                content: string;
                lNIATA: string;
            };
        };
        timeStamp: string;
    };
    error?: {
        systemSpecificResults?: {
            hostCommad?: {
                content: string;
                lNIATA: string;
            };
            message?: string;
            shortText?: string;
        };
        type: string;
        timeStamp: string;
    };
    warning?: {
        systemSpecificResults?: {
            hostCommad?: {
                content: string;
                lNIATA: string;
            };
            message?: string;
            shortText?: string;
        };
        type: string;
    };
    status: string;
}

interface Warning {
    code: string;
    message: string;
}

interface QueueNotification {
    queue: string;
    warning: Warning;
}

interface BookingClassify {
    isTicketed: boolean;
    flightStatuses: string[];
    allCancelled: boolean;
    ticketingDeadline: Date | null;
    deadlineExpired: boolean;
    action: 'place' | 'remove';
}

interface BookingSource {
    agentSine: string;
    pseudoCityCode: string;
}

interface QueueContext {
    queueNumber: string;
}

interface QueueAccess {
    bookingId: string;
    dateTime: string;
    notifications: QueueNotification[];
    context: QueueContext;
    paragraph: BookingText;
    source: BookingSource;
    classify: BookingClassify;
}

interface QueueCountRS {
    applicationResults: ApplicationResults;
    queueInfo: QueueInfo;
    total: QueueTotal[];
}
interface QueueInfo {
    queueIdentifier: QueueIdentifier[];
    dateTime: string;
    pseudoCityCode: string;
}
interface QueueIdentifier {
    count: string;
    number: string;
}
interface QueueTotal {
    count: string;
    type: 'MESSAGE' | 'SPECIALS' | 'PNRS';
}

interface LineInfo {
    index: string;
    dateTime: string;
    passengerName?: string;
    agent: string;
    pcc: string;
    bookingId: string;
}
interface QueueBookingInfo {
    num: string;
    bookingId: string;
    date: string;
    placeBy: string;
    name?: string;
}
interface QueueAccessList {
    lines?: Array<LineInfo>;
    list: Array<QueueBookingInfo>;
    paragraph: BookingText;
    queue: string;
}

interface QueueAccessOptions {
    number: string;
    pcc?: string;
}
interface QueueAccessResponse extends QueueAccess {
}

interface QueueCountResponse extends QueueCountRS {
}

interface QueueIgnoreResponse extends QueueAccessResponse {
}

interface QueuePlaceOptions extends QueueAccessOptions {
}
interface QueuePlaceResponse extends QueueAccessResponse {
}

interface QueueRemoveResponse extends QueueAccessResponse {
}

interface QueueExitResponse {
    paragraph: BookingText;
}

interface QueueAccessListOptions extends QueueAccessOptions {
    primaryPassenger?: boolean;
}
interface QueueAccessListResponse extends QueueAccessList {
}

declare class Queue {
    private readonly sabre;
    private readonly meta;
    constructor(sabre: Sabre);
    /**
     * List Queues
     *
     * See https://developer.sabre.com/docs/soap_apis/management/queue/Get_Queue_Count
     * @param pcc string
     * @returns QueueCountResponse
     */
    count(pcc?: string): Promise<QueueCountResponse>;
    /**
     * Access queue
     *
     * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
     * @param payload QueueAccessOptions
     * @returns QueueAccessResponse
     */
    access(payload: QueueAccessOptions): Promise<QueueAccessResponse>;
    /**
     * Get PNR list from queue (Stateless)
     *
     * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
     * @param payload QueueAccessListOptions
     * @returns QueueAccessListResponse
     */
    accessList(payload: QueueAccessListOptions): Promise<QueueAccessListResponse>;
    /**
     * Ignore PNR & Next
     *
     * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
     * @returns QueueIgnoreResponse
     */
    ignore(): Promise<QueueIgnoreResponse>;
    /**
     * Remove PNR & Next
     *
     * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
     * @returns QueueRemoveResponse
     */
    remove(): Promise<QueueRemoveResponse>;
    /**
     * Ignore PNR & Exit
     *
     * See https://developer.sabre.com/docs/soap_apis/management/queue/Access_Queue
     * @returns QueueExitResponse
     */
    exit(): Promise<QueueExitResponse>;
    /**
     * Queue Place "Stateful Single Queue"
     *
     * See https://developer.sabre.com/docs/soap_apis/management/queue/Place_Queue_Message
     * @param payload QueuePlaceOptions
     * @returns QueuePlaceResponse
     */
    place(payload: QueuePlaceOptions): Promise<QueuePlaceResponse>;
}

interface ReportOptions {
    date: string;
    pcc?: string;
}
interface DailySalesReportResponseSuccess {
    dailySalesReportRS: DailySalesReportRS;
}
interface DailySalesReportRS {
    applicationResults: ApplicationResults;
    salesReport?: SalesReport;
}
interface SalesReport {
    creationDetails: {
        source: {
            agencyName: string;
            createDateTime: string;
            pseudoCityCode: string;
        };
    };
    issuanceData?: IssuanceData[];
}
interface IssuanceData {
    agentSine: string;
    commission: string;
    documentType: string;
    domesticInternational: string;
    indicatorOne: string;
    indicatorTwo: string;
    issueTime: string;
    itineraryRef: string;
    stockItemCount: string;
    ticketPrinter: string;
    ticketStock: string;
    payment: Payment[];
    personName?: string;
    ticketingInfo?: TicketingInfo;
    ticketingFees?: TicketingFees;
}
interface Payment {
    form: {
        content: string;
        amount: string;
        currencyCode: string;
    };
}
interface TicketingInfo {
    ticketing?: {
        conjunctiveCount: string;
        eTicketNumber: string;
        ind: string;
        invoiceNumber: string;
        statusCode: string;
        usedCount: string;
    };
}
interface TicketingFees {
    feeInformation?: {
        amount: string;
        guaranteeType: string;
    };
}

declare const CUPON_TYPE: {
    readonly F: "F";
    readonly P: "P";
    readonly E: "E";
};
type CuponType = keyof typeof CUPON_TYPE;

declare const DOCUMENT_TYPE: {
    readonly TKT: "TKT";
    readonly EMD: "EMD";
    readonly RFEMD: "RFEMD";
    readonly RFND: "RFND";
    readonly MCO: "MCO";
};
type DocumentType = keyof typeof DOCUMENT_TYPE;

declare const SETTLEMENT_TYPE: {
    readonly TAT: "TAT";
    readonly TCH: "TCH";
    readonly TKT: "TKT";
};
type SettlementType = keyof typeof SETTLEMENT_TYPE;

declare const TRANSACTION_TYPE: {
    readonly SALE: "SALE";
    readonly CNCL: "CNCL";
    readonly RFND: "RFND";
    readonly VOID: "VOID";
};
type TransactionType = keyof typeof TRANSACTION_TYPE;

interface SummaryOptions {
    date: string;
    pcc?: string;
    airline?: {
        code?: string;
        number?: string;
    };
    settlementType?: SettlementType;
    documentType?: DocumentType;
    documentNumber?: string;
}
interface DailySalesSummaryResponseSuccess {
    dailySalesSummaryRS: DailySalesSummaryRS;
}
interface DailySalesSummaryRS {
    header: Header;
    dSHeader: DSHeader;
    dailySalesReport: DailySalesReport;
    version: string;
    isQueryStillRunning: string;
}
interface Header {
    orchestrationID: {
        content: string;
        seq: string;
    };
    results: {
        success: {
            system: string;
        };
    };
    messageID: string;
}
interface DSHeader {
    pseudoCityCode: string;
    agencyName: string;
}
interface DailySalesReport {
    reportDate: string;
    transaction?: Array<Transaction>;
    totalDailySales: TotalDailySales;
}
interface Transaction {
    nonInteractive?: string;
    electronicDocument?: string;
    itineraryType?: string;
    documentType: DocumentType;
    settlementType: SettlementType;
    pnrLocator?: string;
    passengerName?: string;
    documentDetails: {
        documentNumber: string;
        stockType?: string;
        documentStatusCode?: string;
        stockDetails?: {
            cuponType: CuponType;
        };
        transactionCode: TransactionType;
    };
    airlineCode: {
        content: string;
        airlineNumber: string;
    };
    commission?: {
        amount: string;
        percent: string;
    };
    payments?: {
        currencyCode: {
            value: string;
            decimalPlace: string;
        };
        documentPayment: {
            paymentTotal: string;
            paymentDetail: {
                fop: string;
                category: string;
                cardType?: string;
                paymentAmount: string;
            };
        };
    };
    agentSine: string;
    agentPseudoCity: string;
    transactionDateTime: string;
}
interface TotalDailySales {
    transactionType: TransactionType;
    salesBySettlement: {
        settlementType: SettlementType;
        saleTotals: {
            currencyCode: string;
            cashTotals: {
                content: number;
                count: string;
            };
            creditTotals: {
                content: number;
                count: string;
            };
            commissionTotals: {
                content: number;
                count: string;
            };
        };
    };
}

declare class DailySales {
    private readonly sabre;
    constructor(sabre: Sabre);
    /**
     * See https://developer.sabre.com/docs/soap_apis/air/fulfill/Get_Sales_Reports
     * @param payload ReportOptions
     * @returns DailySalesReportRS
     */
    report(payload: ReportOptions): Promise<DailySalesReportRS>;
    /**
     * See https://developer.sabre.com/docs/soap_apis/air/fulfill/display_audit_trail
     * @param payload
     * @returns DailySalesSummaryRS
     */
    summary(payload: SummaryOptions): Promise<DailySalesSummaryRS>;
}

interface UsernameTokenOptions {
    username: string;
    password: string;
    pcc: string;
    domain?: string;
    clientId?: string;
    clientSecret?: string;
}

interface SessionCreateOptions {
    authorization: UsernameTokenOptions;
    conversationId: string;
}

interface SabreCommandResponseSuccess {
    sabreCommandLLSRS: SabreCommandLLSRS;
}
interface SabreCommandLLSRS {
    applicationResults: ApplicationResults;
    response?: string;
}

interface CurrencyConversionOptions {
    from: string;
    to: string;
    date: string;
}

declare class Currency {
    private readonly sabre;
    constructor(sabre: Sabre);
    /**
     * See https://developer.sabre.com/docs/soap_apis/management/utility/Send_Sabre_Command
     * Sabre equivalent command -> DC¥USD1/MXN/19MAR25
     */
    conversion(payload: CurrencyConversionOptions): Promise<SabreCommandLLSRS>;
}

declare class Sabre {
    private readonly options;
    private readonly headers;
    private readonly headersRequest;
    private lastReq;
    private lastRes;
    readonly authentication: Authentication;
    readonly queue: Queue;
    readonly dailySales: DailySales;
    readonly currency: Currency;
    constructor(options?: SabreOptions);
    setAction(action: Actions): void;
    setAuthorization(token: string): void;
    getAuthorization(): string;
    getLastRequest(): {} | FetchRequestOptions;
    getLastResponse(): string;
    fetchRequest(options?: FetchRequestOptions | {}): Promise<string>;
    post(handlerRequest: (payload: HeadersRequestOptions) => string, options?: PostOptions): Promise<string>;
    auth(handlerRequest: (payload: SessionCreateOptions) => string, options?: PostOptions): Promise<string>;
}

declare class ErrorInResponse extends Error {
    constructor(message: string);
}

declare class FaultError extends Error {
    constructor(message: string);
}

export { type Actions, type CurrencyConversionOptions, type DailySalesReportRS, type DailySalesReportResponseSuccess, type DailySalesSummaryRS, type DailySalesSummaryResponseSuccess, ErrorInResponse, FaultError, type FetchRequestOptions, type QueueAccessListOptions, type QueueAccessListResponse, type QueueAccessOptions, type QueueAccessResponse, type QueueCountResponse, type QueueExitResponse, type QueueIgnoreResponse, type QueuePlaceOptions, type QueuePlaceResponse, type QueueRemoveResponse, type ReportOptions, type SabreCommandLLSRS, type SabreCommandResponseSuccess, Sabre as SabreLegacy, type SabreOptions, type SummaryOptions };