mollie-api-typescript 1.3.7 → 1.4.0

package/src/models/entitybalancetransfer.ts

@@ -4,26 +4,16 @@
  */
 
 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$Outbound, Amount$outboundSchema } from "./amount.js";
 import {
   BalanceTransferCategory,
-  BalanceTransferCategory$inboundSchema,
   BalanceTransferCategory$outboundSchema,
 } from "./balancetransfercategory.js";
 import {
   EntityBalanceTransferParty,
-  EntityBalanceTransferParty$inboundSchema,
   EntityBalanceTransferParty$Outbound,
   EntityBalanceTransferParty$outboundSchema,
 } from "./entitybalancetransferparty.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export type EntityBalanceTransfer = {
   /**
@@ -63,20 +53,6 @@ export type EntityBalanceTransfer = {
   testmode?: boolean | undefined;
 };
 
-/** @internal */
-export const EntityBalanceTransfer$inboundSchema: z.ZodType<
-  EntityBalanceTransfer,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  amount: Amount$inboundSchema,
-  source: EntityBalanceTransferParty$inboundSchema,
-  destination: EntityBalanceTransferParty$inboundSchema,
-  description: z.string(),
-  category: BalanceTransferCategory$inboundSchema.optional(),
-  metadata: z.record(z.any()).optional(),
-  testmode: z.boolean().optional(),
-});
 /** @internal */
 export type EntityBalanceTransfer$Outbound = {
   amount: Amount$Outbound;
@@ -110,12 +86,3 @@ export function entityBalanceTransferToJSON(
     EntityBalanceTransfer$outboundSchema.parse(entityBalanceTransfer),
   );
 }
-export function entityBalanceTransferFromJSON(
-  jsonString: string,
-): SafeParseResult<EntityBalanceTransfer, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EntityBalanceTransfer$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityBalanceTransfer' from JSON`,
-  );
-}

package/src/models/entitybalancetransferparty.ts

@@ -4,14 +4,10 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../lib/schemas.js";
-import { Result as SafeParseResult } from "../types/fp.js";
 import {
   BalanceTransferPartyType,
-  BalanceTransferPartyType$inboundSchema,
   BalanceTransferPartyType$outboundSchema,
 } from "./balancetransferpartytype.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 /**
  * A party involved in the balance transfer, either the sender or the receiver.
@@ -28,16 +24,6 @@ export type EntityBalanceTransferParty = {
   description: string;
 };
 
-/** @internal */
-export const EntityBalanceTransferParty$inboundSchema: z.ZodType<
-  EntityBalanceTransferParty,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: BalanceTransferPartyType$inboundSchema,
-  id: z.string(),
-  description: z.string(),
-});
 /** @internal */
 export type EntityBalanceTransferParty$Outbound = {
   type: string;
@@ -63,12 +49,3 @@ export function entityBalanceTransferPartyToJSON(
     EntityBalanceTransferParty$outboundSchema.parse(entityBalanceTransferParty),
   );
 }
-export function entityBalanceTransferPartyFromJSON(
-  jsonString: string,
-): SafeParseResult<EntityBalanceTransferParty, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EntityBalanceTransferParty$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityBalanceTransferParty' from JSON`,
-  );
-}

package/src/models/entitybalancetransferpartyresponse.ts

@@ -9,7 +9,6 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import {
   BalanceTransferPartyTypeResponse,
   BalanceTransferPartyTypeResponse$inboundSchema,
-  BalanceTransferPartyTypeResponse$outboundSchema,
 } from "./balancetransferpartytyperesponse.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -38,33 +37,7 @@ export const EntityBalanceTransferPartyResponse$inboundSchema: z.ZodType<
   id: z.string(),
   description: z.string(),
 });
-/** @internal */
-export type EntityBalanceTransferPartyResponse$Outbound = {
-  type: string;
-  id: string;
-  description: string;
-};
 
-/** @internal */
-export const EntityBalanceTransferPartyResponse$outboundSchema: z.ZodType<
-  EntityBalanceTransferPartyResponse$Outbound,
-  z.ZodTypeDef,
-  EntityBalanceTransferPartyResponse
-> = z.object({
-  type: BalanceTransferPartyTypeResponse$outboundSchema,
-  id: z.string(),
-  description: z.string(),
-});
-
-export function entityBalanceTransferPartyResponseToJSON(
-  entityBalanceTransferPartyResponse: EntityBalanceTransferPartyResponse,
-): string {
-  return JSON.stringify(
-    EntityBalanceTransferPartyResponse$outboundSchema.parse(
-      entityBalanceTransferPartyResponse,
-    ),
-  );
-}
 export function entityBalanceTransferPartyResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityBalanceTransferPartyResponse, SDKValidationError> {

package/src/models/entitybalancetransferresponse.ts

@@ -6,35 +6,25 @@
 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 {
   BalanceTransferCategoryResponse,
   BalanceTransferCategoryResponse$inboundSchema,
-  BalanceTransferCategoryResponse$outboundSchema,
 } from "./balancetransfercategoryresponse.js";
 import {
   BalanceTransferStatus,
   BalanceTransferStatus$inboundSchema,
-  BalanceTransferStatus$outboundSchema,
 } from "./balancetransferstatus.js";
 import {
   BalanceTransferStatusReasonResponse,
   BalanceTransferStatusReasonResponse$inboundSchema,
-  BalanceTransferStatusReasonResponse$outboundSchema,
 } from "./balancetransferstatusreasonresponse.js";
 import {
   EntityBalanceTransferPartyResponse,
   EntityBalanceTransferPartyResponse$inboundSchema,
-  EntityBalanceTransferPartyResponse$Outbound,
-  EntityBalanceTransferPartyResponse$outboundSchema,
 } from "./entitybalancetransferpartyresponse.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Mode, Mode$inboundSchema, Mode$outboundSchema } from "./mode.js";
+import { Mode, Mode$inboundSchema } from "./mode.js";
 
 /**
  * The reason for the current status of the transfer, if applicable.
@@ -123,33 +113,7 @@ export const EntityBalanceTransferResponseStatusReason$inboundSchema: z.ZodType<
   code: BalanceTransferStatusReasonResponse$inboundSchema,
   message: z.string(),
 });
-/** @internal */
-export type EntityBalanceTransferResponseStatusReason$Outbound = {
-  code: string;
-  message: string;
-};
 
-/** @internal */
-export const EntityBalanceTransferResponseStatusReason$outboundSchema:
-  z.ZodType<
-    EntityBalanceTransferResponseStatusReason$Outbound,
-    z.ZodTypeDef,
-    EntityBalanceTransferResponseStatusReason
-  > = z.object({
-    code: BalanceTransferStatusReasonResponse$outboundSchema,
-    message: z.string(),
-  });
-
-export function entityBalanceTransferResponseStatusReasonToJSON(
-  entityBalanceTransferResponseStatusReason:
-    EntityBalanceTransferResponseStatusReason,
-): string {
-  return JSON.stringify(
-    EntityBalanceTransferResponseStatusReason$outboundSchema.parse(
-      entityBalanceTransferResponseStatusReason,
-    ),
-  );
-}
 export function entityBalanceTransferResponseStatusReasonFromJSON(
   jsonString: string,
 ): SafeParseResult<
@@ -188,55 +152,7 @@ export const EntityBalanceTransferResponse$inboundSchema: z.ZodType<
   executedAt: z.nullable(z.string()).optional(),
   mode: Mode$inboundSchema,
 });
-/** @internal */
-export type EntityBalanceTransferResponse$Outbound = {
-  resource: string;
-  id: string;
-  amount: Amount$Outbound;
-  source: EntityBalanceTransferPartyResponse$Outbound;
-  destination: EntityBalanceTransferPartyResponse$Outbound;
-  description: string;
-  status: string;
-  statusReason: EntityBalanceTransferResponseStatusReason$Outbound;
-  category?: string | undefined;
-  metadata?: { [k: string]: any } | undefined;
-  createdAt: string;
-  executedAt?: string | null | undefined;
-  mode: string;
-};
 
-/** @internal */
-export const EntityBalanceTransferResponse$outboundSchema: z.ZodType<
-  EntityBalanceTransferResponse$Outbound,
-  z.ZodTypeDef,
-  EntityBalanceTransferResponse
-> = z.object({
-  resource: z.string(),
-  id: z.string(),
-  amount: Amount$outboundSchema,
-  source: EntityBalanceTransferPartyResponse$outboundSchema,
-  destination: EntityBalanceTransferPartyResponse$outboundSchema,
-  description: z.string(),
-  status: BalanceTransferStatus$outboundSchema,
-  statusReason: z.lazy(() =>
-    EntityBalanceTransferResponseStatusReason$outboundSchema
-  ),
-  category: BalanceTransferCategoryResponse$outboundSchema.optional(),
-  metadata: z.record(z.any()).optional(),
-  createdAt: z.string(),
-  executedAt: z.nullable(z.string()).optional(),
-  mode: Mode$outboundSchema,
-});
-
-export function entityBalanceTransferResponseToJSON(
-  entityBalanceTransferResponse: EntityBalanceTransferResponse,
-): string {
-  return JSON.stringify(
-    EntityBalanceTransferResponse$outboundSchema.parse(
-      entityBalanceTransferResponse,
-    ),
-  );
-}
 export function entityBalanceTransferResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityBalanceTransferResponse, SDKValidationError> {

package/src/models/entitycapability.ts

@@ -9,18 +9,14 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import {
   CapabilityStatus,
   CapabilityStatus$inboundSchema,
-  CapabilityStatus$outboundSchema,
 } from "./capabilitystatus.js";
 import {
   CapabilityStatusReason,
   CapabilityStatusReason$inboundSchema,
-  CapabilityStatusReason$outboundSchema,
 } from "./capabilitystatusreason.js";
 import {
   EntityCapabilityRequirement,
   EntityCapabilityRequirement$inboundSchema,
-  EntityCapabilityRequirement$Outbound,
-  EntityCapabilityRequirement$outboundSchema,
 } from "./entitycapabilityrequirement.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -50,35 +46,7 @@ export const EntityCapability$inboundSchema: z.ZodType<
   statusReason: z.nullable(CapabilityStatusReason$inboundSchema),
   requirements: z.array(EntityCapabilityRequirement$inboundSchema),
 });
-/** @internal */
-export type EntityCapability$Outbound = {
-  resource: string;
-  name: string;
-  status: string;
-  statusReason: string | null;
-  requirements: Array<EntityCapabilityRequirement$Outbound>;
-};
 
-/** @internal */
-export const EntityCapability$outboundSchema: z.ZodType<
-  EntityCapability$Outbound,
-  z.ZodTypeDef,
-  EntityCapability
-> = z.object({
-  resource: z.string(),
-  name: z.string(),
-  status: CapabilityStatus$outboundSchema,
-  statusReason: z.nullable(CapabilityStatusReason$outboundSchema),
-  requirements: z.array(EntityCapabilityRequirement$outboundSchema),
-});
-
-export function entityCapabilityToJSON(
-  entityCapability: EntityCapability,
-): string {
-  return JSON.stringify(
-    EntityCapability$outboundSchema.parse(entityCapability),
-  );
-}
 export function entityCapabilityFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityCapability, SDKValidationError> {

package/src/models/entitycapabilityrequirement.ts

@@ -10,15 +10,9 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import {
   CapabilityRequirementStatus,
   CapabilityRequirementStatus$inboundSchema,
-  CapabilityRequirementStatus$outboundSchema,
 } from "./capabilityrequirementstatus.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import {
-  Url,
-  Url$inboundSchema,
-  Url$Outbound,
-  Url$outboundSchema,
-} from "./url.js";
+import { Url, Url$inboundSchema } from "./url.js";
 
 export type EntityCapabilityRequirementLinks = {
   /**
@@ -59,29 +53,7 @@ export const EntityCapabilityRequirementLinks$inboundSchema: z.ZodType<
 > = z.object({
   dashboard: Url$inboundSchema.optional(),
 });
-/** @internal */
-export type EntityCapabilityRequirementLinks$Outbound = {
-  dashboard?: Url$Outbound | undefined;
-};
 
-/** @internal */
-export const EntityCapabilityRequirementLinks$outboundSchema: z.ZodType<
-  EntityCapabilityRequirementLinks$Outbound,
-  z.ZodTypeDef,
-  EntityCapabilityRequirementLinks
-> = z.object({
-  dashboard: Url$outboundSchema.optional(),
-});
-
-export function entityCapabilityRequirementLinksToJSON(
-  entityCapabilityRequirementLinks: EntityCapabilityRequirementLinks,
-): string {
-  return JSON.stringify(
-    EntityCapabilityRequirementLinks$outboundSchema.parse(
-      entityCapabilityRequirementLinks,
-    ),
-  );
-}
 export function entityCapabilityRequirementLinksFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityCapabilityRequirementLinks, SDKValidationError> {
@@ -107,39 +79,7 @@ export const EntityCapabilityRequirement$inboundSchema: z.ZodType<
     "_links": "links",
   });
 });
-/** @internal */
-export type EntityCapabilityRequirement$Outbound = {
-  id: string;
-  status: string;
-  dueDate: string | null;
-  _links: EntityCapabilityRequirementLinks$Outbound;
-};
-
-/** @internal */
-export const EntityCapabilityRequirement$outboundSchema: z.ZodType<
-  EntityCapabilityRequirement$Outbound,
-  z.ZodTypeDef,
-  EntityCapabilityRequirement
-> = z.object({
-  id: z.string(),
-  status: CapabilityRequirementStatus$outboundSchema,
-  dueDate: z.nullable(z.string()),
-  links: z.lazy(() => EntityCapabilityRequirementLinks$outboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    links: "_links",
-  });
-});
 
-export function entityCapabilityRequirementToJSON(
-  entityCapabilityRequirement: EntityCapabilityRequirement,
-): string {
-  return JSON.stringify(
-    EntityCapabilityRequirement$outboundSchema.parse(
-      entityCapabilityRequirement,
-    ),
-  );
-}
 export function entityCapabilityRequirementFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityCapabilityRequirement, SDKValidationError> {

package/src/models/entitycapture.ts

@@ -4,18 +4,13 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../lib/schemas.js";
-import { Result as SafeParseResult } from "../types/fp.js";
 import {
   AmountNullable,
-  AmountNullable$inboundSchema,
   AmountNullable$Outbound,
   AmountNullable$outboundSchema,
 } from "./amountnullable.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
   Metadata,
-  Metadata$inboundSchema,
   Metadata$Outbound,
   Metadata$outboundSchema,
 } from "./metadata.js";
@@ -38,16 +33,6 @@ export type EntityCapture = {
   metadata?: Metadata | null | undefined;
 };
 
-/** @internal */
-export const EntityCapture$inboundSchema: z.ZodType<
-  EntityCapture,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  description: z.string().optional(),
-  amount: z.nullable(AmountNullable$inboundSchema).optional(),
-  metadata: z.nullable(Metadata$inboundSchema).optional(),
-});
 /** @internal */
 export type EntityCapture$Outbound = {
   description?: string | undefined;
@@ -69,12 +54,3 @@ export const EntityCapture$outboundSchema: z.ZodType<
 export function entityCaptureToJSON(entityCapture: EntityCapture): string {
   return JSON.stringify(EntityCapture$outboundSchema.parse(entityCapture));
 }
-export function entityCaptureFromJSON(
-  jsonString: string,
-): SafeParseResult<EntityCapture, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EntityCapture$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityCapture' from JSON`,
-  );
-}

package/src/models/entitychargeback.ts

@@ -7,25 +7,10 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 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 {
-  Url,
-  Url$inboundSchema,
-  Url$Outbound,
-  Url$outboundSchema,
-} from "./url.js";
-import {
-  UrlNullable,
-  UrlNullable$inboundSchema,
-  UrlNullable$Outbound,
-  UrlNullable$outboundSchema,
-} from "./urlnullable.js";
+import { Url, Url$inboundSchema } from "./url.js";
+import { UrlNullable, UrlNullable$inboundSchema } from "./urlnullable.js";
 
 /**
  * This optional field will contain the approximate amount that will be deducted from your account balance, converted
@@ -159,31 +144,7 @@ export const EntityChargebackSettlementAmount$inboundSchema: z.ZodType<
   currency: z.string(),
   value: z.string(),
 });
-/** @internal */
-export type EntityChargebackSettlementAmount$Outbound = {
-  currency: string;
-  value: string;
-};
-
-/** @internal */
-export const EntityChargebackSettlementAmount$outboundSchema: z.ZodType<
-  EntityChargebackSettlementAmount$Outbound,
-  z.ZodTypeDef,
-  EntityChargebackSettlementAmount
-> = z.object({
-  currency: z.string(),
-  value: z.string(),
-});
 
-export function entityChargebackSettlementAmountToJSON(
-  entityChargebackSettlementAmount: EntityChargebackSettlementAmount,
-): string {
-  return JSON.stringify(
-    EntityChargebackSettlementAmount$outboundSchema.parse(
-      entityChargebackSettlementAmount,
-    ),
-  );
-}
 export function entityChargebackSettlementAmountFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityChargebackSettlementAmount, SDKValidationError> {
@@ -203,29 +164,7 @@ export const EntityChargebackReason$inboundSchema: z.ZodType<
   code: z.string(),
   description: z.string(),
 });
-/** @internal */
-export type EntityChargebackReason$Outbound = {
-  code: string;
-  description: string;
-};
-
-/** @internal */
-export const EntityChargebackReason$outboundSchema: z.ZodType<
-  EntityChargebackReason$Outbound,
-  z.ZodTypeDef,
-  EntityChargebackReason
-> = z.object({
-  code: z.string(),
-  description: z.string(),
-});
 
-export function entityChargebackReasonToJSON(
-  entityChargebackReason: EntityChargebackReason,
-): string {
-  return JSON.stringify(
-    EntityChargebackReason$outboundSchema.parse(entityChargebackReason),
-  );
-}
 export function entityChargebackReasonFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityChargebackReason, SDKValidationError> {
@@ -247,33 +186,7 @@ export const EntityChargebackLinks$inboundSchema: z.ZodType<
   settlement: z.nullable(UrlNullable$inboundSchema).optional(),
   documentation: Url$inboundSchema,
 });
-/** @internal */
-export type EntityChargebackLinks$Outbound = {
-  self: Url$Outbound;
-  payment: Url$Outbound;
-  settlement?: UrlNullable$Outbound | null | undefined;
-  documentation: Url$Outbound;
-};
-
-/** @internal */
-export const EntityChargebackLinks$outboundSchema: z.ZodType<
-  EntityChargebackLinks$Outbound,
-  z.ZodTypeDef,
-  EntityChargebackLinks
-> = z.object({
-  self: Url$outboundSchema,
-  payment: Url$outboundSchema,
-  settlement: z.nullable(UrlNullable$outboundSchema).optional(),
-  documentation: Url$outboundSchema,
-});
 
-export function entityChargebackLinksToJSON(
-  entityChargebackLinks: EntityChargebackLinks,
-): string {
-  return JSON.stringify(
-    EntityChargebackLinks$outboundSchema.parse(entityChargebackLinks),
-  );
-}
 export function entityChargebackLinksFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityChargebackLinks, SDKValidationError> {
@@ -308,55 +221,7 @@ export const EntityChargeback$inboundSchema: z.ZodType<
     "_links": "links",
   });
 });
-/** @internal */
-export type EntityChargeback$Outbound = {
-  resource: string;
-  id: string;
-  amount: Amount$Outbound;
-  settlementAmount?:
-    | EntityChargebackSettlementAmount$Outbound
-    | null
-    | undefined;
-  reason?: EntityChargebackReason$Outbound | null | undefined;
-  paymentId: string;
-  settlementId?: string | null | undefined;
-  createdAt: string;
-  reversedAt?: string | null | undefined;
-  _links: EntityChargebackLinks$Outbound;
-};
 
-/** @internal */
-export const EntityChargeback$outboundSchema: z.ZodType<
-  EntityChargeback$Outbound,
-  z.ZodTypeDef,
-  EntityChargeback
-> = z.object({
-  resource: z.string(),
-  id: z.string(),
-  amount: Amount$outboundSchema,
-  settlementAmount: z.nullable(
-    z.lazy(() => EntityChargebackSettlementAmount$outboundSchema),
-  ).optional(),
-  reason: z.nullable(z.lazy(() => EntityChargebackReason$outboundSchema))
-    .optional(),
-  paymentId: z.string(),
-  settlementId: z.nullable(z.string()).optional(),
-  createdAt: z.string(),
-  reversedAt: z.nullable(z.string()).optional(),
-  links: z.lazy(() => EntityChargebackLinks$outboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    links: "_links",
-  });
-});
-
-export function entityChargebackToJSON(
-  entityChargeback: EntityChargeback,
-): string {
-  return JSON.stringify(
-    EntityChargeback$outboundSchema.parse(entityChargeback),
-  );
-}
 export function entityChargebackFromJSON(
   jsonString: string,
 ): SafeParseResult<EntityChargeback, SDKValidationError> {

package/src/models/entitycustomer.ts

@@ -4,17 +4,12 @@
  */
 
 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 {
   LocaleResponse,
-  LocaleResponse$inboundSchema,
   LocaleResponse$outboundSchema,
 } from "./localeresponse.js";
 import {
   Metadata,
-  Metadata$inboundSchema,
   Metadata$Outbound,
   Metadata$outboundSchema,
 } from "./metadata.js";
@@ -51,18 +46,6 @@ export type EntityCustomer = {
   testmode?: boolean | null | undefined;
 };
 
-/** @internal */
-export const EntityCustomer$inboundSchema: z.ZodType<
-  EntityCustomer,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  name: z.nullable(z.string()).optional(),
-  email: z.nullable(z.string()).optional(),
-  locale: z.nullable(LocaleResponse$inboundSchema).optional(),
-  metadata: z.nullable(Metadata$inboundSchema).optional(),
-  testmode: z.nullable(z.boolean()).optional(),
-});
 /** @internal */
 export type EntityCustomer$Outbound = {
   name?: string | null | undefined;
@@ -88,12 +71,3 @@ export const EntityCustomer$outboundSchema: z.ZodType<
 export function entityCustomerToJSON(entityCustomer: EntityCustomer): string {
   return JSON.stringify(EntityCustomer$outboundSchema.parse(entityCustomer));
 }
-export function entityCustomerFromJSON(
-  jsonString: string,
-): SafeParseResult<EntityCustomer, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EntityCustomer$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityCustomer' from JSON`,
-  );
-}