mollie-api-typescript 1.3.8 → 1.4.0

package/src/models/sessionlineitem.ts

@@ -4,18 +4,9 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../lib/schemas.js";
-import { Result as SafeParseResult } from "../types/fp.js";
-import {
-  Amount,
-  Amount$inboundSchema,
-  Amount$Outbound,
-  Amount$outboundSchema,
-} from "./amount.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Amount, Amount$Outbound, Amount$outboundSchema } from "./amount.js";
 import {
   PaymentLineTypeResponse,
-  PaymentLineTypeResponse$inboundSchema,
   PaymentLineTypeResponse$outboundSchema,
 } from "./paymentlinetyperesponse.js";
 
@@ -77,25 +68,6 @@ export type SessionLineItem = {
   productUrl?: string | undefined;
 };
 
-/** @internal */
-export const SessionLineItem$inboundSchema: z.ZodType<
-  SessionLineItem,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: PaymentLineTypeResponse$inboundSchema.optional(),
-  description: z.string(),
-  quantity: z.number().int(),
-  quantityUnit: z.string().optional(),
-  unitPrice: Amount$inboundSchema,
-  discountAmount: Amount$inboundSchema.optional(),
-  totalAmount: Amount$inboundSchema,
-  vatRate: z.string().optional(),
-  vatAmount: Amount$inboundSchema.optional(),
-  sku: z.string().optional(),
-  imageUrl: z.string().optional(),
-  productUrl: z.string().optional(),
-});
 /** @internal */
 export type SessionLineItem$Outbound = {
   type?: string | undefined;
@@ -137,12 +109,3 @@ export function sessionLineItemToJSON(
 ): string {
   return JSON.stringify(SessionLineItem$outboundSchema.parse(sessionLineItem));
 }
-export function sessionLineItemFromJSON(
-  jsonString: string,
-): SafeParseResult<SessionLineItem, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SessionLineItem$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SessionLineItem' from JSON`,
-  );
-}

package/src/models/sessionlineitemresponse.ts

@@ -6,17 +6,11 @@
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import {
-  Amount,
-  Amount$inboundSchema,
-  Amount$Outbound,
-  Amount$outboundSchema,
-} from "./amount.js";
+import { Amount, Amount$inboundSchema } from "./amount.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
   PaymentLineTypeResponse,
   PaymentLineTypeResponse$inboundSchema,
-  PaymentLineTypeResponse$outboundSchema,
 } from "./paymentlinetyperesponse.js";
 
 export type SessionLineItemResponse = {
@@ -96,49 +90,7 @@ export const SessionLineItemResponse$inboundSchema: z.ZodType<
   imageUrl: z.string().optional(),
   productUrl: z.string().optional(),
 });
-/** @internal */
-export type SessionLineItemResponse$Outbound = {
-  type?: string | undefined;
-  description: string;
-  quantity: number;
-  quantityUnit?: string | undefined;
-  unitPrice: Amount$Outbound;
-  discountAmount?: Amount$Outbound | undefined;
-  totalAmount: Amount$Outbound;
-  vatRate?: string | undefined;
-  vatAmount?: Amount$Outbound | undefined;
-  sku?: string | undefined;
-  imageUrl?: string | undefined;
-  productUrl?: string | undefined;
-};
-
-/** @internal */
-export const SessionLineItemResponse$outboundSchema: z.ZodType<
-  SessionLineItemResponse$Outbound,
-  z.ZodTypeDef,
-  SessionLineItemResponse
-> = z.object({
-  type: PaymentLineTypeResponse$outboundSchema.optional(),
-  description: z.string(),
-  quantity: z.number().int(),
-  quantityUnit: z.string().optional(),
-  unitPrice: Amount$outboundSchema,
-  discountAmount: Amount$outboundSchema.optional(),
-  totalAmount: Amount$outboundSchema,
-  vatRate: z.string().optional(),
-  vatAmount: Amount$outboundSchema.optional(),
-  sku: z.string().optional(),
-  imageUrl: z.string().optional(),
-  productUrl: z.string().optional(),
-});
 
-export function sessionLineItemResponseToJSON(
-  sessionLineItemResponse: SessionLineItemResponse,
-): string {
-  return JSON.stringify(
-    SessionLineItemResponse$outboundSchema.parse(sessionLineItemResponse),
-  );
-}
 export function sessionLineItemResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<SessionLineItemResponse, SDKValidationError> {

package/src/models/sessionrequest.ts

@@ -4,30 +4,19 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../lib/schemas.js";
-import { Result as SafeParseResult } from "../types/fp.js";
-import {
-  Amount,
-  Amount$inboundSchema,
-  Amount$Outbound,
-  Amount$outboundSchema,
-} from "./amount.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Amount, Amount$Outbound, Amount$outboundSchema } from "./amount.js";
 import {
   PaymentAddress,
-  PaymentAddress$inboundSchema,
   PaymentAddress$Outbound,
   PaymentAddress$outboundSchema,
 } from "./paymentaddress.js";
 import {
   SessionLineItem,
-  SessionLineItem$inboundSchema,
   SessionLineItem$Outbound,
   SessionLineItem$outboundSchema,
 } from "./sessionlineitem.js";
 import {
   SessionSequenceType,
-  SessionSequenceType$inboundSchema,
   SessionSequenceType$outboundSchema,
 } from "./sessionsequencetype.js";
 
@@ -109,14 +98,6 @@ export type SessionRequest = {
   testmode?: boolean | null | undefined;
 };
 
-/** @internal */
-export const SessionRequestPayment$inboundSchema: z.ZodType<
-  SessionRequestPayment,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  webhookUrl: z.string().optional(),
-});
 /** @internal */
 export type SessionRequestPayment$Outbound = {
   webhookUrl?: string | undefined;
@@ -138,35 +119,7 @@ export function sessionRequestPaymentToJSON(
     SessionRequestPayment$outboundSchema.parse(sessionRequestPayment),
   );
 }
-export function sessionRequestPaymentFromJSON(
-  jsonString: string,
-): SafeParseResult<SessionRequestPayment, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SessionRequestPayment$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SessionRequestPayment' from JSON`,
-  );
-}
 
-/** @internal */
-export const SessionRequest$inboundSchema: z.ZodType<
-  SessionRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  amount: Amount$inboundSchema,
-  description: z.string(),
-  lines: z.array(SessionLineItem$inboundSchema),
-  redirectUrl: z.string(),
-  billingAddress: PaymentAddress$inboundSchema.optional(),
-  shippingAddress: PaymentAddress$inboundSchema.optional(),
-  customerId: z.string().optional(),
-  sequenceType: SessionSequenceType$inboundSchema.optional(),
-  metadata: z.record(z.any()).optional(),
-  payment: z.lazy(() => SessionRequestPayment$inboundSchema).optional(),
-  profileId: z.string().optional(),
-  testmode: z.nullable(z.boolean()).optional(),
-});
 /** @internal */
 export type SessionRequest$Outbound = {
   amount: Amount$Outbound;
@@ -206,12 +159,3 @@ export const SessionRequest$outboundSchema: z.ZodType<
 export function sessionRequestToJSON(sessionRequest: SessionRequest): string {
   return JSON.stringify(SessionRequest$outboundSchema.parse(sessionRequest));
 }
-export function sessionRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<SessionRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SessionRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SessionRequest' from JSON`,
-  );
-}

package/src/models/sessionresponse.ts

@@ -9,37 +9,22 @@ import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
 import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import {
-  Amount,
-  Amount$inboundSchema,
-  Amount$Outbound,
-  Amount$outboundSchema,
-} from "./amount.js";
+import { Amount, Amount$inboundSchema } from "./amount.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Mode, Mode$inboundSchema, Mode$outboundSchema } from "./mode.js";
+import { Mode, Mode$inboundSchema } from "./mode.js";
 import {
   PaymentAddress,
   PaymentAddress$inboundSchema,
-  PaymentAddress$Outbound,
-  PaymentAddress$outboundSchema,
 } from "./paymentaddress.js";
 import {
   SessionLineItemResponse,
   SessionLineItemResponse$inboundSchema,
-  SessionLineItemResponse$Outbound,
-  SessionLineItemResponse$outboundSchema,
 } from "./sessionlineitemresponse.js";
 import {
   SessionSequenceTypeResponse,
   SessionSequenceTypeResponse$inboundSchema,
-  SessionSequenceTypeResponse$outboundSchema,
 } from "./sessionsequencetyperesponse.js";
-import {
-  Url,
-  Url$inboundSchema,
-  Url$Outbound,
-  Url$outboundSchema,
-} from "./url.js";
+import { Url, Url$inboundSchema } from "./url.js";
 
 /**
  * The session's status.
@@ -166,12 +151,6 @@ export const SessionResponseStatus$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(SessionResponseStatus);
-/** @internal */
-export const SessionResponseStatus$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  SessionResponseStatus
-> = openEnums.outboundSchema(SessionResponseStatus);
 
 /** @internal */
 export const SessionResponsePayment$inboundSchema: z.ZodType<
@@ -181,27 +160,7 @@ export const SessionResponsePayment$inboundSchema: z.ZodType<
 > = z.object({
   webhookUrl: z.string().optional(),
 });
-/** @internal */
-export type SessionResponsePayment$Outbound = {
-  webhookUrl?: string | undefined;
-};
-
-/** @internal */
-export const SessionResponsePayment$outboundSchema: z.ZodType<
-  SessionResponsePayment$Outbound,
-  z.ZodTypeDef,
-  SessionResponsePayment
-> = z.object({
-  webhookUrl: z.string().optional(),
-});
 
-export function sessionResponsePaymentToJSON(
-  sessionResponsePayment: SessionResponsePayment,
-): string {
-  return JSON.stringify(
-    SessionResponsePayment$outboundSchema.parse(sessionResponsePayment),
-  );
-}
 export function sessionResponsePaymentFromJSON(
   jsonString: string,
 ): SafeParseResult<SessionResponsePayment, SDKValidationError> {
@@ -220,27 +179,7 @@ export const SessionResponseLinks$inboundSchema: z.ZodType<
 > = z.object({
   self: Url$inboundSchema,
 });
-/** @internal */
-export type SessionResponseLinks$Outbound = {
-  self: Url$Outbound;
-};
 
-/** @internal */
-export const SessionResponseLinks$outboundSchema: z.ZodType<
-  SessionResponseLinks$Outbound,
-  z.ZodTypeDef,
-  SessionResponseLinks
-> = z.object({
-  self: Url$outboundSchema,
-});
-
-export function sessionResponseLinksToJSON(
-  sessionResponseLinks: SessionResponseLinks,
-): string {
-  return JSON.stringify(
-    SessionResponseLinks$outboundSchema.parse(sessionResponseLinks),
-  );
-}
 export function sessionResponseLinksFromJSON(
   jsonString: string,
 ): SafeParseResult<SessionResponseLinks, SDKValidationError> {
@@ -280,63 +219,7 @@ export const SessionResponse$inboundSchema: z.ZodType<
     "_links": "links",
   });
 });
-/** @internal */
-export type SessionResponse$Outbound = {
-  resource: string;
-  id: string;
-  mode: string;
-  clientAccessToken: string;
-  status: string;
-  amount: Amount$Outbound;
-  description: string;
-  lines: Array<SessionLineItemResponse$Outbound>;
-  redirectUrl: string;
-  billingAddress?: PaymentAddress$Outbound | undefined;
-  shippingAddress?: PaymentAddress$Outbound | undefined;
-  customerId?: string | undefined;
-  sequenceType?: string | undefined;
-  metadata?: { [k: string]: any } | undefined;
-  payment?: SessionResponsePayment$Outbound | undefined;
-  profileId: string;
-  createdAt: string;
-  _links: SessionResponseLinks$Outbound;
-};
-
-/** @internal */
-export const SessionResponse$outboundSchema: z.ZodType<
-  SessionResponse$Outbound,
-  z.ZodTypeDef,
-  SessionResponse
-> = z.object({
-  resource: z.string(),
-  id: z.string(),
-  mode: Mode$outboundSchema,
-  clientAccessToken: z.string(),
-  status: SessionResponseStatus$outboundSchema,
-  amount: Amount$outboundSchema,
-  description: z.string(),
-  lines: z.array(SessionLineItemResponse$outboundSchema),
-  redirectUrl: z.string(),
-  billingAddress: PaymentAddress$outboundSchema.optional(),
-  shippingAddress: PaymentAddress$outboundSchema.optional(),
-  customerId: z.string().optional(),
-  sequenceType: SessionSequenceTypeResponse$outboundSchema.optional(),
-  metadata: z.record(z.any()).optional(),
-  payment: z.lazy(() => SessionResponsePayment$outboundSchema).optional(),
-  profileId: z.string(),
-  createdAt: z.string(),
-  links: z.lazy(() => SessionResponseLinks$outboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    links: "_links",
-  });
-});
 
-export function sessionResponseToJSON(
-  sessionResponse: SessionResponse,
-): string {
-  return JSON.stringify(SessionResponse$outboundSchema.parse(sessionResponse));
-}
 export function sessionResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<SessionResponse, SDKValidationError> {

package/src/models/sessionsequencetype.ts

@@ -12,11 +12,7 @@ export const SessionSequenceType = {
 } as const;
 export type SessionSequenceType = ClosedEnum<typeof SessionSequenceType>;
 
-/** @internal */
-export const SessionSequenceType$inboundSchema: z.ZodNativeEnum<
-  typeof SessionSequenceType
-> = z.nativeEnum(SessionSequenceType);
 /** @internal */
 export const SessionSequenceType$outboundSchema: z.ZodNativeEnum<
   typeof SessionSequenceType
-> = SessionSequenceType$inboundSchema;
+> = z.nativeEnum(SessionSequenceType);

package/src/models/sessionsequencetyperesponse.ts

@@ -21,9 +21,3 @@ export const SessionSequenceTypeResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(SessionSequenceTypeResponse);
-/** @internal */
-export const SessionSequenceTypeResponse$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  SessionSequenceTypeResponse
-> = openEnums.outboundSchema(SessionSequenceTypeResponse);

package/src/models/settlementcapturestatus.ts

@@ -24,9 +24,3 @@ export const SettlementCaptureStatus$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(SettlementCaptureStatus);
-/** @internal */
-export const SettlementCaptureStatus$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  SettlementCaptureStatus
-> = openEnums.outboundSchema(SettlementCaptureStatus);

package/src/models/settlementmode.ts

@@ -24,9 +24,3 @@ export const SettlementMode$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(SettlementMode);
-/** @internal */
-export const SettlementMode$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  SettlementMode
-> = openEnums.outboundSchema(SettlementMode);

package/src/models/settlementpaymentstatus.ts

@@ -24,9 +24,3 @@ export const SettlementPaymentStatus$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(SettlementPaymentStatus);
-/** @internal */
-export const SettlementPaymentStatus$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  SettlementPaymentStatus
-> = openEnums.outboundSchema(SettlementPaymentStatus);

package/src/models/settlementrefundstatus.ts

@@ -24,9 +24,3 @@ export const SettlementRefundStatus$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(SettlementRefundStatus);
-/** @internal */
-export const SettlementRefundStatus$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  SettlementRefundStatus
-> = openEnums.outboundSchema(SettlementRefundStatus);

package/src/models/sorting.ts

@@ -13,8 +13,5 @@ export const Sorting = {
 export type Sorting = ClosedEnum<typeof Sorting>;
 
 /** @internal */
-export const Sorting$inboundSchema: z.ZodNativeEnum<typeof Sorting> = z
+export const Sorting$outboundSchema: z.ZodNativeEnum<typeof Sorting> = z
   .nativeEnum(Sorting);
-/** @internal */
-export const Sorting$outboundSchema: z.ZodNativeEnum<typeof Sorting> =
-  Sorting$inboundSchema;

package/src/models/statushistoryentryresponse.ts

@@ -7,16 +7,10 @@ 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 {
-  StatusReason2,
-  StatusReason2$inboundSchema,
-  StatusReason2$Outbound,
-  StatusReason2$outboundSchema,
-} from "./statusreason2.js";
+import { StatusReason2, StatusReason2$inboundSchema } from "./statusreason2.js";
 import {
   TransferStatus,
   TransferStatus$inboundSchema,
-  TransferStatus$outboundSchema,
 } from "./transferstatus.js";
 
 /**
@@ -52,31 +46,7 @@ export const StatusHistoryEntryResponse$inboundSchema: z.ZodType<
   createdAt: z.string(),
   statusReason: z.nullable(StatusReason2$inboundSchema).optional(),
 });
-/** @internal */
-export type StatusHistoryEntryResponse$Outbound = {
-  status: string;
-  createdAt: string;
-  statusReason?: StatusReason2$Outbound | null | undefined;
-};
-
-/** @internal */
-export const StatusHistoryEntryResponse$outboundSchema: z.ZodType<
-  StatusHistoryEntryResponse$Outbound,
-  z.ZodTypeDef,
-  StatusHistoryEntryResponse
-> = z.object({
-  status: TransferStatus$outboundSchema,
-  createdAt: z.string(),
-  statusReason: z.nullable(StatusReason2$outboundSchema).optional(),
-});
 
-export function statusHistoryEntryResponseToJSON(
-  statusHistoryEntryResponse: StatusHistoryEntryResponse,
-): string {
-  return JSON.stringify(
-    StatusHistoryEntryResponse$outboundSchema.parse(statusHistoryEntryResponse),
-  );
-}
 export function statusHistoryEntryResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<StatusHistoryEntryResponse, SDKValidationError> {

package/src/models/statusreason.ts

@@ -166,9 +166,6 @@ export type StatusReason = {
 export const Code$inboundSchema: z.ZodNativeEnum<typeof Code> = z.nativeEnum(
   Code,
 );
-/** @internal */
-export const Code$outboundSchema: z.ZodNativeEnum<typeof Code> =
-  Code$inboundSchema;
 
 /** @internal */
 export const StatusReason$inboundSchema: z.ZodType<
@@ -179,25 +176,7 @@ export const StatusReason$inboundSchema: z.ZodType<
   code: Code$inboundSchema,
   message: z.string(),
 });
-/** @internal */
-export type StatusReason$Outbound = {
-  code: string;
-  message: string;
-};
 
-/** @internal */
-export const StatusReason$outboundSchema: z.ZodType<
-  StatusReason$Outbound,
-  z.ZodTypeDef,
-  StatusReason
-> = z.object({
-  code: Code$outboundSchema,
-  message: z.string(),
-});
-
-export function statusReasonToJSON(statusReason: StatusReason): string {
-  return JSON.stringify(StatusReason$outboundSchema.parse(statusReason));
-}
 export function statusReasonFromJSON(
   jsonString: string,
 ): SafeParseResult<StatusReason, SDKValidationError> {

package/src/models/statusreason2.ts

@@ -10,7 +10,6 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
   StatusReasonCodeResponse,
   StatusReasonCodeResponse$inboundSchema,
-  StatusReasonCodeResponse$outboundSchema,
 } from "./statusreasoncoderesponse.js";
 
 /**
@@ -41,25 +40,7 @@ export const StatusReason2$inboundSchema: z.ZodType<
   code: StatusReasonCodeResponse$inboundSchema.optional(),
   message: z.nullable(z.string()).optional(),
 });
-/** @internal */
-export type StatusReason2$Outbound = {
-  code?: string | undefined;
-  message?: string | null | undefined;
-};
-
-/** @internal */
-export const StatusReason2$outboundSchema: z.ZodType<
-  StatusReason2$Outbound,
-  z.ZodTypeDef,
-  StatusReason2
-> = z.object({
-  code: StatusReasonCodeResponse$outboundSchema.optional(),
-  message: z.nullable(z.string()).optional(),
-});
 
-export function statusReason2ToJSON(statusReason2: StatusReason2): string {
-  return JSON.stringify(StatusReason2$outboundSchema.parse(statusReason2));
-}
 export function statusReason2FromJSON(
   jsonString: string,
 ): SafeParseResult<StatusReason2, SDKValidationError> {

package/src/models/statusreasoncoderesponse.ts

@@ -28,9 +28,3 @@ export const StatusReasonCodeResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(StatusReasonCodeResponse);
-/** @internal */
-export const StatusReasonCodeResponse$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  StatusReasonCodeResponse
-> = openEnums.outboundSchema(StatusReasonCodeResponse);

package/src/models/subgroup.ts

@@ -6,17 +6,10 @@
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import {
-  Amount,
-  Amount$inboundSchema,
-  Amount$Outbound,
-  Amount$outboundSchema,
-} from "./amount.js";
+import { Amount, Amount$inboundSchema } from "./amount.js";
 import {
   ComponentsSubTotals,
   ComponentsSubTotals$inboundSchema,
-  ComponentsSubTotals$Outbound,
-  ComponentsSubTotals$outboundSchema,
 } from "./componentssubtotals.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -37,25 +30,7 @@ export const SubGroup$inboundSchema: z.ZodType<
   amount: Amount$inboundSchema.optional(),
   subtotals: z.nullable(z.array(ComponentsSubTotals$inboundSchema)).optional(),
 });
-/** @internal */
-export type SubGroup$Outbound = {
-  amount?: Amount$Outbound | undefined;
-  subtotals?: Array<ComponentsSubTotals$Outbound> | null | undefined;
-};
 
-/** @internal */
-export const SubGroup$outboundSchema: z.ZodType<
-  SubGroup$Outbound,
-  z.ZodTypeDef,
-  SubGroup
-> = z.object({
-  amount: Amount$outboundSchema.optional(),
-  subtotals: z.nullable(z.array(ComponentsSubTotals$outboundSchema)).optional(),
-});
-
-export function subGroupToJSON(subGroup: SubGroup): string {
-  return JSON.stringify(SubGroup$outboundSchema.parse(subGroup));
-}
 export function subGroupFromJSON(
   jsonString: string,
 ): SafeParseResult<SubGroup, SDKValidationError> {

package/src/models/subscriptionmethod.ts

@@ -19,11 +19,7 @@ export const SubscriptionMethod = {
  */
 export type SubscriptionMethod = ClosedEnum<typeof SubscriptionMethod>;
 
-/** @internal */
-export const SubscriptionMethod$inboundSchema: z.ZodNativeEnum<
-  typeof SubscriptionMethod
-> = z.nativeEnum(SubscriptionMethod);
 /** @internal */
 export const SubscriptionMethod$outboundSchema: z.ZodNativeEnum<
   typeof SubscriptionMethod
-> = SubscriptionMethod$inboundSchema;
+> = z.nativeEnum(SubscriptionMethod);

package/src/models/subscriptionmethodresponse.ts

@@ -28,9 +28,3 @@ export const SubscriptionMethodResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(SubscriptionMethodResponse);
-/** @internal */
-export const SubscriptionMethodResponse$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  SubscriptionMethodResponse
-> = openEnums.outboundSchema(SubscriptionMethodResponse);