@artaio/node-api 0.30.1 → 0.32.0

package/dist/lib/endpoint/organization.d.ts

@@ -1,17 +1,5 @@
-import { ArtaID } from '../ArtaClient';
-import { RestClient } from '../net/RestClient';
-import { DatedInterface, NullableString } from '../utils';
-export interface Organization extends DatedInterface {
-    api_version: string;
-    id: ArtaID;
-    name: string;
-    billing_terms?: NullableString;
-    company_name?: NullableString;
-    display_name?: NullableString;
-    shortcode?: NullableString;
-    status?: NullableString;
-    stripe_customer_id?: NullableString;
-}
+import type { RestClient } from '../net/RestClient';
+import type { Organization } from '../types';
 export declare class OrganizationsEndpoint {
     private readonly artaClient;
     private readonly path;

package/dist/lib/endpoint/payments.d.ts

@@ -1,14 +1,10 @@
-import { ArtaID } from '../ArtaClient';
-import { PaymentContext, SupportedCurrency } from '../MetadataTypes';
-import { RestClient } from '../net/RestClient';
-import { Page } from '../pagination';
-import { DatedInterface } from '../utils';
-export interface Payment extends DatedInterface {
-    id: ArtaID;
-    amount: number;
-    amount_currency: SupportedCurrency;
-    context: PaymentContext;
-    paid_on: Date;
+import type { ArtaID } from '../ArtaClient';
+import type { RestClient } from '../net/RestClient';
+import type { Page } from '../pagination';
+import type { Payment } from '../types';
+export interface UnparsedPayment extends Omit<Payment, 'paid_on' | 'amount'> {
+    paid_on: string;
+    amount: string;
 }
 export declare class PaymentsEndpoint {
     private readonly artaClient;

package/dist/lib/endpoint/payments.js

@@ -1,6 +1,18 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaymentsEndpoint = void 0;
+var utils_1 = require("../utils");
 var endpoint_1 = require("./endpoint");
 var PaymentsEndpoint = /** @class */ (function () {
     function PaymentsEndpoint(artaClient) {
@@ -17,9 +29,7 @@ var PaymentsEndpoint = /** @class */ (function () {
         return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
     };
     PaymentsEndpoint.prototype.enrichFields = function (resource) {
-        resource.amount = Number(resource.amount);
-        resource.paid_on = new Date(resource.paid_on);
-        return resource;
+        return __assign(__assign({}, resource), { amount: Number(resource.amount), paid_on: (0, utils_1.createDateAsUTC)(resource.paid_on) });
     };
     return PaymentsEndpoint;
 }());

package/dist/lib/endpoint/requests.d.ts

@@ -1,38 +1,14 @@
-import { ArtaID } from '../ArtaClient';
-import { AdditionalService, ArtaLocation, ArtaObject, Contact, Disqualification, Insurance, PaymentProcessType, Quote, QuoteRequestStatus, QuoteType, SupportedCurrency } from '../MetadataTypes';
-import { RestClient } from '../net/RestClient';
-import { Page } from '../pagination';
-import { RequestsSearch } from '../search';
-import { DatedInterface, Nullable, NullableString } from '../utils';
-export interface QuoteRequest extends DatedInterface {
-    id: ArtaID;
-    currency: SupportedCurrency;
-    additional_services: AdditionalService[];
-    bookable: {
-        missing: string[];
-        ready: boolean;
-    };
-    destination: ArtaLocation;
-    disqualifications: Disqualification[];
-    insurance: Nullable<Insurance>;
-    internal_reference: NullableString;
-    log_request_id: string;
-    hosted_session_id: Nullable<number>;
-    object_count: number;
-    objects: ArtaObject[];
-    origin: ArtaLocation;
-    payment_process: PaymentProcessType;
-    preferred_quote_types?: Nullable<QuoteType[]>;
-    public_reference?: NullableString;
-    quote_types: QuoteType[];
-    shipping_notes?: NullableString;
-    shortcode: string;
-    quotes: Quote[];
-    status: QuoteRequestStatus;
-    updateContacts: (contacts: UpdateRequestsContactsBody, auth?: string) => Promise<QuoteRequest>;
-    requireCustomQuotes: (customQuote: CustomQuotePayload, auth?: string) => Promise<QuoteRequest>;
-    cancel: (auth?: string) => Promise<QuoteRequest>;
-}
+import type { AdditionalService, ArtaLocation, ArtaObject, Contact, Insurance, QuoteType, SupportedCurrency } from '../types';
+import type { RestClient } from '../net/RestClient';
+import type { Page } from '../pagination';
+import type { RequestsSearch } from '../search';
+import type { QuoteRequest, QuoteRequestListItem } from '../types';
+import type { Nullable, NullableString } from '../utils';
+export type EnrichRequest<T> = T & {
+    updateContacts: (contacts: UpdateRequestsContactsBody, auth?: string) => Promise<T>;
+    requireCustomQuotes: (customQuote: CustomQuotePayload, auth?: string) => Promise<T>;
+    cancel: (auth?: string) => Promise<T>;
+};
 export interface QuoteRequestCreateBody {
     additional_services?: Nullable<AdditionalService[]>;
     currency?: Nullable<SupportedCurrency>;
@@ -61,10 +37,10 @@ export declare class QuoteRequestsEndpoint {
     private readonly path;
     constructor(artaClient: RestClient);
     private enrichFields;
-    getById(id: ArtaID, auth?: string): Promise<QuoteRequest>;
-    list(search?: RequestsSearch, page?: number, pageSize?: number, auth?: string): Promise<Page<QuoteRequest>>;
-    create(payload: QuoteRequestCreateBody, auth?: string): Promise<QuoteRequest>;
-    updateContacts(id: ArtaID, contacts: UpdateRequestsContactsBody, auth?: string): Promise<QuoteRequest>;
-    requireCustomQuotes(id: ArtaID, customQuote: CustomQuotePayload, auth?: string): Promise<QuoteRequest>;
-    cancel(id: ArtaID, auth?: string): Promise<QuoteRequest>;
+    getById(id: string, auth?: string): Promise<EnrichRequest<QuoteRequest>>;
+    list(search?: RequestsSearch, page?: number, pageSize?: number, auth?: string): Promise<Page<EnrichRequest<QuoteRequestListItem>>>;
+    create(payload: QuoteRequestCreateBody, auth?: string): Promise<EnrichRequest<QuoteRequest>>;
+    updateContacts(id: string, contacts: UpdateRequestsContactsBody, auth?: string): Promise<EnrichRequest<QuoteRequest>>;
+    requireCustomQuotes(id: string, customQuote: CustomQuotePayload, auth?: string): Promise<QuoteRequest>;
+    cancel(id: string, auth?: string): Promise<QuoteRequest>;
 }

package/dist/lib/endpoint/requests.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -47,16 +58,17 @@ var QuoteRequestsEndpoint = /** @class */ (function () {
     }
     QuoteRequestsEndpoint.prototype.enrichFields = function (resource) {
         var _this = this;
-        resource.quotes &&
+        if (Object.prototype.hasOwnProperty.call(resource, 'quotes')) {
             resource.quotes.forEach(function (q) {
                 q.total = Number(q.total);
                 q.included_services.forEach(utils_1.parseService);
                 q.optional_services.forEach(utils_1.parseService);
             });
-        resource.updateContacts = function (contacts, auth) { return _this.updateContacts(resource.id, contacts, auth); };
-        resource.requireCustomQuotes = function (customQuote, auth) { return _this.requireCustomQuotes(resource.id, customQuote, auth); };
-        resource.cancel = function (auth) { return _this.cancel(resource.id, auth); };
-        return resource;
+        }
+        var updateContacts = function (contacts, auth) { return _this.updateContacts(resource.id, contacts, auth); };
+        var requireCustomQuotes = function (customQuote, auth) { return _this.requireCustomQuotes(resource.id, customQuote, auth); };
+        var cancel = function (auth) { return _this.cancel(resource.id, auth); };
+        return __assign(__assign({}, resource), { updateContacts: updateContacts, requireCustomQuotes: requireCustomQuotes, cancel: cancel });
     };
     QuoteRequestsEndpoint.prototype.getById = function (id, auth) {
         return this.defaultEndpoint.getById(id, auth);

package/dist/lib/endpoint/shipments.d.ts

@@ -1,76 +1,9 @@
-import { ArtaID } from '../ArtaClient';
-import { ArtaLocation, ArtaObject, ArtaService, EEIFormStatus, InsurancePolicy, PackageStatus, PackingSubType, PaymentProcessType, QuoteType, ShipmentStatus, ShipmentExceptionTypeId, SupportedCurrency } from '../MetadataTypes';
-import { RestClient } from '../net/RestClient';
-import { Page } from '../pagination';
-import { ShipmentsSearch } from '../search';
-import { DatedInterface, Nullable, NullableString } from '../utils';
-export interface Package {
-    depth: number;
-    eta: string;
-    handle_with_care: boolean;
-    height: number;
-    id: number;
-    is_sufficiently_packed: boolean;
-    objects: ArtaObject[];
-    packing_materials: PackingSubType[];
-    status: Nullable<PackageStatus>;
-    unit_of_measurement?: NullableString;
-    weight: number;
-    weight_unit: string;
-    width: number;
-}
-export type ShipmentExceptionStatus = 'in_progress' | 'new' | 'resolved';
-export interface ShipmentException extends DatedInterface {
-    exception_type_label: NullableString;
-    id: ArtaID;
-    package_id: Nullable<number>;
-    resolution: NullableString;
-    status: ShipmentExceptionStatus;
-    type: ShipmentExceptionTypeId;
-}
-export interface ShipmentSchedule {
-    delivery_end: Nullable<Date>;
-    delivery_start: Nullable<Date>;
-    delivery_window_modifier: string;
-    pickup_end: Nullable<Date>;
-    pickup_start: Nullable<Date>;
-    pickup_window_modifier: string;
-}
-export interface ShipmentTracking {
-    carrier_name: string;
-    label_url?: NullableString;
-    package_id: number;
-    tracking_number: string;
-    url: string;
-}
-export interface Shipment extends DatedInterface {
-    id: ArtaID;
-    destination: ArtaLocation;
-    eei_form_status?: Nullable<EEIFormStatus>;
-    emissions?: Nullable<number>;
-    emissions_unit?: NullableString;
-    exceptions?: Nullable<ShipmentException[]>;
-    hosted_session_id?: Nullable<number>;
-    insurance_policy?: Nullable<InsurancePolicy>;
-    internal_reference?: NullableString;
-    log_request_id?: NullableString;
-    object_count: number;
-    origin: ArtaLocation;
-    package_count: number;
-    packages?: Nullable<Package[]>;
-    payment_process?: Nullable<PaymentProcessType>;
-    public_reference?: NullableString;
-    quote_type: QuoteType;
-    schedule?: Nullable<ShipmentSchedule>;
-    services?: Nullable<ArtaService[]>;
-    shipping_notes?: NullableString;
-    shortcode: string;
-    status: ShipmentStatus;
-    total: number;
-    total_currency: SupportedCurrency;
-    url?: NullableString;
-    tracking?: Nullable<ShipmentTracking[]>;
-}
+import type { ArtaID } from '../ArtaClient';
+import type { RestClient } from '../net/RestClient';
+import type { Page } from '../pagination';
+import type { ShipmentsSearch } from '../search';
+import type { NullableString } from '../utils';
+import type { Shipment } from '../types';
 export interface ShipmentCreateBody {
     internal_reference?: NullableString;
     public_reference?: NullableString;

package/dist/lib/endpoint/shipments.js

@@ -9,27 +9,33 @@ var ShipmentsEndpoint = /** @class */ (function () {
         this.path = '/shipments';
         this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient, this.enrichFields.bind(this));
     }
-    ShipmentsEndpoint.prototype.enrichFields = function (r) {
-        r.total = Number(r.total);
-        if (r.emissions) {
-            r.emissions = Number(r.emissions);
+    ShipmentsEndpoint.prototype.enrichFields = function (s) {
+        s.total = Number(s.total);
+        if (s.emissions) {
+            s.emissions = Number(s.emissions);
         }
-        if (r.schedule) {
-            r.schedule.delivery_end = new Date(r.schedule.delivery_end);
-            r.schedule.delivery_start = new Date(r.schedule.delivery_start);
-            r.schedule.pickup_end = new Date(r.schedule.pickup_end);
-            r.schedule.pickup_start = new Date(r.schedule.pickup_start);
+        if (s.schedule) {
+            s.schedule.delivery_end = (0, utils_1.createDateAsUTC)(s.schedule.delivery_end);
+            s.schedule.delivery_start = (0, utils_1.createDateAsUTC)(s.schedule.delivery_start);
+            s.schedule.pickup_end = (0, utils_1.createDateAsUTC)(s.schedule.pickup_end);
+            s.schedule.pickup_start = (0, utils_1.createDateAsUTC)(s.schedule.pickup_start);
         }
-        if (r.packages) {
-            r.packages.forEach(function (p) {
+        if (s.packages) {
+            s.packages.forEach(function (p) {
                 p.depth = Number(p.depth);
                 p.height = Number(p.height);
                 p.weight = Number(p.weight);
                 p.width = Number(p.width);
             });
         }
-        r.services && r.services.forEach(utils_1.parseService);
-        return r;
+        if (s.exceptions) {
+            s.exceptions.forEach(function (e) {
+                e.created_at = (0, utils_1.createDateAsUTC)(e.created_at);
+                e.updated_at = (0, utils_1.createDateAsUTC)(e.updated_at);
+            });
+        }
+        s.services && s.services.forEach(utils_1.parseService);
+        return s;
     };
     ShipmentsEndpoint.prototype.getById = function (id, auth) {
         return this.defaultEndpoint.getById(id, auth);

package/dist/lib/endpoint/trackings.d.ts

@@ -1,22 +1,6 @@
-import { ArtaID } from '../ArtaClient';
-import { RestClient } from '../net/RestClient';
-export interface Carrier {
-    code: string;
-    name: string;
-    phone_number: string;
-    url: string;
-}
-export interface TrackingEvent {
-    date: Date;
-    location: string;
-    summary: string;
-}
-export interface Tracking {
-    carrier: Carrier;
-    events: TrackingEvent[];
-    status: string;
-    tracking_number: string;
-}
+import type { ArtaID } from '../ArtaClient';
+import type { RestClient } from '../net/RestClient';
+import type { Tracking } from '../types';
 export declare class TrackingsEndpoint {
     private readonly artaClient;
     private readonly path;

package/dist/lib/endpoint/trackings.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -45,16 +56,14 @@ var TrackingsEndpoint = /** @class */ (function () {
     }
     TrackingsEndpoint.prototype.getById = function (id, auth) {
         return __awaiter(this, void 0, void 0, function () {
-            var tracking;
+            var unparsedTracking, parsedEvents;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.artaClient.get("".concat(this.path, "/").concat(id), auth)];
                     case 1:
-                        tracking = _a.sent();
-                        tracking.events.forEach(function (e) {
-                            e.date = (0, utils_1.createDateAsUTC)(e.date);
-                        });
-                        return [2 /*return*/, tracking];
+                        unparsedTracking = _a.sent();
+                        parsedEvents = unparsedTracking.events.map(function (event) { return (__assign(__assign({}, event), { date: (0, utils_1.createDateAsUTC)(event.date) })); });
+                        return [2 /*return*/, __assign(__assign({}, unparsedTracking), { events: parsedEvents })];
                 }
             });
         });

package/dist/lib/endpoint/uploads.d.ts

@@ -1,25 +1,14 @@
-import { ArtaID } from '../ArtaClient';
-import { RestClient } from '../net/RestClient';
-import { Page } from '../pagination';
-import { DocumentType, MimeType } from '../MetadataTypes';
-import { DatedInterface, NullableString } from '../utils';
-export interface Upload extends DatedInterface {
-    id: ArtaID;
-    document_type: DocumentType;
-    document_type_label?: NullableString;
-    download_url: NullableString;
-    file_name: string;
-    mime_type: MimeType;
-    size: number;
-    status: string;
-    presigned_url: string;
-}
+import type { ArtaID } from '../ArtaClient';
+import type { RestClient } from '../net/RestClient';
+import type { Page } from '../pagination';
+import type { ArtaDocumentType, ArtaMimeType, Upload } from '../MetadataTypes';
+import type { NullableString } from '../utils';
 export interface UploadCreateBody {
-    document_type: DocumentType;
+    document_type: ArtaDocumentType;
     document_type_label?: NullableString;
     file_name: boolean;
     size: string;
-    mime_type: MimeType;
+    mime_type: ArtaMimeType;
 }
 export interface UploadCreate {
     upload: UploadCreateBody;

package/dist/lib/endpoint/webhookDeliveries.d.ts

@@ -1,21 +1,7 @@
-import { ArtaID } from '../ArtaClient';
-import { WebhookDeliveryStatus, WebhookDeliveryType, WebhookResourceType } from '../MetadataTypes';
-import { RestClient } from '../net/RestClient';
-import { Page } from '../pagination';
-import { DatedInterface, NullableString } from '../utils';
-export interface WebhookDelivery extends DatedInterface {
-    id: ArtaID;
-    resource_id: number;
-    resource_type: WebhookResourceType;
-    response_status_code: number;
-    status: WebhookDeliveryStatus;
-    type: WebhookDeliveryType;
-    webhook_id: number;
-    webhook_url: string;
-    next_retry?: NullableString;
-    request_body?: NullableString;
-    response_body?: NullableString;
-}
+import type { ArtaID } from '../ArtaClient';
+import type { RestClient } from '../net/RestClient';
+import type { Page } from '../pagination';
+import type { WebhookDelivery } from '../types';
 export declare class WebhookDeliveriesEndpoint {
     private readonly artaClient;
     private readonly defaultEndpoint;

package/dist/lib/endpoint/webhooks.d.ts

@@ -1,11 +1,8 @@
-import { ArtaID } from '../ArtaClient';
-import { RestClient } from '../net/RestClient';
-import { DatedInterface } from '../utils';
-import { Page } from '../pagination';
-export interface Webhook extends DatedInterface {
-    id: ArtaID;
-    name: string;
-    url: string;
+import type { ArtaID } from '../ArtaClient';
+import type { RestClient } from '../net/RestClient';
+import type { Page } from '../pagination';
+import type { Webhook } from '../types';
+export interface ExtendedWebhook extends Webhook {
     ping: (auth?: string) => Promise<void>;
     getSecret: (auth?: string) => Promise<string>;
     resetSecret: (auth?: string) => Promise<string>;
@@ -23,11 +20,11 @@ export declare class WebhooksEndpoint {
     private readonly path;
     constructor(artaClient: RestClient);
     private withFunctionCalls;
-    getById(id: ArtaID, auth?: string): Promise<Webhook>;
-    list(page?: number, pageSize?: number, auth?: string): Promise<Page<Webhook>>;
-    listAll(auth?: string): AsyncGenerator<Webhook>;
-    create(payload: WebhookCreateBody, auth?: string): Promise<Webhook>;
-    update(id: ArtaID, payload: Partial<WebhookCreateBody> | Partial<Webhook>, auth?: string): Promise<Webhook>;
+    getById(id: ArtaID, auth?: string): Promise<ExtendedWebhook>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<ExtendedWebhook>>;
+    listAll(auth?: string): AsyncGenerator<ExtendedWebhook>;
+    create(payload: WebhookCreateBody, auth?: string): Promise<ExtendedWebhook>;
+    update(id: ArtaID, payload: Partial<WebhookCreateBody> | Partial<ExtendedWebhook>, auth?: string): Promise<ExtendedWebhook>;
     remove(id: ArtaID, auth?: string): Promise<void>;
     ping(id: ArtaID, auth?: string): Promise<void>;
     getSecret(id: ArtaID, auth?: string): Promise<string>;

package/dist/lib/index.d.ts

@@ -1,19 +1,12 @@
 export { Arta } from './arta';
 export { Logger, LoggerVerbosity } from './logging';
-export { Attachment, AttachmentCreateBodyRequest, AttachmentCreateBodyShipment, AttachmentCreateBody, } from './endpoint/attachment';
-export { EmailRule, EmailRuleCreateBody } from './endpoint/emailRules';
-export { EmailSubscription, EmailSubscriptionCreateBody, } from './endpoint/emailSubscriptions';
-export { HostedSession, HostedSessionCreateBody, } from './endpoint/hostedSessions';
-export { InvoicePayment } from './endpoint/invoicePayments';
-export { Invoice } from './endpoint/invoices';
-export { Key, KeyCreateBody } from './endpoint/keys';
-export { Log } from './endpoint/logs';
+export { AttachmentCreateBodyRequest, AttachmentCreateBodyShipment, AttachmentCreateBody, } from './endpoint/attachment';
+export { EmailRuleCreateBody } from './endpoint/emailRules';
+export { EmailSubscriptionCreateBody, } from './endpoint/emailSubscriptions';
+export { HostedSessionCreateBody, } from './endpoint/hostedSessions';
+export { KeyCreateBody } from './endpoint/keys';
 export * from './MetadataTypes';
-export { Organization } from './endpoint/organization';
-export { Payment } from './endpoint/payments';
-export { Upload, UploadCreateBody } from './endpoint/uploads';
-export { WebhookDelivery } from './endpoint/webhookDeliveries';
-export { Webhook, WebhookCreate } from './endpoint/webhooks';
-export { Tracking, TrackingEvent, Carrier } from './endpoint/trackings';
-export { QuoteRequest, QuoteRequestCreateBody, UpdateRequestsContactsBody, CustomQuotePayload, } from './endpoint/requests';
-export { Package, ShipmentSchedule, ShipmentTracking, Shipment, ShipmentCreateBody, } from './endpoint/shipments';
+export { UploadCreateBody } from './endpoint/uploads';
+export { ExtendedWebhook as Webhook, WebhookCreate } from './endpoint/webhooks';
+export { QuoteRequestCreateBody, UpdateRequestsContactsBody, CustomQuotePayload, } from './endpoint/requests';
+export { ShipmentCreateBody, } from './endpoint/shipments';

package/dist/lib/net/FetchHttpClient.d.ts

@@ -0,0 +1,13 @@
+import type { HttpClient, HttpClientHeaders, HttpClientResponse, HttpRequestParameters } from './HttpClient';
+export declare class FetchHttpClientResponse implements HttpClientResponse {
+    private readonly res;
+    statusCode?: number;
+    headers: HttpClientHeaders;
+    constructor(res: Response);
+    json<T>(): Promise<T>;
+}
+export declare class FetchHttpClient implements HttpClient {
+    private readonly logger;
+    constructor();
+    request(host: string, params?: Partial<HttpRequestParameters>): Promise<HttpClientResponse>;
+}

package/dist/lib/net/FetchHttpClient.js

@@ -0,0 +1,128 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchHttpClient = exports.FetchHttpClientResponse = void 0;
+var logging_1 = require("../logging");
+var FetchHttpClientResponse = /** @class */ (function () {
+    function FetchHttpClientResponse(res) {
+        var _this = this;
+        this.res = res;
+        this.headers = {};
+        this.statusCode = res.status;
+        res.headers.forEach(function (value, key) {
+            _this.headers[key] = value;
+        });
+    }
+    FetchHttpClientResponse.prototype.json = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.res.json()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return FetchHttpClientResponse;
+}());
+exports.FetchHttpClientResponse = FetchHttpClientResponse;
+function initParams(params) {
+    var defaultParams = {
+        protocol: 'https',
+        port: 443,
+        path: '/',
+        method: 'GET',
+        headers: {},
+        requestData: null,
+        timeout: 30000,
+    };
+    return __assign(__assign({}, defaultParams), params);
+}
+var FetchHttpClient = /** @class */ (function () {
+    function FetchHttpClient() {
+        this.logger = (0, logging_1.getLogger)();
+    }
+    FetchHttpClient.prototype.request = function (host, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, protocol, port, path, method, timeout, headers, requestData, url, fetchUrl, setTimeoutId, rejectTimeout, response;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = initParams(params), protocol = _a.protocol, port = _a.port, path = _a.path, method = _a.method, timeout = _a.timeout, headers = _a.headers, requestData = _a.requestData;
+                        url = "".concat(protocol, "://").concat(host, ":").concat(port).concat(path);
+                        this.logger.debug("[".concat(method, "] ").concat(url));
+                        fetchUrl = fetch(url, {
+                            method: method,
+                            headers: headers,
+                            body: requestData,
+                        });
+                        setTimeoutId = null;
+                        rejectTimeout = new Promise(function (_, reject) {
+                            setTimeoutId = setTimeout(function () {
+                                reject(new Error("Request timed out to ".concat(host, ":").concat(port)));
+                            }, timeout);
+                        });
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, Promise.race([fetchUrl, rejectTimeout])];
+                    case 2:
+                        response = _b.sent();
+                        return [2 /*return*/, new FetchHttpClientResponse(response)];
+                    case 3:
+                        setTimeoutId != null && clearTimeout(setTimeoutId);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return FetchHttpClient;
+}());
+exports.FetchHttpClient = FetchHttpClient;