@artaio/node-api 0.27.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 artaio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+Arta Node.js Library
+===
+
+The Arta Node library provides a seamless integration to Arta API for applications running on Node.js using both Typescript or Javascript.
+
+## Documentation
+
+Please refer to [Arta official documentation](https://api-reference.arta.io/).
+
+
+## Getting Started
+
+### 1. Install Arta Node Library
+
+```
+$ npm install arta-node
+```
+
+### 2. Use it to interact with our API in pure JS
+```js
+const { Arta } = require('arta-node');
+const arta = new Arta('<YOUR_API_TOKEN>');
+
+const endpoints = arta.endpoint.list();
+
+const myEndpoint = endpoint[0];
+
+myEndpoint.ping().then(console.log);
+```
+
+### 3. Use it to interact with our API in TS
+```ts
+import { Arta } from 'arta-node';
+const arta: Arta = new Arta('<YOUR_API_TOKEN>');
+
+const endpoints: ArtaEndpoint[] = arta.endpoint.list();
+
+const myEndpoint: ArtaEndpoint = endpoint[0];
+
+myEndpoint.ping().then(console.log);
+```
+
+## Contributing
+
+Please be aware of our zero-dependency policy and ensure that there are no packages under "dependencies" in the `package.json`. Dev dependencies are fine, as these will not be contained in the final published package.
+
+### Development
+To develop a new function on the SDK, run `npm install` to install all the dependencies (only dev dependencies) and then run `npm run build` and the compiled JS code will be stored in the `dist/` folder which is the folder with the content published to NPM.

package/dist/lib/ArtaClient.d.ts

@@ -0,0 +1,21 @@
+import { HttpClient } from './net/HttpClient';
+import { RestClient } from './net/RestClient';
+export type ArtaID = number | string;
+interface ArtaClientConfig {
+    apiKey: string;
+    host: string;
+}
+export declare class ArtaClient implements RestClient {
+    private readonly httpClient;
+    private readonly config;
+    private readonly logger;
+    constructor(httpClient: HttpClient, config: ArtaClientConfig);
+    private request;
+    private makeReqParams;
+    private makeArtaAuthHeader;
+    get(path: string, auth?: string): Promise<any>;
+    post(path: string, payload: any, auth?: string): Promise<any>;
+    patch(path: string, payload: any, auth?: string): Promise<any>;
+    delete(path: string, auth?: string): Promise<void>;
+}
+export {};

package/dist/lib/ArtaClient.js

@@ -0,0 +1,155 @@
+"use strict";
+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.ArtaClient = void 0;
+var error_1 = require("./error");
+var package_json_1 = require("../package.json");
+var logging_1 = require("./logging");
+var ArtaClient = /** @class */ (function () {
+    function ArtaClient(httpClient, config) {
+        this.httpClient = httpClient;
+        this.config = config;
+        this.logger = (0, logging_1.getLogger)();
+    }
+    ArtaClient.prototype.request = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var authValue, req, message, errorResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        authValue = this.makeArtaAuthHeader(this.config.apiKey);
+                        if (params.headers.Authorization == null) {
+                            params.headers.Authorization = authValue;
+                        }
+                        return [4 /*yield*/, this.httpClient.request(this.config.host, params)];
+                    case 1:
+                        req = _a.sent();
+                        message = "[".concat(req.statusCode, "] ").concat(params.method, " ").concat(params.path);
+                        if (!(req.statusCode && req.statusCode >= 400)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, req.json()];
+                    case 2:
+                        errorResponse = _a.sent();
+                        this.logger.error(message);
+                        this.logger.debug('Error body', errorResponse);
+                        throw new error_1.ArtaSDKError(errorResponse, req.statusCode);
+                    case 3:
+                        this.logger.info(message);
+                        return [2 /*return*/, req];
+                }
+            });
+        });
+    };
+    ArtaClient.prototype.makeReqParams = function (path, method, auth, body) {
+        var reqParams = {
+            path: path,
+            method: method,
+            headers: {
+                'User-Agent': "ARTA/v1 arta-node/".concat(package_json_1.version),
+            },
+        };
+        if (auth) {
+            reqParams.headers.Authorization = this.makeArtaAuthHeader(auth);
+        }
+        if (body) {
+            reqParams.requestData = body;
+        }
+        return reqParams;
+    };
+    ArtaClient.prototype.makeArtaAuthHeader = function (apiKey) {
+        return "ARTA_APIKey ".concat(apiKey);
+    };
+    ArtaClient.prototype.get = function (path, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqParams, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        reqParams = this.makeReqParams(path, 'get', auth);
+                        return [4 /*yield*/, this.request(reqParams)];
+                    case 1:
+                        res = _a.sent();
+                        return [2 /*return*/, res.json()];
+                }
+            });
+        });
+    };
+    ArtaClient.prototype.post = function (path, payload, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqParams, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        reqParams = this.makeReqParams(path, 'post', auth, JSON.stringify(payload));
+                        return [4 /*yield*/, this.request(reqParams)];
+                    case 1:
+                        res = _a.sent();
+                        return [2 /*return*/, res.json()];
+                }
+            });
+        });
+    };
+    ArtaClient.prototype.patch = function (path, payload, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reqParams, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        reqParams = this.makeReqParams(path, 'patch', auth, JSON.stringify(payload));
+                        return [4 /*yield*/, this.request(reqParams)];
+                    case 1:
+                        res = _a.sent();
+                        return [2 /*return*/, res.json()];
+                }
+            });
+        });
+    };
+    ArtaClient.prototype.delete = function (path, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request(this.makeReqParams(path, 'delete', auth))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, Promise.resolve()];
+                }
+            });
+        });
+    };
+    return ArtaClient;
+}());
+exports.ArtaClient = ArtaClient;

package/dist/lib/MetadataTypes.d.ts

@@ -0,0 +1,96 @@
+import { Nullable, NullableString } from './utils';
+export type AdditionalService = 'assembly' | 'debris_disposal' | 'deinstallation' | 'destination_additional_labor' | 'destination_building_coi' | 'destination_condition_check' | 'destination_full_condition_report' | 'destination_unpacking' | 'double_blind_bols' | 'installation' | 'origin_building_coi' | 'origin_condition_check' | 'origin_full_condition_report' | 'placement' | 'signature_delivery' | 'tarmac_supervision';
+export type AccessRestriction = 'elevator_only' | 'freight_elevator' | 'loading_dock' | 'loading_dock_low' | 'low_clearance' | 'non_paved' | 'stairs_only' | 'steep_gradient';
+export type Insurance = 'arta_transit_insurance' | 'no_arta_insurance';
+export type PaymentProcessType = 'checkout' | 'checkout_direct' | 'invoicing';
+export type QuoteType = 'parcel' | 'premium' | 'select' | 'self_ship';
+export type QuoteRequestStatus = 'cancelled' | 'closed' | 'disqualified' | 'expired' | 'in_progress' | 'pending' | 'quoted';
+export type EmailNotificationId = 'booking' | 'cancelled' | 'collected' | 'collection' | 'complete' | 'custom_quoted_dashboard' | 'in_transit' | 'invoice' | 'self_ship_label' | 'payment' | 'scheduling' | 'eei';
+export type Recipients = 'payer' | 'origin' | 'destination';
+export type MimeType = 'application/pdf' | 'application/vnd.ms-excel' | 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' | 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' | 'image/jpeg' | 'image/png' | 'text/csv' | 'video/mp4' | 'video/quicktime' | 'application/msword';
+export type DocumentType = 'bill_of_lading' | 'certificate_of_insurance' | 'certificate_of_insurance_template' | 'condition_report' | 'condition_check' | 'image' | 'instructions' | 'airway_bill' | 'commercial_invoice' | 'power_of_attorney' | 'proof_of_export' | 'proof_of_delivery' | 'quote' | 'shipping_label' | 'other';
+export type PackingType = 'alcohol_case' | 'blanket' | 'box' | 'cbin_closed' | 'cbin_open' | 'crate' | 'foam_lined_box' | 'frame' | 'lockbox' | 'no_packing' | 'pallet' | 'portfolio' | 'rug_roll' | 'shadow_box' | 'slipcase' | 'soft_packing' | 'soft_wrap' | 'sonotube' | 'stabilizing_box' | 'tube';
+export type PackingSubType = 'alcohol_case' | 'lay_flat_wine_box' | 'blanket' | 'wardrobe_box' | 'cardboard_box' | 'chandelier_box' | 'chair_box' | 'cbin_closed' | 'cbin_open' | 'ply_box' | 'fine_art_econo_crate' | 'fine_art_international_crate' | 'econo_crate' | 'international_econo_crate' | 'furniture_crate' | 'international_furniture_crate' | 'parcel_crate' | 'museum_crate' | 'international_museum_crate' | 'foam_lined_box' | 'cavity_box' | 'strongbox' | 'double_box' | 'travel_frame' | 'travel_frame_art' | 'travel_frame_other' | 'a_frame' | 'slat_crate' | 'tri_wall_crate' | 'lockbox' | 'no_packing' | 'pallet' | 'international_pallet' | 'portfolio' | 'rug_rolled' | 'shadow_box' | 'slipcase' | 'slipcase_glass_tape' | 'poly_cardboard' | 'bubble_cardboard' | 'garment_bag' | 'poly_only' | 'dartek_only' | 'bubble_only' | 'cling_wrap' | 'cbin_communal' | 'sonotube' | 'stabilizing_box' | 'shipping_tube_small' | 'shipping_tube_large';
+export type ObjectType = 'art' | 'furniture' | 'jewelry' | 'decorative_arts' | 'collectibles' | 'alcohol' | 'automotive' | 'fashion' | 'other';
+export type ObjectSubType = 'painting_unframed' | 'painting_framed' | 'painting_framed_plexi' | 'painting_framed_glass' | 'work_on_paper_unframed' | 'work_on_paper_framed' | 'work_on_paper_framed_plexi' | 'work_on_paper_framed_glass' | 'mixed_media_unframed' | 'mixed_media_framed' | 'mixed_media_framed_plexi' | 'mixed_media_framed_glass' | 'photograph_unframed' | 'photograph_framed' | 'photograph_framed_plexi' | 'photograph_framed_glass' | 'new_media' | 'sculpture' | 'pedestal' | 'pedestal_case_glass' | 'pedestal_case_plexi' | 'ceramic' | 'neon' | 'tapestry' | 'other_art' | 'table' | 'chair' | 'sofa_loveseat_chaise' | 'floor_lamp' | 'floor_lamp_shade' | 'table_lamp' | 'table_lamp_shade' | 'sconce' | 'ottoman' | 'bookcase_storage' | 'nightstand' | 'armoire_dresser' | 'carpet_rug' | 'mirror' | 'chandelier' | 'bedframe' | 'headboard' | 'desk_vanity' | 'media_console' | 'other_furniture' | 'earrings' | 'necklace' | 'bracelet' | 'ring' | 'brooch' | 'watch' | 'cufflinks' | 'eyeglasses' | 'set' | 'precious_stones' | 'snuff_box_cigarette_case' | 'other_jewelry' | 'vase_vessel' | 'bowl' | 'plaque' | 'object_of_vertu' | 'candelabra_candlestick' | 'dinnerware' | 'flatware' | 'glassware' | 'serveware' | 'porcelain_plate' | 'porcelain_bowl' | 'tabletop_accessory' | 'clock' | 'other_decorative_arts' | 'stamp' | 'book' | 'coin' | 'document_manuscript' | 'toy' | 'miniature_model' | 'figurine_doll' | 'neon_sign' | 'memorabilia' | 'camera_electrical' | 'other_collectibles' | 'wine_bottle' | 'spirits_bottle' | 'beer_bottle' | 'wine_case' | 'spirits_case' | 'beer_case' | 'wine_barrel' | 'spirits_barrel' | 'beer_barrel' | 'other_alcohols' | 'car' | 'motorcycle' | 'bus' | 'van' | 'limousine' | 'carriage' | 'trailer' | 'sidecar' | 'other_automotive' | 'clothing' | 'footwear' | 'handbag' | 'accessories' | 'other_fashion' | 'musical_instrument' | 'firearm_weapon' | 'hunting_fishing' | 'medical_equipment' | 'other';
+export type ParcelTransportServices = 'economy' | 'economy_freight' | 'ground' | 'next_day_air' | 'priority' | 'priority_freight' | 'second_day_air' | 'standard';
+export type WebhookDeliveryType = 'request.created' | 'request.status.updated' | 'shipment.created' | 'shipment.eei_form_status.updated' | 'shipment.schedule.updated' | 'shipment.status.updated' | 'shipment.tracking.updated' | 'ping';
+export type ObjectMaterial = 'stone_marble' | 'precious_stones' | 'fiber_synthetic' | 'fabric_natural' | 'taxidermy' | 'carbon_fiber' | 'live_animal' | 'paper' | 'glass' | 'presious_metals' | 'particleboard' | 'styrofoam' | 'wood' | 'photo_film' | 'sand' | 'metal' | 'plexiglass' | 'aquatic_life' | 'canvas' | 'drywall' | 'hard_plastic' | 'vinyl' | 'soft_plastic' | 'leather' | 'rubber' | 'concreate' | 'paint' | 'electronics' | 'fiber_natural' | 'gas' | 'fabric_synthetic' | 'CITES' | 'liquids' | 'salts';
+export type ArtaTrackingServiceType = 'transport' | 'location' | 'handling' | 'packing' | 'storage' | 'administration' | 'taxes_duties_fees' | 'security' | 'equipment';
+export type ArtaTrackingServiceSubType = 'specialized' | 'consolidated' | 'freight' | 'parcel' | 'collection' | 'delivery' | 'location' | 'unpacking' | 'condition' | 'installation' | 'deinstallation' | 'debris_disposal' | 'site_visit' | 'handling' | 'packing' | 'packing_materials' | 'receive_release' | 'warehouse' | 'customs' | 'coi' | 'administration' | 'taxes_duties' | 'fees' | 'security' | 'equipment';
+export type ArtaTrackingServiceSubSubType = 'armored_transport' | 'dedicated_transport' | 'specialized_shuttle' | 'road_groupage' | 'sea_groupage' | 'sea_freight' | 'ltl_freight' | 'ftl_freight' | 'air_freight' | 'cargo_air_freight' | 'parcel' | 'priority_freight' | 'economy_freight' | 'collection' | 'art_fair_collection' | 'residential_collection' | 'airport_collection' | 'port_collection' | 'dock_collection' | 'consolidated_collection' | 'failed_collection' | 'recollection' | 'delivery' | 'inside_delivery' | 'art_fair_delivery' | 'room_of_choice_delivery' | 'curbside_delivery' | 'residential_delivery' | 'signature_delivery' | 'saturday_delivery' | 'sunday_delivery' | 'scheduled_delivery' | 'after_hours_delivery' | 'airport_delivery' | 'port_delivery' | 'dock_delivery' | 'failed_delivery' | 'redelivery' | 'origin_additional_stops' | 'destination_additional_stops' | 'origin_off_route' | 'destination_off_route' | 'must_fly' | 'origin_unpacking_soft' | 'destination_unpacking_soft' | 'origin_unpacking_wood' | 'destination_unpacking_wood' | 'origin_unpacking' | 'destination_unpacking' | 'origin_full_condition_report' | 'destination_full_condition_report' | 'origin_condition_check' | 'destination_condition_check' | 'installation' | 'placement' | 'assembly' | 'deinstallation' | 'disassembly' | 'debris_disposal' | 'crate_disposal' | 'soft_packed_disposal' | 'origin_site_visit' | 'destination_site_visit' | 'origin_additional_labor' | 'destination_additional_labor' | 'airport_handling' | 'origin_oversized_handling' | 'destination_oversized_handling' | 'origin_additional_stairs' | 'destination_additional_stairs' | 'packing_labor' | 'crate_fabrication' | 't_frame_fabrication' | 'fabrication' | 'retrofitting' | 'additional_packing' | 'pack_into' | 'poly' | 'dartek' | 'bubble' | 'cling_wrap' | 'cbin_communal' | 'blanket' | 'portfolio' | 'poly_cardboard' | 'bubble_cardboard' | 'rug_rolled' | 'cbin_closed' | 'cbin_open' | 'garment_bag' | 'wardrobe_box' | 'cardboard_box' | 'chandelier_box' | 'chair_box' | 'slipcase' | 'glass_tape' | 'stabilizing_box' | 'shadow_box' | 'foam_lined_box' | 'cavity_box' | 'strongbox' | 'double_box' | 'shipping_tube_small' | 'shipping_tube_large' | 'sonotube' | 'alcohol_case' | 'lay_flat_wine_box' | 'lockbox' | 'travel_frame' | 'travel_frame_art' | 'travel_frame_other' | 'a_frame' | 'slat_crate' | 'tri_wall_crate' | 'ply_box' | 'fine_art_econo_crate' | 'fine_art_international_crate' | 'econo_crate' | 'international_econo_crate' | 'furniture_crate' | 'international_furniture_crate' | 'parcel_crate' | 'museum_crate' | 'international_museum_crate' | 'pallet' | 'international_pallet' | 'warehouse_handling' | 'receive_in_fee' | 'release_fee' | 'storage' | 'temp_storage' | 'viewing_room' | 'staging' | 'import_customs_formalities' | 'export_customs_formalities' | 'origin_building_coi' | 'destination_building_coi' | 'double_blind_bols' | 'power_of_attorney' | 'administrative' | 'mpf' | 'bond' | 'duties' | 'taxes' | 'disbursement' | 'temporary_customs_entry' | 'fuel_surcharge' | 'tarmac_supervision' | 'courier_onboard' | 'fork_lift' | 'gantry' | 'pallet_jack' | 'scaffolding' | 'rigging' | 'lift_gate' | 'ramp' | 'floor_protection';
+export type DisqualificationReasonCode = 'external_service_unavailable' | 'client_timeout_reached';
+export type PackageStatus = 'pending' | 'transit' | 'out_for_delivery' | 'delivered' | 'unknown' | 'notfound' | 'undelivered' | 'exception' | 'expired';
+export type EEIFormStatus = 'pending' | 'cleared' | 'approved' | 'rejected' | 'submitted';
+export type ShipmentStatus = 'pending' | 'confirmed' | 'collected' | 'in_transit' | 'completed';
+export type WebhookResourceType = 'ping' | 'request' | 'shipment';
+export type WebhookDeliveryStatus = 'delivered' | 'failed';
+export type PaymentContext = 'hosted_checkout' | 'invoiced';
+export type SupportedCurrency = 'CAD' | 'EUR' | 'GBP' | 'HKD' | 'USD';
+export type AuthTypes = 'api_key';
+export type APIStatus = 'active' | 'beta' | 'deprecated';
+export interface Contact {
+    name: string;
+    email_address?: NullableString;
+    phone_number?: NullableString;
+}
+export interface ArtaLocation {
+    access_restrictions?: Nullable<AccessRestriction[]>;
+    address_line_1?: NullableString;
+    address_line_2?: NullableString;
+    address_line_3?: NullableString;
+    city?: NullableString;
+    region?: NullableString;
+    postal_code?: NullableString;
+    country: string;
+    title?: NullableString;
+    contacts?: Nullable<Contact[]>;
+}
+export type Details = {
+    materials?: Nullable<ObjectMaterial[]>;
+    creation_date?: NullableString;
+    creator?: NullableString;
+    notes?: NullableString;
+    title?: NullableString;
+    is_fragile?: Nullable<boolean>;
+    is_cites?: Nullable<boolean>;
+};
+export interface ArtaObject {
+    internal_reference?: NullableString;
+    current_packing?: Nullable<PackingSubType[]>;
+    details?: Nullable<Details>;
+    height: number | string;
+    width: number | string;
+    weight?: Nullable<number | string>;
+    value: number | string;
+    depth?: Nullable<number | string>;
+    images?: Nullable<string[]>;
+    public_reference?: string;
+    subtype: ObjectSubType;
+    unit_of_measurement?: NullableString;
+    weight_unit?: NullableString;
+    value_currency: SupportedCurrency;
+}
+export interface Disqualification {
+    quote_types: QuoteType[];
+    reason?: NullableString;
+    reason_code: DisqualificationReasonCode;
+}
+export interface InsurancePolicy {
+    amount: number;
+    amount_currency: SupportedCurrency;
+    id: string;
+    insured_value: number;
+    insured_value_currency: SupportedCurrency;
+}
+export interface ArtaService {
+    amount: number;
+    amount_currency: SupportedCurrency;
+    included_services: ArtaService[];
+    is_requested: boolean;
+    is_required: boolean;
+    name: string;
+    sub_subtype: ArtaTrackingServiceSubSubType;
+    subtype: ArtaTrackingServiceSubType;
+    type: ArtaTrackingServiceType;
+}

package/dist/lib/MetadataTypes.js

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

package/dist/lib/arta.d.ts

@@ -0,0 +1,45 @@
+import { Logger, LoggerVerbosity } from './logging';
+import { AttachmentsEndpoint } from './endpoint/attachment';
+import { EmailRulesEndpoint } from './endpoint/emailRules';
+import { EmailSubscriptionsEndpoint } from './endpoint/emailSubscriptions';
+import { HostedSessionsEndpoint } from './endpoint/hostedSessions';
+import { InvoicePaymentsEndpoint } from './endpoint/invoicePayments';
+import { InvoicesEndpoint } from './endpoint/invoices';
+import { KeysEndpoint } from './endpoint/keys';
+import { LogsEndpoint } from './endpoint/logs';
+import { MetadataEndpoint } from './endpoint/metadata';
+import { OrganizationsEndpoint } from './endpoint/organization';
+import { PaymentsEndpoint } from './endpoint/payments';
+import { UploadsEndpoint } from './endpoint/uploads';
+import { WebhookDeliveriesEndpoint } from './endpoint/webhookDeliveries';
+import { WebhooksEndpoint } from './endpoint/webhooks';
+import { TrackingsEndpoint } from './endpoint/trackings';
+import { QuoteRequestsEndpoint } from './endpoint/requests';
+import { ShipmentsEndpoint } from './endpoint/shipments';
+export interface ArtaConfig {
+    host: string;
+    verbosity: LoggerVerbosity;
+    logger: Logger;
+}
+export declare class Arta {
+    private readonly artaClient;
+    private readonly config;
+    attachments: AttachmentsEndpoint;
+    email_rules: EmailRulesEndpoint;
+    email_subscriptions: EmailSubscriptionsEndpoint;
+    hosted_sessions: HostedSessionsEndpoint;
+    invoice_payments: InvoicePaymentsEndpoint;
+    invoices: InvoicesEndpoint;
+    keys: KeysEndpoint;
+    logs: LogsEndpoint;
+    metadata: MetadataEndpoint;
+    organizations: OrganizationsEndpoint;
+    payments: PaymentsEndpoint;
+    requests: QuoteRequestsEndpoint;
+    shipments: ShipmentsEndpoint;
+    trackings: TrackingsEndpoint;
+    uploads: UploadsEndpoint;
+    webhook_deliveries: WebhookDeliveriesEndpoint;
+    webhooks: WebhooksEndpoint;
+    constructor(apiKey: string, config?: Partial<ArtaConfig>);
+}

package/dist/lib/arta.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arta = void 0;
+var ArtaClient_1 = require("./ArtaClient");
+var logging_1 = require("./logging");
+var NodeHttpClient_1 = require("./net/NodeHttpClient");
+var attachment_1 = require("./endpoint/attachment");
+var emailRules_1 = require("./endpoint/emailRules");
+var emailSubscriptions_1 = require("./endpoint/emailSubscriptions");
+var hostedSessions_1 = require("./endpoint/hostedSessions");
+var invoicePayments_1 = require("./endpoint/invoicePayments");
+var invoices_1 = require("./endpoint/invoices");
+var keys_1 = require("./endpoint/keys");
+var logs_1 = require("./endpoint/logs");
+var metadata_1 = require("./endpoint/metadata");
+var organization_1 = require("./endpoint/organization");
+var payments_1 = require("./endpoint/payments");
+var uploads_1 = require("./endpoint/uploads");
+var webhookDeliveries_1 = require("./endpoint/webhookDeliveries");
+var webhooks_1 = require("./endpoint/webhooks");
+var trackings_1 = require("./endpoint/trackings");
+var requests_1 = require("./endpoint/requests");
+var shipments_1 = require("./endpoint/shipments");
+var defaultConfig = {
+    host: 'api.arta.io',
+    verbosity: 'ERROR',
+    logger: console,
+};
+var Arta = /** @class */ (function () {
+    function Arta(apiKey, config) {
+        this.config = Object.assign(defaultConfig, config);
+        (0, logging_1.initLogger)(this.config.logger, this.config.verbosity);
+        this.artaClient = new ArtaClient_1.ArtaClient(new NodeHttpClient_1.NodeHttpClient(), {
+            apiKey: apiKey,
+            host: this.config.host,
+        });
+        this.attachments = new attachment_1.AttachmentsEndpoint(this.artaClient);
+        this.email_rules = new emailRules_1.EmailRulesEndpoint(this.artaClient);
+        this.email_subscriptions = new emailSubscriptions_1.EmailSubscriptionsEndpoint(this.artaClient);
+        this.hosted_sessions = new hostedSessions_1.HostedSessionsEndpoint(this.artaClient);
+        this.invoice_payments = new invoicePayments_1.InvoicePaymentsEndpoint(this.artaClient);
+        this.invoices = new invoices_1.InvoicesEndpoint(this.artaClient);
+        this.keys = new keys_1.KeysEndpoint(this.artaClient);
+        this.logs = new logs_1.LogsEndpoint(this.artaClient);
+        this.metadata = new metadata_1.MetadataEndpoint(this.artaClient);
+        this.organizations = new organization_1.OrganizationsEndpoint(this.artaClient);
+        this.payments = new payments_1.PaymentsEndpoint(this.artaClient);
+        this.requests = new requests_1.QuoteRequestsEndpoint(this.artaClient);
+        this.shipments = new shipments_1.ShipmentsEndpoint(this.artaClient);
+        this.trackings = new trackings_1.TrackingsEndpoint(this.artaClient);
+        this.uploads = new uploads_1.UploadsEndpoint(this.artaClient);
+        this.webhook_deliveries = new webhookDeliveries_1.WebhookDeliveriesEndpoint(this.artaClient);
+        this.webhooks = new webhooks_1.WebhooksEndpoint(this.artaClient);
+    }
+    return Arta;
+}());
+exports.Arta = Arta;

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

@@ -0,0 +1,32 @@
+import { ArtaID } from '../ArtaClient';
+import { RestClient } from '../net/RestClient';
+import { DatedInterface, NullableString } from '../utils';
+import { Page } from '../pagination';
+export interface Attachment extends DatedInterface {
+    id: ArtaID;
+    upload_id: number;
+    request_id?: NullableString;
+    shipment_id?: NullableString;
+}
+export interface AttachmentCreateBodyRequest {
+    upload_id: number;
+    request_id: string;
+}
+export interface AttachmentCreateBodyShipment {
+    upload_id: number;
+    shipment_id: string;
+}
+export type AttachmentCreateBody = AttachmentCreateBodyRequest | AttachmentCreateBodyShipment;
+export interface AttachmentCreate {
+    attachment: AttachmentCreateBody;
+}
+export declare class AttachmentsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<Attachment>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<Attachment>>;
+    create(payload: AttachmentCreateBody, auth?: string): Promise<Attachment>;
+    remove(id: ArtaID, auth?: string): Promise<void>;
+}

package/dist/lib/endpoint/attachment.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentsEndpoint = void 0;
+var endpoint_1 = require("./endpoint");
+var AttachmentsEndpoint = /** @class */ (function () {
+    function AttachmentsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/attachments';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient);
+    }
+    AttachmentsEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    AttachmentsEndpoint.prototype.list = function (page, pageSize, auth) {
+        if (page === void 0) { page = 1; }
+        if (pageSize === void 0) { pageSize = 20; }
+        return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
+    };
+    AttachmentsEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ attachment: payload }, auth);
+    };
+    AttachmentsEndpoint.prototype.remove = function (id, auth) {
+        return this.defaultEndpoint.remove(id, auth);
+    };
+    return AttachmentsEndpoint;
+}());
+exports.AttachmentsEndpoint = AttachmentsEndpoint;

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

@@ -0,0 +1,30 @@
+import { ArtaID } from '../ArtaClient';
+import { RestClient } from '../net/RestClient';
+import { DatedInterface } from '../utils';
+import { Page } from '../pagination';
+import { EmailNotificationId, Recipients } from '../MetadataTypes';
+export interface EmailRule extends DatedInterface {
+    id: ArtaID;
+    email_notification_id: EmailNotificationId;
+    recipients: Recipients[];
+}
+export interface EmailRuleCreateBody {
+    email_notification_id: EmailNotificationId;
+    recipients: Recipients[];
+}
+export interface EmailRuleCreate {
+    email_rule: EmailRuleCreateBody;
+}
+export declare class EmailRulesEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<EmailRule>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<EmailRule>>;
+    update(id: ArtaID, payload: {
+        recipients: Recipients[];
+    }, auth?: string): Promise<EmailRule>;
+    create(payload: EmailRuleCreateBody, auth?: string): Promise<EmailRule>;
+    remove(id: ArtaID, auth?: string): Promise<void>;
+}

package/dist/lib/endpoint/emailRules.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailRulesEndpoint = void 0;
+var endpoint_1 = require("./endpoint");
+var EmailRulesEndpoint = /** @class */ (function () {
+    function EmailRulesEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/email_rules';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient);
+    }
+    EmailRulesEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    EmailRulesEndpoint.prototype.list = function (page, pageSize, auth) {
+        if (page === void 0) { page = 1; }
+        if (pageSize === void 0) { pageSize = 20; }
+        return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
+    };
+    EmailRulesEndpoint.prototype.update = function (id, payload, auth) {
+        var emailRulesPayload = {
+            email_rule: payload,
+        };
+        return this.defaultEndpoint.update(id, emailRulesPayload, auth);
+    };
+    EmailRulesEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ email_rule: payload }, auth);
+    };
+    EmailRulesEndpoint.prototype.remove = function (id, auth) {
+        return this.defaultEndpoint.remove(id, auth);
+    };
+    return EmailRulesEndpoint;
+}());
+exports.EmailRulesEndpoint = EmailRulesEndpoint;

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

@@ -0,0 +1,32 @@
+import { ArtaID } from '../ArtaClient';
+import { RestClient } from '../net/RestClient';
+import { DatedInterface, NullableString } from '../utils';
+import { Page } from '../pagination';
+import { EmailNotificationId } from '../MetadataTypes';
+export interface EmailSubscription extends DatedInterface {
+    id: ArtaID;
+    email_notification_ids: EmailNotificationId;
+    email_address: string;
+    name?: NullableString;
+}
+export interface EmailSubscriptionCreateBody {
+    email_notification_ids: EmailNotificationId;
+    email_address: string;
+    name?: NullableString;
+}
+export interface EmailSubscriptionCreate {
+    email_subscription: EmailSubscriptionCreateBody;
+}
+export declare class EmailSubscriptionsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<EmailSubscription>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<EmailSubscription>>;
+    update(id: ArtaID, payload: {
+        email_notification_ids: EmailNotificationId[];
+    }, auth?: string): Promise<EmailSubscription>;
+    create(payload: EmailSubscriptionCreateBody, auth?: string): Promise<EmailSubscription>;
+    remove(id: ArtaID, auth?: string): Promise<void>;
+}