@moovio/sdk 26.10.0-dev.1 → 26.10.0-dev.3

package/src/models/errors/updateissuedcarderror.ts

@@ -12,6 +12,7 @@ export type UpdateIssuedCardErrorData = {
   nickname?: string | undefined;
   metadata?: string | undefined;
   billingAddress?: components.AddressError | undefined;
+  controls?: components.UpdateIssuingControlsError | undefined;
 };
 
 export class UpdateIssuedCardError extends MoovError {
@@ -19,6 +20,7 @@ export class UpdateIssuedCardError extends MoovError {
   nickname?: string | undefined;
   metadata?: string | undefined;
   billingAddress?: components.AddressError | undefined;
+  controls?: components.UpdateIssuingControlsError | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: UpdateIssuedCardErrorData;
@@ -36,6 +38,7 @@ export class UpdateIssuedCardError extends MoovError {
     if (err.nickname != null) this.nickname = err.nickname;
     if (err.metadata != null) this.metadata = err.metadata;
     if (err.billingAddress != null) this.billingAddress = err.billingAddress;
+    if (err.controls != null) this.controls = err.controls;
 
     this.name = "UpdateIssuedCardError";
   }
@@ -51,6 +54,7 @@ export const UpdateIssuedCardError$inboundSchema: z.ZodType<
   nickname: types.optional(types.string()),
   metadata: types.optional(types.string()),
   billingAddress: types.optional(components.AddressError$inboundSchema),
+  controls: types.optional(components.UpdateIssuingControlsError$inboundSchema),
   request$: z.instanceof(Request),
   response$: z.instanceof(Response),
   body$: z.string(),
@@ -69,6 +73,7 @@ export type UpdateIssuedCardError$Outbound = {
   nickname?: string | undefined;
   metadata?: string | undefined;
   billingAddress?: components.AddressError$Outbound | undefined;
+  controls?: components.UpdateIssuingControlsError$Outbound | undefined;
 };
 
 /** @internal */
@@ -83,4 +88,5 @@ export const UpdateIssuedCardError$outboundSchema: z.ZodType<
     nickname: z.string().optional(),
     metadata: z.string().optional(),
     billingAddress: components.AddressError$outboundSchema.optional(),
+    controls: components.UpdateIssuingControlsError$outboundSchema.optional(),
   }));

package/src/models/errors/upsertunderwritingerror.ts

@@ -17,6 +17,7 @@ export type UpsertUnderwritingErrorData = {
   collectFunds?: components.CollectFundsError | undefined;
   moneyTransfer?: components.MoneyTransferError | undefined;
   sendFunds?: components.SendFundsError | undefined;
+  cardIssuing?: components.CardIssuingError | undefined;
   averageMonthlyTransactionVolume?: string | undefined;
   error?: string | undefined;
   averageTransactionSize?: string | undefined;
@@ -36,6 +37,7 @@ export class UpsertUnderwritingError extends MoovError {
   collectFunds?: components.CollectFundsError | undefined;
   moneyTransfer?: components.MoneyTransferError | undefined;
   sendFunds?: components.SendFundsError | undefined;
+  cardIssuing?: components.CardIssuingError | undefined;
   averageMonthlyTransactionVolume?: string | undefined;
   error?: string | undefined;
   averageTransactionSize?: string | undefined;
@@ -69,6 +71,7 @@ export class UpsertUnderwritingError extends MoovError {
     if (err.collectFunds != null) this.collectFunds = err.collectFunds;
     if (err.moneyTransfer != null) this.moneyTransfer = err.moneyTransfer;
     if (err.sendFunds != null) this.sendFunds = err.sendFunds;
+    if (err.cardIssuing != null) this.cardIssuing = err.cardIssuing;
     if (err.averageMonthlyTransactionVolume != null) {
       this.averageMonthlyTransactionVolume =
         err.averageMonthlyTransactionVolume;
@@ -107,6 +110,7 @@ export const UpsertUnderwritingError$inboundSchema: z.ZodType<
   collectFunds: types.optional(components.CollectFundsError$inboundSchema),
   moneyTransfer: types.optional(components.MoneyTransferError$inboundSchema),
   sendFunds: types.optional(components.SendFundsError$inboundSchema),
+  cardIssuing: types.optional(components.CardIssuingError$inboundSchema),
   averageMonthlyTransactionVolume: types.optional(types.string()),
   error: types.optional(types.string()),
   averageTransactionSize: types.optional(types.string()),
@@ -141,6 +145,7 @@ export type UpsertUnderwritingError$Outbound = {
   collectFunds?: components.CollectFundsError$Outbound | undefined;
   moneyTransfer?: components.MoneyTransferError$Outbound | undefined;
   sendFunds?: components.SendFundsError$Outbound | undefined;
+  cardIssuing?: components.CardIssuingError$Outbound | undefined;
   averageMonthlyTransactionVolume?: string | undefined;
   error?: string | undefined;
   averageTransactionSize?: string | undefined;
@@ -170,6 +175,7 @@ export const UpsertUnderwritingError$outboundSchema: z.ZodType<
     collectFunds: components.CollectFundsError$outboundSchema.optional(),
     moneyTransfer: components.MoneyTransferError$outboundSchema.optional(),
     sendFunds: components.SendFundsError$outboundSchema.optional(),
+    cardIssuing: components.CardIssuingError$outboundSchema.optional(),
     averageMonthlyTransactionVolume: z.string().optional(),
     error: z.string().optional(),
     averageTransactionSize: z.string().optional(),

package/src/models/operations/createbankaccountattestation.ts

@@ -0,0 +1,136 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 * as types from "../../types/primitives.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CreateBankAccountAttestationRequest = {
+  accountID: string;
+  bankAccountID: string;
+  createBankAccountAttestation: components.CreateBankAccountAttestation;
+};
+
+export type CreateBankAccountAttestationResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.BankAccountAttestation;
+};
+
+/** @internal */
+export const CreateBankAccountAttestationRequest$inboundSchema: z.ZodType<
+  CreateBankAccountAttestationRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  accountID: types.string(),
+  bankAccountID: types.string(),
+  CreateBankAccountAttestation:
+    components.CreateBankAccountAttestation$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "CreateBankAccountAttestation": "createBankAccountAttestation",
+  });
+});
+/** @internal */
+export type CreateBankAccountAttestationRequest$Outbound = {
+  accountID: string;
+  bankAccountID: string;
+  CreateBankAccountAttestation:
+    components.CreateBankAccountAttestation$Outbound;
+};
+
+/** @internal */
+export const CreateBankAccountAttestationRequest$outboundSchema: z.ZodType<
+  CreateBankAccountAttestationRequest$Outbound,
+  z.ZodTypeDef,
+  CreateBankAccountAttestationRequest
+> = z.object({
+  accountID: z.string(),
+  bankAccountID: z.string(),
+  createBankAccountAttestation:
+    components.CreateBankAccountAttestation$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    createBankAccountAttestation: "CreateBankAccountAttestation",
+  });
+});
+
+export function createBankAccountAttestationRequestToJSON(
+  createBankAccountAttestationRequest: CreateBankAccountAttestationRequest,
+): string {
+  return JSON.stringify(
+    CreateBankAccountAttestationRequest$outboundSchema.parse(
+      createBankAccountAttestationRequest,
+    ),
+  );
+}
+export function createBankAccountAttestationRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBankAccountAttestationRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateBankAccountAttestationRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBankAccountAttestationRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateBankAccountAttestationResponse$inboundSchema: z.ZodType<
+  CreateBankAccountAttestationResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.BankAccountAttestation$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+/** @internal */
+export type CreateBankAccountAttestationResponse$Outbound = {
+  Headers: { [k: string]: Array<string> };
+  Result: components.BankAccountAttestation$Outbound;
+};
+
+/** @internal */
+export const CreateBankAccountAttestationResponse$outboundSchema: z.ZodType<
+  CreateBankAccountAttestationResponse$Outbound,
+  z.ZodTypeDef,
+  CreateBankAccountAttestationResponse
+> = z.object({
+  headers: z.record(z.array(z.string())),
+  result: components.BankAccountAttestation$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    headers: "Headers",
+    result: "Result",
+  });
+});
+
+export function createBankAccountAttestationResponseToJSON(
+  createBankAccountAttestationResponse: CreateBankAccountAttestationResponse,
+): string {
+  return JSON.stringify(
+    CreateBankAccountAttestationResponse$outboundSchema.parse(
+      createBankAccountAttestationResponse,
+    ),
+  );
+}
+export function createBankAccountAttestationResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateBankAccountAttestationResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateBankAccountAttestationResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateBankAccountAttestationResponse' from JSON`,
+  );
+}

package/src/models/operations/createcancellation.ts

@@ -19,6 +19,7 @@ export type CreateCancellationRequest = {
    * The transfer ID to cancel.
    */
   transferID: string;
+  createCancellation: components.CreateCancellation;
 };
 
 export type CreateCancellationResponse = {
@@ -34,11 +35,17 @@ export const CreateCancellationRequest$inboundSchema: z.ZodType<
 > = z.object({
   accountID: types.string(),
   transferID: types.string(),
+  CreateCancellation: components.CreateCancellation$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "CreateCancellation": "createCancellation",
+  });
 });
 /** @internal */
 export type CreateCancellationRequest$Outbound = {
   accountID: string;
   transferID: string;
+  CreateCancellation: components.CreateCancellation$Outbound;
 };
 
 /** @internal */
@@ -49,6 +56,11 @@ export const CreateCancellationRequest$outboundSchema: z.ZodType<
 > = z.object({
   accountID: z.string(),
   transferID: z.string(),
+  createCancellation: components.CreateCancellation$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    createCancellation: "CreateCancellation",
+  });
 });
 
 export function createCancellationRequestToJSON(

package/src/models/operations/createcapture.ts

@@ -0,0 +1,142 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 * as types from "../../types/primitives.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CreateCaptureRequest = {
+  /**
+   * Prevents duplicate captures from being created.
+   */
+  xIdempotencyKey: string;
+  /**
+   * Moov account ID of the partner for the transfer.
+   */
+  accountID: string;
+  /**
+   * Identifier for the auth-capture `card-payment` transfer.
+   */
+  transferID: string;
+  createCapture: components.CreateCapture;
+};
+
+export type CreateCaptureResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.Capture;
+};
+
+/** @internal */
+export const CreateCaptureRequest$inboundSchema: z.ZodType<
+  CreateCaptureRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "x-idempotency-key": types.string(),
+  accountID: types.string(),
+  transferID: types.string(),
+  CreateCapture: components.CreateCapture$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "x-idempotency-key": "xIdempotencyKey",
+    "CreateCapture": "createCapture",
+  });
+});
+/** @internal */
+export type CreateCaptureRequest$Outbound = {
+  "x-idempotency-key": string;
+  accountID: string;
+  transferID: string;
+  CreateCapture: components.CreateCapture$Outbound;
+};
+
+/** @internal */
+export const CreateCaptureRequest$outboundSchema: z.ZodType<
+  CreateCaptureRequest$Outbound,
+  z.ZodTypeDef,
+  CreateCaptureRequest
+> = z.object({
+  xIdempotencyKey: z.string(),
+  accountID: z.string(),
+  transferID: z.string(),
+  createCapture: components.CreateCapture$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    xIdempotencyKey: "x-idempotency-key",
+    createCapture: "CreateCapture",
+  });
+});
+
+export function createCaptureRequestToJSON(
+  createCaptureRequest: CreateCaptureRequest,
+): string {
+  return JSON.stringify(
+    CreateCaptureRequest$outboundSchema.parse(createCaptureRequest),
+  );
+}
+export function createCaptureRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateCaptureRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateCaptureRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateCaptureRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateCaptureResponse$inboundSchema: z.ZodType<
+  CreateCaptureResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.Capture$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+/** @internal */
+export type CreateCaptureResponse$Outbound = {
+  Headers: { [k: string]: Array<string> };
+  Result: components.Capture$Outbound;
+};
+
+/** @internal */
+export const CreateCaptureResponse$outboundSchema: z.ZodType<
+  CreateCaptureResponse$Outbound,
+  z.ZodTypeDef,
+  CreateCaptureResponse
+> = z.object({
+  headers: z.record(z.array(z.string())),
+  result: components.Capture$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    headers: "Headers",
+    result: "Result",
+  });
+});
+
+export function createCaptureResponseToJSON(
+  createCaptureResponse: CreateCaptureResponse,
+): string {
+  return JSON.stringify(
+    CreateCaptureResponse$outboundSchema.parse(createCaptureResponse),
+  );
+}
+export function createCaptureResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateCaptureResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateCaptureResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateCaptureResponse' from JSON`,
+  );
+}

package/src/models/operations/createreversal.ts

@@ -23,7 +23,7 @@ export type CreateReversalRequest = {
    * The transfer ID to reverse.
    */
   transferID: string;
-  createReversal?: components.CreateReversal | undefined;
+  createReversal: components.CreateReversal;
 };
 
 export type CreateReversalResponse = {
@@ -40,7 +40,7 @@ export const CreateReversalRequest$inboundSchema: z.ZodType<
   "x-idempotency-key": types.string(),
   accountID: types.string(),
   transferID: types.string(),
-  CreateReversal: types.optional(components.CreateReversal$inboundSchema),
+  CreateReversal: components.CreateReversal$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "x-idempotency-key": "xIdempotencyKey",
@@ -52,7 +52,7 @@ export type CreateReversalRequest$Outbound = {
   "x-idempotency-key": string;
   accountID: string;
   transferID: string;
-  CreateReversal?: components.CreateReversal$Outbound | undefined;
+  CreateReversal: components.CreateReversal$Outbound;
 };
 
 /** @internal */
@@ -64,7 +64,7 @@ export const CreateReversalRequest$outboundSchema: z.ZodType<
   xIdempotencyKey: z.string(),
   accountID: z.string(),
   transferID: z.string(),
-  createReversal: components.CreateReversal$outboundSchema.optional(),
+  createReversal: components.CreateReversal$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     xIdempotencyKey: "x-idempotency-key",

package/src/models/operations/getbankaccountattestationeligibility.ts

@@ -0,0 +1,149 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 * as types from "../../types/primitives.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type GetBankAccountAttestationEligibilityRequest = {
+  accountID: string;
+  bankAccountID: string;
+  /**
+   * Date to check eligibility against, as if it were the `attestedAt` value of a new attestation. Defaults
+   *
+   * @remarks
+   * to the current date.
+   */
+  attestedAt?: Date | undefined;
+};
+
+export type GetBankAccountAttestationEligibilityResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.BankAccountAttestationEligibility;
+};
+
+/** @internal */
+export const GetBankAccountAttestationEligibilityRequest$inboundSchema:
+  z.ZodType<
+    GetBankAccountAttestationEligibilityRequest,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    accountID: types.string(),
+    bankAccountID: types.string(),
+    attestedAt: types.optional(types.date()),
+  });
+/** @internal */
+export type GetBankAccountAttestationEligibilityRequest$Outbound = {
+  accountID: string;
+  bankAccountID: string;
+  attestedAt?: string | undefined;
+};
+
+/** @internal */
+export const GetBankAccountAttestationEligibilityRequest$outboundSchema:
+  z.ZodType<
+    GetBankAccountAttestationEligibilityRequest$Outbound,
+    z.ZodTypeDef,
+    GetBankAccountAttestationEligibilityRequest
+  > = z.object({
+    accountID: z.string(),
+    bankAccountID: z.string(),
+    attestedAt: z.date().transform(v =>
+      v.toISOString().slice(0, "YYYY-MM-DD".length)
+    ).optional(),
+  });
+
+export function getBankAccountAttestationEligibilityRequestToJSON(
+  getBankAccountAttestationEligibilityRequest:
+    GetBankAccountAttestationEligibilityRequest,
+): string {
+  return JSON.stringify(
+    GetBankAccountAttestationEligibilityRequest$outboundSchema.parse(
+      getBankAccountAttestationEligibilityRequest,
+    ),
+  );
+}
+export function getBankAccountAttestationEligibilityRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetBankAccountAttestationEligibilityRequest,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetBankAccountAttestationEligibilityRequest$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetBankAccountAttestationEligibilityRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetBankAccountAttestationEligibilityResponse$inboundSchema:
+  z.ZodType<
+    GetBankAccountAttestationEligibilityResponse,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    Headers: z.record(z.array(z.string())).default({}),
+    Result: components.BankAccountAttestationEligibility$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "Headers": "headers",
+      "Result": "result",
+    });
+  });
+/** @internal */
+export type GetBankAccountAttestationEligibilityResponse$Outbound = {
+  Headers: { [k: string]: Array<string> };
+  Result: components.BankAccountAttestationEligibility$Outbound;
+};
+
+/** @internal */
+export const GetBankAccountAttestationEligibilityResponse$outboundSchema:
+  z.ZodType<
+    GetBankAccountAttestationEligibilityResponse$Outbound,
+    z.ZodTypeDef,
+    GetBankAccountAttestationEligibilityResponse
+  > = z.object({
+    headers: z.record(z.array(z.string())),
+    result: components.BankAccountAttestationEligibility$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      headers: "Headers",
+      result: "Result",
+    });
+  });
+
+export function getBankAccountAttestationEligibilityResponseToJSON(
+  getBankAccountAttestationEligibilityResponse:
+    GetBankAccountAttestationEligibilityResponse,
+): string {
+  return JSON.stringify(
+    GetBankAccountAttestationEligibilityResponse$outboundSchema.parse(
+      getBankAccountAttestationEligibilityResponse,
+    ),
+  );
+}
+export function getBankAccountAttestationEligibilityResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetBankAccountAttestationEligibilityResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetBankAccountAttestationEligibilityResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetBankAccountAttestationEligibilityResponse' from JSON`,
+  );
+}