@paddle/paddle-node-sdk 0.1.0

package/dist/internal/api/client.d.ts

@@ -0,0 +1,13 @@
+import { type QueryParameters } from '../base';
+import { type PaddleOptions } from '../types/config';
+export declare class Client {
+    private readonly apiKey;
+    private readonly options;
+    private readonly baseUrl;
+    constructor(apiKey: string, options: PaddleOptions);
+    private getBaseUrl;
+    private getHeaders;
+    get<Q, R>(url: string, queryParams?: QueryParameters<Q>): Promise<R>;
+    post<B, R>(url: string, requestBody: B): Promise<R>;
+    patch<B, R>(url: string, requestBody: B): Promise<R>;
+}

package/dist/internal/api/client.js

@@ -0,0 +1,69 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const constants_1 = require("./constants");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const version_1 = require("../../version");
+const environment_1 = require("./environment");
+class Client {
+    constructor(apiKey, options) {
+        this.apiKey = apiKey;
+        this.options = options;
+        this.baseUrl = this.getBaseUrl(this.options.environment);
+    }
+    getBaseUrl(environment) {
+        const urlBasedOnEnv = constants_1.API_ENVIRONMENT_TO_BASE_URL_MAP[environment !== null && environment !== void 0 ? environment : environment_1.Environment.production];
+        return urlBasedOnEnv || '';
+    }
+    getHeaders() {
+        return {
+            Authorization: `bearer ${this.apiKey}`,
+            'user-agent': `PaddleSDK/node ${version_1.SDK_VERSION}`,
+        };
+    }
+    get(url, queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let finalUrl = url.includes(this.baseUrl) ? url : `${this.baseUrl}${url}`;
+            if (!finalUrl.includes('?') && queryParams) {
+                finalUrl += queryParams.toQueryString();
+            }
+            const rawResponse = yield (0, node_fetch_1.default)(finalUrl, {
+                headers: this.getHeaders(),
+            });
+            return rawResponse.json();
+        });
+    }
+    post(url, requestBody) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rawResponse = yield (0, node_fetch_1.default)(`${this.baseUrl}${url}`, {
+                method: 'POST',
+                body: JSON.stringify(requestBody),
+                headers: this.getHeaders(),
+            });
+            return rawResponse.json();
+        });
+    }
+    patch(url, requestBody) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rawResponse = yield (0, node_fetch_1.default)(`${this.baseUrl}${url}`, {
+                method: 'PATCH',
+                body: JSON.stringify(requestBody),
+                headers: this.getHeaders(),
+            });
+            return rawResponse.json();
+        });
+    }
+}
+exports.Client = Client;

package/dist/internal/api/constants.d.ts

@@ -0,0 +1,2 @@
+import { Environment } from './environment';
+export declare const API_ENVIRONMENT_TO_BASE_URL_MAP: Record<Environment, string>;

package/dist/internal/api/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_ENVIRONMENT_TO_BASE_URL_MAP = void 0;
+const environment_1 = require("./environment");
+exports.API_ENVIRONMENT_TO_BASE_URL_MAP = {
+    [environment_1.Environment.production]: 'https://api.paddle.com',
+    [environment_1.Environment.sandbox]: 'https://sandbox-api.paddle.com',
+};

package/dist/internal/api/environment.d.ts

@@ -0,0 +1,4 @@
+export declare enum Environment {
+    sandbox = "sandbox",
+    production = "production"
+}

package/dist/internal/api/environment.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = void 0;
+var Environment;
+(function (Environment) {
+    Environment["sandbox"] = "sandbox";
+    Environment["production"] = "production";
+})(Environment || (exports.Environment = Environment = {}));

package/dist/internal/base/base-resource.d.ts

@@ -0,0 +1,8 @@
+import { type Client } from '../api/client';
+import { type ErrorResponse, type Response } from '../types/response';
+export declare class BaseResource {
+    protected readonly client: Client;
+    constructor(client: Client);
+    protected handleError(error: ErrorResponse): void;
+    protected handleResponse<T>(response: Response<T> | ErrorResponse): T;
+}

package/dist/internal/base/base-resource.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResource = void 0;
+const generic_1 = require("../errors/generic");
+class BaseResource {
+    constructor(client) {
+        this.client = client;
+    }
+    handleError(error) {
+        if (error.error) {
+            throw new generic_1.ApiError(error.error);
+        }
+    }
+    handleResponse(response) {
+        const entityResponse = response;
+        const error = response;
+        this.handleError(error);
+        return entityResponse.data;
+    }
+}
+exports.BaseResource = BaseResource;

package/dist/internal/base/collection.d.ts

@@ -0,0 +1,13 @@
+import { type Client } from '../api/client';
+import { type ErrorResponse, type ResponsePaginated } from '../types/response';
+export declare abstract class Collection<T, C> implements AsyncIterable<C> {
+    private readonly client;
+    private hasMore;
+    private nextLink;
+    private data;
+    constructor(client: Client, initialUri: string);
+    next(): Promise<C[]>;
+    protected handlePaginatedResponse<T>(response: ResponsePaginated<T> | ErrorResponse): ResponsePaginated<T>;
+    abstract fromJson(data: any): C;
+    [Symbol.asyncIterator](): AsyncIterator<C>;
+}

package/dist/internal/base/collection.js

@@ -0,0 +1,65 @@
+"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 __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.Collection = void 0;
+const generic_1 = require("../errors/generic");
+class Collection {
+    constructor(client, initialUri) {
+        this.client = client;
+        this.hasMore = true;
+        this.data = [];
+        this.nextLink = initialUri;
+    }
+    next() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.get(this.nextLink);
+            const handledResponse = this.handlePaginatedResponse(response);
+            this.hasMore = (_a = handledResponse.meta.pagination.has_more) !== null && _a !== void 0 ? _a : false;
+            this.nextLink = handledResponse.meta.pagination.next;
+            this.data = handledResponse.data.map((data) => this.fromJson(data));
+            return this.data.length > 0 ? this.data : [];
+        });
+    }
+    handlePaginatedResponse(response) {
+        const entityResponse = response;
+        const error = response;
+        if (error.error) {
+            throw new generic_1.ApiError(error.error);
+        }
+        return entityResponse;
+    }
+    [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+            while (this.hasMore) {
+                yield __await(this.next());
+                for (let index = 0; index < this.data.length; index++) {
+                    if (this.data[index]) {
+                        yield yield __await(this.data[index]);
+                    }
+                }
+            }
+        });
+    }
+}
+exports.Collection = Collection;

package/dist/internal/base/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base-resource';
+export * from './query-parameters';
+export * from './path-parameters';
+export * from './collection';

package/dist/internal/base/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base-resource"), exports);
+__exportStar(require("./query-parameters"), exports);
+__exportStar(require("./path-parameters"), exports);
+__exportStar(require("./collection"), exports);

package/dist/internal/base/path-parameters.d.ts

@@ -0,0 +1,6 @@
+export declare class PathParameters<T> {
+    private readonly url;
+    private readonly pathParameters;
+    constructor(url: string, pathParameters: T);
+    deriveUrl(): string;
+}

package/dist/internal/base/path-parameters.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathParameters = void 0;
+class PathParameters {
+    constructor(url, pathParameters) {
+        this.url = url;
+        this.pathParameters = pathParameters;
+    }
+    deriveUrl() {
+        let updatedUrl = this.url;
+        for (const key in this.pathParameters) {
+            const value = this.pathParameters[key];
+            if (key && value) {
+                updatedUrl = updatedUrl.split(`{${key}}`).join(value.toString());
+            }
+        }
+        return updatedUrl;
+    }
+}
+exports.PathParameters = PathParameters;

package/dist/internal/base/query-parameters.d.ts

@@ -0,0 +1,5 @@
+export declare class QueryParameters<T> {
+    private readonly queryParameters;
+    constructor(queryParameters: T);
+    toQueryString(): string;
+}

package/dist/internal/base/query-parameters.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryParameters = void 0;
+class QueryParameters {
+    constructor(queryParameters) {
+        this.queryParameters = queryParameters;
+    }
+    toQueryString() {
+        const urlSearchParam = new URLSearchParams();
+        for (const key in this.queryParameters) {
+            const value = this.queryParameters[key];
+            if (key && value) {
+                urlSearchParam.append(key, `${value}`);
+            }
+        }
+        return '?' + urlSearchParam.toString();
+    }
+}
+exports.QueryParameters = QueryParameters;

package/dist/internal/errors/generic.d.ts

@@ -0,0 +1,12 @@
+import { type ErrorDetail } from '../../internal';
+export declare class ApiError extends Error {
+    private readonly type;
+    private readonly code;
+    private readonly detail;
+    private readonly documentationUrl;
+    constructor(errorDetail: ErrorDetail);
+    getType(): string;
+    getCode(): string;
+    getDetail(): string;
+    getDocumentation(): string;
+}

package/dist/internal/errors/generic.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(errorDetail) {
+        super(errorDetail.detail);
+        this.type = errorDetail.type;
+        this.code = errorDetail.code;
+        this.detail = errorDetail.detail;
+        this.documentationUrl = errorDetail.documentationUrl;
+    }
+    getType() {
+        return this.type;
+    }
+    getCode() {
+        return this.code;
+    }
+    getDetail() {
+        return this.detail;
+    }
+    getDocumentation() {
+        return this.documentationUrl;
+    }
+}
+exports.ApiError = ApiError;

package/dist/internal/index.d.ts

@@ -0,0 +1,3 @@
+export type { ErrorResponse, ResponsePaginated, Response, ErrorDetail } from './types/response';
+export type { PaddleOptions } from './types/config';
+export { Environment } from './api/environment';

package/dist/internal/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = void 0;
+var environment_1 = require("./api/environment");
+Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return environment_1.Environment; } });

package/dist/internal/types/config.d.ts

@@ -0,0 +1,4 @@
+import { type Environment } from '../api/environment';
+export interface PaddleOptions {
+    environment?: Environment;
+}

package/dist/internal/types/config.js

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

package/dist/internal/types/response.d.ts

@@ -0,0 +1,31 @@
+export interface Pagination {
+    per_page: number;
+    next: string;
+    has_more: boolean;
+    estimated_total: number;
+}
+export interface Meta {
+    request_id: string;
+}
+export interface MetaPaginated {
+    request_id: string;
+    pagination: Pagination;
+}
+export interface Response<T> {
+    data: T;
+    meta: Meta;
+}
+export interface ResponsePaginated<T> {
+    data: T[];
+    meta: MetaPaginated;
+}
+export interface ErrorDetail {
+    type: string;
+    code: string;
+    detail: string;
+    documentationUrl: string;
+}
+export interface ErrorResponse {
+    error: ErrorDetail;
+    meta: Meta;
+}

package/dist/internal/types/response.js

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

package/dist/notifications/index.d.ts

@@ -0,0 +1 @@
+export * from './validator/notifications-validator';

package/dist/notifications/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./validator/notifications-validator"), exports);

package/dist/notifications/validator/notifications-validator.d.ts

@@ -0,0 +1,5 @@
+export declare class NotificationsValidator {
+    private static readonly MAX_VALID_TIME_DIFFERENCE;
+    private extractHeader;
+    isValidSignature(requestBody: string, secretKey: string, signature: string): boolean;
+}

package/dist/notifications/validator/notifications-validator.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsValidator = void 0;
+const crypto_1 = require("crypto");
+class NotificationsValidator {
+    extractHeader(header) {
+        const parts = header.split(';');
+        let ts = '';
+        let h1 = '';
+        for (const part of parts) {
+            const [key, value] = part.split('=');
+            if (value) {
+                if (key === 'ts') {
+                    ts = value;
+                }
+                else if (key === 'h1') {
+                    h1 = value;
+                }
+            }
+        }
+        if (ts && h1) {
+            return { ts: parseInt(ts), h1 };
+        }
+        else {
+            throw new Error('Invalid paddle signature');
+        }
+    }
+    isValidSignature(requestBody, secretKey, signature) {
+        const headers = this.extractHeader(signature);
+        const payloadWithTime = `${headers.ts}:${requestBody}`;
+        if (new Date().getTime() > new Date((headers.ts + NotificationsValidator.MAX_VALID_TIME_DIFFERENCE) * 1000).getTime()) {
+            return false;
+        }
+        const hmac = (0, crypto_1.createHmac)('sha256', secretKey);
+        hmac.update(payloadWithTime);
+        const computedHash = hmac.digest('hex');
+        return computedHash === headers.h1;
+    }
+}
+exports.NotificationsValidator = NotificationsValidator;
+NotificationsValidator.MAX_VALID_TIME_DIFFERENCE = 5;

package/dist/paddle.d.ts

@@ -0,0 +1,16 @@
+import { AddressesResource, AdjustmentsResource, BusinessesResource, CustomersResource, DiscountsResource, PricesResource, ProductsResource, SubscriptionsResource, TransactionsResource } from './resources';
+import { type PaddleOptions } from './internal';
+export declare class Paddle {
+    private readonly client;
+    private readonly defaultPaddleOptions;
+    products: ProductsResource;
+    prices: PricesResource;
+    transactions: TransactionsResource;
+    adjustments: AdjustmentsResource;
+    customers: CustomersResource;
+    addresses: AddressesResource;
+    businesses: BusinessesResource;
+    discounts: DiscountsResource;
+    subscriptions: SubscriptionsResource;
+    constructor(apiKey: string, options: PaddleOptions);
+}

package/dist/paddle.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Paddle = void 0;
+const client_1 = require("./internal/api/client");
+const resources_1 = require("./resources");
+const internal_1 = require("./internal");
+class Paddle {
+    constructor(apiKey, options) {
+        this.defaultPaddleOptions = {
+            environment: internal_1.Environment.production,
+        };
+        this.client = new client_1.Client(apiKey, Object.assign(Object.assign({}, this.defaultPaddleOptions), options));
+        this.products = new resources_1.ProductsResource(this.client);
+        this.prices = new resources_1.PricesResource(this.client);
+        this.transactions = new resources_1.TransactionsResource(this.client);
+        this.adjustments = new resources_1.AdjustmentsResource(this.client);
+        this.customers = new resources_1.CustomersResource(this.client);
+        this.addresses = new resources_1.AddressesResource(this.client);
+        this.businesses = new resources_1.BusinessesResource(this.client);
+        this.discounts = new resources_1.DiscountsResource(this.client);
+        this.subscriptions = new resources_1.SubscriptionsResource(this.client);
+    }
+}
+exports.Paddle = Paddle;

package/dist/resources/addresses/index.d.ts

@@ -0,0 +1,10 @@
+import { Address, AddressCollection } from '../../entities';
+import { BaseResource } from '../../internal/base';
+import { type ListAddressQueryParameters, type CreateAddressRequestBody, type UpdateAddressRequestBody } from './operations';
+export * from './operations';
+export declare class AddressesResource extends BaseResource {
+    list(customerId: string, queryParams?: ListAddressQueryParameters): Promise<AddressCollection>;
+    create(customerId: string, createAddressParameters: CreateAddressRequestBody): Promise<Address>;
+    get(customerId: string, addressId: string): Promise<Address>;
+    update(customerId: string, addressId: string, updateProduct: UpdateAddressRequestBody): Promise<Address>;
+}

package/dist/resources/addresses/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressesResource = void 0;
+const entities_1 = require("../../entities");
+const base_1 = require("../../internal/base");
+const AddressPaths = {
+    list: '/customers/{customer_id}/addresses',
+    create: '/customers/{customer_id}/addresses',
+    get: '/customers/{customer_id}/addresses/{address_id}',
+    update: '/customers/{customer_id}/addresses/{address_id}',
+};
+__exportStar(require("./operations"), exports);
+class AddressesResource extends base_1.BaseResource {
+    list(customerId, queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = new base_1.QueryParameters(queryParams);
+            const urlWithPathParams = new base_1.PathParameters(AddressPaths.list, {
+                customer_id: customerId,
+            }).deriveUrl();
+            return new entities_1.AddressCollection(this.client, urlWithPathParams + queryParameters.toQueryString());
+        });
+    }
+    create(customerId, createAddressParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urlWithPathParams = new base_1.PathParameters(AddressPaths.create, {
+                customer_id: customerId,
+            }).deriveUrl();
+            const response = yield this.client.post(urlWithPathParams, createAddressParameters);
+            const data = this.handleResponse(response);
+            return new entities_1.Address(data);
+        });
+    }
+    get(customerId, addressId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urlWithPathParams = new base_1.PathParameters(AddressPaths.get, {
+                customer_id: customerId,
+                address_id: addressId,
+            }).deriveUrl();
+            const response = yield this.client.get(urlWithPathParams);
+            const data = this.handleResponse(response);
+            return new entities_1.Address(data);
+        });
+    }
+    update(customerId, addressId, updateProduct) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urlWithPathParams = new base_1.PathParameters(AddressPaths.update, {
+                customer_id: customerId,
+                address_id: addressId,
+            }).deriveUrl();
+            const response = yield this.client.patch(urlWithPathParams, updateProduct);
+            const data = this.handleResponse(response);
+            return new entities_1.Address(data);
+        });
+    }
+}
+exports.AddressesResource = AddressesResource;

package/dist/resources/addresses/operations/create-address-path-parameters.d.ts

@@ -0,0 +1,3 @@
+export interface CreateAddressPathParameters {
+    customer_id: string;
+}

package/dist/resources/addresses/operations/create-address-path-parameters.js

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

package/dist/resources/addresses/operations/create-address-request-body.d.ts

@@ -0,0 +1,12 @@
+import { type ICustomData } from '../../../types';
+import { type CountryCode } from '../../../enums';
+export interface CreateAddressRequestBody {
+    country_code: CountryCode;
+    description?: string | undefined | null;
+    first_line?: string | undefined | null;
+    second_line?: string | undefined | null;
+    city?: string | undefined | null;
+    postal_code?: string | undefined | null;
+    region?: string | undefined | null;
+    custom_data?: ICustomData | undefined | null;
+}

package/dist/resources/addresses/operations/create-address-request-body.js

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

package/dist/resources/addresses/operations/get-address-path-parameters.d.ts

@@ -0,0 +1,4 @@
+export interface GetAddressPathParameters {
+    customer_id: string;
+    address_id: string;
+}

package/dist/resources/addresses/operations/get-address-path-parameters.js

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