@coinbase-sample/prime-sdk-ts 0.8.0 → 0.8.1

package/dist/orders/index.js

@@ -37,6 +37,7 @@ exports.OrdersService = void 0;
  * limitations under the License.
  */
 const clients_1 = require("../clients");
+const validation_1 = require("../shared/validation");
 const paginatedResponse_1 = require("../shared/paginatedResponse");
 class OrdersService {
     constructor(client) {
@@ -44,6 +45,10 @@ class OrdersService {
     }
     getOrder(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.orderId)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/orders/${request.orderId}`,
                 callOptions: options,
@@ -53,6 +58,10 @@ class OrdersService {
     }
     getOrderEditHistory(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.orderId)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/orders/${request.orderId}/edit_history`,
                 callOptions: options,
@@ -64,6 +73,9 @@ class OrdersService {
     }
     listPortfolioFills(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .check();
             const paginationParams = (0, paginatedResponse_1.getQueryParams)(this.client, request);
             const { limit, cursor, sortDirection, portfolioId } = request, queryParams = __rest(request, ["limit", "cursor", "sortDirection", "portfolioId"]);
             const finalQueryParams = Object.assign(Object.assign({}, paginationParams), queryParams);
@@ -78,6 +90,9 @@ class OrdersService {
     }
     listPortfolioOrders(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .check();
             const paginationParams = (0, paginatedResponse_1.getQueryParams)(this.client, request);
             const { limit, cursor, sortDirection, portfolioId } = request, queryParams = __rest(request, ["limit", "cursor", "sortDirection", "portfolioId"]);
             const finalQueryParams = Object.assign(Object.assign({}, paginationParams), queryParams);
@@ -92,6 +107,10 @@ class OrdersService {
     }
     listOrderFills(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.orderId)
+                .check();
             const paginationParams = (0, paginatedResponse_1.getQueryParams)(this.client, request);
             const { limit, cursor, sortDirection, portfolioId, orderId } = request, queryParams = __rest(request, ["limit", "cursor", "sortDirection", "portfolioId", "orderId"]);
             const finalQueryParams = Object.assign(Object.assign({}, paginationParams), queryParams);
@@ -106,6 +125,9 @@ class OrdersService {
     }
     listOpenOrders(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .check();
             const paginationParams = (0, paginatedResponse_1.getQueryParams)(this.client, request);
             const { limit, cursor, sortDirection, portfolioId } = request, queryParams = __rest(request, ["limit", "cursor", "sortDirection", "portfolioId"]);
             const finalQueryParams = Object.assign(Object.assign({}, paginationParams), queryParams);
@@ -120,6 +142,12 @@ class OrdersService {
     }
     createOrderPreview(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredString((r) => r.productId)
+                .requiredString((r) => r.side)
+                .requiredString((r) => r.type)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/order_preview`,
                 method: clients_1.Method.POST,
@@ -131,6 +159,10 @@ class OrdersService {
     }
     cancelOrder(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.orderId)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/orders/${request.orderId}/cancel`,
                 method: clients_1.Method.POST,
@@ -141,6 +173,13 @@ class OrdersService {
     }
     createOrder(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredString((r) => r.productId)
+                .requiredString((r) => r.side)
+                .requiredUUID((r) => r.clientOrderId)
+                .requiredString((r) => r.type)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/order`,
                 method: clients_1.Method.POST,
@@ -152,6 +191,13 @@ class OrdersService {
     }
     createQuote(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredString((r) => r.productId)
+                .requiredString((r) => r.side)
+                .requiredUUID((r) => r.clientOrderId)
+                .requiredString((r) => r.type)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/rfq`,
                 method: clients_1.Method.POST,
@@ -163,6 +209,13 @@ class OrdersService {
     }
     acceptQuote(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredString((r) => r.productId)
+                .requiredString((r) => r.side)
+                .requiredUUID((r) => r.clientOrderId)
+                .requiredString((r) => r.quoteId)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/accept_quote`,
                 method: clients_1.Method.POST,
@@ -174,6 +227,12 @@ class OrdersService {
     }
     editOrder(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.orderId)
+                .requiredUUID((r) => r.clientOrderId)
+                .requiredString((r) => r.origClientOrderId)
+                .check();
             const { portfolioId, orderId } = request, bodyParams = __rest(request, ["portfolioId", "orderId"]);
             const response = yield this.client.request({
                 url: `portfolios/${portfolioId}/orders/${orderId}/edit`,

package/dist/paymentMethods/index.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaymentMethodsService = void 0;
+const validation_1 = require("../shared/validation");
 class PaymentMethodsService {
     constructor(client) {
         this.client = client;
@@ -17,6 +18,9 @@ class PaymentMethodsService {
     // TODO: rename me to remove Entity in a minor version change
     listEntityPaymentMethods(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.entityId)
+                .check();
             const response = yield this.client.request({
                 url: `entities/${request.entityId}/payment-methods`,
                 callOptions: options,
@@ -26,6 +30,10 @@ class PaymentMethodsService {
     }
     getPaymentMethod(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.entityId)
+                .requiredUUID((r) => r.paymentMethodId)
+                .check();
             const response = yield this.client.request({
                 url: `entities/${request.entityId}/payment-methods/${request.paymentMethodId}`,
                 callOptions: options,

package/dist/portfolios/index.js

@@ -10,12 +10,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PortfoliosService = void 0;
+const validation_1 = require("../shared/validation");
 class PortfoliosService {
     constructor(client) {
         this.client = client;
     }
     getPortfolio(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}`,
                 callOptions: options,
@@ -25,6 +29,9 @@ class PortfoliosService {
     }
     getPortfolioCredit(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/credit`,
                 callOptions: options,
@@ -34,6 +41,9 @@ class PortfoliosService {
     }
     getCounterpartyId(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .check();
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/counterparty`,
                 callOptions: options,

package/dist/positions/index.js

@@ -21,6 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PositionsService = void 0;
+const validation_1 = require("../shared/validation");
 const paginatedResponse_1 = require("../shared/paginatedResponse");
 class PositionsService {
     constructor(client) {
@@ -28,6 +29,9 @@ class PositionsService {
     }
     listAggregateEntityPositions(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.entityId)
+                .check();
             const paginationParams = (0, paginatedResponse_1.getQueryParams)(this.client, request);
             const { limit, cursor, sortDirection, entityId } = request, queryParams = __rest(request, ["limit", "cursor", "sortDirection", "entityId"]);
             const finalQueryParams = Object.assign(Object.assign({}, paginationParams), queryParams);
@@ -42,6 +46,9 @@ class PositionsService {
     }
     listEntityPositions(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.entityId)
+                .check();
             const paginationParams = (0, paginatedResponse_1.getQueryParams)(this.client, request);
             const { limit, cursor, sortDirection, entityId } = request, queryParams = __rest(request, ["limit", "cursor", "sortDirection", "entityId"]);
             const finalQueryParams = Object.assign(Object.assign({}, paginationParams), queryParams);

package/dist/products/index.js

@@ -21,6 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProductsService = void 0;
+const validation_1 = require("../shared/validation");
 const paginatedResponse_1 = require("../shared/paginatedResponse");
 class ProductsService {
     constructor(client) {
@@ -28,6 +29,9 @@ class ProductsService {
     }
     listProducts(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .check();
             const paginationParams = (0, paginatedResponse_1.getQueryParams)(this.client, request);
             const { limit, cursor, sortDirection, portfolioId } = request, queryParams = __rest(request, ["limit", "cursor", "sortDirection", "portfolioId"]);
             const finalQueryParams = Object.assign(Object.assign({}, paginationParams), queryParams);
@@ -42,6 +46,13 @@ class ProductsService {
     }
     listProductCandles(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredString((r) => r.productId)
+                .requiredString((r) => r.startTime)
+                .requiredString((r) => r.endTime)
+                .requiredString((r) => r.granularity)
+                .check();
             const { portfolioId, productId, startTime, endTime, granularity } = request;
             const response = yield this.client.request({
                 url: `portfolios/${portfolioId}/candles`,

package/dist/shared/__tests__/validation.test.js

@@ -29,19 +29,17 @@ describe('validation', () => {
             expect((0, validation_1.isValidUUID)('123e4567-e89b-12d3-a456')).toBe(false);
             expect((0, validation_1.isValidUUID)('123e4567e89b12d3a456426614174000')).toBe(false);
             expect((0, validation_1.isValidUUID)('')).toBe(false);
-            expect((0, validation_1.isValidUUID)('12345678-1234-1234-1234-12345678901g')).toBe(false); // 'g' is not hex
+            expect((0, validation_1.isValidUUID)('12345678-1234-1234-1234-12345678901g')).toBe(false);
         });
     });
-    describe('ValidationResult', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
+    describe('PropertyValidator', () => {
         it('should start with no errors', () => {
+            const validator = (0, validation_1.validate)({});
             expect(validator.hasErrors()).toBe(false);
             expect(validator.getErrors()).toEqual([]);
         });
         it('should accumulate errors', () => {
+            const validator = (0, validation_1.validate)({});
             validator.addError('field1', 'is required');
             validator.addError('field2', 'must be a valid UUID', 'invalid-value');
             expect(validator.hasErrors()).toBe(true);
@@ -57,146 +55,208 @@ describe('validation', () => {
             });
         });
         it('should throw with formatted error message when there are errors', () => {
+            const validator = (0, validation_1.validate)({});
             validator.addError('portfolioId', 'must be a valid UUID', 'bad-id');
             validator.addError('orderId', 'is required');
-            expect(() => validator.throwIfInvalid()).toThrow(errors_1.CoinbasePrimeClientException);
-            expect(() => validator.throwIfInvalid()).toThrow(/Request validation failed:\n  - portfolioId: must be a valid UUID \(received: 'bad-id'\)\n  - orderId: is required/);
+            expect(() => validator.check()).toThrow(errors_1.CoinbasePrimeClientException);
+            expect(() => validator.check()).toThrow(/Request validation failed:\n  - portfolioId: must be a valid UUID \(received: 'bad-id'\)\n  - orderId: is required/);
         });
         it('should not throw when there are no errors', () => {
-            expect(() => validator.throwIfInvalid()).not.toThrow();
+            const validator = (0, validation_1.validate)({});
+            expect(() => validator.check()).not.toThrow();
         });
         it('should include custom context message', () => {
+            const validator = (0, validation_1.validate)({});
             validator.addError('field1', 'is invalid');
-            expect(() => validator.throwIfInvalid('Custom operation failed')).toThrow(/Custom operation failed:/);
+            expect(() => validator.check('Custom operation failed')).toThrow(/Custom operation failed:/);
         });
     });
-    describe('validateRequiredUUID', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
-        it('should not add error for valid UUID', () => {
-            (0, validation_1.validateRequiredUUID)(validator, '123e4567-e89b-12d3-a456-426614174000', 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should add error for undefined', () => {
-            (0, validation_1.validateRequiredUUID)(validator, undefined, 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for null', () => {
-            (0, validation_1.validateRequiredUUID)(validator, null, 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for empty string', () => {
-            (0, validation_1.validateRequiredUUID)(validator, '', 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for whitespace-only string', () => {
-            (0, validation_1.validateRequiredUUID)(validator, '   ', 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('whitespace');
-        });
-        it('should add error for invalid UUID format', () => {
-            (0, validation_1.validateRequiredUUID)(validator, 'not-a-uuid', 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('valid UUID');
+    describe('requiredUUID', () => {
+        it('should not throw for valid UUID', () => {
+            const request = { testId: '123e4567-e89b-12d3-a456-426614174000' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should throw for undefined', () => {
+            const request = { testId: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for null', () => {
+            const request = { testId: null };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for empty string', () => {
+            const request = { testId: '' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for whitespace-only string', () => {
+            const request = { testId: '   ' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/whitespace/);
+        });
+        it('should throw for invalid UUID format', () => {
+            const request = { testId: 'not-a-uuid' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/valid UUID/);
         });
     });
-    describe('validateOptionalUUID', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
-        it('should not add error for valid UUID', () => {
-            (0, validation_1.validateOptionalUUID)(validator, '123e4567-e89b-12d3-a456-426614174000', 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should not add error for undefined', () => {
-            (0, validation_1.validateOptionalUUID)(validator, undefined, 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should not add error for null', () => {
-            (0, validation_1.validateOptionalUUID)(validator, null, 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should not add error for empty string', () => {
-            (0, validation_1.validateOptionalUUID)(validator, '', 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should add error for invalid UUID format', () => {
-            (0, validation_1.validateOptionalUUID)(validator, 'not-a-uuid', 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('valid UUID');
+    describe('optionalUUID', () => {
+        it('should not throw for valid UUID', () => {
+            const request = { testId: '123e4567-e89b-12d3-a456-426614174000' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should not throw for undefined', () => {
+            const request = { testId: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should not throw for null', () => {
+            const request = { testId: null };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should not throw for empty string', () => {
+            const request = { testId: '' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should throw for invalid UUID format', () => {
+            const request = { testId: 'not-a-uuid' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).toThrow(/valid UUID/);
         });
     });
-    describe('validateRequiredString', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
-        it('should not add error for valid string', () => {
-            (0, validation_1.validateRequiredString)(validator, 'valid-string', 'testField');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should add error for undefined', () => {
-            (0, validation_1.validateRequiredString)(validator, undefined, 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for null', () => {
-            (0, validation_1.validateRequiredString)(validator, null, 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for empty string', () => {
-            (0, validation_1.validateRequiredString)(validator, '', 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for whitespace-only string', () => {
-            (0, validation_1.validateRequiredString)(validator, '   ', 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('whitespace');
+    describe('requiredString', () => {
+        it('should not throw for valid string', () => {
+            const request = { testField: 'valid-string' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).not.toThrow();
+        });
+        it('should throw for undefined', () => {
+            const request = { testField: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for null', () => {
+            const request = { testField: null };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for empty string', () => {
+            const request = { testField: '' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for whitespace-only string', () => {
+            const request = { testField: '   ' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).toThrow(/whitespace/);
         });
     });
-    describe('validateOptionalString', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
-        it('should not add error for valid string', () => {
-            (0, validation_1.validateOptionalString)(validator, 'valid-string', 'testField');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should not add error for undefined', () => {
-            (0, validation_1.validateOptionalString)(validator, undefined, 'testField');
-            expect(validator.hasErrors()).toBe(false);
+    describe('optionalString', () => {
+        it('should not throw for valid string', () => {
+            const request = { testField: 'valid-string' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalString((r) => r.testField)
+                .check()).not.toThrow();
+        });
+        it('should not throw for undefined', () => {
+            const request = { testField: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalString((r) => r.testField)
+                .check()).not.toThrow();
+        });
+        it('should not throw for null', () => {
+            const request = { testField: null };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalString((r) => r.testField)
+                .check()).not.toThrow();
+        });
+        it('should throw for whitespace-only when not empty', () => {
+            const request = { testField: '   ' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalString((r) => r.testField)
+                .check()).toThrow(/whitespace/);
         });
-        it('should not add error for null', () => {
-            (0, validation_1.validateOptionalString)(validator, null, 'testField');
-            expect(validator.hasErrors()).toBe(false);
+    });
+    describe('requiredArray', () => {
+        it('should not throw for valid array', () => {
+            const request = { items: ['a', 'b', 'c'] };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredArray((r) => r.items)
+                .check()).not.toThrow();
+        });
+        it('should throw for undefined', () => {
+            const request = { items: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredArray((r) => r.items)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for empty array', () => {
+            const request = { items: [] };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredArray((r) => r.items)
+                .check()).toThrow(/empty array/);
         });
-        it('should add error for whitespace-only when not empty', () => {
-            (0, validation_1.validateOptionalString)(validator, '   ', 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('whitespace');
+    });
+    describe('requiredBoolean', () => {
+        it('should not throw for true', () => {
+            const request = { flag: true };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredBoolean((r) => r.flag)
+                .check()).not.toThrow();
+        });
+        it('should not throw for false', () => {
+            const request = { flag: false };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredBoolean((r) => r.flag)
+                .check()).not.toThrow();
+        });
+        it('should throw for undefined', () => {
+            const request = { flag: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredBoolean((r) => r.flag)
+                .check()).toThrow(/required/);
         });
     });
     describe('multiple field validation', () => {
         it('should collect all validation errors before throwing', () => {
-            const validator = (0, validation_1.createValidator)();
-            // Simulate validating multiple fields at once
-            (0, validation_1.validateRequiredUUID)(validator, undefined, 'portfolioId');
-            (0, validation_1.validateRequiredUUID)(validator, 'invalid-uuid', 'orderId');
-            (0, validation_1.validateRequiredString)(validator, '', 'productId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()).toHaveLength(3);
-            expect(() => validator.throwIfInvalid('getOrder request validation failed')).toThrow(errors_1.CoinbasePrimeClientException);
+            const request = {
+                portfolioId: undefined,
+                orderId: 'invalid-uuid',
+                productId: '',
+            };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.orderId)
+                .requiredString((r) => r.productId)
+                .check('getOrder request validation failed')).toThrow(errors_1.CoinbasePrimeClientException);
             try {
-                validator.throwIfInvalid('getOrder request validation failed');
+                (0, validation_1.validate)(request)
+                    .requiredUUID((r) => r.portfolioId)
+                    .requiredUUID((r) => r.orderId)
+                    .requiredString((r) => r.productId)
+                    .check('getOrder request validation failed');
             }
             catch (error) {
                 if (error instanceof errors_1.CoinbasePrimeClientException) {