@dalmore/api-contracts 1.0.3 → 1.0.6

package/src/common/types/issuer-payment-method.types.spec.ts

@@ -0,0 +1,612 @@
+import { PaymentMethodType } from './payment-methods.types';
+import {
+  PatchIssuerPaymentMethodZod,
+  PaymentMethodConfig,
+  createDefaultIssuerPaymentMethods,
+  stripeConfigSchema,
+  wireConfigSchema,
+  checkConfigSchema,
+  retirementConfigSchema,
+} from './issuer-payment-method.types';
+import { StateCode } from './states.types';
+import { CountryCode } from './countries.types';
+import { typeid } from 'typeid-js';
+import {
+  getRandomName,
+  getRandomCompanyName,
+  getRandomAddress,
+  getRandomCity,
+  getRandomState,
+  getRandomZip,
+  getRandomNumber,
+  getRandomStripeAccountId,
+} from '../../tests/factory/random.factory';
+
+describe('PatchIssuerPaymentMethodZod Schema', () => {
+  it('should validate CREDIT_CARD payment method', () => {
+    const input = {
+      paymentMethodType: PaymentMethodType.CREDIT_CARD,
+      config: {
+        stripeAccountId: getRandomStripeAccountId(),
+      },
+    };
+
+    const result = PatchIssuerPaymentMethodZod.safeParse(input);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate WIRE payment method', () => {
+    const input = {
+      paymentMethodType: PaymentMethodType.WIRE,
+      config: {
+        usAccountHolderName: getRandomName(),
+        usBankName: `${getRandomName()} Bank`,
+        usRoutingNumber: getRandomNumber(100000000, 999999999, 0)
+          .toString()
+          .padStart(9, '0'),
+        usAccountNumber: getRandomNumber(
+          10000000,
+          Number.MAX_SAFE_INTEGER,
+          0,
+        ).toString(),
+        reference: null,
+        swiftId: null,
+      },
+    };
+
+    const result = PatchIssuerPaymentMethodZod.safeParse(input);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate CHECK payment method', () => {
+    const input = {
+      paymentMethodType: PaymentMethodType.CHECK,
+      config: {
+        companyName: getRandomCompanyName(),
+        address: getRandomAddress(),
+        address2: `Suite ${getRandomNumber(1, 999, 0)}`,
+        city: getRandomCity(),
+        state: StateCode[getRandomState() as keyof typeof StateCode],
+        zip: getRandomZip(),
+        country: CountryCode['US'],
+      },
+    };
+
+    const result = PatchIssuerPaymentMethodZod.safeParse(input);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject mismatched payment method type and config', () => {
+    const input = {
+      paymentMethodType: PaymentMethodType.CREDIT_CARD,
+      config: {
+        usAccountHolderName: getRandomName(),
+        usBankName: `${getRandomName()} Bank`,
+        usRoutingNumber: getRandomNumber(100000000, 999999999, 0)
+          .toString()
+          .padStart(9, '0'),
+        usAccountNumber: getRandomNumber(
+          10000000,
+          Number.MAX_SAFE_INTEGER,
+          0,
+        ).toString(),
+      },
+    };
+
+    const result = PatchIssuerPaymentMethodZod.safeParse(input);
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject invalid Stripe account id', () => {
+    const input = {
+      paymentMethodType: PaymentMethodType.CREDIT_CARD,
+      config: {
+        stripeAccountId: 123,
+      },
+    };
+
+    const result = PatchIssuerPaymentMethodZod.safeParse(input);
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject missing required fields', () => {
+    const input = {
+      paymentMethodType: PaymentMethodType.WIRE,
+      config: {
+        usAccountHolderName: getRandomName(),
+        // missing other required fields
+      },
+    };
+
+    const result = PatchIssuerPaymentMethodZod.safeParse(input);
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('Issuer Payment Method Schema Consistency', () => {
+  describe('PatchIssuerPaymentMethodZod and PaymentMethodConfig consistency', () => {
+    it('should use the same stripeConfigSchema for CREDIT_CARD in both schemas', () => {
+      const stripeAccountId = getRandomStripeAccountId();
+      const patchInput = {
+        paymentMethodType: PaymentMethodType.CREDIT_CARD,
+        config: {
+          stripeAccountId,
+        },
+      };
+
+      const configInput = {
+        paymentMethodType: PaymentMethodType.CREDIT_CARD,
+        config: {
+          stripeAccountId,
+        },
+      };
+
+      const patchResult = PatchIssuerPaymentMethodZod.safeParse(patchInput);
+      const configResult = PaymentMethodConfig.safeParse(configInput);
+
+      expect(patchResult.success).toBe(true);
+      expect(configResult.success).toBe(true);
+    });
+
+    it('should use the same stripeConfigSchema for ACH in both schemas', () => {
+      const stripeAccountId = getRandomStripeAccountId();
+      const patchInput = {
+        paymentMethodType: PaymentMethodType.ACH,
+        config: {
+          stripeAccountId,
+        },
+      };
+
+      const configInput = {
+        paymentMethodType: PaymentMethodType.ACH,
+        config: {
+          stripeAccountId,
+        },
+      };
+
+      const patchResult = PatchIssuerPaymentMethodZod.safeParse(patchInput);
+      const configResult = PaymentMethodConfig.safeParse(configInput);
+
+      expect(patchResult.success).toBe(true);
+      expect(configResult.success).toBe(true);
+    });
+
+    it('should use the same wireConfigSchema for WIRE in both schemas', () => {
+      // Generate a valid swiftId (8-11 characters)
+      const bankCode = getRandomName()
+        .substring(0, 4)
+        .toUpperCase()
+        .padEnd(4, 'A');
+      const swiftId = `${bankCode}US33XXX`.substring(0, 11); // Ensure 8-11 chars
+
+      const wireConfig = {
+        usAccountHolderName: getRandomName(),
+        usBankName: `${getRandomName()} Bank`,
+        usRoutingNumber: getRandomNumber(100000000, 999999999, 0)
+          .toString()
+          .padStart(9, '0'),
+        usAccountNumber: getRandomNumber(
+          10000000,
+          Number.MAX_SAFE_INTEGER,
+          0,
+        ).toString(),
+        reference: `REF${getRandomNumber(100, 999, 0)}`,
+        swiftId:
+          swiftId.length >= 8 ? swiftId : `${bankCode}US33XXX`.substring(0, 11),
+      };
+
+      const patchInput = {
+        paymentMethodType: PaymentMethodType.WIRE,
+        config: wireConfig,
+      };
+
+      const configInput = {
+        paymentMethodType: PaymentMethodType.WIRE,
+        config: wireConfig,
+      };
+
+      const patchResult = PatchIssuerPaymentMethodZod.safeParse(patchInput);
+      const configResult = PaymentMethodConfig.safeParse(configInput);
+
+      expect(patchResult.success).toBe(true);
+      expect(configResult.success).toBe(true);
+    });
+
+    it('should use the same checkConfigSchema for CHECK in both schemas', () => {
+      const checkConfig = {
+        companyName: getRandomCompanyName(),
+        address: getRandomAddress(),
+        address2: `Suite ${getRandomNumber(1, 999, 0)}`,
+        city: getRandomCity(),
+        state: StateCode[getRandomState() as keyof typeof StateCode],
+        zip: getRandomZip(),
+        country: CountryCode['US'],
+        reference: `REF${getRandomNumber(100, 999, 0)}`,
+      };
+
+      const patchInput = {
+        paymentMethodType: PaymentMethodType.CHECK,
+        config: checkConfig,
+      };
+
+      const configInput = {
+        paymentMethodType: PaymentMethodType.CHECK,
+        config: checkConfig,
+      };
+
+      const patchResult = PatchIssuerPaymentMethodZod.safeParse(patchInput);
+      const configResult = PaymentMethodConfig.safeParse(configInput);
+
+      expect(patchResult.success).toBe(true);
+      expect(configResult.success).toBe(true);
+    });
+
+    it('should use the same retirementConfigSchema for RETIREMENT in both schemas', () => {
+      const retirementConfig = {
+        custodianInstruction: `Custodian instruction for ${getRandomCompanyName()}`,
+        custodianDocument: null,
+      };
+
+      const patchInput = {
+        paymentMethodType: PaymentMethodType.RETIREMENT,
+        config: retirementConfig,
+      };
+
+      const configInput = {
+        paymentMethodType: PaymentMethodType.RETIREMENT,
+        config: retirementConfig,
+      };
+
+      const patchResult = PatchIssuerPaymentMethodZod.safeParse(patchInput);
+      const configResult = PaymentMethodConfig.safeParse(configInput);
+
+      expect(patchResult.success).toBe(true);
+      expect(configResult.success).toBe(true);
+    });
+
+    it('should reject the same invalid configs in both schemas', () => {
+      const invalidWireConfig = {
+        usAccountHolderName: getRandomName(),
+        // Missing required fields
+      };
+
+      const patchInput = {
+        paymentMethodType: PaymentMethodType.WIRE,
+        config: invalidWireConfig,
+      };
+
+      const configInput = {
+        paymentMethodType: PaymentMethodType.WIRE,
+        config: invalidWireConfig,
+      };
+
+      const patchResult = PatchIssuerPaymentMethodZod.safeParse(patchInput);
+      const configResult = PaymentMethodConfig.safeParse(configInput);
+
+      expect(patchResult.success).toBe(false);
+      expect(configResult.success).toBe(false);
+    });
+  });
+
+  describe('Payment method type coverage', () => {
+    it('should cover all payment method types in PatchIssuerPaymentMethodZod', () => {
+      const paymentMethodTypes = Object.values(PaymentMethodType);
+      const coveredTypes = new Set<string>();
+
+      // Test each payment method type
+      paymentMethodTypes.forEach((type) => {
+        let config: any;
+        switch (type) {
+          case PaymentMethodType.CREDIT_CARD:
+          case PaymentMethodType.ACH:
+          case PaymentMethodType.BANK_ACCOUNT:
+            config = { stripeAccountId: getRandomStripeAccountId() };
+            break;
+          case PaymentMethodType.WIRE:
+            config = {
+              usAccountHolderName: getRandomName(),
+              usBankName: `${getRandomName()} Bank`,
+              usRoutingNumber: getRandomNumber(100000000, 999999999, 0)
+                .toString()
+                .padStart(9, '0'),
+              usAccountNumber: getRandomNumber(
+                10000000,
+                Number.MAX_SAFE_INTEGER,
+                0,
+              ).toString(),
+            };
+            break;
+          case PaymentMethodType.CHECK:
+            config = {
+              companyName: getRandomCompanyName(),
+              address: getRandomAddress(),
+              city: getRandomCity(),
+              state: StateCode[getRandomState() as keyof typeof StateCode],
+              zip: getRandomZip(),
+              country: CountryCode['US'],
+            };
+            break;
+          case PaymentMethodType.RETIREMENT:
+            config = {
+              custodianInstruction: `Custodian instruction for ${getRandomCompanyName()}`,
+            };
+            break;
+        }
+
+        const result = PatchIssuerPaymentMethodZod.safeParse({
+          paymentMethodType: type,
+          config,
+        });
+
+        if (result.success) {
+          coveredTypes.add(type);
+        }
+      });
+
+      // BANK_ACCOUNT is in PatchIssuerPaymentMethodZod but not in PaymentMethodConfig
+      // This is expected behavior, so we check that all types that should be covered are covered
+      expect(coveredTypes.has(PaymentMethodType.CREDIT_CARD)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.ACH)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.BANK_ACCOUNT)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.WIRE)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.CHECK)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.RETIREMENT)).toBe(true);
+    });
+
+    it('should cover all payment method types in PaymentMethodConfig', () => {
+      const paymentMethodTypes = Object.values(PaymentMethodType);
+      const coveredTypes = new Set<string>();
+
+      // Test each payment method type
+      paymentMethodTypes.forEach((type) => {
+        let config: any;
+        switch (type) {
+          case PaymentMethodType.CREDIT_CARD:
+          case PaymentMethodType.ACH:
+            config = { stripeAccountId: getRandomStripeAccountId() };
+            break;
+          case PaymentMethodType.WIRE:
+            config = {
+              usAccountHolderName: getRandomName(),
+              usBankName: `${getRandomName()} Bank`,
+              usRoutingNumber: getRandomNumber(100000000, 999999999, 0)
+                .toString()
+                .padStart(9, '0'),
+              usAccountNumber: getRandomNumber(
+                10000000,
+                Number.MAX_SAFE_INTEGER,
+                0,
+              ).toString(),
+            };
+            break;
+          case PaymentMethodType.CHECK:
+            config = {
+              companyName: getRandomCompanyName(),
+              address: getRandomAddress(),
+              city: getRandomCity(),
+              state: StateCode[getRandomState() as keyof typeof StateCode],
+              zip: getRandomZip(),
+              country: CountryCode['US'],
+            };
+            break;
+          case PaymentMethodType.RETIREMENT:
+            config = {
+              custodianInstruction: `Custodian instruction for ${getRandomCompanyName()}`,
+            };
+            break;
+          case PaymentMethodType.BANK_ACCOUNT:
+            // BANK_ACCOUNT is not in PaymentMethodConfig, skip it
+            return;
+        }
+
+        const result = PaymentMethodConfig.safeParse({
+          paymentMethodType: type,
+          config,
+        });
+
+        if (result.success) {
+          coveredTypes.add(type);
+        }
+      });
+
+      // PaymentMethodConfig doesn't include BANK_ACCOUNT, which is expected
+      expect(coveredTypes.has(PaymentMethodType.CREDIT_CARD)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.ACH)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.WIRE)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.CHECK)).toBe(true);
+      expect(coveredTypes.has(PaymentMethodType.RETIREMENT)).toBe(true);
+    });
+  });
+
+  describe('createDefaultIssuerPaymentMethods schema consistency', () => {
+    it('should create payment methods with valid configs that match their schemas', () => {
+      const issuerId = typeid('issuer').toString();
+      const defaultMethods = createDefaultIssuerPaymentMethods(issuerId);
+
+      defaultMethods.forEach((method) => {
+        let configSchema: any;
+        switch (method.paymentMethodType) {
+          case PaymentMethodType.CREDIT_CARD:
+          case PaymentMethodType.ACH:
+          case PaymentMethodType.BANK_ACCOUNT:
+            configSchema = stripeConfigSchema;
+            break;
+          case PaymentMethodType.WIRE:
+            configSchema = wireConfigSchema;
+            break;
+          case PaymentMethodType.CHECK:
+            configSchema = checkConfigSchema;
+            break;
+          case PaymentMethodType.RETIREMENT:
+            configSchema = retirementConfigSchema;
+            break;
+          default:
+            throw new Error(
+              `Unknown payment method type: ${method.paymentMethodType}`,
+            );
+        }
+
+        // Parse the config string back to object
+        const configObj =
+          typeof method.config === 'string'
+            ? JSON.parse(method.config)
+            : method.config;
+
+        // Validate the config against its schema
+        const result = configSchema.safeParse(configObj);
+        expect(result.success).toBe(true);
+      });
+    });
+
+    it('should create all expected payment method types', () => {
+      const issuerId = typeid('issuer').toString();
+      const defaultMethods = createDefaultIssuerPaymentMethods(issuerId);
+
+      const createdTypes = defaultMethods.map((m) => m.paymentMethodType);
+      const expectedTypes = [
+        PaymentMethodType.CREDIT_CARD,
+        PaymentMethodType.ACH,
+        PaymentMethodType.BANK_ACCOUNT,
+        PaymentMethodType.WIRE,
+        PaymentMethodType.CHECK,
+        PaymentMethodType.RETIREMENT,
+      ];
+
+      expectedTypes.forEach((expectedType) => {
+        expect(createdTypes).toContain(expectedType);
+      });
+
+      expect(defaultMethods.length).toBe(expectedTypes.length);
+    });
+
+    it('should create payment methods that can be validated by PatchIssuerPaymentMethodZod', () => {
+      const issuerId = typeid('issuer').toString();
+      const defaultMethods = createDefaultIssuerPaymentMethods(issuerId);
+
+      defaultMethods.forEach((method) => {
+        const configObj =
+          typeof method.config === 'string'
+            ? JSON.parse(method.config)
+            : method.config;
+
+        const input = {
+          paymentMethodType: method.paymentMethodType,
+          config: configObj,
+        };
+
+        const result = PatchIssuerPaymentMethodZod.safeParse(input);
+
+        // BANK_ACCOUNT might not be in PaymentMethodConfig but should be in PatchIssuerPaymentMethodZod
+        expect(result.success).toBe(true);
+      });
+    });
+  });
+
+  describe('Config schema field consistency', () => {
+    it('should have consistent field definitions in wireConfigSchema', () => {
+      // Generate a valid swiftId (8-11 characters, alphanumeric)
+      // SWIFT IDs are typically 8 or 11 characters: 4 letters (bank code) + 2 letters (country) + 2 chars (location) + optional 3 chars (branch)
+      const bankCode = getRandomName()
+        .substring(0, 4)
+        .toUpperCase()
+        .padEnd(4, 'A');
+      const countryCode = 'US';
+      const locationCode = '33';
+      const branchCode = 'XXX'; // Optional 3-character branch code
+      const swiftId =
+        `${bankCode}${countryCode}${locationCode}${branchCode}`.substring(
+          0,
+          11,
+        ); // Ensure max 11 chars
+
+      const validConfig = {
+        usAccountHolderName: getRandomName(),
+        usBankName: `${getRandomName()} Bank`,
+        usRoutingNumber: getRandomNumber(100000000, 999999999, 0)
+          .toString()
+          .padStart(9, '0'),
+        usAccountNumber: getRandomNumber(
+          10000000,
+          Number.MAX_SAFE_INTEGER,
+          0,
+        ).toString(),
+        reference: `REF${getRandomNumber(100, 999, 0)}`,
+        swiftId:
+          swiftId.length >= 8
+            ? swiftId
+            : `${bankCode}${countryCode}${locationCode}XXX`.substring(0, 11),
+      };
+
+      const result = wireConfigSchema.safeParse(validConfig);
+      expect(result.success).toBe(true);
+
+      // Verify all expected fields are present
+      if (result.success) {
+        expect(result.data).toHaveProperty('usAccountHolderName');
+        expect(result.data).toHaveProperty('usBankName');
+        expect(result.data).toHaveProperty('usRoutingNumber');
+        expect(result.data).toHaveProperty('usAccountNumber');
+        expect(result.data).toHaveProperty('reference');
+        expect(result.data).toHaveProperty('swiftId');
+      }
+    });
+
+    it('should have consistent field definitions in checkConfigSchema', () => {
+      const validConfig = {
+        companyName: getRandomCompanyName(),
+        address: getRandomAddress(),
+        address2: `Suite ${getRandomNumber(1, 999, 0)}`,
+        city: getRandomCity(),
+        state: StateCode[getRandomState() as keyof typeof StateCode],
+        zip: getRandomZip(),
+        country: CountryCode['US'],
+        reference: `REF${getRandomNumber(100, 999, 0)}`,
+      };
+
+      const result = checkConfigSchema.safeParse(validConfig);
+      expect(result.success).toBe(true);
+
+      // Verify all expected fields are present
+      if (result.success) {
+        expect(result.data).toHaveProperty('companyName');
+        expect(result.data).toHaveProperty('address');
+        expect(result.data).toHaveProperty('address2');
+        expect(result.data).toHaveProperty('city');
+        expect(result.data).toHaveProperty('state');
+        expect(result.data).toHaveProperty('zip');
+        expect(result.data).toHaveProperty('country');
+        expect(result.data).toHaveProperty('reference');
+      }
+    });
+
+    it('should have consistent field definitions in retirementConfigSchema', () => {
+      const validConfig = {
+        custodianInstruction: `Custodian instruction for ${getRandomCompanyName()}`,
+        custodianDocument: null,
+      };
+
+      const result = retirementConfigSchema.safeParse(validConfig);
+      expect(result.success).toBe(true);
+
+      // Verify all expected fields are present
+      if (result.success) {
+        expect(result.data).toHaveProperty('custodianInstruction');
+        expect(result.data).toHaveProperty('custodianDocument');
+      }
+    });
+
+    it('should have consistent field definitions in stripeConfigSchema', () => {
+      const validConfig = {
+        stripeAccountId: getRandomStripeAccountId(),
+      };
+
+      const result = stripeConfigSchema.safeParse(validConfig);
+      expect(result.success).toBe(true);
+
+      // Verify all expected fields are present
+      if (result.success) {
+        expect(result.data).toHaveProperty('stripeAccountId');
+      }
+    });
+  });
+});

package/src/common/types/offering.types.spec.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { OfferingSettings, OfferingFeeType } from './offering.types';
+
+describe('OfferingSettings Schema', () => {
+  it('should pass with all null or undefined values', () => {
+    const data = {
+      settingsBrokerageFeeValue: null,
+      settingsBrokerageFeeType: null,
+      settingsCardFeeValue: null,
+      settingsCardFeeType: null,
+      settingsDisbursementFeeValue: null,
+      settingsDisbursementFeeType: null,
+      settingsRefundPoolFeeValue: null,
+      settingsRefundPoolFeeType: null,
+      serviceCharges: null,
+      serviceChargesType: null,
+    };
+    expect(() => OfferingSettings.parse(data)).not.toThrow();
+  });
+
+  it('should pass with valid non-null pair values', () => {
+    const data = {
+      settingsBrokerageFeeValue: 50,
+      settingsBrokerageFeeType: OfferingFeeType.PERCENTAGE,
+      settingsCardFeeValue: 25,
+      settingsCardFeeType: OfferingFeeType.PERCENTAGE,
+      settingsDisbursementFeeValue: 30,
+      settingsDisbursementFeeType: OfferingFeeType.PERCENTAGE,
+      settingsRefundPoolFeeValue: 40,
+      settingsRefundPoolFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).not.toThrow();
+  });
+
+  it('should fail if one of a pair is null and the other is not', () => {
+    const data = {
+      settingsBrokerageFeeValue: 10,
+      settingsBrokerageFeeType: null,
+      settingsCardFeeValue: null,
+      settingsCardFeeType: OfferingFeeType.PERCENTAGE,
+      settingsDisbursementFeeValue: 15,
+      settingsDisbursementFeeType: null,
+      settingsRefundPoolFeeValue: null,
+      settingsRefundPoolFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsBrokerageFeeType and settingsBrokerageFeeValue must both be either null or not-null',
+    );
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsCardFeeType and settingsCardFeeValue must both be either null or not-null',
+    );
+  });
+
+  it('should fail if percentage fee values exceed 100', () => {
+    const data = {
+      settingsBrokerageFeeValue: 101,
+      settingsBrokerageFeeType: OfferingFeeType.PERCENTAGE,
+      settingsCardFeeValue: 50,
+      settingsCardFeeType: OfferingFeeType.PERCENTAGE,
+      settingsDisbursementFeeValue: 200,
+      settingsDisbursementFeeType: OfferingFeeType.PERCENTAGE,
+      settingsRefundPoolFeeValue: 150,
+      settingsRefundPoolFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsBrokerageFeeValue must be less than or equal to 100',
+    );
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsDisbursementFeeValue must be less than 100',
+    );
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsRefundPoolFeeValue must be less than or equal to 100',
+    );
+  });
+
+  it('should fail if required values are missing', () => {
+    const data = {
+      settingsBrokerageFeeValue: undefined,
+      settingsBrokerageFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).toThrow(z.ZodError);
+  });
+
+  it('should fail if invalid types are provided', () => {
+    const data = {
+      settingsBrokerageFeeValue: 'invalid', // should be a number
+      settingsBrokerageFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).toThrow(z.ZodError);
+  });
+});