@artaio/node-api 0.27.0

package/dist/lib/endpoint/emailSubscriptions.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailSubscriptionsEndpoint = void 0;
+var endpoint_1 = require("./endpoint");
+var EmailSubscriptionsEndpoint = /** @class */ (function () {
+    function EmailSubscriptionsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/email_subscriptions';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient);
+    }
+    EmailSubscriptionsEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    EmailSubscriptionsEndpoint.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);
+    };
+    EmailSubscriptionsEndpoint.prototype.update = function (id, payload, auth) {
+        var emailNotificationPayload = {
+            email_subscription: payload,
+        };
+        return this.defaultEndpoint.update(id, emailNotificationPayload, auth);
+    };
+    EmailSubscriptionsEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ email_subscription: payload }, auth);
+    };
+    EmailSubscriptionsEndpoint.prototype.remove = function (id, auth) {
+        return this.defaultEndpoint.remove(id, auth);
+    };
+    return EmailSubscriptionsEndpoint;
+}());
+exports.EmailSubscriptionsEndpoint = EmailSubscriptionsEndpoint;

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

@@ -0,0 +1,26 @@
+import { ArtaID } from '../ArtaClient';
+import { RestClient } from '../net/RestClient';
+import { DatedInterface } from '../utils';
+import { Page } from '../pagination';
+import { QueryParameters } from '../queryParams';
+export interface Endpoint<T, U> {
+    list: (queryParam?: QueryParameters, auth?: string) => Promise<Page<T>>;
+    listAll: (auth?: string, onReturn?: (params: any) => T) => AsyncGenerator<T>;
+    getById: (id: ArtaID, auth?: string) => Promise<T>;
+    create: (payload: U, auth?: string) => Promise<T>;
+    update: (id: ArtaID, payload: Partial<U> | Partial<T>, auth?: string) => Promise<T>;
+    remove: (id: ArtaID, auth?: string) => Promise<void>;
+}
+export declare class DefaultEndpoint<T extends DatedInterface, U> implements Endpoint<T, U> {
+    private readonly artaClient;
+    private readonly onReturn?;
+    private readonly path;
+    constructor(path: string, artaClient: RestClient, onReturn?: ((params: any) => T) | undefined);
+    getById(id: ArtaID, auth?: string): Promise<T>;
+    list(queryParam?: QueryParameters, auth?: string): Promise<Page<T>>;
+    listAll(auth?: string): AsyncGenerator<T>;
+    create(payload: U, auth?: string): Promise<T>;
+    update(id: ArtaID, payload: Partial<U> | Partial<T>, auth?: string): Promise<T>;
+    remove(id: ArtaID, auth?: string): Promise<void>;
+    private processBody;
+}

package/dist/lib/endpoint/endpoint.js

@@ -0,0 +1,168 @@
+"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 };
+    }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultEndpoint = void 0;
+var utils_1 = require("../utils");
+var queryParams_1 = require("../queryParams");
+var DefaultEndpoint = /** @class */ (function () {
+    function DefaultEndpoint(path, artaClient, onReturn) {
+        this.artaClient = artaClient;
+        this.onReturn = onReturn;
+        this.path = path.startsWith('/') ? path : "/".concat(path);
+    }
+    DefaultEndpoint.prototype.getById = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var req;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.get("".concat(this.path, "/").concat(id), auth)];
+                    case 1:
+                        req = _a.sent();
+                        return [2 /*return*/, this.processBody(req)];
+                }
+            });
+        });
+    };
+    DefaultEndpoint.prototype.list = function (queryParam, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var toUseQueryParam, queryParams, body, items;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        toUseQueryParam = queryParam !== null && queryParam !== void 0 ? queryParam : queryParams_1.defaultQueryParams;
+                        queryParams = (0, queryParams_1.parseQueryParams)(toUseQueryParam);
+                        return [4 /*yield*/, this.artaClient.get("".concat(this.path).concat(queryParams), auth)];
+                    case 1:
+                        body = _a.sent();
+                        items = body.items.map(this.processBody.bind(this));
+                        return [2 /*return*/, { items: items, metadata: body.metadata }];
+                }
+            });
+        });
+    };
+    DefaultEndpoint.prototype.listAll = function (auth) {
+        return __asyncGenerator(this, arguments, function listAll_1() {
+            var page, returned_elements, body, _i, _a, item;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        page = 1;
+                        returned_elements = 0;
+                        _b.label = 1;
+                    case 1: return [4 /*yield*/, __await(this.artaClient.get("".concat(this.path, "?page=").concat(page), auth))];
+                    case 2:
+                        body = _b.sent();
+                        page = body.metadata.page + 1;
+                        _i = 0, _a = body.items;
+                        _b.label = 3;
+                    case 3:
+                        if (!(_i < _a.length)) return [3 /*break*/, 7];
+                        item = _a[_i];
+                        returned_elements++;
+                        return [4 /*yield*/, __await(this.processBody(item))];
+                    case 4: return [4 /*yield*/, _b.sent()];
+                    case 5:
+                        _b.sent();
+                        _b.label = 6;
+                    case 6:
+                        _i++;
+                        return [3 /*break*/, 3];
+                    case 7:
+                        if (body.metadata.total_count > returned_elements) return [3 /*break*/, 1];
+                        _b.label = 8;
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DefaultEndpoint.prototype.create = function (payload, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var body;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.post(this.path, payload, auth)];
+                    case 1:
+                        body = _a.sent();
+                        return [2 /*return*/, this.processBody(body)];
+                }
+            });
+        });
+    };
+    DefaultEndpoint.prototype.update = function (id, payload, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var body;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.patch("".concat(this.path, "/").concat(id), payload, auth)];
+                    case 1:
+                        body = _a.sent();
+                        return [2 /*return*/, this.processBody(body)];
+                }
+            });
+        });
+    };
+    DefaultEndpoint.prototype.remove = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.artaClient.delete("".concat(this.path, "/").concat(id), auth)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    DefaultEndpoint.prototype.processBody = function (payload) {
+        var resource = (0, utils_1.convertDatesToUtc)(payload);
+        resource = this.onReturn ? this.onReturn(resource) : resource;
+        return resource;
+    };
+    return DefaultEndpoint;
+}());
+exports.DefaultEndpoint = DefaultEndpoint;

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

@@ -0,0 +1,53 @@
+import { ArtaID } from '../ArtaClient';
+import { RestClient } from '../net/RestClient';
+import { Page } from '../pagination';
+import { AdditionalService, ArtaLocation, ArtaObject, Insurance, PaymentProcessType, QuoteType, QuoteRequestStatus } from '../MetadataTypes';
+import { DatedInterface, Nullable, NullableString } from '../utils';
+import { HostedSessionsSearch } from '../search';
+export interface HostedSession extends DatedInterface {
+    id: ArtaID;
+    additional_services?: Nullable<AdditionalService[]>;
+    cancel_url?: NullableString;
+    destination?: Nullable<ArtaLocation>;
+    insurance?: Nullable<Insurance>;
+    internal_reference?: NullableString;
+    objects: ArtaObject[];
+    origin: ArtaLocation;
+    preferred_quote_types?: Nullable<QuoteType[]>;
+    public_reference?: NullableString;
+    shipping_notes?: NullableString;
+    success_url?: NullableString;
+    payment_process: PaymentProcessType;
+    private_token: string;
+    shortcode: string;
+    status: QuoteRequestStatus;
+    url?: NullableString;
+    cancel: (auth?: string) => Promise<HostedSession>;
+}
+export interface HostedSessionCreateBody {
+    additional_services?: Nullable<AdditionalService[]>;
+    cancel_url?: NullableString;
+    destination?: Nullable<ArtaLocation>;
+    insurance?: Nullable<Insurance>;
+    internal_reference?: NullableString;
+    objects: ArtaObject[];
+    origin: ArtaLocation;
+    preferred_quote_types?: Nullable<QuoteType[]>;
+    public_reference?: NullableString;
+    shipping_notes?: NullableString;
+    success_url?: NullableString;
+}
+export interface HostedSessionCreate {
+    hosted_session: HostedSessionCreateBody;
+}
+export declare class HostedSessionsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    private withFunctionCalls;
+    getById(id: ArtaID, auth?: string): Promise<HostedSession>;
+    list(search?: HostedSessionsSearch, page?: number, pageSize?: number, auth?: string): Promise<Page<HostedSession>>;
+    create(payload: HostedSessionCreateBody, auth?: string): Promise<HostedSession>;
+    cancel(id: ArtaID, auth?: string): Promise<HostedSession>;
+}

package/dist/lib/endpoint/hostedSessions.js

@@ -0,0 +1,81 @@
+"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.HostedSessionsEndpoint = void 0;
+var utils_1 = require("../utils");
+var endpoint_1 = require("./endpoint");
+var HostedSessionsEndpoint = /** @class */ (function () {
+    function HostedSessionsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/hosted_sessions';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient, this.withFunctionCalls.bind(this));
+    }
+    HostedSessionsEndpoint.prototype.withFunctionCalls = function (hostedSession) {
+        var _this = this;
+        hostedSession.cancel = function (auth) {
+            return _this.cancel(hostedSession.id, auth);
+        };
+        return hostedSession;
+    };
+    HostedSessionsEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    HostedSessionsEndpoint.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);
+    };
+    HostedSessionsEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ hosted_session: payload }, auth);
+    };
+    HostedSessionsEndpoint.prototype.cancel = function (id, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawSession;
+            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:
+                        rawSession = _a.sent();
+                        return [2 /*return*/, this.withFunctionCalls((0, utils_1.convertDatesToUtc)(rawSession))];
+                }
+            });
+        });
+    };
+    return HostedSessionsEndpoint;
+}());
+exports.HostedSessionsEndpoint = HostedSessionsEndpoint;

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

@@ -0,0 +1,24 @@
+import { ArtaID } from '../ArtaClient';
+import { SupportedCurrency } from '../MetadataTypes';
+import { RestClient } from '../net/RestClient';
+import { Page } from '../pagination';
+import { DatedInterface, NullableString } from '../utils';
+export interface InvoicePayment extends DatedInterface {
+    id: ArtaID;
+    amount: number;
+    amount_currency: SupportedCurrency;
+    credit_id: NullableString;
+    invoice_id: NullableString;
+    paid_on: Date;
+    payment_id?: NullableString;
+    shipment_id?: NullableString;
+}
+export declare class InvoicePaymentsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<InvoicePayment>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<InvoicePayment>>;
+    private enrichFields;
+}

package/dist/lib/endpoint/invoicePayments.js

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

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

@@ -0,0 +1,27 @@
+import { ArtaID } from '../ArtaClient';
+import { SupportedCurrency } from '../MetadataTypes';
+import { RestClient } from '../net/RestClient';
+import { Page } from '../pagination';
+import { DatedInterface, Nullable, NullableString } from '../utils';
+export interface Invoice extends DatedInterface {
+    amount_owed: number;
+    amount_owed_currency: SupportedCurrency;
+    amount_paid: number;
+    amount_paid_currency: SupportedCurrency;
+    created_at: Date;
+    invoice_url?: NullableString;
+    id: ArtaID;
+    issued_on: Nullable<Date>;
+    shipment_id: NullableString;
+    status: string;
+    updated_at: Date;
+}
+export declare class InvoicesEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<Invoice>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<Invoice>>;
+    private enrichFields;
+}

package/dist/lib/endpoint/invoices.js

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

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

@@ -0,0 +1,28 @@
+import { ArtaID } from '../ArtaClient';
+import { RestClient } from '../net/RestClient';
+import { DatedInterface, NullableString } from '../utils';
+import { Page } from '../pagination';
+export interface Key extends DatedInterface {
+    id: ArtaID;
+    is_testing: boolean;
+    name?: NullableString;
+    token: string;
+}
+export interface KeyCreateBody {
+    is_testing: boolean;
+    name?: NullableString;
+}
+export interface KeyCreate {
+    api_key: KeyCreateBody;
+}
+export declare class KeysEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<Key>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<Key>>;
+    listAll(auth?: string): AsyncGenerator<Key>;
+    create(payload: KeyCreateBody, auth?: string): Promise<Key>;
+    remove(id: ArtaID, auth?: string): Promise<void>;
+}

package/dist/lib/endpoint/keys.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeysEndpoint = void 0;
+var endpoint_1 = require("./endpoint");
+var KeysEndpoint = /** @class */ (function () {
+    function KeysEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/api_keys';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient);
+    }
+    KeysEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    KeysEndpoint.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);
+    };
+    KeysEndpoint.prototype.listAll = function (auth) {
+        return this.defaultEndpoint.listAll(auth);
+    };
+    KeysEndpoint.prototype.create = function (payload, auth) {
+        return this.defaultEndpoint.create({ api_key: payload }, auth);
+    };
+    KeysEndpoint.prototype.remove = function (id, auth) {
+        return this.defaultEndpoint.remove(id, auth);
+    };
+    return KeysEndpoint;
+}());
+exports.KeysEndpoint = KeysEndpoint;

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

@@ -0,0 +1,29 @@
+import { ArtaID } from '../ArtaClient';
+import { RestClient } from '../net/RestClient';
+import { Page } from '../pagination';
+import { DatedInterface, NullableString } from '../utils';
+export interface Log extends DatedInterface {
+    api_key_id: number;
+    arta_version: string;
+    end_at: Date;
+    id: ArtaID;
+    created_at: Date;
+    method: string;
+    path: string;
+    query_params: string;
+    request_body?: NullableString;
+    request_id: string;
+    response_body?: NullableString;
+    start_at: Date;
+    status: number;
+    updated_at: Date;
+}
+export declare class LogsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<Log>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<Log>>;
+    private enrichFields;
+}

package/dist/lib/endpoint/logs.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogsEndpoint = void 0;
+var utils_1 = require("../utils");
+var endpoint_1 = require("./endpoint");
+var LogsEndpoint = /** @class */ (function () {
+    function LogsEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/logs';
+        this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient, this.enrichFields);
+    }
+    LogsEndpoint.prototype.getById = function (id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    };
+    LogsEndpoint.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);
+    };
+    LogsEndpoint.prototype.enrichFields = function (resource) {
+        resource.start_at = (0, utils_1.createDateAsUTC)(resource.start_at);
+        resource.end_at = (0, utils_1.createDateAsUTC)(resource.end_at);
+        return resource;
+    };
+    return LogsEndpoint;
+}());
+exports.LogsEndpoint = LogsEndpoint;

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

@@ -0,0 +1,67 @@
+import { AccessRestriction, APIStatus, ArtaTrackingServiceSubSubType, ArtaTrackingServiceSubType, ArtaTrackingServiceType, AuthTypes, EmailNotificationId, Insurance, ObjectMaterial, ObjectSubType, ObjectType, PackageStatus, PackingSubType, PackingType, ParcelTransportServices, PaymentProcessType, QuoteRequestStatus, QuoteType, Recipients, ShipmentStatus, SupportedCurrency } from '../MetadataTypes';
+import { RestClient } from '../net/RestClient';
+export interface APIVersionMetadata {
+    authentication: AuthTypes[];
+    description: string;
+    id: string;
+    status: APIStatus;
+}
+export interface CurrencyMetadata {
+    symbol: string;
+    id: SupportedCurrency;
+    name: string;
+}
+export interface EmailNotificationMetadata {
+    description: string;
+    optional_recipients: Recipients;
+    id: EmailNotificationId;
+}
+export interface BaseMetadata<T> {
+    description: string;
+    id: T;
+    name: string;
+}
+export type InsurancesMetadata = BaseMetadata<Insurance>;
+export type LocationAccessRestrictionMetadata = BaseMetadata<AccessRestriction>;
+export type ObjectMaterialsMetadata = BaseMetadata<ObjectMaterial>;
+export interface ObjectMetadata extends BaseMetadata<ObjectType> {
+    subtypes: BaseMetadata<ObjectSubType>[];
+}
+export type PackageStatusesMetadata = BaseMetadata<PackageStatus>;
+export interface PackingMetadata extends BaseMetadata<PackingType> {
+    subtypes: BaseMetadata<PackingSubType>[];
+}
+export type ParcelTransportServicesMetadata = BaseMetadata<ParcelTransportServices>;
+export type PaymentProcessTypeMetadata = BaseMetadata<PaymentProcessType>;
+export type QuotesMetadata = BaseMetadata<QuoteType>;
+export type RequestStatusesMetadata = BaseMetadata<QuoteRequestStatus>;
+export interface ServiceSubSubTypeMetadata extends BaseMetadata<ArtaTrackingServiceSubSubType> {
+    is_requestable: boolean;
+}
+export interface ServicesSubTypeMetadata extends BaseMetadata<ArtaTrackingServiceSubType> {
+    sub_subtypes: ServiceSubSubTypeMetadata[];
+}
+export interface ServicesMetadata extends BaseMetadata<ArtaTrackingServiceType> {
+    subtypes: ServicesSubTypeMetadata[];
+}
+export type ShipmentStatusesMetadata = BaseMetadata<ShipmentStatus>;
+export declare class MetadataEndpoint {
+    private readonly artaClient;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    apiVersions(auth?: string): Promise<APIVersionMetadata[]>;
+    currencies(auth?: string): Promise<CurrencyMetadata[]>;
+    emailNotifications(auth?: string): Promise<EmailNotificationMetadata[]>;
+    insurances(auth?: string): Promise<InsurancesMetadata[]>;
+    locationAccessRestrictions(auth?: string): Promise<LocationAccessRestrictionMetadata[]>;
+    objectMaterials(auth?: string): Promise<ObjectMaterialsMetadata[]>;
+    objects(auth?: string): Promise<ObjectMetadata[]>;
+    packageStatuses(auth?: string): Promise<PackageStatusesMetadata[]>;
+    packings(auth?: string): Promise<PackingMetadata[]>;
+    parcelTransportServices(auth?: string): Promise<ParcelTransportServicesMetadata[]>;
+    paymentProcessTypes(auth?: string): Promise<PaymentProcessTypeMetadata[]>;
+    quotes(auth?: string): Promise<QuotesMetadata[]>;
+    requestStatuses(auth?: string): Promise<RequestStatusesMetadata[]>;
+    services(auth?: string): Promise<ServicesMetadata[]>;
+    shipmentStatuses(auth?: string): Promise<ShipmentStatusesMetadata[]>;
+}