mollie-api-typescript 0.8.4 → 0.8.5

package/src/models/entitychargeback.ts

@@ -12,12 +12,6 @@ import {
   Amount$Outbound,
   Amount$outboundSchema,
 } from "./amount.js";
-import {
-  AmountNullable,
-  AmountNullable$inboundSchema,
-  AmountNullable$Outbound,
-  AmountNullable$outboundSchema,
-} from "./amountnullable.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
   Url,
@@ -32,6 +26,29 @@ import {
   UrlNullable$outboundSchema,
 } from "./urlnullable.js";
 
+/**
+ * This optional field will contain the approximate amount that will be deducted from your account balance, converted
+ *
+ * @remarks
+ * to the currency your account is settled in.
+ *
+ * The amount is a **negative** amount.
+ *
+ * Since the field contains an estimated amount during chargeback processing, it may change over time. To retrieve
+ * accurate settlement amounts we recommend using the [List balance transactions endpoint](list-balance-transactions)
+ * instead.
+ */
+export type EntityChargebackSettlementAmount = {
+  /**
+   * A three-character ISO 4217 currency code.
+   */
+  currency: string;
+  /**
+   * A string containing an exact monetary amount in the given currency.
+   */
+  value: string;
+};
+
 /**
  * Reason for the chargeback as given by the bank. Only available for chargebacks of SEPA Direct Debit payments.
  */
@@ -76,21 +93,45 @@ export type EntityChargeback = {
    * endpoint.
    */
   resource: string;
+  /**
+   * The identifier uniquely referring to this chargeback. Example: `chb_n9z0tp`.
+   */
   id: string;
   /**
    * In v2 endpoints, monetary amounts are represented as objects with a `currency` and `value` field.
    */
   amount: Amount;
   /**
-   * In v2 endpoints, monetary amounts are represented as objects with a `currency` and `value` field.
+   * This optional field will contain the approximate amount that will be deducted from your account balance, converted
+   *
+   * @remarks
+   * to the currency your account is settled in.
+   *
+   * The amount is a **negative** amount.
+   *
+   * Since the field contains an estimated amount during chargeback processing, it may change over time. To retrieve
+   * accurate settlement amounts we recommend using the [List balance transactions endpoint](list-balance-transactions)
+   * instead.
    */
-  settlementAmount?: AmountNullable | null | undefined;
+  settlementAmount?: EntityChargebackSettlementAmount | null | undefined;
   /**
    * Reason for the chargeback as given by the bank. Only available for chargebacks of SEPA Direct Debit payments.
    */
   reason?: Reason | null | undefined;
+  /**
+   * The unique identifier of the payment this chargeback was created for. For example: `tr_5B8cwPMGnU6qLbRvo7qEZo`.
+   *
+   * @remarks
+   * The full payment object can be retrieved via the payment URL in the `_links` object.
+   */
   paymentId: string;
-  settlementId?: string | undefined;
+  /**
+   * The identifier referring to the settlement this payment was settled with. For example, `stl_BkEjN2eBb`. This field
+   *
+   * @remarks
+   * is omitted if the refund is not settled (yet).
+   */
+  settlementId?: string | null | undefined;
   /**
    * The entity's date and time of creation, in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
    */
@@ -108,6 +149,50 @@ export type EntityChargeback = {
   links: EntityChargebackLinks;
 };
 
+/** @internal */
+export const EntityChargebackSettlementAmount$inboundSchema: z.ZodType<
+  EntityChargebackSettlementAmount,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  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> {
+  return safeParse(
+    jsonString,
+    (x) => EntityChargebackSettlementAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EntityChargebackSettlementAmount' from JSON`,
+  );
+}
+
 /** @internal */
 export const Reason$inboundSchema: z.ZodType<Reason, z.ZodTypeDef, unknown> = z
   .object({
@@ -200,10 +285,12 @@ export const EntityChargeback$inboundSchema: z.ZodType<
   resource: z.string(),
   id: z.string(),
   amount: Amount$inboundSchema,
-  settlementAmount: z.nullable(AmountNullable$inboundSchema).optional(),
+  settlementAmount: z.nullable(
+    z.lazy(() => EntityChargebackSettlementAmount$inboundSchema),
+  ).optional(),
   reason: z.nullable(z.lazy(() => Reason$inboundSchema)).optional(),
   paymentId: z.string(),
-  settlementId: z.string().optional(),
+  settlementId: z.nullable(z.string()).optional(),
   createdAt: z.string(),
   reversedAt: z.nullable(z.string()).optional(),
   _links: z.lazy(() => EntityChargebackLinks$inboundSchema),
@@ -217,10 +304,13 @@ export type EntityChargeback$Outbound = {
   resource: string;
   id: string;
   amount: Amount$Outbound;
-  settlementAmount?: AmountNullable$Outbound | null | undefined;
+  settlementAmount?:
+    | EntityChargebackSettlementAmount$Outbound
+    | null
+    | undefined;
   reason?: Reason$Outbound | null | undefined;
   paymentId: string;
-  settlementId?: string | undefined;
+  settlementId?: string | null | undefined;
   createdAt: string;
   reversedAt?: string | null | undefined;
   _links: EntityChargebackLinks$Outbound;
@@ -235,10 +325,12 @@ export const EntityChargeback$outboundSchema: z.ZodType<
   resource: z.string(),
   id: z.string(),
   amount: Amount$outboundSchema,
-  settlementAmount: z.nullable(AmountNullable$outboundSchema).optional(),
+  settlementAmount: z.nullable(
+    z.lazy(() => EntityChargebackSettlementAmount$outboundSchema),
+  ).optional(),
   reason: z.nullable(z.lazy(() => Reason$outboundSchema)).optional(),
   paymentId: z.string(),
-  settlementId: z.string().optional(),
+  settlementId: z.nullable(z.string()).optional(),
   createdAt: z.string(),
   reversedAt: z.nullable(z.string()).optional(),
   links: z.lazy(() => EntityChargebackLinks$outboundSchema),

package/src/models/entitycustomer.ts

@@ -19,7 +19,6 @@ import {
 } from "./metadata.js";
 
 export type EntityCustomer = {
-  id?: string | undefined;
   /**
    * The full name of the customer.
    */
@@ -57,7 +56,6 @@ export const EntityCustomer$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().optional(),
   name: z.nullable(z.string()).optional(),
   email: z.nullable(z.string()).optional(),
   locale: z.nullable(LocaleResponse$inboundSchema).optional(),
@@ -66,7 +64,6 @@ export const EntityCustomer$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type EntityCustomer$Outbound = {
-  id?: string | undefined;
   name?: string | null | undefined;
   email?: string | null | undefined;
   locale?: string | null | undefined;
@@ -80,7 +77,6 @@ export const EntityCustomer$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EntityCustomer
 > = z.object({
-  id: z.string().optional(),
   name: z.nullable(z.string()).optional(),
   email: z.nullable(z.string()).optional(),
   locale: z.nullable(LocaleResponse$outboundSchema).optional(),

package/src/models/entityinvoice.ts

@@ -5,6 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 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,
@@ -13,11 +15,6 @@ import {
   Amount$outboundSchema,
 } from "./amount.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import {
-  InvoiceStatus,
-  InvoiceStatus$inboundSchema,
-  InvoiceStatus$outboundSchema,
-} from "./invoicestatus.js";
 import {
   Url,
   Url$inboundSchema,
@@ -25,6 +22,65 @@ import {
   Url$outboundSchema,
 } from "./url.js";
 
+/**
+ * Status of the invoice.
+ */
+export const EntityInvoiceStatus = {
+  Open: "open",
+  Paid: "paid",
+  Overdue: "overdue",
+} as const;
+/**
+ * Status of the invoice.
+ */
+export type EntityInvoiceStatus = OpenEnum<typeof EntityInvoiceStatus>;
+
+/**
+ * Total amount of the invoice, excluding VAT.
+ */
+export type NetAmount = {
+  /**
+   * A three-character ISO 4217 currency code.
+   */
+  currency: string;
+  /**
+   * A string containing an exact monetary amount in the given currency.
+   */
+  value: string;
+};
+
+/**
+ * VAT amount of the invoice. Only applicable to merchants registered in the Netherlands. For EU merchants, VAT will
+ *
+ * @remarks
+ * be shifted to the recipient (as per article 44 and 196 in the EU VAT Directive 2006/112). For merchants outside
+ * the EU, no VAT will be charged.
+ */
+export type VatAmount = {
+  /**
+   * A three-character ISO 4217 currency code.
+   */
+  currency: string;
+  /**
+   * A string containing an exact monetary amount in the given currency.
+   */
+  value: string;
+};
+
+/**
+ * Total amount of the invoice, including VAT.
+ */
+export type GrossAmount = {
+  /**
+   * A three-character ISO 4217 currency code.
+   */
+  currency: string;
+  /**
+   * A string containing an exact monetary amount in the given currency.
+   */
+  value: string;
+};
+
 export type EntityInvoiceLine = {
   /**
    * The administrative period in `YYYY-MM` on which the line should be booked.
@@ -83,22 +139,23 @@ export type EntityInvoice = {
    * The VAT number to which the invoice was issued to, if applicable.
    */
   vatNumber: string | null;
+  status: EntityInvoiceStatus;
   /**
-   * Status of the invoice.
-   */
-  status: InvoiceStatus;
-  /**
-   * In v2 endpoints, monetary amounts are represented as objects with a `currency` and `value` field.
+   * Total amount of the invoice, excluding VAT.
    */
-  netAmount: Amount;
+  netAmount: NetAmount;
   /**
-   * In v2 endpoints, monetary amounts are represented as objects with a `currency` and `value` field.
+   * VAT amount of the invoice. Only applicable to merchants registered in the Netherlands. For EU merchants, VAT will
+   *
+   * @remarks
+   * be shifted to the recipient (as per article 44 and 196 in the EU VAT Directive 2006/112). For merchants outside
+   * the EU, no VAT will be charged.
    */
-  vatAmount: Amount;
+  vatAmount: VatAmount;
   /**
-   * In v2 endpoints, monetary amounts are represented as objects with a `currency` and `value` field.
+   * Total amount of the invoice, including VAT.
    */
-  grossAmount: Amount;
+  grossAmount: GrossAmount;
   /**
    * The collection of products which make up the invoice.
    */
@@ -121,6 +178,133 @@ export type EntityInvoice = {
   links: EntityInvoiceLinks;
 };
 
+/** @internal */
+export const EntityInvoiceStatus$inboundSchema: z.ZodType<
+  EntityInvoiceStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(EntityInvoiceStatus);
+/** @internal */
+export const EntityInvoiceStatus$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  EntityInvoiceStatus
+> = openEnums.outboundSchema(EntityInvoiceStatus);
+
+/** @internal */
+export const NetAmount$inboundSchema: z.ZodType<
+  NetAmount,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  currency: z.string(),
+  value: z.string(),
+});
+/** @internal */
+export type NetAmount$Outbound = {
+  currency: string;
+  value: string;
+};
+
+/** @internal */
+export const NetAmount$outboundSchema: z.ZodType<
+  NetAmount$Outbound,
+  z.ZodTypeDef,
+  NetAmount
+> = z.object({
+  currency: z.string(),
+  value: z.string(),
+});
+
+export function netAmountToJSON(netAmount: NetAmount): string {
+  return JSON.stringify(NetAmount$outboundSchema.parse(netAmount));
+}
+export function netAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<NetAmount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NetAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NetAmount' from JSON`,
+  );
+}
+
+/** @internal */
+export const VatAmount$inboundSchema: z.ZodType<
+  VatAmount,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  currency: z.string(),
+  value: z.string(),
+});
+/** @internal */
+export type VatAmount$Outbound = {
+  currency: string;
+  value: string;
+};
+
+/** @internal */
+export const VatAmount$outboundSchema: z.ZodType<
+  VatAmount$Outbound,
+  z.ZodTypeDef,
+  VatAmount
+> = z.object({
+  currency: z.string(),
+  value: z.string(),
+});
+
+export function vatAmountToJSON(vatAmount: VatAmount): string {
+  return JSON.stringify(VatAmount$outboundSchema.parse(vatAmount));
+}
+export function vatAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<VatAmount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VatAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VatAmount' from JSON`,
+  );
+}
+
+/** @internal */
+export const GrossAmount$inboundSchema: z.ZodType<
+  GrossAmount,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  currency: z.string(),
+  value: z.string(),
+});
+/** @internal */
+export type GrossAmount$Outbound = {
+  currency: string;
+  value: string;
+};
+
+/** @internal */
+export const GrossAmount$outboundSchema: z.ZodType<
+  GrossAmount$Outbound,
+  z.ZodTypeDef,
+  GrossAmount
+> = z.object({
+  currency: z.string(),
+  value: z.string(),
+});
+
+export function grossAmountToJSON(grossAmount: GrossAmount): string {
+  return JSON.stringify(GrossAmount$outboundSchema.parse(grossAmount));
+}
+export function grossAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<GrossAmount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GrossAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GrossAmount' from JSON`,
+  );
+}
+
 /** @internal */
 export const EntityInvoiceLine$inboundSchema: z.ZodType<
   EntityInvoiceLine,
@@ -227,10 +411,10 @@ export const EntityInvoice$inboundSchema: z.ZodType<
   id: z.string(),
   reference: z.string(),
   vatNumber: z.nullable(z.string()),
-  status: InvoiceStatus$inboundSchema,
-  netAmount: Amount$inboundSchema,
-  vatAmount: Amount$inboundSchema,
-  grossAmount: Amount$inboundSchema,
+  status: EntityInvoiceStatus$inboundSchema,
+  netAmount: z.lazy(() => NetAmount$inboundSchema),
+  vatAmount: z.lazy(() => VatAmount$inboundSchema),
+  grossAmount: z.lazy(() => GrossAmount$inboundSchema),
   lines: z.array(z.lazy(() => EntityInvoiceLine$inboundSchema)),
   issuedAt: z.string(),
   paidAt: z.nullable(z.string()).optional(),
@@ -248,9 +432,9 @@ export type EntityInvoice$Outbound = {
   reference: string;
   vatNumber: string | null;
   status: string;
-  netAmount: Amount$Outbound;
-  vatAmount: Amount$Outbound;
-  grossAmount: Amount$Outbound;
+  netAmount: NetAmount$Outbound;
+  vatAmount: VatAmount$Outbound;
+  grossAmount: GrossAmount$Outbound;
   lines: Array<EntityInvoiceLine$Outbound>;
   issuedAt: string;
   paidAt?: string | null | undefined;
@@ -268,10 +452,10 @@ export const EntityInvoice$outboundSchema: z.ZodType<
   id: z.string(),
   reference: z.string(),
   vatNumber: z.nullable(z.string()),
-  status: InvoiceStatus$outboundSchema,
-  netAmount: Amount$outboundSchema,
-  vatAmount: Amount$outboundSchema,
-  grossAmount: Amount$outboundSchema,
+  status: EntityInvoiceStatus$outboundSchema,
+  netAmount: z.lazy(() => NetAmount$outboundSchema),
+  vatAmount: z.lazy(() => VatAmount$outboundSchema),
+  grossAmount: z.lazy(() => GrossAmount$outboundSchema),
   lines: z.array(z.lazy(() => EntityInvoiceLine$outboundSchema)),
   issuedAt: z.string(),
   paidAt: z.nullable(z.string()).optional(),