@moovio/sdk 0.11.5 → 0.12.0

package/test/tests/representatives.test.ts

@@ -0,0 +1,83 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { createAccount, createAccountWithWallet, createRepresentative } from "../utils/utils";
+import type { Account, Representative } from "../../models/components";
+import { moov } from "../setup";
+
+let account: Account;
+let representative: Representative;
+describe("Representative", () => {
+  beforeAll(async () => {
+    account = await createAccount();
+  });
+  describe("Creating a representative", () => {
+    test("should create a representative", async () => {
+      const representativeCreated = await createRepresentative(account.accountID);
+      expect(representativeCreated).toBeDefined();
+      representative = representativeCreated;
+    });
+  });
+  describe("Representative-dependent tests", () => {
+    beforeEach(async () => {
+      if (!representative) {
+        representative = await createRepresentative(account.accountID);
+      }
+    });
+    describe("Listing and getting representatives", () => {
+      test("should list representatives", async () => {
+        const { result } = await moov.representatives.list({ accountID: account.accountID });
+        expect(result).toBeDefined();
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some((r) => r.representativeID === representative.representativeID)).toBe(true);
+      });
+      test("should be able to get a representative", async () => {
+        const { result } = await moov.representatives.get({
+          accountID: account.accountID,
+          representativeID: representative.representativeID,
+        });
+        expect(result).toBeDefined();
+        expect(result.representativeID).toBe(representative.representativeID);
+        expect(result.email).toBe(representative.email!);
+      });
+      test("listing representatives should fail if the account is not found", async () => {
+        expect(() => moov.representatives.list({ accountID: "not-a-valid-account-id" })).toThrowError(
+          "API error occurred: Status 403 Content-Type  Body ",
+        );
+      });
+      test("getting a representative should fail if the account is not found", async () => {
+        expect(() =>
+          moov.representatives.get({
+            accountID: "not-a-valid-account-id",
+            representativeID: representative.representativeID,
+          }),
+        ).toThrowError("API error occurred: Status 403 Content-Type  Body ");
+      });
+    });
+    describe("Updating a representative", () => {
+      beforeEach(async () => {
+        representative = await createRepresentative(account.accountID);
+      });
+      test("should be able to update a representative", async () => {
+        const { result } = await moov.representatives.update({
+          accountID: account.accountID,
+          representativeID: representative.representativeID,
+          updateRepresentative: {
+            email: "mia.wallece@bigkahunaburger.com",
+          },
+        });
+        expect(result).toBeDefined();
+        expect(result.email).toBe("mia.wallece@bigkahunaburger.com");
+      });
+      test("updating a representative should fail if the account is not found", async () => {
+        expect(() =>
+          moov.representatives.update({
+            accountID: "not-a-valid-account-id",
+            representativeID: representative.representativeID,
+            updateRepresentative: {
+              email: "mia.wallece@bigkahunaburger.com",
+            },
+          }),
+        ).toThrowError("API error occurred: Status 403 Content-Type  Body ");
+      });
+    });
+  });
+});

package/test/tests/transfers.test.ts

@@ -0,0 +1,122 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { ids, moov } from "../setup";
+import {
+  crateAccountAndGetTransferOptions,
+  createAccount,
+  createAccountWithWallet,
+  createBankAccount,
+  createCard,
+  SOURCE_ACCOUNT_ID,
+  UUID_REGEX,
+  waitFor,
+} from "../utils/utils";
+import type { CreateTransferOptions, PaymentMethod, TransferResponse } from "../../models/components";
+import { sleep } from "bun";
+import type { CreateTransferRequest } from "../../models/operations";
+
+let destinationAccountID: string;
+let sourcePaymentMethodID: string;
+let destinationPaymentMethodID: string;
+let transfer: TransferResponse;
+describe("Transfers", () => {
+  // Setup accounts and payment methods
+
+  describe("Transfer Creation", () => {
+    beforeAll(async () => {
+      const availablePaymentMethods = await crateAccountAndGetTransferOptions();
+      sourcePaymentMethodID = availablePaymentMethods.sourceOptions![0].paymentMethodID!;
+      destinationPaymentMethodID = availablePaymentMethods.destinationOptions![0].paymentMethodID!;
+    });
+    test("should be able to create a simple ASYNC transfer between accounts", async () => {
+      const transferRequest: CreateTransferRequest = {
+        xIdempotencyKey: crypto.randomUUID(),
+        accountID: SOURCE_ACCOUNT_ID,
+        createTransfer: {
+          source: {
+            paymentMethodID: sourcePaymentMethodID,
+          },
+          destination: {
+            paymentMethodID: destinationPaymentMethodID,
+          },
+          amount: {
+            currency: "USD",
+            value: 1,
+          },
+        },
+      };
+
+      const { result } = await moov.transfers.create(transferRequest);
+      expect(result).toBeDefined();
+      expect(result.transferID).toBeDefined();
+      expect(result.createdOn).toBeDefined();
+      expect(result.transferID).toMatch(UUID_REGEX);
+      transfer = result;
+    });
+
+    test("Should be able to create a simple SYNC transfer between accounts", async () => {
+      const transferRequest: CreateTransferRequest = {
+        xIdempotencyKey: crypto.randomUUID(),
+        xWaitFor: "rail-response",
+        accountID: SOURCE_ACCOUNT_ID,
+        createTransfer: {
+          source: {
+            paymentMethodID: sourcePaymentMethodID,
+          },
+          destination: {
+            paymentMethodID: destinationPaymentMethodID,
+          },
+          amount: {
+            currency: "USD",
+            value: 1,
+          },
+        },
+      };
+
+      const { result } = await moov.transfers.create(transferRequest);
+      expect(result).toBeDefined();
+      expect(result.transferID).toBeDefined();
+      expect(result.createdOn).toBeDefined();
+      expect(result.transferID).toMatch(UUID_REGEX);
+      transfer = result;
+    });
+
+    test("should fail to create transfer with invalid amount", async () => {
+      const transferRequest: CreateTransferRequest = {
+        xIdempotencyKey: crypto.randomUUID(),
+        accountID: SOURCE_ACCOUNT_ID,
+        createTransfer: {
+          source: {
+            paymentMethodID: sourcePaymentMethodID,
+          },
+          destination: {
+            paymentMethodID: destinationPaymentMethodID,
+          },
+          amount: {
+            currency: "USD",
+            value: 0,
+          },
+        },
+      };
+
+      await expect(() => moov.transfers.create(transferRequest)).toThrowError(
+        'API error occurred: {"amount":"amount value must be greater than or equal to 0.01"}',
+      );
+    });
+  });
+
+  describe.todo("Transfer Management", () => {
+    beforeEach(async () => {});
+
+    test("should list transfers", async () => {});
+
+    test("should get transfer details", async () => {});
+
+    test("should update transfer metadata", async () => {});
+
+    test("should list transfer refunds", async () => {});
+  });
+
+  describe.todo("Transfer Options", () => {
+    test("should generate transfer options", async () => {});
+  });
+});

package/test/tests/wallets.test.ts

@@ -0,0 +1,31 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { ids, moov } from "../setup";
+import { createAccount, createAccountWithWallet } from "../utils/utils";
+
+let accountID = "a920f147-ed53-4aa1-977c-d11cc192979c"; // default account ID
+describe("Wallets", () => {
+  beforeAll(async () => {
+    const account = await createAccountWithWallet();
+    accountID = account.accountID;
+  });
+
+  describe("Listing", () => {
+    test("should be able to list wallets", async () => {
+      const { result } = await moov.wallets.list({ accountID });
+      expect(result).toBeDefined();
+      expect(result.length).toEqual(1);
+      expect(result[0].availableBalance).toEqual({
+        currency: "USD",
+        value: 0,
+        valueDecimal: "0",
+      });
+    });
+    test("listing should fail if accountID is not provided", async () => {
+      expect(() => moov.wallets.list({ accountID: "" })).toThrowError(
+        "API error occurred: Status 403 Content-Type  Body",
+      );
+    });
+  });
+
+  describe.todo("Getting Wallets", () => {});
+});

package/test/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+
+    // Add Bun types
+    "types": ["bun-types"]
+  }
+}

package/test/utils/utils.ts

@@ -0,0 +1,276 @@
+import { Chance } from "chance";
+import { ids, moov } from "../setup";
+import type {
+  BankAccount,
+  BankAccountPayload,
+  CreateAccount,
+  CreateRepresentative,
+  CreateTransferOptions,
+  LinkCard,
+  PaymentMethod,
+} from "../../models/components";
+import { merge } from "remeda";
+import { sleep } from "bun";
+import { expect } from "bun:test";
+const chance = new Chance();
+
+export type DeepPartial<T> = T extends object
+  ? {
+      [P in keyof T]?: DeepPartial<T[P]>;
+    }
+  : T;
+
+export const SOURCE_ACCOUNT_ID = "5acdc734-8c9d-448f-be13-136efa707b7b"; // Ramen Corp
+export const UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+const getDefaultAccount = () => {
+  const truncatedLegalBusinessName = chance.company().slice(0, 50); // Because the total lenght has to be less than 64 chars
+  const legalBusinessName = `${truncatedLegalBusinessName} ${new Date().getTime()}`; // 50 chars + ~10 chars fot the timestamp
+
+  return {
+    accountType: "business",
+    profile: {
+      business: {
+        legalBusinessName,
+      },
+    },
+  };
+};
+
+const getDefaultRepresentative = (): CreateRepresentative => {
+  return {
+    name: {
+      firstName: "Vince",
+      lastName: "Vega",
+    },
+    email: "vince.vega@example.com",
+    address: {
+      addressLine1: "123 Main St",
+      city: "Anytown",
+      country: "US",
+      stateOrProvince: "CA",
+      postalCode: "12345",
+    },
+    birthDate: {
+      day: 1,
+      month: 1,
+      year: 1990,
+    },
+    governmentID: {
+      ssn: {
+        full: "123456789",
+      },
+    },
+    responsibilities: {
+      isOwner: true,
+      isController: true,
+      ownershipPercentage: 80,
+      jobTitle: "CEO",
+    },
+  };
+};
+/**
+ * Creates a default account, merges the provided account with the default account, and returns the result.
+ * It also adds the account to the seen list so we can later delete it in the `afterAll` hook in setup.ts.
+ * @param account - The account to merge with the default account.
+ * @returns The created account.
+ */
+export const createAccount = async (account: DeepPartial<CreateAccount> = {}) => {
+  const mergedAccount = merge(getDefaultAccount(), account) as CreateAccount;
+  const { result } = await moov.accounts.create(mergedAccount);
+
+  ids.seen({ accountID: result.accountID });
+  return result;
+};
+
+export const createRepresentative = async (
+  accountID: string,
+  representative: DeepPartial<CreateRepresentative> = {},
+) => {
+  const mergedRepresentative = merge(getDefaultRepresentative(), representative) as CreateRepresentative;
+  const { result } = await moov.representatives.create({
+    accountID: accountID,
+    createRepresentative: mergedRepresentative,
+  });
+  ids.seen({ accountID, representativeID: result.representativeID });
+  return result;
+};
+
+export const createAccountWithWallet = async (account: DeepPartial<CreateAccount> = {}) => {
+  // Create the account with the KYC fields needed for the wallet
+  const ts = new Date().getTime();
+  const baseAccount = {
+    ...getDefaultAccount(),
+    capabilities: ["wallet"],
+    profile: {
+      business: {
+        website: `https://bigkahunawallet.com/${ts}`,
+        legalBusinessName: `Big Kahuna Wallet ${ts}`,
+        businessType: "llc",
+        taxID: {
+          ein: {
+            number: "123456789",
+          },
+        },
+        phone: {
+          number: "1234567890",
+        },
+        address: {
+          addressLine1: "123 Main St",
+          city: "Anytown",
+          country: "US",
+          stateOrProvince: "CA",
+          postalCode: "12345",
+        },
+      },
+    },
+  };
+  const mergedAccount = merge(baseAccount, account) as CreateAccount;
+  const createdAccount = await createAccount(mergedAccount);
+  // Get the terms of service token
+  const {
+    result: { token },
+  } = await moov.accounts.getTermsOfServiceToken({
+    origin: "https://moov.io",
+    referer: "https://moov.io",
+  });
+  // Create the representative (which adds it to the account)
+  await createRepresentative(createdAccount.accountID);
+  // Update the account with the terms of service token AND ownersProvided to true
+  const { result: patchResult } = await moov.accounts.update({
+    accountID: createdAccount.accountID,
+    patchAccount: {
+      profile: {
+        business: {
+          ownersProvided: true,
+        },
+      },
+      termsOfService: {
+        token,
+      },
+    },
+  });
+  // get capabilities for account
+  let walletCapability;
+  do {
+    const { result } = await moov.capabilities.get({
+      accountID: createdAccount.accountID,
+      capabilityID: "wallet",
+    });
+    walletCapability = result;
+    if (walletCapability.status !== "enabled") {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  } while (walletCapability.status !== "enabled");
+
+  return patchResult;
+};
+
+/**
+ * Creates a bank account for the given account ID. Optionally, you can provide a bank account to merge with the default bank account.
+ * It also adds the bank account to the seen list so we can later delete it in the `afterAll` hook in setup.ts.
+ * @param accountID - The ID of the account to create the bank account for.
+ * @param bankAccount - The bank account to merge with the default bank account.
+ * @returns The created bank account.
+ */
+export const createBankAccount = async (accountID: string, bankAccount: Partial<BankAccount> = {}) => {
+  const defaultBankAccount = {
+    account: {
+      holderName: "Marcellus Wallace",
+      holderType: "individual",
+      accountNumber: chance.integer({ min: 1000000000, max: 9999999999 }).toString(),
+      bankAccountType: "checking",
+      routingNumber: "121000248",
+    },
+  };
+  const mergedBankAccount = merge(defaultBankAccount, bankAccount) as BankAccountPayload;
+  const { result } = await moov.bankAccounts.link({
+    accountID,
+    linkBankAccount: mergedBankAccount,
+  });
+  ids.seen({ accountID, bankAccountID: result.bankAccountID });
+  return { bankAccount: result, accountNumber: mergedBankAccount.account.accountNumber };
+};
+
+export const createCard = async (accountID: string, card: DeepPartial<LinkCard> = {}) => {
+  const defaultCard = {
+    cardNumber: "4111111111111111",
+    cardCvv: "123",
+    expiration: {
+      month: "01",
+      year: "52",
+    },
+    billingAddress: {
+      addressLine1: "123 Main St",
+      city: "Anytown",
+      country: "US",
+      postalCode: "12345",
+      stateOrProvince: "CA",
+    },
+  };
+  const mergedCard = merge(defaultCard, card) as LinkCard;
+  const { result } = await moov.cards.link({
+    accountID,
+    linkCard: mergedCard,
+  });
+  ids.seen({ accountID, cardID: result.cardID });
+  return { card: result, cardNumber: mergedCard.cardNumber };
+};
+
+export const crateAccountAndGetTransferOptions = async () => {
+  const doneCheck = (data: { result: PaymentMethod[] }) => data.result.length > 0;
+
+  // Create destination account with card and bank account
+  const destinationAccount = await createAccountWithWallet();
+  const destinationAccountID = destinationAccount.accountID;
+  await createBankAccount(destinationAccountID);
+  createCard(destinationAccountID);
+
+  // Get the payment method ID for the card
+  const { result: destinationPaymentMethods } = await waitFor(
+    () => moov.paymentMethods.list({ accountID: destinationAccountID }),
+    {
+      doneCheck,
+    },
+  );
+
+  const generateOptionsRequest: CreateTransferOptions = {
+    source: { accountID: SOURCE_ACCOUNT_ID },
+    destination: { accountID: destinationAccountID },
+    amount: { currency: "USD", value: 1 },
+  };
+  const { result: availablePaymentMethods } = await moov.transfers.generateOptions(generateOptionsRequest);
+  expect(availablePaymentMethods).toBeDefined();
+  expect(availablePaymentMethods.sourceOptions).toBeArray();
+  expect(availablePaymentMethods.sourceOptions!.length).toBeGreaterThan(0);
+  expect(availablePaymentMethods.destinationOptions).toBeArray();
+  expect(availablePaymentMethods.destinationOptions!.length).toBeGreaterThan(0);
+  return availablePaymentMethods;
+};
+
+export const waitFor = async <T>(
+  callback: () => Promise<T>,
+  options: { doneCheck?: (data: T) => boolean; interval?: number; timeout?: number } = {},
+): Promise<T> => {
+  const { interval = 250, timeout = 10000 } = options;
+  const startTime = Date.now();
+  const doneCheck = options.doneCheck || ((data) => !!data);
+  const i = 0;
+
+  while (true) {
+    try {
+      const result = await callback();
+      if (doneCheck(result)) {
+        return result;
+      }
+    } catch (error) {
+      // Ignore errors and continue polling
+    }
+
+    if (Date.now() - startTime >= timeout) {
+      throw new Error("waitFor timed out");
+    }
+
+    await sleep(interval);
+  }
+};

package/models/components/enrichedindustry.d.ts

@@ -1,47 +0,0 @@
-import * as z from "zod";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-/**
- * An industry's MCC/SIC/NAICS codes, along with descriptive title.
- */
-export type EnrichedIndustry = {
-    title: string;
-    /**
-     * North American Industry Classification System
-     */
-    naics: string;
-    /**
-     * Standard Industrial Classification
-     */
-    sic: string;
-    /**
-     * Merchant Category Code
-     */
-    mcc: string;
-};
-/** @internal */
-export declare const EnrichedIndustry$inboundSchema: z.ZodType<EnrichedIndustry, z.ZodTypeDef, unknown>;
-/** @internal */
-export type EnrichedIndustry$Outbound = {
-    title: string;
-    naics: string;
-    sic: string;
-    mcc: string;
-};
-/** @internal */
-export declare const EnrichedIndustry$outboundSchema: z.ZodType<EnrichedIndustry$Outbound, z.ZodTypeDef, EnrichedIndustry>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace EnrichedIndustry$ {
-    /** @deprecated use `EnrichedIndustry$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<EnrichedIndustry, z.ZodTypeDef, unknown>;
-    /** @deprecated use `EnrichedIndustry$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<EnrichedIndustry$Outbound, z.ZodTypeDef, EnrichedIndustry>;
-    /** @deprecated use `EnrichedIndustry$Outbound` instead. */
-    type Outbound = EnrichedIndustry$Outbound;
-}
-export declare function enrichedIndustryToJSON(enrichedIndustry: EnrichedIndustry): string;
-export declare function enrichedIndustryFromJSON(jsonString: string): SafeParseResult<EnrichedIndustry, SDKValidationError>;
-//# sourceMappingURL=enrichedindustry.d.ts.map

package/models/components/enrichedindustry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"enrichedindustry.d.ts","sourceRoot":"","sources":["../../src/models/components/enrichedindustry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,EAAE,MAAM,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,gBAAgB;AAChB,eAAO,MAAM,8BAA8B,EAAE,CAAC,CAAC,OAAO,CACpD,gBAAgB,EAChB,CAAC,CAAC,UAAU,EACZ,OAAO,CAMP,CAAC;AAEH,gBAAgB;AAChB,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,gBAAgB;AAChB,eAAO,MAAM,+BAA+B,EAAE,CAAC,CAAC,OAAO,CACrD,yBAAyB,EACzB,CAAC,CAAC,UAAU,EACZ,gBAAgB,CAMhB,CAAC;AAEH;;;GAGG;AACH,yBAAiB,iBAAiB,CAAC;IACjC,gEAAgE;IACzD,MAAM,aAAa,oDAAiC,CAAC;IAC5D,iEAAiE;IAC1D,MAAM,cAAc,sEAAkC,CAAC;IAC9D,2DAA2D;IAC3D,KAAY,QAAQ,GAAG,yBAAyB,CAAC;CAClD;AAED,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,gBAAgB,GACjC,MAAM,CAIR;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,GACjB,eAAe,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAMvD"}

package/models/components/enrichedindustry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"enrichedindustry.js","sourceRoot":"","sources":["../../src/models/components/enrichedindustry.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEH,wDAMC;AAED,4DAQC;AArFD,uCAAyB;AACzB,qDAAiD;AAuBjD,gBAAgB;AACH,QAAA,8BAA8B,GAIvC,CAAC,CAAC,MAAM,CAAC;IACX,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;IACf,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;CAChB,CAAC,CAAC;AAUH,gBAAgB;AACH,QAAA,+BAA+B,GAIxC,CAAC,CAAC,MAAM,CAAC;IACX,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;IACf,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;CAChB,CAAC,CAAC;AAEH;;;GAGG;AACH,IAAiB,iBAAiB,CAOjC;AAPD,WAAiB,iBAAiB;IAChC,gEAAgE;IACnD,+BAAa,GAAG,sCAA8B,CAAC;IAC5D,iEAAiE;IACpD,gCAAc,GAAG,uCAA+B,CAAC;AAGhE,CAAC,EAPgB,iBAAiB,iCAAjB,iBAAiB,QAOjC;AAED,SAAgB,sBAAsB,CACpC,gBAAkC;IAElC,OAAO,IAAI,CAAC,SAAS,CACnB,uCAA+B,CAAC,KAAK,CAAC,gBAAgB,CAAC,CACxD,CAAC;AACJ,CAAC;AAED,SAAgB,wBAAwB,CACtC,UAAkB;IAElB,OAAO,IAAA,sBAAS,EACd,UAAU,EACV,CAAC,CAAC,EAAE,EAAE,CAAC,sCAA8B,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAC1D,8CAA8C,CAC/C,CAAC;AACJ,CAAC"}

package/src/models/components/enrichedindustry.ts

@@ -1,90 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-
-import * as z from "zod";
-import { safeParse } from "../../lib/schemas.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-
-/**
- * An industry's MCC/SIC/NAICS codes, along with descriptive title.
- */
-export type EnrichedIndustry = {
-  title: string;
-  /**
-   * North American Industry Classification System
-   */
-  naics: string;
-  /**
-   * Standard Industrial Classification
-   */
-  sic: string;
-  /**
-   * Merchant Category Code
-   */
-  mcc: string;
-};
-
-/** @internal */
-export const EnrichedIndustry$inboundSchema: z.ZodType<
-  EnrichedIndustry,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  title: z.string(),
-  naics: z.string(),
-  sic: z.string(),
-  mcc: z.string(),
-});
-
-/** @internal */
-export type EnrichedIndustry$Outbound = {
-  title: string;
-  naics: string;
-  sic: string;
-  mcc: string;
-};
-
-/** @internal */
-export const EnrichedIndustry$outboundSchema: z.ZodType<
-  EnrichedIndustry$Outbound,
-  z.ZodTypeDef,
-  EnrichedIndustry
-> = z.object({
-  title: z.string(),
-  naics: z.string(),
-  sic: z.string(),
-  mcc: z.string(),
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace EnrichedIndustry$ {
-  /** @deprecated use `EnrichedIndustry$inboundSchema` instead. */
-  export const inboundSchema = EnrichedIndustry$inboundSchema;
-  /** @deprecated use `EnrichedIndustry$outboundSchema` instead. */
-  export const outboundSchema = EnrichedIndustry$outboundSchema;
-  /** @deprecated use `EnrichedIndustry$Outbound` instead. */
-  export type Outbound = EnrichedIndustry$Outbound;
-}
-
-export function enrichedIndustryToJSON(
-  enrichedIndustry: EnrichedIndustry,
-): string {
-  return JSON.stringify(
-    EnrichedIndustry$outboundSchema.parse(enrichedIndustry),
-  );
-}
-
-export function enrichedIndustryFromJSON(
-  jsonString: string,
-): SafeParseResult<EnrichedIndustry, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EnrichedIndustry$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EnrichedIndustry' from JSON`,
-  );
-}