@artaio/node-api 1.6.0 → 1.8.0

package/dist/lib/arta.d.ts

@@ -1,4 +1,5 @@
 import type { Logger, LoggerVerbosity } from './logging';
+import { AddressVerificationsEndpoint } from './endpoint/addressVerifications';
 import { AttachmentsEndpoint } from './endpoint/attachment';
 import { EmailRulesEndpoint } from './endpoint/emailRules';
 import { EmailSubscriptionsEndpoint } from './endpoint/emailSubscriptions';
@@ -15,6 +16,8 @@ import { WebhookDeliveriesEndpoint } from './endpoint/webhookDeliveries';
 import { WebhooksEndpoint } from './endpoint/webhooks';
 import { TrackingsEndpoint } from './endpoint/trackings';
 import { QuoteRequestsEndpoint } from './endpoint/requests';
+import { SelfShipCollectionAvailabilityChecksEndpoint } from './endpoint/selfShipCollectionAvailabilityChecks';
+import { SelfShipCollectionsEndpoint } from './endpoint/selfShipCollections';
 import { ShipmentsEndpoint } from './endpoint/shipments';
 import { TagsEndpoint } from './endpoint/tags';
 export interface ArtaConfig {
@@ -25,6 +28,7 @@ export interface ArtaConfig {
 export declare class Arta {
     private readonly artaClient;
     private readonly config;
+    address_verifications: AddressVerificationsEndpoint;
     attachments: AttachmentsEndpoint;
     email_rules: EmailRulesEndpoint;
     email_subscriptions: EmailSubscriptionsEndpoint;
@@ -37,6 +41,8 @@ export declare class Arta {
     organizations: OrganizationsEndpoint;
     payments: PaymentsEndpoint;
     requests: QuoteRequestsEndpoint;
+    self_ship_collection_availability_checks: SelfShipCollectionAvailabilityChecksEndpoint;
+    self_ship_collections: SelfShipCollectionsEndpoint;
     shipments: ShipmentsEndpoint;
     tags: TagsEndpoint;
     trackings: TrackingsEndpoint;

package/dist/lib/arta.js

@@ -4,6 +4,7 @@ exports.Arta = void 0;
 var ArtaClient_1 = require("./ArtaClient");
 var logging_1 = require("./logging");
 var FetchHttpClient_1 = require("./net/FetchHttpClient");
+var addressVerifications_1 = require("./endpoint/addressVerifications");
 var attachment_1 = require("./endpoint/attachment");
 var emailRules_1 = require("./endpoint/emailRules");
 var emailSubscriptions_1 = require("./endpoint/emailSubscriptions");
@@ -20,6 +21,8 @@ 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 selfShipCollectionAvailabilityChecks_1 = require("./endpoint/selfShipCollectionAvailabilityChecks");
+var selfShipCollections_1 = require("./endpoint/selfShipCollections");
 var shipments_1 = require("./endpoint/shipments");
 var tags_1 = require("./endpoint/tags");
 var defaultConfig = {
@@ -35,6 +38,7 @@ var Arta = /** @class */ (function () {
             apiKey: apiKey,
             host: this.config.host,
         });
+        this.address_verifications = new addressVerifications_1.AddressVerificationsEndpoint(this.artaClient);
         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);
@@ -47,6 +51,9 @@ var Arta = /** @class */ (function () {
         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.self_ship_collection_availability_checks =
+            new selfShipCollectionAvailabilityChecks_1.SelfShipCollectionAvailabilityChecksEndpoint(this.artaClient);
+        this.self_ship_collections = new selfShipCollections_1.SelfShipCollectionsEndpoint(this.artaClient);
         this.shipments = new shipments_1.ShipmentsEndpoint(this.artaClient);
         this.tags = new tags_1.TagsEndpoint(this.artaClient);
         this.trackings = new trackings_1.TrackingsEndpoint(this.artaClient);

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

@@ -0,0 +1,30 @@
+import type { ArtaID } from '../ArtaClient';
+import type { RestClient } from '../net/RestClient';
+import type { Page } from '../pagination';
+import type { AddressVerification } from '../types';
+export interface AddressVerificationCreateBodyInput {
+    address_line_1: string;
+    address_line_2?: string | null;
+    address_line_3?: string | null;
+    city?: string | null;
+    region?: string | null;
+    postal_code?: string | null;
+    country: string;
+}
+export interface AddressVerificationCreateBody {
+    input: AddressVerificationCreateBodyInput;
+    reference?: string | null;
+}
+export interface AddressVerificationCreate {
+    address_verification: AddressVerificationCreateBody;
+}
+export declare class AddressVerificationsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<AddressVerification>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<AddressVerification>>;
+    listAll(auth?: string): AsyncGenerator<AddressVerification>;
+    create(payload: AddressVerificationCreateBody, auth?: string): Promise<AddressVerification>;
+}

package/dist/lib/endpoint/addressVerifications.js

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

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

@@ -0,0 +1,28 @@
+import type { RestClient } from '../net/RestClient';
+import type { SelfShipCollectionAvailabilityCheck } from '../types';
+export interface SelfShipCollectionAvailabilityCheckCreateBody {
+    location: {
+        address_line_1: string;
+        address_line_2?: string | null;
+        city: string;
+        region: string;
+        postal_code: string;
+        country: string;
+        close_time: string;
+    };
+    service: {
+        carrier: 'fedex';
+        code: 'express' | 'ground';
+        route: 'domestic' | 'international';
+    };
+    collection_date: string;
+}
+export interface SelfShipCollectionAvailabilityCheckCreate {
+    self_ship_collection_availability_check: SelfShipCollectionAvailabilityCheckCreateBody;
+}
+export declare class SelfShipCollectionAvailabilityChecksEndpoint {
+    private readonly artaClient;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    create(payload: SelfShipCollectionAvailabilityCheckCreateBody, auth?: string): Promise<SelfShipCollectionAvailabilityCheck>;
+}

package/dist/lib/endpoint/selfShipCollectionAvailabilityChecks.js

@@ -0,0 +1,54 @@
+"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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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.SelfShipCollectionAvailabilityChecksEndpoint = void 0;
+var SelfShipCollectionAvailabilityChecksEndpoint = /** @class */ (function () {
+    function SelfShipCollectionAvailabilityChecksEndpoint(artaClient) {
+        this.artaClient = artaClient;
+        this.path = '/self_ship_collection_availability_checks';
+    }
+    SelfShipCollectionAvailabilityChecksEndpoint.prototype.create = function (payload, auth) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.artaClient.post(this.path, { self_ship_collection_availability_check: payload }, auth)];
+            });
+        });
+    };
+    return SelfShipCollectionAvailabilityChecksEndpoint;
+}());
+exports.SelfShipCollectionAvailabilityChecksEndpoint = SelfShipCollectionAvailabilityChecksEndpoint;

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

@@ -0,0 +1,41 @@
+import type { ArtaID } from '../ArtaClient';
+import type { RestClient } from '../net/RestClient';
+import type { Page } from '../pagination';
+import type { SelfShipCollection } from '../types';
+export interface SelfShipCollectionCreateBody {
+    location: {
+        address_line_1: string;
+        address_line_2?: string | null;
+        city: string;
+        region: string;
+        postal_code: string;
+        country: string;
+        close_time: string;
+        package_location: 'front' | 'none' | 'rear' | 'side';
+        contact: {
+            name: string;
+            phone_number: string;
+            email_address: string;
+        };
+    };
+    service: {
+        carrier: 'fedex';
+        code: 'express' | 'ground';
+        route: 'domestic' | 'international';
+    };
+    collection_date: string;
+    collection_time: string;
+}
+export interface SelfShipCollectionCreate {
+    self_ship_collection: SelfShipCollectionCreateBody;
+}
+export declare class SelfShipCollectionsEndpoint {
+    private readonly artaClient;
+    private readonly defaultEndpoint;
+    private readonly path;
+    constructor(artaClient: RestClient);
+    getById(id: ArtaID, auth?: string): Promise<SelfShipCollection>;
+    list(page?: number, pageSize?: number, auth?: string): Promise<Page<SelfShipCollection>>;
+    listAll(auth?: string): AsyncGenerator<SelfShipCollection>;
+    create(payload: SelfShipCollectionCreateBody, auth?: string): Promise<SelfShipCollection>;
+}

package/dist/lib/endpoint/selfShipCollections.js

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

package/dist/lib/index.d.ts

@@ -1,5 +1,6 @@
 export { Arta } from './arta';
 export { Logger, LoggerVerbosity } from './logging';
+export { AddressVerificationCreateBody } from './endpoint/addressVerifications';
 export { AttachmentCreateBodyRequest, AttachmentCreateBodyShipment, AttachmentCreateBody, } from './endpoint/attachment';
 export { EmailRuleCreateBody } from './endpoint/emailRules';
 export { EmailSubscriptionCreateBody } from './endpoint/emailSubscriptions';
@@ -9,4 +10,6 @@ export * from './MetadataTypes';
 export { UploadCreateBody } from './endpoint/uploads';
 export { ExtendedWebhook as Webhook, WebhookCreate } from './endpoint/webhooks';
 export { QuoteRequestCreateBody, UpdateRequestsContactsBody, CustomQuotePayload, } from './endpoint/requests';
+export { SelfShipCollectionAvailabilityCheckCreateBody } from './endpoint/selfShipCollectionAvailabilityChecks';
+export { SelfShipCollectionCreateBody } from './endpoint/selfShipCollections';
 export { ShipmentCreateBody } from './endpoint/shipments';

package/dist/lib/types.d.ts

@@ -1100,3 +1100,85 @@ export type ArtaInboundObject = {
         value_currency?: (("CAD" | "CHF" | "EUR" | "GBP" | "HKD" | "USD") | null) | undefined;
     }[] | null) | undefined;
 };
+export type AddressVerification = {
+    updated_at: Date;
+    created_at: Date;
+    id: string;
+    shortcode: string;
+    status: "success" | "partial" | "failed";
+    match_level: "delivery_point" | "premise" | "thoroughfare" | "locality" | "administrative_area" | "none";
+    reference: string | null;
+    input: {
+        address_line_1: string;
+        address_line_2: string | null;
+        address_line_3: string | null;
+        city: string | null;
+        region: string | null;
+        postal_code: string | null;
+        country: string;
+    };
+    recommendation: {
+        address_line_1: string | null;
+        address_line_2: string | null;
+        address_line_3: string | null;
+        city: string | null;
+        region: string | null;
+        postal_code: string | null;
+        country: string | null;
+        latitude: number | null;
+        longitude: number | null;
+        is_residential: boolean | null;
+    };
+};
+export type SelfShipCollection = {
+    updated_at: Date;
+    created_at: Date;
+    id: string;
+    status: "scheduled" | "closed" | "cancelled" | "incomplete";
+    shortcode: string;
+    closed_at: string | null;
+    collection_date: string;
+    collection_time: string;
+    location: {
+        address_line_1: string;
+        address_line_2: string | null;
+        city: string;
+        region: string;
+        postal_code: string;
+        country: string;
+        close_time: string;
+        package_location: "front" | "none" | "rear" | "side";
+        contact: {
+            name: string;
+            phone_number: string;
+            email_address: string;
+        };
+    };
+    service: {
+        carrier: "fedex";
+        code: "express" | "ground";
+        route: "domestic" | "international";
+    };
+};
+export type SelfShipCollectionAvailabilityCheck = {
+    location: {
+        address_line_1: string;
+        address_line_2: string | null;
+        city: string;
+        region: string;
+        postal_code: string;
+        country: string;
+        close_time: string;
+    };
+    service: {
+        carrier: "fedex";
+        code: "express" | "ground";
+        route: "domestic" | "international";
+    };
+    collection_date: string;
+    availabilities: {
+        collection_date: string;
+        collection_times: string[];
+        residential_available: boolean;
+    }[];
+};

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@artaio/node-api",
-    "version": "1.6.0",
+    "version": "1.8.0",
     "description": "The Arta Node library provides a seamless integration to Arta API for backend applications using both Typescript or Javascript.",
     "scripts": {
         "build": "npm run build:types && tsc -p tsconfig-build.json",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artaio/node-api",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "The Arta Node library provides a seamless integration to Arta API for backend applications using both Typescript or Javascript.",
   "scripts": {
     "build": "npm run build:types && tsc -p tsconfig-build.json",