@moovio/sdk 25.4.0 → 25.7.0

package/src/models/components/collectfundscardpayments.ts

@@ -0,0 +1,93 @@
+/*
+ * 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 {
+  CardAcceptanceMethods,
+  CardAcceptanceMethods$inboundSchema,
+  CardAcceptanceMethods$Outbound,
+  CardAcceptanceMethods$outboundSchema,
+} from "./cardacceptancemethods.js";
+import {
+  EstimatedActivity,
+  EstimatedActivity$inboundSchema,
+  EstimatedActivity$Outbound,
+  EstimatedActivity$outboundSchema,
+} from "./estimatedactivity.js";
+import {
+  Fulfillment,
+  Fulfillment$inboundSchema,
+  Fulfillment$Outbound,
+  Fulfillment$outboundSchema,
+} from "./fulfillment.js";
+import {
+  RefundPolicy,
+  RefundPolicy$inboundSchema,
+  RefundPolicy$outboundSchema,
+} from "./refundpolicy.js";
+
+export type CollectFundsCardPayments = {
+  /**
+   * Describes the distribution of card transactions by payment method.
+   */
+  cardAcceptanceMethods?: CardAcceptanceMethods | undefined;
+  currentlyAcceptsCards?: boolean | undefined;
+  estimatedActivity?: EstimatedActivity | undefined;
+  fulfillment?: Fulfillment | undefined;
+  refundPolicy?: RefundPolicy | undefined;
+};
+
+/** @internal */
+export const CollectFundsCardPayments$inboundSchema: z.ZodType<
+  CollectFundsCardPayments,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cardAcceptanceMethods: CardAcceptanceMethods$inboundSchema.optional(),
+  currentlyAcceptsCards: z.boolean().optional(),
+  estimatedActivity: EstimatedActivity$inboundSchema.optional(),
+  fulfillment: Fulfillment$inboundSchema.optional(),
+  refundPolicy: RefundPolicy$inboundSchema.optional(),
+});
+/** @internal */
+export type CollectFundsCardPayments$Outbound = {
+  cardAcceptanceMethods?: CardAcceptanceMethods$Outbound | undefined;
+  currentlyAcceptsCards?: boolean | undefined;
+  estimatedActivity?: EstimatedActivity$Outbound | undefined;
+  fulfillment?: Fulfillment$Outbound | undefined;
+  refundPolicy?: string | undefined;
+};
+
+/** @internal */
+export const CollectFundsCardPayments$outboundSchema: z.ZodType<
+  CollectFundsCardPayments$Outbound,
+  z.ZodTypeDef,
+  CollectFundsCardPayments
+> = z.object({
+  cardAcceptanceMethods: CardAcceptanceMethods$outboundSchema.optional(),
+  currentlyAcceptsCards: z.boolean().optional(),
+  estimatedActivity: EstimatedActivity$outboundSchema.optional(),
+  fulfillment: Fulfillment$outboundSchema.optional(),
+  refundPolicy: RefundPolicy$outboundSchema.optional(),
+});
+
+export function collectFundsCardPaymentsToJSON(
+  collectFundsCardPayments: CollectFundsCardPayments,
+): string {
+  return JSON.stringify(
+    CollectFundsCardPayments$outboundSchema.parse(collectFundsCardPayments),
+  );
+}
+export function collectFundsCardPaymentsFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectFundsCardPayments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectFundsCardPayments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectFundsCardPayments' from JSON`,
+  );
+}

package/src/models/components/collectfundscardpaymentserror.ts

@@ -0,0 +1,87 @@
+/*
+ * 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 {
+  CardAcceptanceMethodsError,
+  CardAcceptanceMethodsError$inboundSchema,
+  CardAcceptanceMethodsError$Outbound,
+  CardAcceptanceMethodsError$outboundSchema,
+} from "./cardacceptancemethodserror.js";
+import {
+  EstimatedActivityError,
+  EstimatedActivityError$inboundSchema,
+  EstimatedActivityError$Outbound,
+  EstimatedActivityError$outboundSchema,
+} from "./estimatedactivityerror.js";
+import {
+  FulfillmentError,
+  FulfillmentError$inboundSchema,
+  FulfillmentError$Outbound,
+  FulfillmentError$outboundSchema,
+} from "./fulfillmenterror.js";
+
+export type CollectFundsCardPaymentsError = {
+  cardAcceptanceMethods?: CardAcceptanceMethodsError | undefined;
+  currentlyAcceptsCards?: string | undefined;
+  estimatedActivity?: EstimatedActivityError | undefined;
+  fulfillment?: FulfillmentError | undefined;
+  refundPolicy?: string | undefined;
+};
+
+/** @internal */
+export const CollectFundsCardPaymentsError$inboundSchema: z.ZodType<
+  CollectFundsCardPaymentsError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cardAcceptanceMethods: CardAcceptanceMethodsError$inboundSchema.optional(),
+  currentlyAcceptsCards: z.string().optional(),
+  estimatedActivity: EstimatedActivityError$inboundSchema.optional(),
+  fulfillment: FulfillmentError$inboundSchema.optional(),
+  refundPolicy: z.string().optional(),
+});
+/** @internal */
+export type CollectFundsCardPaymentsError$Outbound = {
+  cardAcceptanceMethods?: CardAcceptanceMethodsError$Outbound | undefined;
+  currentlyAcceptsCards?: string | undefined;
+  estimatedActivity?: EstimatedActivityError$Outbound | undefined;
+  fulfillment?: FulfillmentError$Outbound | undefined;
+  refundPolicy?: string | undefined;
+};
+
+/** @internal */
+export const CollectFundsCardPaymentsError$outboundSchema: z.ZodType<
+  CollectFundsCardPaymentsError$Outbound,
+  z.ZodTypeDef,
+  CollectFundsCardPaymentsError
+> = z.object({
+  cardAcceptanceMethods: CardAcceptanceMethodsError$outboundSchema.optional(),
+  currentlyAcceptsCards: z.string().optional(),
+  estimatedActivity: EstimatedActivityError$outboundSchema.optional(),
+  fulfillment: FulfillmentError$outboundSchema.optional(),
+  refundPolicy: z.string().optional(),
+});
+
+export function collectFundsCardPaymentsErrorToJSON(
+  collectFundsCardPaymentsError: CollectFundsCardPaymentsError,
+): string {
+  return JSON.stringify(
+    CollectFundsCardPaymentsError$outboundSchema.parse(
+      collectFundsCardPaymentsError,
+    ),
+  );
+}
+export function collectFundsCardPaymentsErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectFundsCardPaymentsError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectFundsCardPaymentsError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectFundsCardPaymentsError' from JSON`,
+  );
+}

package/src/models/components/collectfundserror.ts

@@ -0,0 +1,67 @@
+/*
+ * 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 {
+  CollectFundsAchError,
+  CollectFundsAchError$inboundSchema,
+  CollectFundsAchError$Outbound,
+  CollectFundsAchError$outboundSchema,
+} from "./collectfundsacherror.js";
+import {
+  CollectFundsCardPaymentsError,
+  CollectFundsCardPaymentsError$inboundSchema,
+  CollectFundsCardPaymentsError$Outbound,
+  CollectFundsCardPaymentsError$outboundSchema,
+} from "./collectfundscardpaymentserror.js";
+
+export type CollectFundsError = {
+  ach?: CollectFundsAchError | undefined;
+  cardPayments?: CollectFundsCardPaymentsError | undefined;
+};
+
+/** @internal */
+export const CollectFundsError$inboundSchema: z.ZodType<
+  CollectFundsError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ach: CollectFundsAchError$inboundSchema.optional(),
+  cardPayments: CollectFundsCardPaymentsError$inboundSchema.optional(),
+});
+/** @internal */
+export type CollectFundsError$Outbound = {
+  ach?: CollectFundsAchError$Outbound | undefined;
+  cardPayments?: CollectFundsCardPaymentsError$Outbound | undefined;
+};
+
+/** @internal */
+export const CollectFundsError$outboundSchema: z.ZodType<
+  CollectFundsError$Outbound,
+  z.ZodTypeDef,
+  CollectFundsError
+> = z.object({
+  ach: CollectFundsAchError$outboundSchema.optional(),
+  cardPayments: CollectFundsCardPaymentsError$outboundSchema.optional(),
+});
+
+export function collectFundsErrorToJSON(
+  collectFundsError: CollectFundsError,
+): string {
+  return JSON.stringify(
+    CollectFundsError$outboundSchema.parse(collectFundsError),
+  );
+}
+export function collectFundsErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectFundsError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectFundsError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectFundsError' from JSON`,
+  );
+}

package/src/models/components/createaccount.ts

@@ -6,16 +6,16 @@ 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 {
-  AccountType,
-  AccountType$inboundSchema,
-  AccountType$outboundSchema,
-} from "./accounttype.js";
 import {
   CapabilityID,
   CapabilityID$inboundSchema,
   CapabilityID$outboundSchema,
 } from "./capabilityid.js";
+import {
+  CreateAccountType,
+  CreateAccountType$inboundSchema,
+  CreateAccountType$outboundSchema,
+} from "./createaccounttype.js";
 import {
   CreateProfile,
   CreateProfile$inboundSchema,
@@ -43,10 +43,7 @@ import {
 } from "./termsofservicepayload.js";
 
 export type CreateAccount = {
-  /**
-   * The type of entity represented by this account.
-   */
-  accountType: AccountType;
+  accountType: CreateAccountType;
   profile: CreateProfile;
   /**
    * Free-form key-value pair list. Useful for storing information that is not captured elsewhere.
@@ -81,7 +78,7 @@ export const CreateAccount$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  accountType: AccountType$inboundSchema,
+  accountType: CreateAccountType$inboundSchema,
   profile: CreateProfile$inboundSchema,
   metadata: z.record(z.string()).optional(),
   termsOfService: TermsOfServicePayload$inboundSchema.optional(),
@@ -110,7 +107,7 @@ export const CreateAccount$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateAccount
 > = z.object({
-  accountType: AccountType$outboundSchema,
+  accountType: CreateAccountType$outboundSchema,
   profile: CreateProfile$outboundSchema,
   metadata: z.record(z.string()).optional(),
   termsOfService: TermsOfServicePayload$outboundSchema.optional(),

package/src/models/components/createaccounttype.ts

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const CreateAccountType = {
+  Individual: "individual",
+  Business: "business",
+} as const;
+export type CreateAccountType = ClosedEnum<typeof CreateAccountType>;
+
+/** @internal */
+export const CreateAccountType$inboundSchema: z.ZodNativeEnum<
+  typeof CreateAccountType
+> = z.nativeEnum(CreateAccountType);
+/** @internal */
+export const CreateAccountType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateAccountType
+> = CreateAccountType$inboundSchema;

package/src/models/components/createticket.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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  TicketContact,
+  TicketContact$inboundSchema,
+  TicketContact$Outbound,
+  TicketContact$outboundSchema,
+} from "./ticketcontact.js";
+
+/**
+ * Request to create a new support ticket.
+ */
+export type CreateTicket = {
+  title: string;
+  body: string;
+  author?: string | undefined;
+  contact: TicketContact;
+  foreignID?: string | undefined;
+};
+
+/** @internal */
+export const CreateTicket$inboundSchema: z.ZodType<
+  CreateTicket,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  title: z.string(),
+  body: z.string(),
+  author: z.string().optional(),
+  contact: TicketContact$inboundSchema,
+  foreignID: z.string().optional(),
+});
+/** @internal */
+export type CreateTicket$Outbound = {
+  title: string;
+  body: string;
+  author?: string | undefined;
+  contact: TicketContact$Outbound;
+  foreignID?: string | undefined;
+};
+
+/** @internal */
+export const CreateTicket$outboundSchema: z.ZodType<
+  CreateTicket$Outbound,
+  z.ZodTypeDef,
+  CreateTicket
+> = z.object({
+  title: z.string(),
+  body: z.string(),
+  author: z.string().optional(),
+  contact: TicketContact$outboundSchema,
+  foreignID: z.string().optional(),
+});
+
+export function createTicketToJSON(createTicket: CreateTicket): string {
+  return JSON.stringify(CreateTicket$outboundSchema.parse(createTicket));
+}
+export function createTicketFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateTicket, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateTicket$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateTicket' from JSON`,
+  );
+}

package/src/models/components/createticketcontacterror.ts

@@ -0,0 +1,55 @@
+/*
+ * 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";
+
+export type CreateTicketContactError = {
+  email?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const CreateTicketContactError$inboundSchema: z.ZodType<
+  CreateTicketContactError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  email: z.string().optional(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type CreateTicketContactError$Outbound = {
+  email?: string | undefined;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const CreateTicketContactError$outboundSchema: z.ZodType<
+  CreateTicketContactError$Outbound,
+  z.ZodTypeDef,
+  CreateTicketContactError
+> = z.object({
+  email: z.string().optional(),
+  name: z.string().optional(),
+});
+
+export function createTicketContactErrorToJSON(
+  createTicketContactError: CreateTicketContactError,
+): string {
+  return JSON.stringify(
+    CreateTicketContactError$outboundSchema.parse(createTicketContactError),
+  );
+}
+export function createTicketContactErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateTicketContactError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateTicketContactError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateTicketContactError' from JSON`,
+  );
+}

package/src/models/components/enrichedindustries.ts

@@ -7,14 +7,14 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
-  EnrichedIndustry,
-  EnrichedIndustry$inboundSchema,
-  EnrichedIndustry$Outbound,
-  EnrichedIndustry$outboundSchema,
-} from "./enrichedindustry.js";
+  IndustryTaxonomy,
+  IndustryTaxonomy$inboundSchema,
+  IndustryTaxonomy$Outbound,
+  IndustryTaxonomy$outboundSchema,
+} from "./industrytaxonomy.js";
 
 export type EnrichedIndustries = {
-  industries: Array<EnrichedIndustry>;
+  industries: Array<IndustryTaxonomy>;
 };
 
 /** @internal */
@@ -23,11 +23,11 @@ export const EnrichedIndustries$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  industries: z.array(EnrichedIndustry$inboundSchema),
+  industries: z.array(IndustryTaxonomy$inboundSchema),
 });
 /** @internal */
 export type EnrichedIndustries$Outbound = {
-  industries: Array<EnrichedIndustry$Outbound>;
+  industries: Array<IndustryTaxonomy$Outbound>;
 };
 
 /** @internal */
@@ -36,7 +36,7 @@ export const EnrichedIndustries$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EnrichedIndustries
 > = z.object({
-  industries: z.array(EnrichedIndustry$outboundSchema),
+  industries: z.array(IndustryTaxonomy$outboundSchema),
 });
 
 export function enrichedIndustriesToJSON(

package/src/models/components/estimatedactivity.ts

@@ -0,0 +1,67 @@
+/*
+ * 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 {
+  MonthlyVolumeRange,
+  MonthlyVolumeRange$inboundSchema,
+  MonthlyVolumeRange$outboundSchema,
+} from "./monthlyvolumerange.js";
+
+export type EstimatedActivity = {
+  averageTransactionAmount?: number | undefined;
+  maximumTransactionAmount?: number | undefined;
+  /**
+   * The low value in each range is included. The high value in each range is excluded.
+   */
+  monthlyVolumeRange?: MonthlyVolumeRange | undefined;
+};
+
+/** @internal */
+export const EstimatedActivity$inboundSchema: z.ZodType<
+  EstimatedActivity,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  averageTransactionAmount: z.number().int().optional(),
+  maximumTransactionAmount: z.number().int().optional(),
+  monthlyVolumeRange: MonthlyVolumeRange$inboundSchema.optional(),
+});
+/** @internal */
+export type EstimatedActivity$Outbound = {
+  averageTransactionAmount?: number | undefined;
+  maximumTransactionAmount?: number | undefined;
+  monthlyVolumeRange?: string | undefined;
+};
+
+/** @internal */
+export const EstimatedActivity$outboundSchema: z.ZodType<
+  EstimatedActivity$Outbound,
+  z.ZodTypeDef,
+  EstimatedActivity
+> = z.object({
+  averageTransactionAmount: z.number().int().optional(),
+  maximumTransactionAmount: z.number().int().optional(),
+  monthlyVolumeRange: MonthlyVolumeRange$outboundSchema.optional(),
+});
+
+export function estimatedActivityToJSON(
+  estimatedActivity: EstimatedActivity,
+): string {
+  return JSON.stringify(
+    EstimatedActivity$outboundSchema.parse(estimatedActivity),
+  );
+}
+export function estimatedActivityFromJSON(
+  jsonString: string,
+): SafeParseResult<EstimatedActivity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EstimatedActivity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EstimatedActivity' from JSON`,
+  );
+}

package/src/models/components/estimatedactivityerror.ts

@@ -0,0 +1,59 @@
+/*
+ * 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";
+
+export type EstimatedActivityError = {
+  averageTransactionAmount?: string | undefined;
+  maximumTransactionAmount?: string | undefined;
+  monthlyVolumeRange?: string | undefined;
+};
+
+/** @internal */
+export const EstimatedActivityError$inboundSchema: z.ZodType<
+  EstimatedActivityError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  averageTransactionAmount: z.string().optional(),
+  maximumTransactionAmount: z.string().optional(),
+  monthlyVolumeRange: z.string().optional(),
+});
+/** @internal */
+export type EstimatedActivityError$Outbound = {
+  averageTransactionAmount?: string | undefined;
+  maximumTransactionAmount?: string | undefined;
+  monthlyVolumeRange?: string | undefined;
+};
+
+/** @internal */
+export const EstimatedActivityError$outboundSchema: z.ZodType<
+  EstimatedActivityError$Outbound,
+  z.ZodTypeDef,
+  EstimatedActivityError
+> = z.object({
+  averageTransactionAmount: z.string().optional(),
+  maximumTransactionAmount: z.string().optional(),
+  monthlyVolumeRange: z.string().optional(),
+});
+
+export function estimatedActivityErrorToJSON(
+  estimatedActivityError: EstimatedActivityError,
+): string {
+  return JSON.stringify(
+    EstimatedActivityError$outboundSchema.parse(estimatedActivityError),
+  );
+}
+export function estimatedActivityErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<EstimatedActivityError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EstimatedActivityError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EstimatedActivityError' from JSON`,
+  );
+}

package/src/models/components/fulfillment.ts

@@ -0,0 +1,61 @@
+/*
+ * 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 {
+  FulfillmentMethod,
+  FulfillmentMethod$inboundSchema,
+  FulfillmentMethod$outboundSchema,
+} from "./fulfillmentmethod.js";
+import {
+  FulfillmentTimeframe,
+  FulfillmentTimeframe$inboundSchema,
+  FulfillmentTimeframe$outboundSchema,
+} from "./fulfillmenttimeframe.js";
+
+export type Fulfillment = {
+  method?: FulfillmentMethod | undefined;
+  timeframe?: FulfillmentTimeframe | undefined;
+};
+
+/** @internal */
+export const Fulfillment$inboundSchema: z.ZodType<
+  Fulfillment,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  method: FulfillmentMethod$inboundSchema.optional(),
+  timeframe: FulfillmentTimeframe$inboundSchema.optional(),
+});
+/** @internal */
+export type Fulfillment$Outbound = {
+  method?: string | undefined;
+  timeframe?: string | undefined;
+};
+
+/** @internal */
+export const Fulfillment$outboundSchema: z.ZodType<
+  Fulfillment$Outbound,
+  z.ZodTypeDef,
+  Fulfillment
+> = z.object({
+  method: FulfillmentMethod$outboundSchema.optional(),
+  timeframe: FulfillmentTimeframe$outboundSchema.optional(),
+});
+
+export function fulfillmentToJSON(fulfillment: Fulfillment): string {
+  return JSON.stringify(Fulfillment$outboundSchema.parse(fulfillment));
+}
+export function fulfillmentFromJSON(
+  jsonString: string,
+): SafeParseResult<Fulfillment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Fulfillment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Fulfillment' from JSON`,
+  );
+}