@moovio/sdk 26.10.0-dev.1 → 26.10.0-dev.2

package/src/models/components/issuedcontrols.ts

@@ -0,0 +1,180 @@
+/*
+ * 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 {
+  IssuedVelocityLimit,
+  IssuedVelocityLimit$inboundSchema,
+  IssuedVelocityLimit$Outbound,
+  IssuedVelocityLimit$outboundSchema,
+} from "./issuedvelocitylimit.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.
+ */
+export type IssuedControlsAllowedSchedule = {
+  /**
+   * 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>;
+};
+
+/**
+ * Spend controls applied to an issued card, including velocity runtime state.
+ */
+export type IssuedControls = {
+  /**
+   * Indicates if the card is single-use. If true, the card closes after the first authorization.
+   */
+  singleUse?: boolean | undefined;
+  /**
+   * The spending limits per time interval, including current runtime state.
+   */
+  velocityLimits?: Array<IssuedVelocityLimit> | 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.
+   */
+  allowedSchedule?: IssuedControlsAllowedSchedule | null | undefined;
+  /**
+   * A spend cutoff date and time. When set, all authorizations after this datetime are declined regardless of other controls.
+   */
+  expiresOn?: Date | null | undefined;
+};
+
+/** @internal */
+export const IssuedControlsAllowedSchedule$inboundSchema: z.ZodType<
+  IssuedControlsAllowedSchedule,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  timezone: types.string(),
+  windows: z.array(ScheduleWindow$inboundSchema),
+});
+/** @internal */
+export type IssuedControlsAllowedSchedule$Outbound = {
+  timezone: string;
+  windows: Array<ScheduleWindow$Outbound>;
+};
+
+/** @internal */
+export const IssuedControlsAllowedSchedule$outboundSchema: z.ZodType<
+  IssuedControlsAllowedSchedule$Outbound,
+  z.ZodTypeDef,
+  IssuedControlsAllowedSchedule
+> = z.object({
+  timezone: z.string(),
+  windows: z.array(ScheduleWindow$outboundSchema),
+});
+
+export function issuedControlsAllowedScheduleToJSON(
+  issuedControlsAllowedSchedule: IssuedControlsAllowedSchedule,
+): string {
+  return JSON.stringify(
+    IssuedControlsAllowedSchedule$outboundSchema.parse(
+      issuedControlsAllowedSchedule,
+    ),
+  );
+}
+export function issuedControlsAllowedScheduleFromJSON(
+  jsonString: string,
+): SafeParseResult<IssuedControlsAllowedSchedule, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => IssuedControlsAllowedSchedule$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'IssuedControlsAllowedSchedule' from JSON`,
+  );
+}
+
+/** @internal */
+export const IssuedControls$inboundSchema: z.ZodType<
+  IssuedControls,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  singleUse: types.optional(types.boolean()),
+  velocityLimits: types.optional(z.array(IssuedVelocityLimit$inboundSchema)),
+  merchantCategoryRestrictions: types.optional(
+    MerchantCategoryRestrictions$inboundSchema,
+  ),
+  merchantRestrictions: types.optional(MerchantRestrictions$inboundSchema),
+  allowedSchedule: z.nullable(
+    z.lazy(() => IssuedControlsAllowedSchedule$inboundSchema),
+  ).optional(),
+  expiresOn: z.nullable(types.date()).optional(),
+});
+/** @internal */
+export type IssuedControls$Outbound = {
+  singleUse?: boolean | undefined;
+  velocityLimits?: Array<IssuedVelocityLimit$Outbound> | undefined;
+  merchantCategoryRestrictions?:
+    | MerchantCategoryRestrictions$Outbound
+    | undefined;
+  merchantRestrictions?: MerchantRestrictions$Outbound | undefined;
+  allowedSchedule?: IssuedControlsAllowedSchedule$Outbound | null | undefined;
+  expiresOn?: string | null | undefined;
+};
+
+/** @internal */
+export const IssuedControls$outboundSchema: z.ZodType<
+  IssuedControls$Outbound,
+  z.ZodTypeDef,
+  IssuedControls
+> = z.object({
+  singleUse: z.boolean().optional(),
+  velocityLimits: z.array(IssuedVelocityLimit$outboundSchema).optional(),
+  merchantCategoryRestrictions: MerchantCategoryRestrictions$outboundSchema
+    .optional(),
+  merchantRestrictions: MerchantRestrictions$outboundSchema.optional(),
+  allowedSchedule: z.nullable(
+    z.lazy(() => IssuedControlsAllowedSchedule$outboundSchema),
+  ).optional(),
+  expiresOn: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+});
+
+export function issuedControlsToJSON(issuedControls: IssuedControls): string {
+  return JSON.stringify(IssuedControls$outboundSchema.parse(issuedControls));
+}
+export function issuedControlsFromJSON(
+  jsonString: string,
+): SafeParseResult<IssuedControls, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => IssuedControls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'IssuedControls' from JSON`,
+  );
+}

package/src/models/components/issuedvelocitylimit.ts

@@ -0,0 +1,112 @@
+/*
+ * 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 {
+  IssuingIntervalLimit,
+  IssuingIntervalLimit$inboundSchema,
+  IssuingIntervalLimit$outboundSchema,
+} from "./issuingintervallimit.js";
+
+/**
+ * A velocity limit with its current runtime state.
+ */
+export type IssuedVelocityLimit = {
+  /**
+   * The maximum amount in cents that can be spent in a given interval.
+   */
+  amount?: number | undefined;
+  /**
+   * The maximum number of transactions allowed in the given interval.
+   */
+  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;
+  /**
+   * The amount in cents already spent in the current interval.
+   */
+  amountUsed?: number | undefined;
+  /**
+   * The amount in cents remaining in the current interval.
+   */
+  amountRemaining?: number | undefined;
+  /**
+   * The number of transactions already made in the current interval.
+   */
+  countUsed?: number | undefined;
+  /**
+   * The number of transactions remaining in the current interval.
+   */
+  countRemaining?: number | undefined;
+  /**
+   * When the current interval resets. Absent for per-transaction limits.
+   */
+  resetsOn?: Date | undefined;
+};
+
+/** @internal */
+export const IssuedVelocityLimit$inboundSchema: z.ZodType<
+  IssuedVelocityLimit,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  amount: types.optional(types.number()),
+  count: types.optional(types.number()),
+  interval: IssuingIntervalLimit$inboundSchema,
+  amountUsed: types.optional(types.number()),
+  amountRemaining: types.optional(types.number()),
+  countUsed: types.optional(types.number()),
+  countRemaining: types.optional(types.number()),
+  resetsOn: types.optional(types.date()),
+});
+/** @internal */
+export type IssuedVelocityLimit$Outbound = {
+  amount?: number | undefined;
+  count?: number | undefined;
+  interval: string;
+  amountUsed?: number | undefined;
+  amountRemaining?: number | undefined;
+  countUsed?: number | undefined;
+  countRemaining?: number | undefined;
+  resetsOn?: string | undefined;
+};
+
+/** @internal */
+export const IssuedVelocityLimit$outboundSchema: z.ZodType<
+  IssuedVelocityLimit$Outbound,
+  z.ZodTypeDef,
+  IssuedVelocityLimit
+> = z.object({
+  amount: z.number().int().optional(),
+  count: z.number().int().optional(),
+  interval: IssuingIntervalLimit$outboundSchema,
+  amountUsed: z.number().int().optional(),
+  amountRemaining: z.number().int().optional(),
+  countUsed: z.number().int().optional(),
+  countRemaining: z.number().int().optional(),
+  resetsOn: z.date().transform(v => v.toISOString()).optional(),
+});
+
+export function issuedVelocityLimitToJSON(
+  issuedVelocityLimit: IssuedVelocityLimit,
+): string {
+  return JSON.stringify(
+    IssuedVelocityLimit$outboundSchema.parse(issuedVelocityLimit),
+  );
+}
+export function issuedVelocityLimitFromJSON(
+  jsonString: string,
+): SafeParseResult<IssuedVelocityLimit, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => IssuedVelocityLimit$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'IssuedVelocityLimit' from JSON`,
+  );
+}

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 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;