@vendit-dev/thirdparty-adapters 0.7.6 → 0.7.8

package/lib/types/common.d.ts

@@ -0,0 +1,385 @@
+/// <reference types="node" />
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Checks whether the type is never
+ * @typeParam T - type which may be never
+ * ```
+ * IsAny<never> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+export type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+interface File extends Blob {
+    readonly lastModified: number;
+    readonly name: string;
+}
+interface FileList {
+    readonly length: number;
+    item(index: number): File | null;
+    [index: number]: File;
+}
+export type BrowserNativeObject = Date | FileList | File;
+/**
+ * Type alias to `string` which describes a lodash-like path through an object.
+ * E.g. `'foo.bar.0.baz'`
+ */
+export type PathString = string;
+/**
+ * Type which can be traversed through with a {@link PathString}.
+ * I.e. objects, arrays, and tuples
+ */
+export type Traversable = object;
+/**
+ * Type to query whether an array type T is a tuple type.
+ * @typeParam T - type which may be an array or tuple
+ * @example
+ * ```
+ * IsTuple<[number]> = true
+ * IsTuple<number[]> = false
+ * ```
+ */
+export type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
+/**
+ * Type which can be used to index an array or tuple type.
+ */
+export type ArrayKey = number;
+/**
+ * Type which can be used to index an object.
+ */
+export type Key = string;
+/**
+ * Type to assert that a type is a {@link Key}.
+ * @typeParam T - type which may be a {@link Key}
+ */
+export type AsKey<T> = Extract<T, Key>;
+/**
+ * Type to convert a type to a {@link Key}.
+ * @typeParam T - type which may be converted to a {@link Key}
+ */
+export type ToKey<T> = T extends ArrayKey ? `${T}` : AsKey<T>;
+/**
+ * Type which describes a path through an object
+ * as a list of individual {@link Key}s.
+ */
+export type PathTuple = Key[];
+/**
+ * Type to assert that a type is a {@link PathTuple}.
+ * @typeParam T - type which may be a {@link PathTuple}
+ */
+export type AsPathTuple<T> = Extract<T, PathTuple>;
+/**
+ * Type to intersect a union type.
+ * See https://fettblog.eu/typescript-union-to-intersection/
+ * @typeParam U - union
+ * @example
+ * ```
+ * UnionToIntersection<{ foo: string } | { bar: number }>
+ *   = { foo: string; bar: number }
+ * ```
+ */
+export type UnionToIntersection<U> = (U extends any ? (_: U) => any : never) extends (_: infer I) => any ? I : never;
+/**
+ * Type which appends a {@link Key} to the {@link PathTuple} only if it is not
+ * blank, i.e. not the empty string.
+ * @typeParam PT - path
+ * @typeParam K  - key
+ * @example
+ * ```
+ * AppendNonBlankKey<['foo'], 'bar'> = ['foo', 'bar']
+ * AppendNonBlankKey<['foo'], ''> = ['foo']
+ * ```
+ */
+type AppendNonBlankKey<PT extends PathTuple, K extends Key> = K extends '' ? PT : [...PT, K];
+/**
+ * Type to implement {@link SplitPathString} tail recursively.
+ * @typeParam PS - remaining {@link PathString} which should be split into its
+ *                 individual {@link Key}s
+ * @typeParam PT - accumulator of the {@link Key}s which have been split from
+ *                 the original {@link PathString} already
+ */
+type SplitPathStringImpl<PS extends PathString, PT extends PathTuple> = PS extends `${infer K}.${infer R}` ? SplitPathStringImpl<R, AppendNonBlankKey<PT, K>> : AppendNonBlankKey<PT, PS>;
+/**
+ * Type to split a {@link PathString} into a {@link PathTuple}.
+ * The individual {@link Key}s may be empty strings.
+ * @typeParam PS  - {@link PathString} which should be split into its
+ *                  individual {@link Key}s
+ * @example
+ * ```
+ * SplitPathString<'foo'> = ['foo']
+ * SplitPathString<'foo.bar.0.baz'> = ['foo', 'bar', '0', 'baz']
+ * SplitPathString<'.'> = []
+ * ```
+ */
+export type SplitPathString<PS extends PathString> = SplitPathStringImpl<PS, [
+]>;
+/**
+ * Type to implement {@link JoinPathTuple} tail-recursively.
+ * @typeParam PT - remaining {@link Key}s which needs to be joined
+ * @typeParam PS - accumulator of the already joined {@link Key}s
+ */
+type JoinPathTupleImpl<PT extends PathTuple, PS extends PathString> = PT extends [infer K, ...infer R] ? JoinPathTupleImpl<AsPathTuple<R>, `${PS}.${AsKey<K>}`> : PS;
+/**
+ * Type to join a {@link PathTuple} to a {@link PathString}.
+ * @typeParam PT - {@link PathTuple} which should be joined.
+ * @example
+ * ```
+ * JoinPathTuple<['foo']> = 'foo'
+ * JoinPathTuple<['foo', 'bar', '0', 'baz']> = 'foo.bar.0.baz'
+ * JoinPathTuple<[]> = never
+ * ```
+ */
+export type JoinPathTuple<PT extends PathTuple> = PT extends [
+    infer K,
+    ...infer R
+] ? JoinPathTupleImpl<AsPathTuple<R>, AsKey<K>> : never;
+/**
+ * Type which converts all keys of an object to {@link Key}s.
+ * @typeParam T - object type
+ * @example
+ * ```
+ * MapKeys<{0: string}> = {'0': string}
+ * ```
+ */
+type MapKeys<T> = {
+    [K in keyof T as ToKey<K>]: T[K];
+};
+/**
+ * Type to access a type by a key.
+ *  - Returns undefined if it can't be indexed by that key.
+ *  - Returns null if the type is null.
+ *  - Returns undefined if the type is not traversable.
+ * @typeParam T - type which is indexed by the key
+ * @typeParam K - key into the type
+ * ```
+ * TryAccess<{foo: string}, 'foo'> = string
+ * TryAccess<{foo: string}, 'bar'> = undefined
+ * TryAccess<null, 'foo'> = null
+ * TryAccess<string, 'foo'> = undefined
+ * ```
+ */
+type TryAccess<T, K> = K extends keyof T ? T[K] : T extends null ? null : undefined;
+/**
+ * Type to access an array type by a key.
+ * Returns undefined if the key is non-numeric.
+ * @typeParam T - type which is indexed by the key
+ * @typeParam K - key into the type
+ * ```
+ * TryAccessArray<string[], '0'> = string
+ * TryAccessArray<string[], 'foo'> = undefined
+ * ```
+ */
+type TryAccessArray<T extends ReadonlyArray<any>, K extends Key> = K extends `${ArrayKey}` ? T[number] : TryAccess<T, K>;
+/**
+ * Type to evaluate the type which the given key points to.
+ * @typeParam T - type which is indexed by the key
+ * @typeParam K - key into the type
+ * @example
+ * ```
+ * EvaluateKey<{foo: string}, 'foo'> = string
+ * EvaluateKey<[number, string], '1'> = string
+ * EvaluateKey<string[], '1'> = string
+ * ```
+ */
+export type EvaluateKey<T, K extends Key> = T extends ReadonlyArray<any> ? IsTuple<T> extends true ? TryAccess<T, K> : TryAccessArray<T, K> : TryAccess<MapKeys<T>, K>;
+/**
+ * Type to evaluate the type which the given path points to.
+ * @typeParam T  - deeply nested type which is indexed by the path
+ * @typeParam PT - path into the deeply nested type
+ * @example
+ * ```
+ * EvaluatePath<{foo: {bar: string}}, ['foo', 'bar']> = string
+ * EvaluatePath<[number, string], ['1']> = string
+ * EvaluatePath<number, []> = number
+ * EvaluatePath<number, ['foo']> = undefined
+ * ```
+ */
+export type EvaluatePath<T, PT extends PathTuple> = PT extends [
+    infer K,
+    ...infer R
+] ? EvaluatePath<EvaluateKey<T, AsKey<K>>, AsPathTuple<R>> : T;
+/**
+ * Type which given a tuple type returns its own keys, i.e. only its indices.
+ * @typeParam T - tuple type
+ * @example
+ * ```
+ * TupleKeys<[number, string]> = '0' | '1'
+ * ```
+ */
+export type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
+/**
+ * Type which extracts all numeric keys from an object.
+ * @typeParam T - type
+ * @example
+ * ```
+ * NumericObjectKeys<{0: string, '1': string, foo: string}> = '0' | '1'
+ * ```
+ */
+type NumericObjectKeys<T extends Traversable> = ToKey<Extract<keyof T, ArrayKey | `${ArrayKey}`>>;
+/**
+ * Type which extracts all numeric keys from an object, tuple, or array.
+ * If a union is passed, it evaluates to the overlapping numeric keys.
+ * @typeParam T - type
+ * @example
+ * ```
+ * NumericKeys<{0: string, '1': string, foo: string}> = '0' | '1'
+ * NumericKeys<number[]> = `${number}`
+ * NumericKeys<[string, number]> = '0' | '1'
+ * NumericKeys<{0: string, '1': string} | [number] | number[]> = '0'
+ * ```
+ */
+export type NumericKeys<T extends Traversable> = UnionToIntersection<T extends ReadonlyArray<any> ? IsTuple<T> extends true ? [TupleKeys<T>] : [ToKey<ArrayKey>] : [NumericObjectKeys<T>]>[never];
+/**
+ * Type which extracts all keys from an object.
+ * If a union is passed, it evaluates to the overlapping keys.
+ * @typeParam T - object type
+ * @example
+ * ```
+ * ObjectKeys<{foo: string, bar: string}, string> = 'foo' | 'bar'
+ * ObjectKeys<{foo: string, bar: number}, string> = 'foo'
+ * ```
+ */
+export type ObjectKeys<T extends Traversable> = Exclude<ToKey<keyof T>, `${string}.${string}` | ''>;
+/**
+ * Type to check whether a type's property matches the constraint type
+ * and return its key. Converts the key to a {@link Key}.
+ * @typeParam T - type whose property should be checked
+ * @typeParam K - key of the property
+ * @typeParam U - constraint type
+ * @example
+ * ```
+ * CheckKeyConstraint<{foo: string}, 'foo', string> = 'foo'
+ * CheckKeyConstraint<{foo: string}, 'foo', number> = never
+ * CheckKeyConstraint<string[], number, string> = `${number}`
+ * ```
+ */
+export type CheckKeyConstraint<T, K extends Key, U> = K extends any ? EvaluateKey<T, K> extends U ? K : never : never;
+/**
+ * Type which evaluates to true when the type is an array or tuple or is a union
+ * which contains an array or tuple.
+ * @typeParam T - type
+ * @example
+ * ```
+ * ContainsIndexable<{foo: string}> = false
+ * ContainsIndexable<{foo: string} | number[]> = true
+ * ```
+ */
+export type ContainsIndexable<T> = IsNever<Extract<T, ReadonlyArray<any>>> extends true ? false : true;
+/**
+ * Type to implement {@link Keys} for non-nullable values.
+ * @typeParam T - non-nullable type whose property should be checked
+ */
+type KeysImpl<T> = [T] extends [Traversable] ? ContainsIndexable<T> extends true ? NumericKeys<T> : ObjectKeys<T> : never;
+/**
+ * Type to find all properties of a type that match the constraint type
+ * and return their keys.
+ * If a union is passed, it evaluates to the overlapping keys.
+ * @typeParam T - type whose property should be checked
+ * @typeParam U - constraint type
+ * @example
+ * ```
+ * Keys<{foo: string, bar: string}, string> = 'foo' | 'bar'
+ * Keys<{foo?: string, bar?: string}> = 'foo' | 'bar'
+ * Keys<{foo: string, bar: number}, string> = 'foo'
+ * Keys<[string, number], string> = '0'
+ * Keys<string[], string> = `${number}`
+ * Keys<{0: string, '1': string} | [number] | number[]> = '0'
+ * ```
+ */
+export type Keys<T, U = unknown> = IsAny<T> extends true ? Key : IsNever<T> extends true ? Key : IsNever<NonNullable<T>> extends true ? never : CheckKeyConstraint<T, KeysImpl<NonNullable<T>>, U>;
+/**
+ * Type to check whether a {@link Key} is present in a type.
+ * If a union of {@link Key}s is passed, all {@link Key}s have to be present
+ * in the type.
+ * @typeParam T - type which is introspected
+ * @typeParam K - key
+ * @example
+ * ```
+ * HasKey<{foo: string}, 'foo'> = true
+ * HasKey<{foo: string}, 'bar'> = false
+ * HasKey<{foo: string}, 'foo' | 'bar'> = false
+ * ```
+ */
+export type HasKey<T, K extends Key> = IsNever<Exclude<K, Keys<T>>>;
+/**
+ * Type to implement {@link ValidPathPrefix} tail recursively.
+ * @typeParam T   - type which the path should be checked against
+ * @typeParam PT  - path which should exist within the given type
+ * @typeParam VPT - accumulates the prefix of {@link Key}s which have been
+ *                  confirmed to exist already
+ */
+type ValidPathPrefixImpl<T, PT extends PathTuple, VPT extends PathTuple> = PT extends [infer K, ...infer R] ? HasKey<T, AsKey<K>> extends true ? ValidPathPrefixImpl<EvaluateKey<T, AsKey<K>>, AsPathTuple<R>, AsPathTuple<[...VPT, K]>> : VPT : VPT;
+/**
+ * Type to find the longest path prefix which is still valid,
+ * i.e. exists within the given type.
+ * @typeParam T  - type which the path should be checked against
+ * @typeParam PT - path which should exist within the given type
+ * @example
+ * ```
+ * ValidPathPrefix<{foo: {bar: string}}, ['foo', 'bar']> = ['foo', 'bar']
+ * ValidPathPrefix<{foo: {bar: string}}, ['foo', 'ba']> = ['foo']
+ * ```
+ */
+export type ValidPathPrefix<T, PT extends PathTuple> = ValidPathPrefixImpl<T, PT, [
+]>;
+/**
+ * Type to check whether a path through a type exists.
+ * @typeParam T  - type which the path should be checked against
+ * @typeParam PT - path which should exist within the given type
+ * @example
+ * ```
+ * HasPath<{foo: {bar: string}}, ['foo', 'bar']> = true
+ * HasPath<{foo: {bar: string}}, ['foo', 'ba']> = false
+ * ```
+ */
+export type HasPath<T, PT extends PathTuple> = ValidPathPrefix<T, PT> extends PT ? true : false;
+export type FieldValues = Record<string, any>;
+/**
+ * Helper function to break apart T1 and check if any are equal to T2
+ *
+ * See {@link IsEqual}
+ */
+type AnyIsEqual<T1, T2> = T1 extends T2 ? IsEqual<T1, T2> extends true ? true : never : never;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link Path}
+ */
+type PathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? `${K}` : true extends AnyIsEqual<TraversedTypes, V> ? `${K}` : `${K}` | `${K}.${PathInternal<V, TraversedTypes | V>}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from exported contract.
+ *
+ * See {@link Path}
+ */
+type PathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+/**
+ * Type which eagerly collects all paths through a type
+ * @typeParam T - type which should be introspected
+ * @example
+ * ```
+ * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
+ * ```
+ */
+export type Path<T> = T extends any ? PathInternal<T> : never;
+/**
+ * See {@link Path}
+ */
+export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>;
+export {};

package/lib/types/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './common';
+export * from './amanoKorea';

package/lib/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./amanoKorea"), exports);

package/lib/types/tl-lincoln.ota.d.ts

@@ -0,0 +1 @@
+export declare const TL_LINCOLN_TO_VENDIT_OTA_MAP: Record<string, string>;

package/lib/types/tl-lincoln.ota.js

@@ -0,0 +1,119 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TL_LINCOLN_TO_VENDIT_OTA_MAP = void 0;
+var TlLincolnOta;
+(function (TlLincolnOta) {
+    TlLincolnOta["JEJU_COM"] = "Jeju.com";
+    TlLincolnOta["M12"] = "M12";
+    TlLincolnOta["NEW_MY_REAL_TRIP"] = "(New)MyRealTrip";
+    TlLincolnOta["GAGOPATOUR"] = "Gagopatour";
+    TlLincolnOta["BOOKING_DOT_COM"] = "Booking.com";
+    TlLincolnOta["AGODA"] = "Agoda";
+    TlLincolnOta["EXPEDIA"] = "Expedia";
+    TlLincolnOta["DOTW"] = "DOTW";
+    TlLincolnOta["HOTUSA"] = "HOTUSA";
+    TlLincolnOta["DIDA_TRAVEL"] = "DIDA TRAVEL";
+    TlLincolnOta["TIDESQUARE"] = "TIDESQUARE";
+    TlLincolnOta["OH_MY_HOTEL"] = "Ohmyhotel";
+    TlLincolnOta["AIRBNB"] = "Airbnb";
+    TlLincolnOta["FLIGGY"] = "Fliggy";
+    TlLincolnOta["HAFH"] = "Hafh";
+    TlLincolnOta["SHIJI"] = "Shiji";
+    TlLincolnOta["TRIPLA"] = "Tripla";
+    TlLincolnOta["D_EDGE"] = "D-EDGE";
+    TlLincolnOta["RAKUTEN_TRAVEL_OVERSEAS"] = "Rakuten Travel(overseas)";
+    TlLincolnOta["DYNATECH"] = "Dynatech";
+    TlLincolnOta["CTRIP"] = "Ctrip";
+    TlLincolnOta["HPDS"] = "HPDS";
+    TlLincolnOta["SUITE_SMART"] = "SUITE Smart";
+    TlLincolnOta["ORBITZ"] = "Orbitz";
+    TlLincolnOta["HOTELBEDS"] = "Hotelbeds";
+    TlLincolnOta["GTA"] = "GTA";
+    TlLincolnOta["KONEST"] = "Konest";
+    TlLincolnOta["SYN_XIS"] = "SynXis";
+    TlLincolnOta["HIKARI_GLOBAL"] = "Hikari Global";
+    TlLincolnOta["HOTELS_COMBINED"] = "HotelsCombined";
+    TlLincolnOta["AHN"] = "AHN";
+    TlLincolnOta["HOTEL_N_JOY"] = "HotelNJoy";
+    TlLincolnOta["INTERPARK"] = "Interpark";
+    TlLincolnOta["ZYX_JQ_TRAVEL"] = "ZYX-JQTravel";
+    TlLincolnOta["CODY"] = "Cody";
+    TlLincolnOta["COUPANG"] = "Coupang";
+    TlLincolnOta["JTB_JHS"] = "JTB-JHS";
+    TlLincolnOta["HOTEL_PASS"] = "HotelPass";
+    TlLincolnOta["HIS_VACATION"] = "HIS VACATION";
+    TlLincolnOta["WEBTOUR"] = "Webtour";
+    TlLincolnOta["TRIPBTOZ"] = "Tripbtoz";
+    TlLincolnOta["BAROJABA"] = "Barojaba";
+    TlLincolnOta["DRTRIP"] = "Drtrip";
+    TlLincolnOta["NANUGO"] = "Nanugo";
+    TlLincolnOta["ONDA"] = "Onda";
+    TlLincolnOta["GC_COMPANY"] = "GC Company";
+    TlLincolnOta["TRIPTOPAZ"] = "Triptopaz";
+    TlLincolnOta["TAMNAO"] = "Tamnao";
+    TlLincolnOta["STAYNMORE"] = "STAYNMORE";
+    TlLincolnOta["ALLSTAY"] = "Allstay";
+    TlLincolnOta["ROOMIO"] = "Roomio";
+    TlLincolnOta["ALLMYTOUR"] = "Allmytour";
+    TlLincolnOta["MYREALTRIP"] = "Myrealtrip";
+    TlLincolnOta["YANOLJA"] = "Yanolja";
+    TlLincolnOta["T_MON"] = "T-mon";
+})(TlLincolnOta || (TlLincolnOta = {}));
+exports.TL_LINCOLN_TO_VENDIT_OTA_MAP = (_a = {},
+    _a[TlLincolnOta.JEJU_COM] = 'Jeju.com',
+    _a[TlLincolnOta.M12] = 'M12',
+    _a[TlLincolnOta.NEW_MY_REAL_TRIP] = '(New)MyRealTrip',
+    _a[TlLincolnOta.GAGOPATOUR] = 'Gagopatour',
+    _a[TlLincolnOta.BOOKING_DOT_COM] = 'BOOKINGDOTCOM',
+    _a[TlLincolnOta.AGODA] = 'AGODA',
+    _a[TlLincolnOta.EXPEDIA] = 'EXPEDIA',
+    _a[TlLincolnOta.DOTW] = 'DOTW',
+    _a[TlLincolnOta.HOTUSA] = 'HOTUSA',
+    _a[TlLincolnOta.DIDA_TRAVEL] = 'DIDA TRAVEL',
+    _a[TlLincolnOta.TIDESQUARE] = 'TIDESQUARE',
+    _a[TlLincolnOta.OH_MY_HOTEL] = 'Ohmyhotel',
+    _a[TlLincolnOta.AIRBNB] = 'AIRBNB',
+    _a[TlLincolnOta.FLIGGY] = 'FLIGGY',
+    _a[TlLincolnOta.HAFH] = 'HAFH',
+    _a[TlLincolnOta.SHIJI] = 'SHIJI',
+    _a[TlLincolnOta.TRIPLA] = 'TRIPLA',
+    _a[TlLincolnOta.D_EDGE] = 'D-EDGE',
+    _a[TlLincolnOta.RAKUTEN_TRAVEL_OVERSEAS] = 'RAKUTEN TRAVEL',
+    _a[TlLincolnOta.DYNATECH] = 'DYNATECH',
+    _a[TlLincolnOta.CTRIP] = 'CTRIP',
+    _a[TlLincolnOta.HPDS] = 'HPDS',
+    _a[TlLincolnOta.SUITE_SMART] = 'SUITE SMART',
+    _a[TlLincolnOta.ORBITZ] = 'ORBITZ',
+    _a[TlLincolnOta.HOTELBEDS] = 'HOTELBEDS',
+    _a[TlLincolnOta.GTA] = 'GTA',
+    _a[TlLincolnOta.KONEST] = 'KONEST',
+    _a[TlLincolnOta.SYN_XIS] = 'SynXis',
+    _a[TlLincolnOta.HIKARI_GLOBAL] = 'HIKARI GLOBAL',
+    _a[TlLincolnOta.HOTELS_COMBINED] = 'HOTELSCOMBINE',
+    _a[TlLincolnOta.AHN] = 'AHN',
+    _a[TlLincolnOta.HOTEL_N_JOY] = 'HOTELNJOY',
+    _a[TlLincolnOta.INTERPARK] = 'INTERPARK',
+    _a[TlLincolnOta.ZYX_JQ_TRAVEL] = 'ZYX-JQTravel',
+    _a[TlLincolnOta.CODY] = 'Cody',
+    _a[TlLincolnOta.COUPANG] = 'COUPANG',
+    _a[TlLincolnOta.JTB_JHS] = 'JTB-JHS',
+    _a[TlLincolnOta.HOTEL_PASS] = TlLincolnOta.HOTEL_PASS,
+    _a[TlLincolnOta.HIS_VACATION] = TlLincolnOta.HIS_VACATION,
+    _a[TlLincolnOta.WEBTOUR] = 'WEBTOUR',
+    _a[TlLincolnOta.TRIPBTOZ] = 'TRIPBTOZ',
+    _a[TlLincolnOta.BAROJABA] = 'BAROJABA',
+    _a[TlLincolnOta.DRTRIP] = 'DRTRIP',
+    _a[TlLincolnOta.NANUGO] = 'NANUGO',
+    _a[TlLincolnOta.ONDA] = 'ONDA',
+    _a[TlLincolnOta.GC_COMPANY] = 'YEOGIEOTTAE',
+    _a[TlLincolnOta.TRIPTOPAZ] = 'TRIPTOPAZ',
+    _a[TlLincolnOta.TAMNAO] = 'TAMNAO',
+    _a[TlLincolnOta.STAYNMORE] = 'STAYNMORE',
+    _a[TlLincolnOta.ALLSTAY] = 'ALLSTAY',
+    _a[TlLincolnOta.ROOMIO] = 'ROOMIO',
+    _a[TlLincolnOta.ALLMYTOUR] = 'ALLMYTOUR',
+    _a[TlLincolnOta.MYREALTRIP] = 'MYREALTRIP',
+    _a[TlLincolnOta.YANOLJA] = 'YANOLJA',
+    _a[TlLincolnOta.T_MON] = 'TMON',
+    _a);

package/lib/utils/function.d.ts

@@ -0,0 +1,2 @@
+import { FieldValues } from '../types';
+export declare const groupBy: <T extends FieldValues, K extends import("../types").Path<T>>(array: T[], key: K) => Record<string, T[]>;

package/lib/utils/function.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBy = void 0;
+var groupBy = function (array, key) { return array.reduce(function (acc, cur) {
+    var keys = key.split('.');
+    var lastKey = keys.pop();
+    var target = keys.reduce(function (a, k) { return a[k]; }, cur);
+    var value = target[lastKey];
+    if (!acc[value]) {
+        acc[value] = [];
+    }
+    acc[value].push(cur);
+    return acc;
+}, {}); };
+exports.groupBy = groupBy;

package/package.json

@@ -1,51 +1,50 @@
 {
-  "name": "@vendit-dev/thirdparty-adapters",
-  "version": "0.7.6",
-  "description": "Third party adapters between v-cloud and other PMS/CMS providers.",
-  "main": "lib/index.js",
-  "scripts": {
-    "build": "tsc",
-    "dev": "node ./test/index.js",
-    "npm-login": "npm login",
-    "publish": "npm publish"
-  },
-  "keywords": [
-    "vendit"
-  ],
-  "author": "Vendit <dev@vendit.co.kr> (https://vendit.co.kr)",
-  "license": "MIT",
-  "devDependencies": {
-    "@babel/cli": "^7.10.5",
-    "@babel/core": "^7.10.5",
-    "@babel/node": "^7.10.5",
-    "@babel/plugin-proposal-class-properties": "^7.10.4",
-    "@babel/plugin-proposal-optional-chaining": "^7.10.4",
-    "@babel/preset-env": "^7.10.4",
-    "@babel/preset-flow": "^7.10.4",
-    "@types/ioredis": "^5.0.0",
-    "@types/node": "^20.4.5",
-    "@types/node-fetch": "^2.6.1",
-    "@types/npm": "^7.19.1",
-    "@types/sequelize": "^4.28.15",
-    "@types/tedious": "^4.0.9",
-    "@types/validator": "^13.7.17",
-    "@typescript-eslint/eslint-plugin": "^3.6.1",
-    "@typescript-eslint/parser": "^3.6.1",
-    "@vendit-dev/utility-modules": "^0.20.1",
-    "babel-eslint": "^10.1.0",
-    "babel-plugin-module-resolver": "^4.0.0",
-    "cross-env": "^7.0.2",
-    "eslint": "^7.4.0",
-    "eslint-config-airbnb-base": "^13.1.0",
-    "eslint-plugin-import": "^2.16.0",
-    "typescript": "4.9.3"
-  },
-  "dependencies": {
-    "moment": "^2.29.2",
-    "node-fetch": "2",
-    "npm": "6",
-    "sequelize": "^6.32.1",
-    "tedious": "6.2.1",
-    "uuid": "^8.3.2"
-  }
+	"name": "@vendit-dev/thirdparty-adapters",
+	"version": "0.7.8",
+	"description": "Third party adapters between v-cloud and other PMS/CMS providers.",
+	"main": "lib/index.js",
+	"scripts": {
+		"build": "tsc",
+		"dev": "node ./test/tl-lincoln.test.js",
+		"npm-login": "npm login",
+		"publish": "npm publish"
+	},
+	"keywords": ["vendit"],
+	"author": "Vendit <dev@vendit.co.kr> (https://vendit.co.kr)",
+	"license": "MIT",
+	"devDependencies": {
+		"@babel/cli": "^7.10.5",
+		"@babel/core": "^7.10.5",
+		"@babel/node": "^7.10.5",
+		"@babel/plugin-proposal-class-properties": "^7.10.4",
+		"@babel/plugin-proposal-optional-chaining": "^7.10.4",
+		"@babel/preset-env": "^7.10.4",
+		"@babel/preset-flow": "^7.10.4",
+		"@types/ioredis": "^5.0.0",
+		"@types/node": "^20.4.5",
+		"@types/node-fetch": "^2.6.1",
+		"@types/npm": "^7.19.1",
+		"@types/sequelize": "^4.28.15",
+		"@types/tedious": "^4.0.9",
+		"@types/validator": "^13.7.17",
+		"@typescript-eslint/eslint-plugin": "^3.6.1",
+		"@typescript-eslint/parser": "^3.6.1",
+		"@vendit-dev/utility-modules": "^0.20.1",
+		"babel-eslint": "^10.1.0",
+		"babel-plugin-module-resolver": "^4.0.0",
+		"cross-env": "^7.0.2",
+		"eslint": "^7.4.0",
+		"eslint-config-airbnb-base": "^13.1.0",
+		"eslint-plugin-import": "^2.16.0",
+		"typescript": "4.9.3"
+	},
+	"dependencies": {
+		"fast-xml-parser": "^4.4.0",
+		"moment": "^2.29.2",
+		"node-fetch": "2",
+		"npm": "6",
+		"sequelize": "^6.32.1",
+		"tedious": "6.2.1",
+		"uuid": "^8.3.2"
+	}
 }

package/lib/utils/number.util.d.ts

@@ -1 +0,0 @@
-export declare function findMinimumNumbersForSum(target: number, numbers: number[]): number[];