mollie-api-typescript 0.8.1 → 0.8.3

package/src/models/{entitymandate.ts → mandaterequest.ts}

@@ -17,7 +17,7 @@ import {
   MandateStatus$outboundSchema,
 } from "./mandatestatus.js";
 
-export type EntityMandate = {
+export type MandateRequest = {
   id?: string | undefined;
   /**
    * Payment method of the mandate.
@@ -26,11 +26,11 @@ export type EntityMandate = {
    *
    * SEPA Direct Debit and PayPal mandates can be created directly.
    */
-  method?: MandateMethod | undefined;
+  method: MandateMethod;
   /**
    * The customer's name.
    */
-  consumerName?: string | undefined;
+  consumerName: string;
   /**
    * The customer's IBAN. Required for SEPA Direct Debit mandates.
    */
@@ -89,14 +89,14 @@ export type EntityMandate = {
 };
 
 /** @internal */
-export const EntityMandate$inboundSchema: z.ZodType<
-  EntityMandate,
+export const MandateRequest$inboundSchema: z.ZodType<
+  MandateRequest,
   z.ZodTypeDef,
   unknown
 > = z.object({
   id: z.string().optional(),
-  method: MandateMethod$inboundSchema.optional(),
-  consumerName: z.string().optional(),
+  method: MandateMethod$inboundSchema,
+  consumerName: z.string(),
   consumerAccount: z.nullable(z.string()).optional(),
   consumerBic: z.nullable(z.string()).optional(),
   consumerEmail: z.nullable(z.string()).optional(),
@@ -109,10 +109,10 @@ export const EntityMandate$inboundSchema: z.ZodType<
   testmode: z.nullable(z.boolean()).optional(),
 });
 /** @internal */
-export type EntityMandate$Outbound = {
+export type MandateRequest$Outbound = {
   id?: string | undefined;
-  method?: string | undefined;
-  consumerName?: string | undefined;
+  method: string;
+  consumerName: string;
   consumerAccount?: string | null | undefined;
   consumerBic?: string | null | undefined;
   consumerEmail?: string | null | undefined;
@@ -126,14 +126,14 @@ export type EntityMandate$Outbound = {
 };
 
 /** @internal */
-export const EntityMandate$outboundSchema: z.ZodType<
-  EntityMandate$Outbound,
+export const MandateRequest$outboundSchema: z.ZodType<
+  MandateRequest$Outbound,
   z.ZodTypeDef,
-  EntityMandate
+  MandateRequest
 > = z.object({
   id: z.string().optional(),
-  method: MandateMethod$outboundSchema.optional(),
-  consumerName: z.string().optional(),
+  method: MandateMethod$outboundSchema,
+  consumerName: z.string(),
   consumerAccount: z.nullable(z.string()).optional(),
   consumerBic: z.nullable(z.string()).optional(),
   consumerEmail: z.nullable(z.string()).optional(),
@@ -146,15 +146,15 @@ export const EntityMandate$outboundSchema: z.ZodType<
   testmode: z.nullable(z.boolean()).optional(),
 });
 
-export function entityMandateToJSON(entityMandate: EntityMandate): string {
-  return JSON.stringify(EntityMandate$outboundSchema.parse(entityMandate));
+export function mandateRequestToJSON(mandateRequest: MandateRequest): string {
+  return JSON.stringify(MandateRequest$outboundSchema.parse(mandateRequest));
 }
-export function entityMandateFromJSON(
+export function mandateRequestFromJSON(
   jsonString: string,
-): SafeParseResult<EntityMandate, SDKValidationError> {
+): SafeParseResult<MandateRequest, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => EntityMandate$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EntityMandate' from JSON`,
+    (x) => MandateRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MandateRequest' from JSON`,
   );
 }

package/src/models/mandateresponse.ts

@@ -90,12 +90,12 @@ export type MandateResponse = {
   /**
    * Indicates the response contains a mandate object. Will always contain the string `mandate` for this endpoint.
    */
-  resource?: string | undefined;
-  id?: string | undefined;
+  resource: string;
+  id: string;
   /**
    * Whether this entity was created in live mode or in test mode.
    */
-  mode?: Mode | undefined;
+  mode: Mode;
   /**
    * Payment method of the mandate.
    *
@@ -103,35 +103,35 @@ export type MandateResponse = {
    *
    * SEPA Direct Debit and PayPal mandates can be created directly.
    */
-  method?: MandateMethodResponse | undefined;
-  details?: MandateResponseDetails | undefined;
+  method: MandateMethodResponse;
+  details: MandateResponseDetails;
   /**
    * The date when the mandate was signed in `YYYY-MM-DD` format.
    */
-  signatureDate?: string | null | undefined;
+  signatureDate: string | null;
   /**
    * A custom mandate reference. For SEPA Direct Debit, it is vital to provide a unique reference. Some banks will
    *
    * @remarks
    * decline Direct Debit payments if the mandate reference is not unique.
    */
-  mandateReference?: string | null | undefined;
+  mandateReference: string | null;
   /**
    * The status of the mandate. A status can be `pending` for mandates when the first payment is not yet finalized, or
    *
    * @remarks
    * when we did not received the IBAN yet from the first payment.
    */
-  status?: MandateStatus | undefined;
-  customerId?: string | undefined;
+  status: MandateStatus;
+  customerId: string;
   /**
    * The entity's date and time of creation, in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
    */
-  createdAt?: string | undefined;
+  createdAt: string;
   /**
    * An object with several relevant URLs. Every URL object will contain an `href` and a `type` field.
    */
-  links?: MandateResponseLinks | undefined;
+  links: MandateResponseLinks;
 };
 
 /** @internal */
@@ -247,17 +247,17 @@ export const MandateResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  resource: z.string().optional(),
-  id: z.string().optional(),
-  mode: Mode$inboundSchema.optional(),
-  method: MandateMethodResponse$inboundSchema.optional(),
-  details: z.lazy(() => MandateResponseDetails$inboundSchema).optional(),
-  signatureDate: z.nullable(z.string()).optional(),
-  mandateReference: z.nullable(z.string()).optional(),
-  status: MandateStatus$inboundSchema.optional(),
-  customerId: z.string().optional(),
-  createdAt: z.string().optional(),
-  _links: z.lazy(() => MandateResponseLinks$inboundSchema).optional(),
+  resource: z.string(),
+  id: z.string(),
+  mode: Mode$inboundSchema,
+  method: MandateMethodResponse$inboundSchema,
+  details: z.lazy(() => MandateResponseDetails$inboundSchema),
+  signatureDate: z.nullable(z.string()),
+  mandateReference: z.nullable(z.string()),
+  status: MandateStatus$inboundSchema,
+  customerId: z.string(),
+  createdAt: z.string(),
+  _links: z.lazy(() => MandateResponseLinks$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
     "_links": "links",
@@ -265,17 +265,17 @@ export const MandateResponse$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type MandateResponse$Outbound = {
-  resource?: string | undefined;
-  id?: string | undefined;
-  mode?: string | undefined;
-  method?: string | undefined;
-  details?: MandateResponseDetails$Outbound | undefined;
-  signatureDate?: string | null | undefined;
-  mandateReference?: string | null | undefined;
-  status?: string | undefined;
-  customerId?: string | undefined;
-  createdAt?: string | undefined;
-  _links?: MandateResponseLinks$Outbound | undefined;
+  resource: string;
+  id: string;
+  mode: string;
+  method: string;
+  details: MandateResponseDetails$Outbound;
+  signatureDate: string | null;
+  mandateReference: string | null;
+  status: string;
+  customerId: string;
+  createdAt: string;
+  _links: MandateResponseLinks$Outbound;
 };
 
 /** @internal */
@@ -284,17 +284,17 @@ export const MandateResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   MandateResponse
 > = z.object({
-  resource: z.string().optional(),
-  id: z.string().optional(),
-  mode: Mode$outboundSchema.optional(),
-  method: MandateMethodResponse$outboundSchema.optional(),
-  details: z.lazy(() => MandateResponseDetails$outboundSchema).optional(),
-  signatureDate: z.nullable(z.string()).optional(),
-  mandateReference: z.nullable(z.string()).optional(),
-  status: MandateStatus$outboundSchema.optional(),
-  customerId: z.string().optional(),
-  createdAt: z.string().optional(),
-  links: z.lazy(() => MandateResponseLinks$outboundSchema).optional(),
+  resource: z.string(),
+  id: z.string(),
+  mode: Mode$outboundSchema,
+  method: MandateMethodResponse$outboundSchema,
+  details: z.lazy(() => MandateResponseDetails$outboundSchema),
+  signatureDate: z.nullable(z.string()),
+  mandateReference: z.nullable(z.string()),
+  status: MandateStatus$outboundSchema,
+  customerId: z.string(),
+  createdAt: z.string(),
+  links: z.lazy(() => MandateResponseLinks$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
     links: "_links",

package/src/models/mandatestatus.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 /**
  * The status of the mandate. A status can be `pending` for mandates when the first payment is not yet finalized, or
@@ -33,17 +30,10 @@ export const MandateStatus$inboundSchema: z.ZodType<
   MandateStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(MandateStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(MandateStatus);
 /** @internal */
 export const MandateStatus$outboundSchema: z.ZodType<
-  MandateStatus,
+  string,
   z.ZodTypeDef,
   MandateStatus
-> = z.union([
-  z.nativeEnum(MandateStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(MandateStatus);

package/src/models/methodresponse.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 /**
  * Normally, a payment method screen is shown. However, when using this parameter, you can choose a specific payment
@@ -87,17 +84,10 @@ export const MethodResponse$inboundSchema: z.ZodType<
   MethodResponse,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(MethodResponse),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(MethodResponse);
 /** @internal */
 export const MethodResponse$outboundSchema: z.ZodType<
-  MethodResponse,
+  string,
   z.ZodTypeDef,
   MethodResponse
-> = z.union([
-  z.nativeEnum(MethodResponse),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(MethodResponse);

package/src/models/methodstatus.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 /**
  * The payment method's activation status for this profile.
@@ -29,17 +26,10 @@ export const MethodStatus$inboundSchema: z.ZodType<
   MethodStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(MethodStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(MethodStatus);
 /** @internal */
 export const MethodStatus$outboundSchema: z.ZodType<
-  MethodStatus,
+  string,
   z.ZodTypeDef,
   MethodStatus
-> = z.union([
-  z.nativeEnum(MethodStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(MethodStatus);

package/src/models/mode.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 /**
  * Whether this entity was created in live mode or in test mode.
@@ -22,15 +19,8 @@ export const Mode = {
 export type Mode = OpenEnum<typeof Mode>;
 
 /** @internal */
-export const Mode$inboundSchema: z.ZodType<Mode, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(Mode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+export const Mode$inboundSchema: z.ZodType<Mode, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Mode);
 /** @internal */
-export const Mode$outboundSchema: z.ZodType<Mode, z.ZodTypeDef, Mode> = z.union(
-  [
-    z.nativeEnum(Mode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ],
-);
+export const Mode$outboundSchema: z.ZodType<string, z.ZodTypeDef, Mode> =
+  openEnums.outboundSchema(Mode);

package/src/models/onboardingstatus.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 /**
  * The current status of the organization's onboarding process.
@@ -27,17 +24,10 @@ export const OnboardingStatus$inboundSchema: z.ZodType<
   OnboardingStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OnboardingStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OnboardingStatus);
 /** @internal */
 export const OnboardingStatus$outboundSchema: z.ZodType<
-  OnboardingStatus,
+  string,
   z.ZodTypeDef,
   OnboardingStatus
-> = z.union([
-  z.nativeEnum(OnboardingStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OnboardingStatus);

package/src/models/operations/createclientlink.ts

@@ -14,7 +14,7 @@ export type CreateClientLinkRequest = {
    * A unique key to ensure idempotent requests. This key should be a UUID v4 string.
    */
   idempotencyKey?: string | undefined;
-  entityClientLink?: models.EntityClientLink | undefined;
+  clientLinkRequest?: models.ClientLinkRequest | undefined;
 };
 
 /** @internal */
@@ -24,17 +24,17 @@ export const CreateClientLinkRequest$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   "idempotency-key": z.string().optional(),
-  "entity-client-link": models.EntityClientLink$inboundSchema.optional(),
+  "client-link-request": models.ClientLinkRequest$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "idempotency-key": "idempotencyKey",
-    "entity-client-link": "entityClientLink",
+    "client-link-request": "clientLinkRequest",
   });
 });
 /** @internal */
 export type CreateClientLinkRequest$Outbound = {
   "idempotency-key"?: string | undefined;
-  "entity-client-link"?: models.EntityClientLink$Outbound | undefined;
+  "client-link-request"?: models.ClientLinkRequest$Outbound | undefined;
 };
 
 /** @internal */
@@ -44,11 +44,11 @@ export const CreateClientLinkRequest$outboundSchema: z.ZodType<
   CreateClientLinkRequest
 > = z.object({
   idempotencyKey: z.string().optional(),
-  entityClientLink: models.EntityClientLink$outboundSchema.optional(),
+  clientLinkRequest: models.ClientLinkRequest$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     idempotencyKey: "idempotency-key",
-    entityClientLink: "entity-client-link",
+    clientLinkRequest: "client-link-request",
   });
 });
 

package/src/models/operations/createmandate.ts

@@ -18,7 +18,7 @@ export type CreateMandateRequest = {
    * A unique key to ensure idempotent requests. This key should be a UUID v4 string.
    */
   idempotencyKey?: string | undefined;
-  entityMandate?: models.EntityMandate | undefined;
+  mandateRequest?: models.MandateRequest | undefined;
 };
 
 /** @internal */
@@ -29,18 +29,18 @@ export const CreateMandateRequest$inboundSchema: z.ZodType<
 > = z.object({
   customerId: z.string(),
   "idempotency-key": z.string().optional(),
-  "entity-mandate": models.EntityMandate$inboundSchema.optional(),
+  "mandate-request": models.MandateRequest$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "idempotency-key": "idempotencyKey",
-    "entity-mandate": "entityMandate",
+    "mandate-request": "mandateRequest",
   });
 });
 /** @internal */
 export type CreateMandateRequest$Outbound = {
   customerId: string;
   "idempotency-key"?: string | undefined;
-  "entity-mandate"?: models.EntityMandate$Outbound | undefined;
+  "mandate-request"?: models.MandateRequest$Outbound | undefined;
 };
 
 /** @internal */
@@ -51,11 +51,11 @@ export const CreateMandateRequest$outboundSchema: z.ZodType<
 > = z.object({
   customerId: z.string(),
   idempotencyKey: z.string().optional(),
-  entityMandate: models.EntityMandate$outboundSchema.optional(),
+  mandateRequest: models.MandateRequest$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     idempotencyKey: "idempotency-key",
-    entityMandate: "entity-mandate",
+    mandateRequest: "mandate-request",
   });
 });
 

package/src/models/operations/createprofile.ts

@@ -14,7 +14,7 @@ export type CreateProfileRequest = {
    * A unique key to ensure idempotent requests. This key should be a UUID v4 string.
    */
   idempotencyKey?: string | undefined;
-  entityProfile: models.EntityProfile;
+  profileRequest: models.ProfileRequest;
 };
 
 /** @internal */
@@ -24,17 +24,17 @@ export const CreateProfileRequest$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   "idempotency-key": z.string().optional(),
-  "entity-profile": models.EntityProfile$inboundSchema,
+  "profile-request": models.ProfileRequest$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "idempotency-key": "idempotencyKey",
-    "entity-profile": "entityProfile",
+    "profile-request": "profileRequest",
   });
 });
 /** @internal */
 export type CreateProfileRequest$Outbound = {
   "idempotency-key"?: string | undefined;
-  "entity-profile": models.EntityProfile$Outbound;
+  "profile-request": models.ProfileRequest$Outbound;
 };
 
 /** @internal */
@@ -44,11 +44,11 @@ export const CreateProfileRequest$outboundSchema: z.ZodType<
   CreateProfileRequest
 > = z.object({
   idempotencyKey: z.string().optional(),
-  entityProfile: models.EntityProfile$outboundSchema,
+  profileRequest: models.ProfileRequest$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     idempotencyKey: "idempotency-key",
-    entityProfile: "entity-profile",
+    profileRequest: "profile-request",
   });
 });
 

package/src/models/operations/createrefund.ts

@@ -18,7 +18,7 @@ export type CreateRefundRequest = {
    * A unique key to ensure idempotent requests. This key should be a UUID v4 string.
    */
   idempotencyKey?: string | undefined;
-  entityRefund?: models.EntityRefund | undefined;
+  refundRequest?: models.RefundRequest | undefined;
 };
 
 /** @internal */
@@ -29,18 +29,18 @@ export const CreateRefundRequest$inboundSchema: z.ZodType<
 > = z.object({
   paymentId: z.string(),
   "idempotency-key": z.string().optional(),
-  "entity-refund": models.EntityRefund$inboundSchema.optional(),
+  "refund-request": models.RefundRequest$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "idempotency-key": "idempotencyKey",
-    "entity-refund": "entityRefund",
+    "refund-request": "refundRequest",
   });
 });
 /** @internal */
 export type CreateRefundRequest$Outbound = {
   paymentId: string;
   "idempotency-key"?: string | undefined;
-  "entity-refund"?: models.EntityRefund$Outbound | undefined;
+  "refund-request"?: models.RefundRequest$Outbound | undefined;
 };
 
 /** @internal */
@@ -51,11 +51,11 @@ export const CreateRefundRequest$outboundSchema: z.ZodType<
 > = z.object({
   paymentId: z.string(),
   idempotencyKey: z.string().optional(),
-  entityRefund: models.EntityRefund$outboundSchema.optional(),
+  refundRequest: models.RefundRequest$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     idempotencyKey: "idempotency-key",
-    entityRefund: "entity-refund",
+    refundRequest: "refund-request",
   });
 });