mollie-api-typescript 1.3.7 → 1.4.0

package/src/models/subscriptionrequest.ts

@@ -4,24 +4,14 @@
  */
 
 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 {
   Metadata,
-  Metadata$inboundSchema,
   Metadata$Outbound,
   Metadata$outboundSchema,
 } from "./metadata.js";
 import {
   SubscriptionMethod,
-  SubscriptionMethod$inboundSchema,
   SubscriptionMethod$outboundSchema,
 } from "./subscriptionmethod.js";
 
@@ -127,15 +117,6 @@ export type SubscriptionRequest = {
   testmode?: boolean | null | undefined;
 };
 
-/** @internal */
-export const SubscriptionRequestApplicationFee$inboundSchema: z.ZodType<
-  SubscriptionRequestApplicationFee,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  amount: Amount$inboundSchema,
-  description: z.string(),
-});
 /** @internal */
 export type SubscriptionRequestApplicationFee$Outbound = {
   amount: Amount$Outbound;
@@ -161,36 +142,7 @@ export function subscriptionRequestApplicationFeeToJSON(
     ),
   );
 }
-export function subscriptionRequestApplicationFeeFromJSON(
-  jsonString: string,
-): SafeParseResult<SubscriptionRequestApplicationFee, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SubscriptionRequestApplicationFee$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SubscriptionRequestApplicationFee' from JSON`,
-  );
-}
 
-/** @internal */
-export const SubscriptionRequest$inboundSchema: z.ZodType<
-  SubscriptionRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  amount: Amount$inboundSchema.optional(),
-  times: z.nullable(z.number().int()).optional(),
-  interval: z.string().optional(),
-  startDate: z.string().optional(),
-  description: z.string().optional(),
-  method: z.nullable(SubscriptionMethod$inboundSchema).optional(),
-  applicationFee: z.lazy(() => SubscriptionRequestApplicationFee$inboundSchema)
-    .optional(),
-  metadata: z.nullable(Metadata$inboundSchema).optional(),
-  webhookUrl: z.nullable(z.string()).optional(),
-  mandateId: z.string().optional(),
-  profileId: z.string().optional(),
-  testmode: z.nullable(z.boolean()).optional(),
-});
 /** @internal */
 export type SubscriptionRequest$Outbound = {
   amount?: Amount$Outbound | undefined;
@@ -235,12 +187,3 @@ export function subscriptionRequestToJSON(
     SubscriptionRequest$outboundSchema.parse(subscriptionRequest),
   );
 }
-export function subscriptionRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<SubscriptionRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SubscriptionRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SubscriptionRequest' from JSON`,
-  );
-}

package/src/models/subscriptionresponse.ts

@@ -9,37 +9,16 @@ 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 {
-  Metadata,
-  Metadata$inboundSchema,
-  Metadata$Outbound,
-  Metadata$outboundSchema,
-} from "./metadata.js";
-import { Mode, Mode$inboundSchema, Mode$outboundSchema } from "./mode.js";
+import { Metadata, Metadata$inboundSchema } from "./metadata.js";
+import { Mode, Mode$inboundSchema } from "./mode.js";
 import {
   SubscriptionMethodResponse,
   SubscriptionMethodResponse$inboundSchema,
-  SubscriptionMethodResponse$outboundSchema,
 } from "./subscriptionmethodresponse.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";
 
 /**
  * The subscription's current status is directly related to the status of the underlying customer or mandate that is
@@ -237,12 +216,6 @@ export const SubscriptionResponseStatus$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(SubscriptionResponseStatus);
-/** @internal */
-export const SubscriptionResponseStatus$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  SubscriptionResponseStatus
-> = openEnums.outboundSchema(SubscriptionResponseStatus);
 
 /** @internal */
 export const SubscriptionResponseApplicationFee$inboundSchema: z.ZodType<
@@ -253,31 +226,7 @@ export const SubscriptionResponseApplicationFee$inboundSchema: z.ZodType<
   amount: Amount$inboundSchema,
   description: z.string(),
 });
-/** @internal */
-export type SubscriptionResponseApplicationFee$Outbound = {
-  amount: Amount$Outbound;
-  description: string;
-};
-
-/** @internal */
-export const SubscriptionResponseApplicationFee$outboundSchema: z.ZodType<
-  SubscriptionResponseApplicationFee$Outbound,
-  z.ZodTypeDef,
-  SubscriptionResponseApplicationFee
-> = z.object({
-  amount: Amount$outboundSchema,
-  description: z.string(),
-});
 
-export function subscriptionResponseApplicationFeeToJSON(
-  subscriptionResponseApplicationFee: SubscriptionResponseApplicationFee,
-): string {
-  return JSON.stringify(
-    SubscriptionResponseApplicationFee$outboundSchema.parse(
-      subscriptionResponseApplicationFee,
-    ),
-  );
-}
 export function subscriptionResponseApplicationFeeFromJSON(
   jsonString: string,
 ): SafeParseResult<SubscriptionResponseApplicationFee, SDKValidationError> {
@@ -302,37 +251,7 @@ export const SubscriptionResponseLinks$inboundSchema: z.ZodType<
   payments: z.nullable(UrlNullable$inboundSchema).optional(),
   documentation: Url$inboundSchema,
 });
-/** @internal */
-export type SubscriptionResponseLinks$Outbound = {
-  self: Url$Outbound;
-  customer: UrlNullable$Outbound | null;
-  mandate?: UrlNullable$Outbound | null | undefined;
-  profile: UrlNullable$Outbound | null;
-  payments?: UrlNullable$Outbound | null | undefined;
-  documentation: Url$Outbound;
-};
-
-/** @internal */
-export const SubscriptionResponseLinks$outboundSchema: z.ZodType<
-  SubscriptionResponseLinks$Outbound,
-  z.ZodTypeDef,
-  SubscriptionResponseLinks
-> = z.object({
-  self: Url$outboundSchema,
-  customer: z.nullable(UrlNullable$outboundSchema),
-  mandate: z.nullable(UrlNullable$outboundSchema).optional(),
-  profile: z.nullable(UrlNullable$outboundSchema),
-  payments: z.nullable(UrlNullable$outboundSchema).optional(),
-  documentation: Url$outboundSchema,
-});
 
-export function subscriptionResponseLinksToJSON(
-  subscriptionResponseLinks: SubscriptionResponseLinks,
-): string {
-  return JSON.stringify(
-    SubscriptionResponseLinks$outboundSchema.parse(subscriptionResponseLinks),
-  );
-}
 export function subscriptionResponseLinksFromJSON(
   jsonString: string,
 ): SafeParseResult<SubscriptionResponseLinks, SDKValidationError> {
@@ -375,71 +294,7 @@ export const SubscriptionResponse$inboundSchema: z.ZodType<
     "_links": "links",
   });
 });
-/** @internal */
-export type SubscriptionResponse$Outbound = {
-  resource: string;
-  id: string;
-  mode: string;
-  status: string;
-  amount: Amount$Outbound;
-  times: number | null;
-  timesRemaining: number | null;
-  interval: string;
-  startDate: string;
-  nextPaymentDate?: string | null | undefined;
-  description: string;
-  method: string | null;
-  applicationFee?: SubscriptionResponseApplicationFee$Outbound | undefined;
-  metadata: Metadata$Outbound | null;
-  webhookUrl: string | null;
-  customerId: string;
-  mandateId?: string | undefined;
-  createdAt: string;
-  canceledAt?: string | null | undefined;
-  _links: SubscriptionResponseLinks$Outbound;
-};
-
-/** @internal */
-export const SubscriptionResponse$outboundSchema: z.ZodType<
-  SubscriptionResponse$Outbound,
-  z.ZodTypeDef,
-  SubscriptionResponse
-> = z.object({
-  resource: z.string(),
-  id: z.string(),
-  mode: Mode$outboundSchema,
-  status: SubscriptionResponseStatus$outboundSchema,
-  amount: Amount$outboundSchema,
-  times: z.nullable(z.number().int()),
-  timesRemaining: z.nullable(z.number().int()),
-  interval: z.string(),
-  startDate: z.string(),
-  nextPaymentDate: z.nullable(z.string()).optional(),
-  description: z.string(),
-  method: z.nullable(SubscriptionMethodResponse$outboundSchema),
-  applicationFee: z.lazy(() =>
-    SubscriptionResponseApplicationFee$outboundSchema
-  ).optional(),
-  metadata: z.nullable(Metadata$outboundSchema),
-  webhookUrl: z.nullable(z.string()),
-  customerId: z.string(),
-  mandateId: z.string().optional(),
-  createdAt: z.string(),
-  canceledAt: z.nullable(z.string()).optional(),
-  links: z.lazy(() => SubscriptionResponseLinks$outboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    links: "_links",
-  });
-});
 
-export function subscriptionResponseToJSON(
-  subscriptionResponse: SubscriptionResponse,
-): string {
-  return JSON.stringify(
-    SubscriptionResponse$outboundSchema.parse(subscriptionResponse),
-  );
-}
 export function subscriptionResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<SubscriptionResponse, SDKValidationError> {

package/src/models/subtotals.ts

@@ -9,39 +9,29 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import {
   BalanceCardAudience,
   BalanceCardAudience$inboundSchema,
-  BalanceCardAudience$outboundSchema,
 } from "./balancecardaudience.js";
 import {
   BalanceCardIssuer,
   BalanceCardIssuer$inboundSchema,
-  BalanceCardIssuer$outboundSchema,
 } from "./balancecardissuer.js";
 import {
   BalanceCardRegion,
   BalanceCardRegion$inboundSchema,
-  BalanceCardRegion$outboundSchema,
 } from "./balancecardregion.js";
 import {
   BalanceFeeType,
   BalanceFeeType$inboundSchema,
-  BalanceFeeType$outboundSchema,
 } from "./balancefeetype.js";
 import {
   BalancePrepaymentPartType,
   BalancePrepaymentPartType$inboundSchema,
-  BalancePrepaymentPartType$outboundSchema,
 } from "./balanceprepaymentparttype.js";
 import {
   BalanceTransactionType,
   BalanceTransactionType$inboundSchema,
-  BalanceTransactionType$outboundSchema,
 } from "./balancetransactiontype.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import {
-  PaymentMethod,
-  PaymentMethod$inboundSchema,
-  PaymentMethod$outboundSchema,
-} from "./paymentmethod.js";
+import { PaymentMethod, PaymentMethod$inboundSchema } from "./paymentmethod.js";
 
 export type SubTotals = {
   /**
@@ -75,37 +65,7 @@ export const SubTotals$inboundSchema: z.ZodType<
   prepaymentPartType: BalancePrepaymentPartType$inboundSchema.optional(),
   transactionType: BalanceTransactionType$inboundSchema.optional(),
 });
-/** @internal */
-export type SubTotals$Outbound = {
-  count?: number | undefined;
-  method?: string | null | undefined;
-  cardIssuer?: string | undefined;
-  cardAudience?: string | undefined;
-  cardRegion?: string | undefined;
-  feeType?: string | undefined;
-  prepaymentPartType?: string | undefined;
-  transactionType?: string | undefined;
-};
 
-/** @internal */
-export const SubTotals$outboundSchema: z.ZodType<
-  SubTotals$Outbound,
-  z.ZodTypeDef,
-  SubTotals
-> = z.object({
-  count: z.number().int().optional(),
-  method: z.nullable(PaymentMethod$outboundSchema).optional(),
-  cardIssuer: BalanceCardIssuer$outboundSchema.optional(),
-  cardAudience: BalanceCardAudience$outboundSchema.optional(),
-  cardRegion: BalanceCardRegion$outboundSchema.optional(),
-  feeType: BalanceFeeType$outboundSchema.optional(),
-  prepaymentPartType: BalancePrepaymentPartType$outboundSchema.optional(),
-  transactionType: BalanceTransactionType$outboundSchema.optional(),
-});
-
-export function subTotalsToJSON(subTotals: SubTotals): string {
-  return JSON.stringify(SubTotals$outboundSchema.parse(subTotals));
-}
 export function subTotalsFromJSON(
   jsonString: string,
 ): SafeParseResult<SubTotals, SDKValidationError> {

package/src/models/terminalbrand.ts

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

package/src/models/terminalmodel.ts

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

package/src/models/transactionresponse.ts

@@ -6,35 +6,18 @@
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import {
-  AfterBalance,
-  AfterBalance$inboundSchema,
-  AfterBalance$Outbound,
-  AfterBalance$outboundSchema,
-} from "./afterbalance.js";
-import {
-  Amount,
-  Amount$inboundSchema,
-  Amount$Outbound,
-  Amount$outboundSchema,
-} from "./amount.js";
-import {
-  Counterparty,
-  Counterparty$inboundSchema,
-  Counterparty$Outbound,
-  Counterparty$outboundSchema,
-} from "./counterparty.js";
+import { AfterBalance, AfterBalance$inboundSchema } from "./afterbalance.js";
+import { Amount, Amount$inboundSchema } from "./amount.js";
+import { Counterparty, Counterparty$inboundSchema } from "./counterparty.js";
 import {
   CreditDebitIndicator,
   CreditDebitIndicator$inboundSchema,
-  CreditDebitIndicator$outboundSchema,
 } from "./creditdebitindicator.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Mode, Mode$inboundSchema, Mode$outboundSchema } from "./mode.js";
+import { Mode, Mode$inboundSchema } from "./mode.js";
 import {
   TransactionType,
   TransactionType$inboundSchema,
-  TransactionType$outboundSchema,
 } from "./transactiontype.js";
 
 export type TransactionResponse = {
@@ -118,49 +101,7 @@ export const TransactionResponse$inboundSchema: z.ZodType<
   mode: Mode$inboundSchema,
   createdAt: z.string(),
 });
-/** @internal */
-export type TransactionResponse$Outbound = {
-  resource: string;
-  id: string;
-  businessAccountId: string;
-  creditDebitIndicator: string;
-  type: string;
-  amount: Amount$Outbound;
-  description?: string | null | undefined;
-  counterparty?: Counterparty$Outbound | undefined;
-  afterBalance?: AfterBalance$Outbound | undefined;
-  processedAt?: string | null | undefined;
-  mode: string;
-  createdAt: string;
-};
-
-/** @internal */
-export const TransactionResponse$outboundSchema: z.ZodType<
-  TransactionResponse$Outbound,
-  z.ZodTypeDef,
-  TransactionResponse
-> = z.object({
-  resource: z.string(),
-  id: z.string(),
-  businessAccountId: z.string(),
-  creditDebitIndicator: CreditDebitIndicator$outboundSchema,
-  type: TransactionType$outboundSchema,
-  amount: Amount$outboundSchema,
-  description: z.nullable(z.string()).optional(),
-  counterparty: Counterparty$outboundSchema.optional(),
-  afterBalance: AfterBalance$outboundSchema.optional(),
-  processedAt: z.nullable(z.string()).optional(),
-  mode: Mode$outboundSchema,
-  createdAt: z.string(),
-});
 
-export function transactionResponseToJSON(
-  transactionResponse: TransactionResponse,
-): string {
-  return JSON.stringify(
-    TransactionResponse$outboundSchema.parse(transactionResponse),
-  );
-}
 export function transactionResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<TransactionResponse, SDKValidationError> {

package/src/models/transactiontype.ts

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

package/src/models/transferrequest.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 {
   Metadata,
-  Metadata$inboundSchema,
   Metadata$Outbound,
   Metadata$outboundSchema,
 } from "./metadata.js";
 import {
   TransferParty,
-  TransferParty$inboundSchema,
   TransferParty$Outbound,
   TransferParty$outboundSchema,
 } from "./transferparty.js";
 import {
   TransferScheme,
-  TransferScheme$inboundSchema,
   TransferScheme$Outbound,
   TransferScheme$outboundSchema,
 } from "./transferscheme.js";
@@ -84,20 +73,6 @@ export type TransferRequest = {
   testmode?: boolean | null | undefined;
 };
 
-/** @internal */
-export const TransferRequest$inboundSchema: z.ZodType<
-  TransferRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  debtorIban: z.string(),
-  creditor: TransferParty$inboundSchema,
-  amount: Amount$inboundSchema,
-  description: z.nullable(z.string()).optional(),
-  transferScheme: TransferScheme$inboundSchema,
-  metadata: z.nullable(Metadata$inboundSchema).optional(),
-  testmode: z.nullable(z.boolean()).optional(),
-});
 /** @internal */
 export type TransferRequest$Outbound = {
   debtorIban: string;
@@ -129,12 +104,3 @@ export function transferRequestToJSON(
 ): string {
   return JSON.stringify(TransferRequest$outboundSchema.parse(transferRequest));
 }
-export function transferRequestFromJSON(
-  jsonString: string,
-): SafeParseResult<TransferRequest, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => TransferRequest$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'TransferRequest' from JSON`,
-  );
-}