@moovio/sdk 26.7.0 → 26.7.2

package/src/models/components/issuingcontrolserror.ts

@@ -7,15 +7,37 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AllowedScheduleError,
+  AllowedScheduleError$inboundSchema,
+  AllowedScheduleError$Outbound,
+  AllowedScheduleError$outboundSchema,
+} from "./allowedscheduleerror.js";
 import {
   IssuingVelocityLimitError,
   IssuingVelocityLimitError$inboundSchema,
   IssuingVelocityLimitError$Outbound,
   IssuingVelocityLimitError$outboundSchema,
 } from "./issuingvelocitylimiterror.js";
+import {
+  MerchantCategoryRestrictionsError,
+  MerchantCategoryRestrictionsError$inboundSchema,
+  MerchantCategoryRestrictionsError$Outbound,
+  MerchantCategoryRestrictionsError$outboundSchema,
+} from "./merchantcategoryrestrictionserror.js";
+import {
+  MerchantRestrictionsError,
+  MerchantRestrictionsError$inboundSchema,
+  MerchantRestrictionsError$Outbound,
+  MerchantRestrictionsError$outboundSchema,
+} from "./merchantrestrictionserror.js";
 
 export type IssuingControlsError = {
   velocityLimits?: { [k: string]: IssuingVelocityLimitError } | undefined;
+  merchantCategoryRestrictions?: MerchantCategoryRestrictionsError | undefined;
+  merchantRestrictions?: MerchantRestrictionsError | undefined;
+  allowedSchedule?: AllowedScheduleError | undefined;
+  expiresOn?: string | undefined;
 };
 
 /** @internal */
@@ -27,12 +49,24 @@ export const IssuingControlsError$inboundSchema: z.ZodType<
   velocityLimits: types.optional(
     z.record(IssuingVelocityLimitError$inboundSchema),
   ),
+  merchantCategoryRestrictions: types.optional(
+    MerchantCategoryRestrictionsError$inboundSchema,
+  ),
+  merchantRestrictions: types.optional(MerchantRestrictionsError$inboundSchema),
+  allowedSchedule: types.optional(AllowedScheduleError$inboundSchema),
+  expiresOn: types.optional(types.string()),
 });
 /** @internal */
 export type IssuingControlsError$Outbound = {
   velocityLimits?:
     | { [k: string]: IssuingVelocityLimitError$Outbound }
     | undefined;
+  merchantCategoryRestrictions?:
+    | MerchantCategoryRestrictionsError$Outbound
+    | undefined;
+  merchantRestrictions?: MerchantRestrictionsError$Outbound | undefined;
+  allowedSchedule?: AllowedScheduleError$Outbound | undefined;
+  expiresOn?: string | undefined;
 };
 
 /** @internal */
@@ -42,6 +76,11 @@ export const IssuingControlsError$outboundSchema: z.ZodType<
   IssuingControlsError
 > = z.object({
   velocityLimits: z.record(IssuingVelocityLimitError$outboundSchema).optional(),
+  merchantCategoryRestrictions: MerchantCategoryRestrictionsError$outboundSchema
+    .optional(),
+  merchantRestrictions: MerchantRestrictionsError$outboundSchema.optional(),
+  allowedSchedule: AllowedScheduleError$outboundSchema.optional(),
+  expiresOn: z.string().optional(),
 });
 
 export function issuingControlsErrorToJSON(

package/src/models/components/issuingcontrolsrestrictionmode.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+/**
+ * Whether the listed items should be allowed (`allow`) or blocked (`block`).
+ */
+export const IssuingControlsRestrictionMode = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+/**
+ * Whether the listed items should be allowed (`allow`) or blocked (`block`).
+ */
+export type IssuingControlsRestrictionMode = OpenEnum<
+  typeof IssuingControlsRestrictionMode
+>;
+
+/** @internal */
+export const IssuingControlsRestrictionMode$inboundSchema: z.ZodType<
+  IssuingControlsRestrictionMode,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(IssuingControlsRestrictionMode);
+/** @internal */
+export const IssuingControlsRestrictionMode$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  IssuingControlsRestrictionMode
+> = openEnums.outboundSchema(IssuingControlsRestrictionMode);

package/src/models/components/issuingintervallimit.ts

@@ -3,24 +3,32 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * Specifies the time frame for a velocity limit. `per-transaction` applies to each individual authorization and never resets. Time-based intervals (where supported) reset at midnight ET.
  */
 export const IssuingIntervalLimit = {
   PerTransaction: "per-transaction",
+  Daily: "daily",
+  Weekly: "weekly",
+  Monthly: "monthly",
 } as const;
 /**
  * Specifies the time frame for a velocity limit. `per-transaction` applies to each individual authorization and never resets. Time-based intervals (where supported) reset at midnight ET.
  */
-export type IssuingIntervalLimit = ClosedEnum<typeof IssuingIntervalLimit>;
+export type IssuingIntervalLimit = OpenEnum<typeof IssuingIntervalLimit>;
 
 /** @internal */
-export const IssuingIntervalLimit$inboundSchema: z.ZodNativeEnum<
-  typeof IssuingIntervalLimit
-> = z.nativeEnum(IssuingIntervalLimit);
+export const IssuingIntervalLimit$inboundSchema: z.ZodType<
+  IssuingIntervalLimit,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(IssuingIntervalLimit);
 /** @internal */
-export const IssuingIntervalLimit$outboundSchema: z.ZodNativeEnum<
-  typeof IssuingIntervalLimit
-> = IssuingIntervalLimit$inboundSchema;
+export const IssuingIntervalLimit$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  IssuingIntervalLimit
+> = openEnums.outboundSchema(IssuingIntervalLimit);

package/src/models/components/issuingmerchantcategory.ts

@@ -0,0 +1,56 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+/**
+ * Predefined merchant category groups.
+ */
+export const IssuingMerchantCategory = {
+  Advertising: "advertising",
+  Airlines: "airlines",
+  AlcoholAndBars: "alcohol-and-bars",
+  CarRental: "car-rental",
+  Education: "education",
+  Electronics: "electronics",
+  FuelAndGas: "fuel-and-gas",
+  Gambling: "gambling",
+  Groceries: "groceries",
+  GroundTransportation: "ground-transportation",
+  HardwareAndHome: "hardware-and-home",
+  Healthcare: "healthcare",
+  LiveEntertainment: "live-entertainment",
+  Lodging: "lodging",
+  Movies: "movies",
+  OfficeSupplies: "office-supplies",
+  Parking: "parking",
+  PersonalCare: "personal-care",
+  ProfessionalServices: "professional-services",
+  RestaurantsAndDining: "restaurants-and-dining",
+  RetailGeneral: "retail-general",
+  RideshareAndTaxis: "rideshare-and-taxis",
+  SoftwareAndSaas: "software-and-saas",
+  SportsAndRecreation: "sports-and-recreation",
+  Subscriptions: "subscriptions",
+  TravelAgencies: "travel-agencies",
+} as const;
+/**
+ * Predefined merchant category groups.
+ */
+export type IssuingMerchantCategory = OpenEnum<typeof IssuingMerchantCategory>;
+
+/** @internal */
+export const IssuingMerchantCategory$inboundSchema: z.ZodType<
+  IssuingMerchantCategory,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(IssuingMerchantCategory);
+/** @internal */
+export const IssuingMerchantCategory$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  IssuingMerchantCategory
+> = openEnums.outboundSchema(IssuingMerchantCategory);

package/src/models/components/issuingscheduleday.ts

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const IssuingScheduleDay = {
+  Monday: "monday",
+  Tuesday: "tuesday",
+  Wednesday: "wednesday",
+  Thursday: "thursday",
+  Friday: "friday",
+  Saturday: "saturday",
+  Sunday: "sunday",
+} as const;
+export type IssuingScheduleDay = ClosedEnum<typeof IssuingScheduleDay>;
+
+/** @internal */
+export const IssuingScheduleDay$inboundSchema: z.ZodNativeEnum<
+  typeof IssuingScheduleDay
+> = z.nativeEnum(IssuingScheduleDay);
+/** @internal */
+export const IssuingScheduleDay$outboundSchema: z.ZodNativeEnum<
+  typeof IssuingScheduleDay
+> = IssuingScheduleDay$inboundSchema;

package/src/models/components/issuingvelocitylimit.ts

@@ -17,7 +17,11 @@ export type IssuingVelocityLimit = {
   /**
    * The maximum amount in cents that can be spent in a given interval.
    */
-  amount: number;
+  amount?: number | undefined;
+  /**
+   * The maximum number of transactions allowed in the given interval. At least one of `amount` or `count` must be set.
+   */
+  count?: number | undefined;
   /**
    * Specifies the time frame for a velocity limit. `per-transaction` applies to each individual authorization and never resets. Time-based intervals (where supported) reset at midnight ET.
    */
@@ -30,12 +34,14 @@ export const IssuingVelocityLimit$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  amount: types.number(),
+  amount: types.optional(types.number()),
+  count: types.optional(types.number()),
   interval: IssuingIntervalLimit$inboundSchema,
 });
 /** @internal */
 export type IssuingVelocityLimit$Outbound = {
-  amount: number;
+  amount?: number | undefined;
+  count?: number | undefined;
   interval: string;
 };
 
@@ -45,7 +51,8 @@ export const IssuingVelocityLimit$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   IssuingVelocityLimit
 > = z.object({
-  amount: z.number().int(),
+  amount: z.number().int().optional(),
+  count: z.number().int().optional(),
   interval: IssuingIntervalLimit$outboundSchema,
 });
 

package/src/models/components/issuingvelocitylimiterror.ts

@@ -10,6 +10,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type IssuingVelocityLimitError = {
   amount?: string | undefined;
+  count?: string | undefined;
   interval?: string | undefined;
 };
 
@@ -20,11 +21,13 @@ export const IssuingVelocityLimitError$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   amount: types.optional(types.string()),
+  count: types.optional(types.string()),
   interval: types.optional(types.string()),
 });
 /** @internal */
 export type IssuingVelocityLimitError$Outbound = {
   amount?: string | undefined;
+  count?: string | undefined;
   interval?: string | undefined;
 };
 
@@ -35,6 +38,7 @@ export const IssuingVelocityLimitError$outboundSchema: z.ZodType<
   IssuingVelocityLimitError
 > = z.object({
   amount: z.string().optional(),
+  count: z.string().optional(),
   interval: z.string().optional(),
 });
 

package/src/models/components/merchantcategories.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  MerchantCategory,
+  MerchantCategory$inboundSchema,
+  MerchantCategory$Outbound,
+  MerchantCategory$outboundSchema,
+} from "./merchantcategory.js";
+
+/**
+ * The predefined merchant category groups available for issued card spend controls.
+ */
+export type MerchantCategories = {
+  merchantCategories: Array<MerchantCategory>;
+};
+
+/** @internal */
+export const MerchantCategories$inboundSchema: z.ZodType<
+  MerchantCategories,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  merchantCategories: z.array(MerchantCategory$inboundSchema),
+});
+/** @internal */
+export type MerchantCategories$Outbound = {
+  merchantCategories: Array<MerchantCategory$Outbound>;
+};
+
+/** @internal */
+export const MerchantCategories$outboundSchema: z.ZodType<
+  MerchantCategories$Outbound,
+  z.ZodTypeDef,
+  MerchantCategories
+> = z.object({
+  merchantCategories: z.array(MerchantCategory$outboundSchema),
+});
+
+export function merchantCategoriesToJSON(
+  merchantCategories: MerchantCategories,
+): string {
+  return JSON.stringify(
+    MerchantCategories$outboundSchema.parse(merchantCategories),
+  );
+}
+export function merchantCategoriesFromJSON(
+  jsonString: string,
+): SafeParseResult<MerchantCategories, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MerchantCategories$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MerchantCategories' from JSON`,
+  );
+}

package/src/models/components/merchantcategory.ts

@@ -0,0 +1,73 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  IssuingMerchantCategory,
+  IssuingMerchantCategory$inboundSchema,
+  IssuingMerchantCategory$outboundSchema,
+} from "./issuingmerchantcategory.js";
+
+/**
+ * A predefined merchant category group and the merchant category codes (MCCs) it covers.
+ */
+export type MerchantCategory = {
+  /**
+   * The predefined category group.
+   */
+  category: IssuingMerchantCategory;
+  /**
+   * The merchant category codes (MCCs) covered by this category. Each entry is either a single
+   *
+   * @remarks
+   * 4-digit MCC, such as `4511`, or an inclusive range of MCCs, such as `3000-3299`.
+   */
+  mccs: Array<string>;
+};
+
+/** @internal */
+export const MerchantCategory$inboundSchema: z.ZodType<
+  MerchantCategory,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  category: IssuingMerchantCategory$inboundSchema,
+  mccs: z.array(types.string()),
+});
+/** @internal */
+export type MerchantCategory$Outbound = {
+  category: string;
+  mccs: Array<string>;
+};
+
+/** @internal */
+export const MerchantCategory$outboundSchema: z.ZodType<
+  MerchantCategory$Outbound,
+  z.ZodTypeDef,
+  MerchantCategory
+> = z.object({
+  category: IssuingMerchantCategory$outboundSchema,
+  mccs: z.array(z.string()),
+});
+
+export function merchantCategoryToJSON(
+  merchantCategory: MerchantCategory,
+): string {
+  return JSON.stringify(
+    MerchantCategory$outboundSchema.parse(merchantCategory),
+  );
+}
+export function merchantCategoryFromJSON(
+  jsonString: string,
+): SafeParseResult<MerchantCategory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MerchantCategory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MerchantCategory' from JSON`,
+  );
+}

package/src/models/components/merchantcategoryrestrictions.ts

@@ -0,0 +1,97 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  IssuingControlsRestrictionMode,
+  IssuingControlsRestrictionMode$inboundSchema,
+  IssuingControlsRestrictionMode$outboundSchema,
+} from "./issuingcontrolsrestrictionmode.js";
+import {
+  IssuingMerchantCategory,
+  IssuingMerchantCategory$inboundSchema,
+  IssuingMerchantCategory$outboundSchema,
+} from "./issuingmerchantcategory.js";
+import {
+  MerchantEntry,
+  MerchantEntry$inboundSchema,
+  MerchantEntry$Outbound,
+  MerchantEntry$outboundSchema,
+} from "./merchantentry.js";
+
+/**
+ * Restricts card usage by merchant category. When not set, all categories are allowed.
+ */
+export type MerchantCategoryRestrictions = {
+  /**
+   * Whether the listed items should be allowed (`allow`) or blocked (`block`).
+   */
+  mode: IssuingControlsRestrictionMode;
+  /**
+   * Predefined category groups to allow or block.
+   */
+  categories?: Array<IssuingMerchantCategory> | undefined;
+  /**
+   * Individual merchant category codes (MCCs) to allow or block, for codes not covered by a predefined category.
+   */
+  customMCCs?: Array<string> | undefined;
+  /**
+   * Merchants that are exempt from category restrictions regardless of their category.
+   */
+  exemptMerchants?: Array<MerchantEntry> | undefined;
+};
+
+/** @internal */
+export const MerchantCategoryRestrictions$inboundSchema: z.ZodType<
+  MerchantCategoryRestrictions,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: IssuingControlsRestrictionMode$inboundSchema,
+  categories: types.optional(z.array(IssuingMerchantCategory$inboundSchema)),
+  customMCCs: types.optional(z.array(types.string())),
+  exemptMerchants: types.optional(z.array(MerchantEntry$inboundSchema)),
+});
+/** @internal */
+export type MerchantCategoryRestrictions$Outbound = {
+  mode: string;
+  categories?: Array<string> | undefined;
+  customMCCs?: Array<string> | undefined;
+  exemptMerchants?: Array<MerchantEntry$Outbound> | undefined;
+};
+
+/** @internal */
+export const MerchantCategoryRestrictions$outboundSchema: z.ZodType<
+  MerchantCategoryRestrictions$Outbound,
+  z.ZodTypeDef,
+  MerchantCategoryRestrictions
+> = z.object({
+  mode: IssuingControlsRestrictionMode$outboundSchema,
+  categories: z.array(IssuingMerchantCategory$outboundSchema).optional(),
+  customMCCs: z.array(z.string()).optional(),
+  exemptMerchants: z.array(MerchantEntry$outboundSchema).optional(),
+});
+
+export function merchantCategoryRestrictionsToJSON(
+  merchantCategoryRestrictions: MerchantCategoryRestrictions,
+): string {
+  return JSON.stringify(
+    MerchantCategoryRestrictions$outboundSchema.parse(
+      merchantCategoryRestrictions,
+    ),
+  );
+}
+export function merchantCategoryRestrictionsFromJSON(
+  jsonString: string,
+): SafeParseResult<MerchantCategoryRestrictions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MerchantCategoryRestrictions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MerchantCategoryRestrictions' from JSON`,
+  );
+}

package/src/models/components/merchantcategoryrestrictionserror.ts

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  MerchantEntryError,
+  MerchantEntryError$inboundSchema,
+  MerchantEntryError$Outbound,
+  MerchantEntryError$outboundSchema,
+} from "./merchantentryerror.js";
+
+export type MerchantCategoryRestrictionsError = {
+  mode?: string | undefined;
+  categories?: { [k: string]: string } | undefined;
+  customMCCs?: { [k: string]: string } | undefined;
+  exemptMerchants?: { [k: string]: MerchantEntryError } | undefined;
+};
+
+/** @internal */
+export const MerchantCategoryRestrictionsError$inboundSchema: z.ZodType<
+  MerchantCategoryRestrictionsError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: types.optional(types.string()),
+  categories: types.optional(z.record(types.string())),
+  customMCCs: types.optional(z.record(types.string())),
+  exemptMerchants: types.optional(z.record(MerchantEntryError$inboundSchema)),
+});
+/** @internal */
+export type MerchantCategoryRestrictionsError$Outbound = {
+  mode?: string | undefined;
+  categories?: { [k: string]: string } | undefined;
+  customMCCs?: { [k: string]: string } | undefined;
+  exemptMerchants?: { [k: string]: MerchantEntryError$Outbound } | undefined;
+};
+
+/** @internal */
+export const MerchantCategoryRestrictionsError$outboundSchema: z.ZodType<
+  MerchantCategoryRestrictionsError$Outbound,
+  z.ZodTypeDef,
+  MerchantCategoryRestrictionsError
+> = z.object({
+  mode: z.string().optional(),
+  categories: z.record(z.string()).optional(),
+  customMCCs: z.record(z.string()).optional(),
+  exemptMerchants: z.record(MerchantEntryError$outboundSchema).optional(),
+});
+
+export function merchantCategoryRestrictionsErrorToJSON(
+  merchantCategoryRestrictionsError: MerchantCategoryRestrictionsError,
+): string {
+  return JSON.stringify(
+    MerchantCategoryRestrictionsError$outboundSchema.parse(
+      merchantCategoryRestrictionsError,
+    ),
+  );
+}
+export function merchantCategoryRestrictionsErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<MerchantCategoryRestrictionsError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MerchantCategoryRestrictionsError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MerchantCategoryRestrictionsError' from JSON`,
+  );
+}

package/src/models/components/merchantentry.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Identifies a merchant by ID, descriptor pattern, or both. At least one of `networkID` or `descriptorPattern` must be set.
+ */
+export type MerchantEntry = {
+  /**
+   * The merchant's unique identifier (ISO 8583 DE42), matched exactly.
+   */
+  networkID?: string | undefined;
+  /**
+   * A case-insensitive RE2 regular expression matched against the merchant descriptor (ISO 8583 DE43).
+   */
+  descriptorPattern?: string | undefined;
+  /**
+   * An optional label for this entry.
+   */
+  name?: string | undefined;
+};
+
+/** @internal */
+export const MerchantEntry$inboundSchema: z.ZodType<
+  MerchantEntry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  networkID: types.optional(types.string()),
+  descriptorPattern: types.optional(types.string()),
+  name: types.optional(types.string()),
+});
+/** @internal */
+export type MerchantEntry$Outbound = {
+  networkID?: string | undefined;
+  descriptorPattern?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const MerchantEntry$outboundSchema: z.ZodType<
+  MerchantEntry$Outbound,
+  z.ZodTypeDef,
+  MerchantEntry
+> = z.object({
+  networkID: z.string().optional(),
+  descriptorPattern: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function merchantEntryToJSON(merchantEntry: MerchantEntry): string {
+  return JSON.stringify(MerchantEntry$outboundSchema.parse(merchantEntry));
+}
+export function merchantEntryFromJSON(
+  jsonString: string,
+): SafeParseResult<MerchantEntry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MerchantEntry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MerchantEntry' from JSON`,
+  );
+}