@artaio/node-api 0.27.0

package/dist/lib/endpoint/metadata.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataEndpoint = void 0;
+var MetadataEndpoint = /** @class */ (function () {
+    function MetadataEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/metadata';
+    }
+    MetadataEndpoint.prototype.apiVersions = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/api_versions"), auth);
+    };
+    MetadataEndpoint.prototype.currencies = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/currencies"), auth);
+    };
+    MetadataEndpoint.prototype.emailNotifications = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/email_notifications"), auth);
+    };
+    MetadataEndpoint.prototype.insurances = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/insurances"), auth);
+    };
+    MetadataEndpoint.prototype.locationAccessRestrictions = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/location_access_restrictions"), auth);
+    };
+    MetadataEndpoint.prototype.objectMaterials = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/object_materials"), auth);
+    };
+    MetadataEndpoint.prototype.objects = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/objects"), auth);
+    };
+    MetadataEndpoint.prototype.packageStatuses = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/package_statuses"), auth);
+    };
+    MetadataEndpoint.prototype.packings = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/packings"), auth);
+    };
+    MetadataEndpoint.prototype.parcelTransportServices = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/parcel_transport_services"), auth);
+    };
+    MetadataEndpoint.prototype.paymentProcessTypes = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/payment_process_types"), auth);
+    };
+    MetadataEndpoint.prototype.quotes = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/quotes"), auth);
+    };
+    MetadataEndpoint.prototype.requestStatuses = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/request_statuses"), auth);
+    };
+    MetadataEndpoint.prototype.services = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/services"), auth);
+    };
+    MetadataEndpoint.prototype.shipmentStatuses = function (auth) {
+        return this.artaClient.get("".concat(this.path, "/shipment_statuses"), auth);
+    };
+    return MetadataEndpoint;
+}());
+exports.MetadataEndpoint = MetadataEndpoint;

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

@@ -0,0 +1,31 @@
+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;
+}
+export declare class OrganizationsEndpoint {
+    private readonly artaClient;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    /** Retrieves the Organization associated with the API Key
+     * @param [auth] An optional API key.
+     * @returns The Organization
+     * @throws ArtaSDKError thrown if some problem happened while communicating with the API.
+     */
+    get(auth?: string): Promise<Organization>;
+    /** Updates the Organization associated with the API Key
+     * @param [auth] An optional API key.
+     * @returns The Organization
+     * @throws ArtaSDKError thrown if some problem happened while communicating with the API.
+     */
+    update(organization: Partial<Organization>, auth?: string): Promise<Organization>;
+}

package/dist/lib/endpoint/organization.js

@@ -0,0 +1,84 @@
+"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.OrganizationsEndpoint = void 0;
+var utils_1 = require("../utils");
+var OrganizationsEndpoint = /** @class */ (function () {
+    function OrganizationsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/organization';
+    }
+    /** Retrieves the Organization associated with the API Key
+     * @param [auth] An optional API key.
+     * @returns The Organization
+     * @throws ArtaSDKError thrown if some problem happened while communicating with the API.
+     */
+    OrganizationsEndpoint.prototype.get = function (auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var artaResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.get(this.path, auth)];
+                    case 1:
+                        artaResponse = _a.sent();
+                        return [2 /*return*/, (0, utils_1.convertDatesToUtc)(artaResponse)];
+                }
+            });
+        });
+    };
+    /** Updates the Organization associated with the API Key
+     * @param [auth] An optional API key.
+     * @returns The Organization
+     * @throws ArtaSDKError thrown if some problem happened while communicating with the API.
+     */
+    OrganizationsEndpoint.prototype.update = function (organization, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var artaResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.patch(this.path, { organization: organization }, auth)];
+                    case 1:
+                        artaResponse = _a.sent();
+                        return [2 /*return*/, (0, utils_1.convertDatesToUtc)(artaResponse)];
+                }
+            });
+        });
+    };
+    return OrganizationsEndpoint;
+}());
+exports.OrganizationsEndpoint = OrganizationsEndpoint;

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

@@ -0,0 +1,21 @@
+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;
+}
+export declare class PaymentsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<Payment>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<Payment>>;
+    private enrichFields;
+}

package/dist/lib/endpoint/payments.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentsEndpoint = void 0;
+var endpoint_1 = require("./endpoint");
+var PaymentsEndpoint = /** @class */ (function () {
+    function PaymentsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/payments';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient, this.enrichFields);
+    }
+    PaymentsEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    PaymentsEndpoint.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);
+    };
+    PaymentsEndpoint.prototype.enrichFields = function (resource) {
+        resource.amount = Number(resource.amount);
+        resource.paid_on = new Date(resource.paid_on);
+        return resource;
+    };
+    return PaymentsEndpoint;
+}());
+exports.PaymentsEndpoint = PaymentsEndpoint;

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

@@ -0,0 +1,80 @@
+import { ArtaID } from '../ArtaClient';
+import { AdditionalService, ArtaLocation, ArtaObject, ArtaService, Contact, Disqualification, Insurance, InsurancePolicy, PaymentProcessType, 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 Quote {
+    id: number;
+    included_services: ArtaService[];
+    included_insurance_policy?: Nullable<InsurancePolicy>;
+    optional_services: ArtaService[];
+    quote_type: QuoteType;
+    status: string;
+    total: number;
+    total_currency: SupportedCurrency;
+}
+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>;
+}
+export interface QuoteRequestCreateBody {
+    additional_services?: Nullable<AdditionalService[]>;
+    currency?: Nullable<SupportedCurrency>;
+    destination: ArtaLocation;
+    insurance?: Nullable<Insurance>;
+    internal_reference?: NullableString;
+    objects: ArtaObject[];
+    origin: ArtaLocation;
+    preferred_quote_types?: Nullable<QuoteType[]>;
+    public_reference?: NullableString;
+    shipping_notes?: NullableString;
+}
+export interface QuoteRequestCreate {
+    request: QuoteRequestCreateBody;
+}
+export interface UpdateRequestsContactsBody {
+    origin?: Nullable<Contact[]>;
+    destination?: Nullable<Contact[]>;
+}
+export interface CustomQuotePayload {
+    note: string;
+}
+export declare class QuoteRequestsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    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>;
+}

package/dist/lib/endpoint/requests.js

@@ -0,0 +1,113 @@
+"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.QuoteRequestsEndpoint = void 0;
+var utils_1 = require("../utils");
+var endpoint_1 = require("./endpoint");
+var QuoteRequestsEndpoint = /** @class */ (function () {
+    function QuoteRequestsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/requests';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient, this.enrichFields.bind(this));
+    }
+    QuoteRequestsEndpoint.prototype.enrichFields = function (resource) {
+        var _this = this;
+        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;
+    };
+    QuoteRequestsEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    QuoteRequestsEndpoint.prototype.list = function (search, page, pageSize, auth) {
+        if (page === void 0) { page = 1; }
+        if (pageSize === void 0) { pageSize = 20; }
+        return this.defaultEndpoint.list({ page: page, page_size: pageSize, search: search }, auth);
+    };
+    QuoteRequestsEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ request: payload }, auth);
+    };
+    QuoteRequestsEndpoint.prototype.updateContacts = function (id, contacts, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawReq;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.patch("".concat(this.path, "/").concat(id, "/contacts"), contacts, auth)];
+                    case 1:
+                        rawReq = _a.sent();
+                        return [2 /*return*/, this.enrichFields(rawReq)];
+                }
+            });
+        });
+    };
+    QuoteRequestsEndpoint.prototype.requireCustomQuotes = function (id, customQuote, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawReq;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.patch("".concat(this.path, "/").concat(id, "/custom"), customQuote, auth)];
+                    case 1:
+                        rawReq = _a.sent();
+                        return [2 /*return*/, this.enrichFields(rawReq)];
+                }
+            });
+        });
+    };
+    QuoteRequestsEndpoint.prototype.cancel = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawReq;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.patch("".concat(this.path, "/").concat(id, "/cancel"), undefined, auth)];
+                    case 1:
+                        rawReq = _a.sent();
+                        return [2 /*return*/, this.enrichFields(rawReq)];
+                }
+            });
+        });
+    };
+    return QuoteRequestsEndpoint;
+}());
+exports.QuoteRequestsEndpoint = QuoteRequestsEndpoint;

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

@@ -0,0 +1,80 @@
+import { ArtaID } from '../ArtaClient';
+import { ArtaLocation, ArtaObject, ArtaService, EEIFormStatus, InsurancePolicy, PackageStatus, PackingSubType, PaymentProcessType, QuoteType, ShipmentStatus, 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 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>;
+    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[]>;
+}
+export interface ShipmentCreateBody {
+    internal_reference?: NullableString;
+    public_reference?: NullableString;
+    quote_id: number;
+    shipping_notes?: NullableString;
+}
+export interface ShipmentCreate {
+    shipment: ShipmentCreateBody;
+}
+export declare class ShipmentsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    private enrichFields;
+    getById(id: ArtaID, auth?: string): Promise<Shipment>;
+    list(search?: ShipmentsSearch, page?: number, pageSize?: number, auth?: string): Promise<Page<Shipment>>;
+    create(payload: ShipmentCreateBody, auth?: string): Promise<Shipment>;
+}

package/dist/lib/endpoint/shipments.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShipmentsEndpoint = void 0;
+var utils_1 = require("../utils");
+var endpoint_1 = require("./endpoint");
+var ShipmentsEndpoint = /** @class */ (function () {
+    function ShipmentsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        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.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 (r.packages) {
+            r.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;
+    };
+    ShipmentsEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    ShipmentsEndpoint.prototype.list = function (search, page, pageSize, auth) {
+        if (page === void 0) { page = 1; }
+        if (pageSize === void 0) { pageSize = 20; }
+        return this.defaultEndpoint.list({ page: page, page_size: pageSize, search: search }, auth);
+    };
+    ShipmentsEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ shipment: payload }, auth);
+    };
+    return ShipmentsEndpoint;
+}());
+exports.ShipmentsEndpoint = ShipmentsEndpoint;

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

@@ -0,0 +1,25 @@
+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;
+}
+export declare class TrackingsEndpoint {
+    private readonly artaClient;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<Tracking>;
+}

package/dist/lib/endpoint/trackings.js

@@ -0,0 +1,64 @@
+"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.TrackingsEndpoint = void 0;
+var utils_1 = require("../utils");
+var TrackingsEndpoint = /** @class */ (function () {
+    function TrackingsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/trackings';
+    }
+    TrackingsEndpoint.prototype.getById = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tracking;
+            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];
+                }
+            });
+        });
+    };
+    return TrackingsEndpoint;
+}());
+exports.TrackingsEndpoint = TrackingsEndpoint;

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

@@ -0,0 +1,36 @@
+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;
+}
+export interface UploadCreateBody {
+    document_type: DocumentType;
+    document_type_label?: NullableString;
+    file_name: boolean;
+    size: string;
+    mime_type: MimeType;
+}
+export interface UploadCreate {
+    upload: UploadCreateBody;
+}
+export declare class UploadsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<Upload>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<Upload>>;
+    create(payload: UploadCreateBody, auth?: string): Promise<Upload>;
+    remove(id: ArtaID, auth?: string): Promise<void>;
+}