@moovio/sdk 0.0.0-dev.26 → 0.0.0-dev.28

package/src/models/components/issuingcontrols.ts

@@ -13,6 +13,38 @@ import {
   IssuingVelocityLimit$Outbound,
   IssuingVelocityLimit$outboundSchema,
 } from "./issuingvelocitylimit.js";
+import {
+  MerchantCategoryRestrictions,
+  MerchantCategoryRestrictions$inboundSchema,
+  MerchantCategoryRestrictions$Outbound,
+  MerchantCategoryRestrictions$outboundSchema,
+} from "./merchantcategoryrestrictions.js";
+import {
+  MerchantRestrictions,
+  MerchantRestrictions$inboundSchema,
+  MerchantRestrictions$Outbound,
+  MerchantRestrictions$outboundSchema,
+} from "./merchantrestrictions.js";
+import {
+  ScheduleWindow,
+  ScheduleWindow$inboundSchema,
+  ScheduleWindow$Outbound,
+  ScheduleWindow$outboundSchema,
+} from "./schedulewindow.js";
+
+/**
+ * Limits card usage to specific days and times. Set to `null` to remove all schedule restrictions.
+ */
+export type AllowedSchedule = {
+  /**
+   * IANA timezone string used to evaluate window boundaries against the authorization time.
+   */
+  timezone: string;
+  /**
+   * Time windows during which the card may authorize. Any matching window allows the transaction.
+   */
+  windows: Array<ScheduleWindow>;
+};
 
 export type IssuingControls = {
   /**
@@ -23,8 +55,64 @@ export type IssuingControls = {
    * Sets the spending limit per time interval. Only one limit per interval is supported.
    */
   velocityLimits?: Array<IssuingVelocityLimit> | undefined;
+  /**
+   * Restricts card usage by merchant category. When not set, all categories are allowed.
+   */
+  merchantCategoryRestrictions?: MerchantCategoryRestrictions | undefined;
+  /**
+   * Restricts card usage to specific merchants, or blocks specific merchants.
+   */
+  merchantRestrictions?: MerchantRestrictions | undefined;
+  /**
+   * Limits card usage to specific days and times. Set to `null` to remove all schedule restrictions.
+   */
+  allowedSchedule?: AllowedSchedule | null | undefined;
+  /**
+   * A spend cutoff date and time. When set, all authorizations after this datetime are declined regardless of other controls. Set to `null` for no cutoff.
+   */
+  expiresOn?: Date | null | undefined;
 };
 
+/** @internal */
+export const AllowedSchedule$inboundSchema: z.ZodType<
+  AllowedSchedule,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  timezone: types.string(),
+  windows: z.array(ScheduleWindow$inboundSchema),
+});
+/** @internal */
+export type AllowedSchedule$Outbound = {
+  timezone: string;
+  windows: Array<ScheduleWindow$Outbound>;
+};
+
+/** @internal */
+export const AllowedSchedule$outboundSchema: z.ZodType<
+  AllowedSchedule$Outbound,
+  z.ZodTypeDef,
+  AllowedSchedule
+> = z.object({
+  timezone: z.string(),
+  windows: z.array(ScheduleWindow$outboundSchema),
+});
+
+export function allowedScheduleToJSON(
+  allowedSchedule: AllowedSchedule,
+): string {
+  return JSON.stringify(AllowedSchedule$outboundSchema.parse(allowedSchedule));
+}
+export function allowedScheduleFromJSON(
+  jsonString: string,
+): SafeParseResult<AllowedSchedule, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AllowedSchedule$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AllowedSchedule' from JSON`,
+  );
+}
+
 /** @internal */
 export const IssuingControls$inboundSchema: z.ZodType<
   IssuingControls,
@@ -33,11 +121,24 @@ export const IssuingControls$inboundSchema: z.ZodType<
 > = z.object({
   singleUse: types.optional(types.boolean()),
   velocityLimits: types.optional(z.array(IssuingVelocityLimit$inboundSchema)),
+  merchantCategoryRestrictions: types.optional(
+    MerchantCategoryRestrictions$inboundSchema,
+  ),
+  merchantRestrictions: types.optional(MerchantRestrictions$inboundSchema),
+  allowedSchedule: z.nullable(z.lazy(() => AllowedSchedule$inboundSchema))
+    .optional(),
+  expiresOn: z.nullable(types.date()).optional(),
 });
 /** @internal */
 export type IssuingControls$Outbound = {
   singleUse?: boolean | undefined;
   velocityLimits?: Array<IssuingVelocityLimit$Outbound> | undefined;
+  merchantCategoryRestrictions?:
+    | MerchantCategoryRestrictions$Outbound
+    | undefined;
+  merchantRestrictions?: MerchantRestrictions$Outbound | undefined;
+  allowedSchedule?: AllowedSchedule$Outbound | null | undefined;
+  expiresOn?: string | null | undefined;
 };
 
 /** @internal */
@@ -48,6 +149,12 @@ export const IssuingControls$outboundSchema: z.ZodType<
 > = z.object({
   singleUse: z.boolean().optional(),
   velocityLimits: z.array(IssuingVelocityLimit$outboundSchema).optional(),
+  merchantCategoryRestrictions: MerchantCategoryRestrictions$outboundSchema
+    .optional(),
+  merchantRestrictions: MerchantRestrictions$outboundSchema.optional(),
+  allowedSchedule: z.nullable(z.lazy(() => AllowedSchedule$outboundSchema))
+    .optional(),
+  expiresOn: z.nullable(z.date().transform(v => v.toISOString())).optional(),
 });
 
 export function issuingControlsToJSON(

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 are the only ones allowed (`allow`) or the ones to block (`block`).
+ */
+export const IssuingControlsRestrictionMode = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+/**
+ * Whether the listed items are the only ones allowed (`allow`) or the ones to block (`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 the velocity limit. Currently supports only per-transaction limits.
+ * 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 the velocity limit. Currently supports only per-transaction limits.
+ * 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,9 +17,13 @@ export type IssuingVelocityLimit = {
   /**
    * The maximum amount in cents that can be spent in a given interval.
    */
-  amount: number;
+  amount?: number | undefined;
   /**
-   * Specifies the time frame for the velocity limit. Currently supports only per-transaction limits.
+   * 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.
    */
   interval: IssuingIntervalLimit;
 };
@@ -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/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.
+ */
+export type MerchantCategoryRestrictions = {
+  /**
+   * Whether the listed categories are the only ones allowed, or the ones to 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 `mid` or `descriptorPattern` must be set.
+ */
+export type MerchantEntry = {
+  /**
+   * The merchant's unique identifier (ISO 8583 DE42), matched exactly.
+   */
+  mid?: 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({
+  mid: types.optional(types.string()),
+  descriptorPattern: types.optional(types.string()),
+  name: types.optional(types.string()),
+});
+/** @internal */
+export type MerchantEntry$Outbound = {
+  mid?: string | undefined;
+  descriptorPattern?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const MerchantEntry$outboundSchema: z.ZodType<
+  MerchantEntry$Outbound,
+  z.ZodTypeDef,
+  MerchantEntry
+> = z.object({
+  mid: 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`,
+  );
+}