mollie-api-typescript 0.9.3 → 0.9.5

package/src/mcp-server/resources.ts

@@ -9,7 +9,11 @@ import {
 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import { Variables } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
-import { ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import {
+  ReadResourceResult,
+  ServerNotification,
+  ServerRequest,
+} from "@modelcontextprotocol/sdk/types.js";
 import { ClientCore } from "../core.js";
 import { ConsoleLogger } from "./console-logger.js";
 import { MCPScope } from "./scopes.js";
@@ -18,7 +22,7 @@ import { isAsyncIterable, isBinaryData, valueToBase64 } from "./shared.js";
 export type ReadResourceCallback = (
   client: ClientCore,
   uri: URL,
-  extra: RequestHandlerExtra,
+  extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 ) => ReadResourceResult | Promise<ReadResourceResult>;
 
 export type ResourceDefinition = {
@@ -34,7 +38,7 @@ export type ReadResourceTemplateCallback = (
   client: ClientCore,
   uri: URL,
   vars: Variables,
-  extra: RequestHandlerExtra,
+  extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 ) => ReadResourceResult | Promise<ReadResourceResult>;
 
 export type ResourceTemplateDefinition = {

package/src/mcp-server/server.ts

@@ -123,7 +123,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "Client",
-    version: "0.9.3",
+    version: "0.9.5",
   });
 
   const client = new ClientCore({

package/src/mcp-server/tools.ts

@@ -4,7 +4,11 @@
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import {
+  CallToolResult,
+  ServerNotification,
+  ServerRequest,
+} from "@modelcontextprotocol/sdk/types.js";
 import { objectOutputType, ZodRawShape, ZodTypeAny } from "zod/v3";
 import { ClientCore } from "../core.js";
 import { ConsoleLogger } from "./console-logger.js";
@@ -20,7 +24,7 @@ export type ToolDefinition<Args extends undefined | ZodRawShape = undefined> =
       tool: (
         client: ClientCore,
         args: objectOutputType<Args, ZodTypeAny>,
-        extra: RequestHandlerExtra,
+        extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
       ) => CallToolResult | Promise<CallToolResult>;
     }
     : {
@@ -30,7 +34,7 @@ export type ToolDefinition<Args extends undefined | ZodRawShape = undefined> =
       args?: undefined;
       tool: (
         client: ClientCore,
-        extra: RequestHandlerExtra,
+        extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
       ) => CallToolResult | Promise<CallToolResult>;
     };
 

package/src/models/entitybalance.ts

@@ -25,7 +25,7 @@ import {
 /**
  * The balance's ISO 4217 currency code.
  */
-export const EntityBalanceCurrency = {
+export const Currency = {
   Eur: "EUR",
   Gbp: "GBP",
   Chf: "CHF",
@@ -42,7 +42,7 @@ export const EntityBalanceCurrency = {
 /**
  * The balance's ISO 4217 currency code.
  */
-export type EntityBalanceCurrency = OpenEnum<typeof EntityBalanceCurrency>;
+export type Currency = OpenEnum<typeof Currency>;
 
 /**
  * The status of the balance.
@@ -64,7 +64,7 @@ export type EntityBalanceStatus = OpenEnum<typeof EntityBalanceStatus>;
  *
  * Settlements created during weekends or on bank holidays will take place on the next business day.
  */
-export const EntityBalanceTransferFrequency = {
+export const TransferFrequency = {
   EveryDay: "every-day",
   Daily: "daily",
   EveryMonday: "every-monday",
@@ -84,9 +84,7 @@ export const EntityBalanceTransferFrequency = {
  *
  * Settlements created during weekends or on bank holidays will take place on the next business day.
  */
-export type EntityBalanceTransferFrequency = OpenEnum<
-  typeof EntityBalanceTransferFrequency
->;
+export type TransferFrequency = OpenEnum<typeof TransferFrequency>;
 
 /**
  * The minimum amount configured for scheduled automatic settlements. As soon as the amount on the balance exceeds
@@ -95,7 +93,7 @@ export type EntityBalanceTransferFrequency = OpenEnum<
  * this threshold, the complete balance will be paid out to the transfer destination according to the configured
  * frequency.
  */
-export type EntityBalanceTransferThreshold = {
+export type TransferThreshold = {
   /**
    * A three-character ISO 4217 currency code.
    */
@@ -112,7 +110,7 @@ export type EntityBalanceTransferThreshold = {
  * @remarks
  * transfer frequency.
  */
-export type EntityBalanceTransferDestination = {
+export type TransferDestination = {
   /**
    * The default destination of automatic scheduled transfers. Currently only `bank-account` is supported.
    *
@@ -134,7 +132,7 @@ export type EntityBalanceTransferDestination = {
 /**
  * The amount directly available on the balance, e.g. `{"currency":"EUR", "value":"100.00"}`.
  */
-export type EntityBalanceAvailableAmount = {
+export type AvailableAmount = {
   /**
    * A three-character ISO 4217 currency code.
    */
@@ -151,7 +149,7 @@ export type EntityBalanceAvailableAmount = {
  * @remarks
  * few days to clear.
  */
-export type EntityBalancePendingAmount = {
+export type PendingAmount = {
   /**
    * A three-character ISO 4217 currency code.
    */
@@ -196,13 +194,13 @@ export type EntityBalance = {
   /**
    * The balance's ISO 4217 currency code.
    */
-  currency: EntityBalanceCurrency;
+  currency: Currency;
   /**
    * The description or name of the balance. Can be used to denote the purpose of the balance.
    */
   description: string;
   status: EntityBalanceStatus;
-  transferFrequency?: EntityBalanceTransferFrequency | undefined;
+  transferFrequency?: TransferFrequency | undefined;
   /**
    * The minimum amount configured for scheduled automatic settlements. As soon as the amount on the balance exceeds
    *
@@ -210,7 +208,7 @@ export type EntityBalance = {
    * this threshold, the complete balance will be paid out to the transfer destination according to the configured
    * frequency.
    */
-  transferThreshold?: EntityBalanceTransferThreshold | undefined;
+  transferThreshold?: TransferThreshold | undefined;
   /**
    * The transfer reference set to be included in all the transfers for this balance.
    */
@@ -221,18 +219,18 @@ export type EntityBalance = {
    * @remarks
    * transfer frequency.
    */
-  transferDestination?: EntityBalanceTransferDestination | null | undefined;
+  transferDestination?: TransferDestination | null | undefined;
   /**
    * The amount directly available on the balance, e.g. `{"currency":"EUR", "value":"100.00"}`.
    */
-  availableAmount: EntityBalanceAvailableAmount;
+  availableAmount: AvailableAmount;
   /**
    * The total amount that is queued to be transferred to your balance. For example, a credit card payment can take a
    *
    * @remarks
    * few days to clear.
    */
-  pendingAmount: EntityBalancePendingAmount;
+  pendingAmount: PendingAmount;
   /**
    * An object with several relevant URLs. Every URL object will contain an `href` and a `type` field.
    */
@@ -240,17 +238,17 @@ export type EntityBalance = {
 };
 
 /** @internal */
-export const EntityBalanceCurrency$inboundSchema: z.ZodType<
-  EntityBalanceCurrency,
+export const Currency$inboundSchema: z.ZodType<
+  Currency,
   z.ZodTypeDef,
   unknown
-> = openEnums.inboundSchema(EntityBalanceCurrency);
+> = openEnums.inboundSchema(Currency);
 /** @internal */
-export const EntityBalanceCurrency$outboundSchema: z.ZodType<
+export const Currency$outboundSchema: z.ZodType<
   string,
   z.ZodTypeDef,
-  EntityBalanceCurrency
-> = openEnums.outboundSchema(EntityBalanceCurrency);
+  Currency
+> = openEnums.outboundSchema(Currency);
 
 /** @internal */
 export const EntityBalanceStatus$inboundSchema: z.ZodType<
@@ -266,21 +264,21 @@ export const EntityBalanceStatus$outboundSchema: z.ZodType<
 > = openEnums.outboundSchema(EntityBalanceStatus);
 
 /** @internal */
-export const EntityBalanceTransferFrequency$inboundSchema: z.ZodType<
-  EntityBalanceTransferFrequency,
+export const TransferFrequency$inboundSchema: z.ZodType<
+  TransferFrequency,
   z.ZodTypeDef,
   unknown
-> = openEnums.inboundSchema(EntityBalanceTransferFrequency);
+> = openEnums.inboundSchema(TransferFrequency);
 /** @internal */
-export const EntityBalanceTransferFrequency$outboundSchema: z.ZodType<
+export const TransferFrequency$outboundSchema: z.ZodType<
   string,
   z.ZodTypeDef,
-  EntityBalanceTransferFrequency
-> = openEnums.outboundSchema(EntityBalanceTransferFrequency);
+  TransferFrequency
+> = openEnums.outboundSchema(TransferFrequency);
 
 /** @internal */
-export const EntityBalanceTransferThreshold$inboundSchema: z.ZodType<
-  EntityBalanceTransferThreshold,
+export const TransferThreshold$inboundSchema: z.ZodType<
+  TransferThreshold,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -288,43 +286,41 @@ export const EntityBalanceTransferThreshold$inboundSchema: z.ZodType<
   value: z.string(),
 });
 /** @internal */
-export type EntityBalanceTransferThreshold$Outbound = {
+export type TransferThreshold$Outbound = {
   currency: string;
   value: string;
 };
 
 /** @internal */
-export const EntityBalanceTransferThreshold$outboundSchema: z.ZodType<
-  EntityBalanceTransferThreshold$Outbound,
+export const TransferThreshold$outboundSchema: z.ZodType<
+  TransferThreshold$Outbound,
   z.ZodTypeDef,
-  EntityBalanceTransferThreshold
+  TransferThreshold
 > = z.object({
   currency: z.string(),
   value: z.string(),
 });
 
-export function entityBalanceTransferThresholdToJSON(
-  entityBalanceTransferThreshold: EntityBalanceTransferThreshold,
+export function transferThresholdToJSON(
+  transferThreshold: TransferThreshold,
 ): string {
   return JSON.stringify(
-    EntityBalanceTransferThreshold$outboundSchema.parse(
-      entityBalanceTransferThreshold,
-    ),
+    TransferThreshold$outboundSchema.parse(transferThreshold),
   );
 }
-export function entityBalanceTransferThresholdFromJSON(
+export function transferThresholdFromJSON(
   jsonString: string,
-): SafeParseResult<EntityBalanceTransferThreshold, SDKValidationError> {
+): SafeParseResult<TransferThreshold, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => EntityBalanceTransferThreshold$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityBalanceTransferThreshold' from JSON`,
+    (x) => TransferThreshold$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TransferThreshold' from JSON`,
   );
 }
 
 /** @internal */
-export const EntityBalanceTransferDestination$inboundSchema: z.ZodType<
-  EntityBalanceTransferDestination,
+export const TransferDestination$inboundSchema: z.ZodType<
+  TransferDestination,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -333,45 +329,43 @@ export const EntityBalanceTransferDestination$inboundSchema: z.ZodType<
   beneficiaryName: z.string().optional(),
 });
 /** @internal */
-export type EntityBalanceTransferDestination$Outbound = {
+export type TransferDestination$Outbound = {
   type?: string | undefined;
   bankAccount?: string | undefined;
   beneficiaryName?: string | undefined;
 };
 
 /** @internal */
-export const EntityBalanceTransferDestination$outboundSchema: z.ZodType<
-  EntityBalanceTransferDestination$Outbound,
+export const TransferDestination$outboundSchema: z.ZodType<
+  TransferDestination$Outbound,
   z.ZodTypeDef,
-  EntityBalanceTransferDestination
+  TransferDestination
 > = z.object({
   type: BalanceTransferDestinationType$outboundSchema.optional(),
   bankAccount: z.string().optional(),
   beneficiaryName: z.string().optional(),
 });
 
-export function entityBalanceTransferDestinationToJSON(
-  entityBalanceTransferDestination: EntityBalanceTransferDestination,
+export function transferDestinationToJSON(
+  transferDestination: TransferDestination,
 ): string {
   return JSON.stringify(
-    EntityBalanceTransferDestination$outboundSchema.parse(
-      entityBalanceTransferDestination,
-    ),
+    TransferDestination$outboundSchema.parse(transferDestination),
   );
 }
-export function entityBalanceTransferDestinationFromJSON(
+export function transferDestinationFromJSON(
   jsonString: string,
-): SafeParseResult<EntityBalanceTransferDestination, SDKValidationError> {
+): SafeParseResult<TransferDestination, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => EntityBalanceTransferDestination$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityBalanceTransferDestination' from JSON`,
+    (x) => TransferDestination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TransferDestination' from JSON`,
   );
 }
 
 /** @internal */
-export const EntityBalanceAvailableAmount$inboundSchema: z.ZodType<
-  EntityBalanceAvailableAmount,
+export const AvailableAmount$inboundSchema: z.ZodType<
+  AvailableAmount,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -379,43 +373,39 @@ export const EntityBalanceAvailableAmount$inboundSchema: z.ZodType<
   value: z.string(),
 });
 /** @internal */
-export type EntityBalanceAvailableAmount$Outbound = {
+export type AvailableAmount$Outbound = {
   currency: string;
   value: string;
 };
 
 /** @internal */
-export const EntityBalanceAvailableAmount$outboundSchema: z.ZodType<
-  EntityBalanceAvailableAmount$Outbound,
+export const AvailableAmount$outboundSchema: z.ZodType<
+  AvailableAmount$Outbound,
   z.ZodTypeDef,
-  EntityBalanceAvailableAmount
+  AvailableAmount
 > = z.object({
   currency: z.string(),
   value: z.string(),
 });
 
-export function entityBalanceAvailableAmountToJSON(
-  entityBalanceAvailableAmount: EntityBalanceAvailableAmount,
+export function availableAmountToJSON(
+  availableAmount: AvailableAmount,
 ): string {
-  return JSON.stringify(
-    EntityBalanceAvailableAmount$outboundSchema.parse(
-      entityBalanceAvailableAmount,
-    ),
-  );
+  return JSON.stringify(AvailableAmount$outboundSchema.parse(availableAmount));
 }
-export function entityBalanceAvailableAmountFromJSON(
+export function availableAmountFromJSON(
   jsonString: string,
-): SafeParseResult<EntityBalanceAvailableAmount, SDKValidationError> {
+): SafeParseResult<AvailableAmount, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => EntityBalanceAvailableAmount$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityBalanceAvailableAmount' from JSON`,
+    (x) => AvailableAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AvailableAmount' from JSON`,
   );
 }
 
 /** @internal */
-export const EntityBalancePendingAmount$inboundSchema: z.ZodType<
-  EntityBalancePendingAmount,
+export const PendingAmount$inboundSchema: z.ZodType<
+  PendingAmount,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -423,35 +413,31 @@ export const EntityBalancePendingAmount$inboundSchema: z.ZodType<
   value: z.string(),
 });
 /** @internal */
-export type EntityBalancePendingAmount$Outbound = {
+export type PendingAmount$Outbound = {
   currency: string;
   value: string;
 };
 
 /** @internal */
-export const EntityBalancePendingAmount$outboundSchema: z.ZodType<
-  EntityBalancePendingAmount$Outbound,
+export const PendingAmount$outboundSchema: z.ZodType<
+  PendingAmount$Outbound,
   z.ZodTypeDef,
-  EntityBalancePendingAmount
+  PendingAmount
 > = z.object({
   currency: z.string(),
   value: z.string(),
 });
 
-export function entityBalancePendingAmountToJSON(
-  entityBalancePendingAmount: EntityBalancePendingAmount,
-): string {
-  return JSON.stringify(
-    EntityBalancePendingAmount$outboundSchema.parse(entityBalancePendingAmount),
-  );
+export function pendingAmountToJSON(pendingAmount: PendingAmount): string {
+  return JSON.stringify(PendingAmount$outboundSchema.parse(pendingAmount));
 }
-export function entityBalancePendingAmountFromJSON(
+export function pendingAmountFromJSON(
   jsonString: string,
-): SafeParseResult<EntityBalancePendingAmount, SDKValidationError> {
+): SafeParseResult<PendingAmount, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => EntityBalancePendingAmount$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityBalancePendingAmount' from JSON`,
+    (x) => PendingAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PendingAmount' from JSON`,
   );
 }
 
@@ -507,18 +493,17 @@ export const EntityBalance$inboundSchema: z.ZodType<
   id: z.string(),
   mode: Mode$inboundSchema,
   createdAt: z.string(),
-  currency: EntityBalanceCurrency$inboundSchema,
+  currency: Currency$inboundSchema,
   description: z.string(),
   status: EntityBalanceStatus$inboundSchema,
-  transferFrequency: EntityBalanceTransferFrequency$inboundSchema.optional(),
-  transferThreshold: z.lazy(() => EntityBalanceTransferThreshold$inboundSchema)
-    .optional(),
+  transferFrequency: TransferFrequency$inboundSchema.optional(),
+  transferThreshold: z.lazy(() => TransferThreshold$inboundSchema).optional(),
   transferReference: z.nullable(z.string()).optional(),
   transferDestination: z.nullable(
-    z.lazy(() => EntityBalanceTransferDestination$inboundSchema),
+    z.lazy(() => TransferDestination$inboundSchema),
   ).optional(),
-  availableAmount: z.lazy(() => EntityBalanceAvailableAmount$inboundSchema),
-  pendingAmount: z.lazy(() => EntityBalancePendingAmount$inboundSchema),
+  availableAmount: z.lazy(() => AvailableAmount$inboundSchema),
+  pendingAmount: z.lazy(() => PendingAmount$inboundSchema),
   _links: z.lazy(() => EntityBalanceLinks$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
@@ -535,14 +520,11 @@ export type EntityBalance$Outbound = {
   description: string;
   status: string;
   transferFrequency?: string | undefined;
-  transferThreshold?: EntityBalanceTransferThreshold$Outbound | undefined;
+  transferThreshold?: TransferThreshold$Outbound | undefined;
   transferReference?: string | null | undefined;
-  transferDestination?:
-    | EntityBalanceTransferDestination$Outbound
-    | null
-    | undefined;
-  availableAmount: EntityBalanceAvailableAmount$Outbound;
-  pendingAmount: EntityBalancePendingAmount$Outbound;
+  transferDestination?: TransferDestination$Outbound | null | undefined;
+  availableAmount: AvailableAmount$Outbound;
+  pendingAmount: PendingAmount$Outbound;
   _links: EntityBalanceLinks$Outbound;
 };
 
@@ -556,18 +538,17 @@ export const EntityBalance$outboundSchema: z.ZodType<
   id: z.string(),
   mode: Mode$outboundSchema,
   createdAt: z.string(),
-  currency: EntityBalanceCurrency$outboundSchema,
+  currency: Currency$outboundSchema,
   description: z.string(),
   status: EntityBalanceStatus$outboundSchema,
-  transferFrequency: EntityBalanceTransferFrequency$outboundSchema.optional(),
-  transferThreshold: z.lazy(() => EntityBalanceTransferThreshold$outboundSchema)
-    .optional(),
+  transferFrequency: TransferFrequency$outboundSchema.optional(),
+  transferThreshold: z.lazy(() => TransferThreshold$outboundSchema).optional(),
   transferReference: z.nullable(z.string()).optional(),
   transferDestination: z.nullable(
-    z.lazy(() => EntityBalanceTransferDestination$outboundSchema),
+    z.lazy(() => TransferDestination$outboundSchema),
   ).optional(),
-  availableAmount: z.lazy(() => EntityBalanceAvailableAmount$outboundSchema),
-  pendingAmount: z.lazy(() => EntityBalancePendingAmount$outboundSchema),
+  availableAmount: z.lazy(() => AvailableAmount$outboundSchema),
+  pendingAmount: z.lazy(() => PendingAmount$outboundSchema),
   links: z.lazy(() => EntityBalanceLinks$outboundSchema),
 }).transform((v) => {
   return remap$(v, {

package/src/models/entitychargeback.ts

@@ -52,7 +52,7 @@ export type EntityChargebackSettlementAmount = {
 /**
  * Reason for the chargeback as given by the bank. Only available for chargebacks of SEPA Direct Debit payments.
  */
-export type EntityChargebackReason = {
+export type Reason = {
   /**
    * Technical code provided by the bank.
    */
@@ -117,7 +117,7 @@ export type EntityChargeback = {
   /**
    * Reason for the chargeback as given by the bank. Only available for chargebacks of SEPA Direct Debit payments.
    */
-  reason?: EntityChargebackReason | null | undefined;
+  reason?: Reason | null | undefined;
   /**
    * The unique identifier of the payment this chargeback was created for. For example: `tr_5B8cwPMGnU6qLbRvo7qEZo`.
    *
@@ -194,44 +194,37 @@ export function entityChargebackSettlementAmountFromJSON(
 }
 
 /** @internal */
-export const EntityChargebackReason$inboundSchema: z.ZodType<
-  EntityChargebackReason,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string(),
-  description: z.string(),
-});
+export const Reason$inboundSchema: z.ZodType<Reason, z.ZodTypeDef, unknown> = z
+  .object({
+    code: z.string(),
+    description: z.string(),
+  });
 /** @internal */
-export type EntityChargebackReason$Outbound = {
+export type Reason$Outbound = {
   code: string;
   description: string;
 };
 
 /** @internal */
-export const EntityChargebackReason$outboundSchema: z.ZodType<
-  EntityChargebackReason$Outbound,
+export const Reason$outboundSchema: z.ZodType<
+  Reason$Outbound,
   z.ZodTypeDef,
-  EntityChargebackReason
+  Reason
 > = z.object({
   code: z.string(),
   description: z.string(),
 });
 
-export function entityChargebackReasonToJSON(
-  entityChargebackReason: EntityChargebackReason,
-): string {
-  return JSON.stringify(
-    EntityChargebackReason$outboundSchema.parse(entityChargebackReason),
-  );
+export function reasonToJSON(reason: Reason): string {
+  return JSON.stringify(Reason$outboundSchema.parse(reason));
 }
-export function entityChargebackReasonFromJSON(
+export function reasonFromJSON(
   jsonString: string,
-): SafeParseResult<EntityChargebackReason, SDKValidationError> {
+): SafeParseResult<Reason, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => EntityChargebackReason$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityChargebackReason' from JSON`,
+    (x) => Reason$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Reason' from JSON`,
   );
 }
 
@@ -295,8 +288,7 @@ export const EntityChargeback$inboundSchema: z.ZodType<
   settlementAmount: z.nullable(
     z.lazy(() => EntityChargebackSettlementAmount$inboundSchema),
   ).optional(),
-  reason: z.nullable(z.lazy(() => EntityChargebackReason$inboundSchema))
-    .optional(),
+  reason: z.nullable(z.lazy(() => Reason$inboundSchema)).optional(),
   paymentId: z.string(),
   settlementId: z.nullable(z.string()).optional(),
   createdAt: z.string(),
@@ -316,7 +308,7 @@ export type EntityChargeback$Outbound = {
     | EntityChargebackSettlementAmount$Outbound
     | null
     | undefined;
-  reason?: EntityChargebackReason$Outbound | null | undefined;
+  reason?: Reason$Outbound | null | undefined;
   paymentId: string;
   settlementId?: string | null | undefined;
   createdAt: string;
@@ -336,8 +328,7 @@ export const EntityChargeback$outboundSchema: z.ZodType<
   settlementAmount: z.nullable(
     z.lazy(() => EntityChargebackSettlementAmount$outboundSchema),
   ).optional(),
-  reason: z.nullable(z.lazy(() => EntityChargebackReason$outboundSchema))
-    .optional(),
+  reason: z.nullable(z.lazy(() => Reason$outboundSchema)).optional(),
   paymentId: z.string(),
   settlementId: z.nullable(z.string()).optional(),
   createdAt: z.string(),