@moovio/sdk 26.2.0 → 26.2.1

package/src/lib/encodings.ts

@@ -479,6 +479,23 @@ export const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
 export const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
 export const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
 
+function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const tag = val[Symbol.toStringTag];
+  if (tag !== "Blob" && tag !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}
+
 export function appendForm(
   fd: FormData,
   key: string,
@@ -487,11 +504,22 @@ export function appendForm(
 ): void {
   if (value == null) {
     return;
-  } else if (value instanceof Blob && fileName) {
-    fd.append(key, value, fileName);
-  } else if (value instanceof Blob) {
-    fd.append(key, value);
+  } else if (isBlobLike(value)) {
+    if (fileName) {
+      fd.append(key, value as Blob, fileName);
+    } else {
+      fd.append(key, value as Blob);
+    }
   } else {
     fd.append(key, String(value));
   }
 }
+
+export async function normalizeBlob(
+  value: Pick<Blob, "arrayBuffer" | "type">,
+): Promise<Blob> {
+  if (value instanceof Blob) {
+    return value;
+  }
+  return new Blob([await value.arrayBuffer()], { type: value.type });
+}

package/src/lib/security.ts

@@ -239,15 +239,27 @@ function applyBearer(
 
 export function resolveGlobalSecurity(
   security: Partial<components.Security> | null | undefined,
+  allowedFields?: number[],
 ): SecurityState | null {
-  return resolveSecurity(
+  let inputs: SecurityInput[][] = [
     [
       {
         type: "http:basic",
         value: { username: security?.username, password: security?.password },
       },
     ],
-  );
+  ];
+
+  if (allowedFields) {
+    inputs = allowedFields.map((i) => {
+      if (i < 0 || i >= inputs.length) {
+        throw new RangeError(`invalid allowedFields index ${i}`);
+      }
+      return inputs[i]!;
+    });
+  }
+
+  return resolveSecurity(...inputs);
 }
 
 export async function extractSecurity<

package/src/mcp-server/mcp-server.ts

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "26.2.0",
+    currentVersion: "26.2.1",
   },
 });
 

package/src/mcp-server/server.ts

@@ -156,6 +156,7 @@ import { tool$terminalApplicationsCreateVersion } from "./tools/terminalApplicat
 import { tool$terminalApplicationsDelete } from "./tools/terminalApplicationsDelete.js";
 import { tool$terminalApplicationsGet } from "./tools/terminalApplicationsGet.js";
 import { tool$terminalApplicationsList } from "./tools/terminalApplicationsList.js";
+import { tool$transfersBatchGetTransfers } from "./tools/transfersBatchGetTransfers.js";
 import { tool$transfersCreate } from "./tools/transfersCreate.js";
 import { tool$transfersCreateCancellation } from "./tools/transfersCreateCancellation.js";
 import { tool$transfersCreateReversal } from "./tools/transfersCreateReversal.js";
@@ -195,7 +196,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "Moov",
-    version: "26.2.0",
+    version: "26.2.1",
   });
 
   const client = new MoovCore({
@@ -339,6 +340,7 @@ export function createMCPServer(deps: {
   tool(tool$transfersGenerateOptions);
   tool(tool$transfersCreate);
   tool(tool$transfersList);
+  tool(tool$transfersBatchGetTransfers);
   tool(tool$transfersGet);
   tool(tool$transfersUpdate);
   tool(tool$transfersCreateCancellation);

package/src/mcp-server/tools/applePayLinkToken.ts

@@ -12,12 +12,12 @@ const args = {
 
 export const tool$applePayLinkToken: ToolDefinition<typeof args> = {
   name: "apple-pay-link-token",
-  description: `Connect an Apple Pay token to the specified account. 
+  description: `Connect an Apple Pay token to the specified account.
 
-Read our [Apple Pay tutorial](https://docs.moov.io/guides/sources/cards/apple-pay/#register-your-domains) to learn more. 
+Read our [Apple Pay tutorial](https://docs.moov.io/guides/sources/cards/apple-pay/#register-your-domains) to learn more.
 The \`token\` data is defined by Apple Pay and should be passed through from Apple Pay's response unmodified.
 
-To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/)
 you'll need to specify the \`/accounts/{accountID}/cards.write\` scope.`,
   args,
   tool: async (client, args, ctx) => {

package/src/mcp-server/tools/cardIssuingUpdate.ts

@@ -31,6 +31,8 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.write\` scope.`,
       };
     }
 
-    return formatResult(void 0, apiCall);
+    const value = result.value.result;
+
+    return formatResult(value, apiCall);
   },
 };

package/src/mcp-server/tools/transfersBatchGetTransfers.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { transfersBatchGetTransfers } from "../../funcs/transfersBatchGetTransfers.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.BatchGetTransfersRequest$inboundSchema,
+};
+
+export const tool$transfersBatchGetTransfers: ToolDefinition<typeof args> = {
+  name: "transfers-batch-get-transfers",
+  description:
+    `Retrieve transfer details for multiple transfers in one request. The response is a map from each
+requested transfer ID to its full transfer details when available; IDs that are not found or not
+accessible under this account are omitted from the map.
+
+Read our [transfers overview guide](https://docs.moov.io/guides/money-movement/overview/) to learn more.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/)
+you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await transfersBatchGetTransfers(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value.result;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/models/components/batchgettransfersrequest.ts

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Array of transfer IDs to fetch.
+ */
+export type BatchGetTransfersRequest = {
+  transferIDs: Array<string>;
+};
+
+/** @internal */
+export const BatchGetTransfersRequest$inboundSchema: z.ZodType<
+  BatchGetTransfersRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  transferIDs: z.array(z.string()),
+});
+/** @internal */
+export type BatchGetTransfersRequest$Outbound = {
+  transferIDs: Array<string>;
+};
+
+/** @internal */
+export const BatchGetTransfersRequest$outboundSchema: z.ZodType<
+  BatchGetTransfersRequest$Outbound,
+  z.ZodTypeDef,
+  BatchGetTransfersRequest
+> = z.object({
+  transferIDs: z.array(z.string()),
+});
+
+export function batchGetTransfersRequestToJSON(
+  batchGetTransfersRequest: BatchGetTransfersRequest,
+): string {
+  return JSON.stringify(
+    BatchGetTransfersRequest$outboundSchema.parse(batchGetTransfersRequest),
+  );
+}
+export function batchGetTransfersRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<BatchGetTransfersRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BatchGetTransfersRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BatchGetTransfersRequest' from JSON`,
+  );
+}

package/src/models/components/index.ts

@@ -68,6 +68,7 @@ export * from "./bankaccountverificationmethod.js";
 export * from "./bankaccountverificationstatus.js";
 export * from "./bankaccountwaitfor.js";
 export * from "./basicpaymentmethod.js";
+export * from "./batchgettransfersrequest.js";
 export * from "./billablefee.js";
 export * from "./billingcountandamount.js";
 export * from "./billinginterchangeprogramfee.js";
@@ -259,6 +260,10 @@ export * from "./industrycodes.js";
 export * from "./industrytaxonomy.js";
 export * from "./instantbankcreditpaymentmethod.js";
 export * from "./instantbankcredittransferpaymentmethod.js";
+export * from "./instantbankfailurecode.js";
+export * from "./instantbanknetwork.js";
+export * from "./instantbanktransactiondetails.js";
+export * from "./instantbanktransactionstatus.js";
 export * from "./instantpaymentfees.js";
 export * from "./institutionssearchresponse.js";
 export * from "./invoicestatus.js";

package/src/models/components/instantbankfailurecode.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Status codes for instant-bank failures.
+ */
+export const InstantBankFailureCode = {
+  ProcessingError: "processing-error",
+  InvalidAccount: "invalid-account",
+  AccountClosed: "account-closed",
+  AccountBlocked: "account-blocked",
+  InvalidField: "invalid-field",
+  TransactionNotSupported: "transaction-not-supported",
+  LimitExceeded: "limit-exceeded",
+  InvalidAmount: "invalid-amount",
+  CustomerDeceased: "customer-deceased",
+  ParticipantNotAvailable: "participant-not-available",
+  Other: "other",
+} as const;
+/**
+ * Status codes for instant-bank failures.
+ */
+export type InstantBankFailureCode = ClosedEnum<typeof InstantBankFailureCode>;
+
+/** @internal */
+export const InstantBankFailureCode$inboundSchema: z.ZodNativeEnum<
+  typeof InstantBankFailureCode
+> = z.nativeEnum(InstantBankFailureCode);
+/** @internal */
+export const InstantBankFailureCode$outboundSchema: z.ZodNativeEnum<
+  typeof InstantBankFailureCode
+> = InstantBankFailureCode$inboundSchema;

package/src/models/components/instantbanknetwork.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * The network that the transaction was processed on.
+ */
+export const InstantBankNetwork = {
+  Fednow: "fednow",
+  Rtp: "rtp",
+} as const;
+/**
+ * The network that the transaction was processed on.
+ */
+export type InstantBankNetwork = ClosedEnum<typeof InstantBankNetwork>;
+
+/** @internal */
+export const InstantBankNetwork$inboundSchema: z.ZodNativeEnum<
+  typeof InstantBankNetwork
+> = z.nativeEnum(InstantBankNetwork);
+/** @internal */
+export const InstantBankNetwork$outboundSchema: z.ZodNativeEnum<
+  typeof InstantBankNetwork
+> = InstantBankNetwork$inboundSchema;

package/src/models/components/instantbanktransactiondetails.ts

@@ -0,0 +1,120 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  InstantBankFailureCode,
+  InstantBankFailureCode$inboundSchema,
+  InstantBankFailureCode$outboundSchema,
+} from "./instantbankfailurecode.js";
+import {
+  InstantBankNetwork,
+  InstantBankNetwork$inboundSchema,
+  InstantBankNetwork$outboundSchema,
+} from "./instantbanknetwork.js";
+import {
+  InstantBankTransactionStatus,
+  InstantBankTransactionStatus$inboundSchema,
+  InstantBankTransactionStatus$outboundSchema,
+} from "./instantbanktransactionstatus.js";
+
+/**
+ * Instant-bank specific details about the transaction.
+ */
+export type InstantBankTransactionDetails = {
+  /**
+   * The network that the transaction was processed on.
+   */
+  network: InstantBankNetwork;
+  /**
+   * Status of a transaction within the instant-bank lifecycle.
+   */
+  status: InstantBankTransactionStatus;
+  /**
+   * Response code returned by network on failure.
+   */
+  networkResponseCode?: string | undefined;
+  /**
+   * Status codes for instant-bank failures.
+   */
+  failureCode?: InstantBankFailureCode | undefined;
+  endToEndID?: string | undefined;
+  initiatedOn?: Date | undefined;
+  completedOn?: Date | undefined;
+  failedOn?: Date | undefined;
+  acceptedWithoutPostingOn?: Date | undefined;
+};
+
+/** @internal */
+export const InstantBankTransactionDetails$inboundSchema: z.ZodType<
+  InstantBankTransactionDetails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  network: InstantBankNetwork$inboundSchema,
+  status: InstantBankTransactionStatus$inboundSchema,
+  networkResponseCode: z.string().optional(),
+  failureCode: InstantBankFailureCode$inboundSchema.optional(),
+  endToEndID: z.string().optional(),
+  initiatedOn: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  completedOn: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  failedOn: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  acceptedWithoutPostingOn: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ).optional(),
+});
+/** @internal */
+export type InstantBankTransactionDetails$Outbound = {
+  network: string;
+  status: string;
+  networkResponseCode?: string | undefined;
+  failureCode?: string | undefined;
+  endToEndID?: string | undefined;
+  initiatedOn?: string | undefined;
+  completedOn?: string | undefined;
+  failedOn?: string | undefined;
+  acceptedWithoutPostingOn?: string | undefined;
+};
+
+/** @internal */
+export const InstantBankTransactionDetails$outboundSchema: z.ZodType<
+  InstantBankTransactionDetails$Outbound,
+  z.ZodTypeDef,
+  InstantBankTransactionDetails
+> = z.object({
+  network: InstantBankNetwork$outboundSchema,
+  status: InstantBankTransactionStatus$outboundSchema,
+  networkResponseCode: z.string().optional(),
+  failureCode: InstantBankFailureCode$outboundSchema.optional(),
+  endToEndID: z.string().optional(),
+  initiatedOn: z.date().transform(v => v.toISOString()).optional(),
+  completedOn: z.date().transform(v => v.toISOString()).optional(),
+  failedOn: z.date().transform(v => v.toISOString()).optional(),
+  acceptedWithoutPostingOn: z.date().transform(v => v.toISOString()).optional(),
+});
+
+export function instantBankTransactionDetailsToJSON(
+  instantBankTransactionDetails: InstantBankTransactionDetails,
+): string {
+  return JSON.stringify(
+    InstantBankTransactionDetails$outboundSchema.parse(
+      instantBankTransactionDetails,
+    ),
+  );
+}
+export function instantBankTransactionDetailsFromJSON(
+  jsonString: string,
+): SafeParseResult<InstantBankTransactionDetails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InstantBankTransactionDetails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InstantBankTransactionDetails' from JSON`,
+  );
+}

package/src/models/components/instantbanktransactionstatus.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Status of a transaction within the instant-bank lifecycle.
+ */
+export const InstantBankTransactionStatus = {
+  Initiated: "initiated",
+  Completed: "completed",
+  Failed: "failed",
+  AcceptedWithoutPosting: "accepted-without-posting",
+} as const;
+/**
+ * Status of a transaction within the instant-bank lifecycle.
+ */
+export type InstantBankTransactionStatus = ClosedEnum<
+  typeof InstantBankTransactionStatus
+>;
+
+/** @internal */
+export const InstantBankTransactionStatus$inboundSchema: z.ZodNativeEnum<
+  typeof InstantBankTransactionStatus
+> = z.nativeEnum(InstantBankTransactionStatus);
+/** @internal */
+export const InstantBankTransactionStatus$outboundSchema: z.ZodNativeEnum<
+  typeof InstantBankTransactionStatus
+> = InstantBankTransactionStatus$inboundSchema;

package/src/models/components/transferdestination.ts

@@ -24,6 +24,12 @@ import {
   CardTransactionDetails$Outbound,
   CardTransactionDetails$outboundSchema,
 } from "./cardtransactiondetails.js";
+import {
+  InstantBankTransactionDetails,
+  InstantBankTransactionDetails$inboundSchema,
+  InstantBankTransactionDetails$Outbound,
+  InstantBankTransactionDetails$outboundSchema,
+} from "./instantbanktransactiondetails.js";
 import {
   RTPFailureCode,
   RTPFailureCode$inboundSchema,
@@ -120,6 +126,10 @@ export type TransferDestination = {
    * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
    */
   rtpDetails?: RtpDetails | undefined;
+  /**
+   * Instant-bank specific details about the transaction.
+   */
+  instantBankDetails?: InstantBankTransactionDetails | undefined;
 };
 
 /** @internal */
@@ -196,6 +206,7 @@ export const TransferDestination$inboundSchema: z.ZodType<
   applePay: ApplePayResponse$inboundSchema.optional(),
   cardDetails: CardTransactionDetails$inboundSchema.optional(),
   rtpDetails: z.lazy(() => RtpDetails$inboundSchema).optional(),
+  instantBankDetails: InstantBankTransactionDetails$inboundSchema.optional(),
 });
 /** @internal */
 export type TransferDestination$Outbound = {
@@ -209,6 +220,7 @@ export type TransferDestination$Outbound = {
   applePay?: ApplePayResponse$Outbound | undefined;
   cardDetails?: CardTransactionDetails$Outbound | undefined;
   rtpDetails?: RtpDetails$Outbound | undefined;
+  instantBankDetails?: InstantBankTransactionDetails$Outbound | undefined;
 };
 
 /** @internal */
@@ -227,6 +239,7 @@ export const TransferDestination$outboundSchema: z.ZodType<
   applePay: ApplePayResponse$outboundSchema.optional(),
   cardDetails: CardTransactionDetails$outboundSchema.optional(),
   rtpDetails: z.lazy(() => RtpDetails$outboundSchema).optional(),
+  instantBankDetails: InstantBankTransactionDetails$outboundSchema.optional(),
 });
 
 export function transferDestinationToJSON(

package/src/models/components/webhookbillingstatementcreated.ts

@@ -8,6 +8,7 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type WebhookBillingStatementCreated = {
+  accountID: string;
   statementID: string;
 };
 
@@ -17,10 +18,12 @@ export const WebhookBillingStatementCreated$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  accountID: z.string(),
   statementID: z.string(),
 });
 /** @internal */
 export type WebhookBillingStatementCreated$Outbound = {
+  accountID: string;
   statementID: string;
 };
 
@@ -30,6 +33,7 @@ export const WebhookBillingStatementCreated$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   WebhookBillingStatementCreated
 > = z.object({
+  accountID: z.string(),
   statementID: z.string(),
 });
 

package/src/models/components/webhookdata.ts

@@ -265,11 +265,11 @@ export type WebhookData =
   | WebhookDataTicketCreated
   | WebhookDataTicketMessageAdded
   | WebhookDataWalletCreated
+  | WebhookBillingStatementCreated
   | WebhookDataAccountCreated
   | WebhookDataAccountUpdated
   | WebhookDataAccountDisconnected
-  | WebhookDataNetworkIDUpdated
-  | WebhookBillingStatementCreated;
+  | WebhookDataNetworkIDUpdated;
 
 /** @internal */
 export const WebhookData$inboundSchema: z.ZodType<
@@ -309,11 +309,11 @@ export const WebhookData$inboundSchema: z.ZodType<
   WebhookDataTicketCreated$inboundSchema,
   WebhookDataTicketMessageAdded$inboundSchema,
   WebhookDataWalletCreated$inboundSchema,
+  WebhookBillingStatementCreated$inboundSchema,
   WebhookDataAccountCreated$inboundSchema,
   WebhookDataAccountUpdated$inboundSchema,
   WebhookDataAccountDisconnected$inboundSchema,
   WebhookDataNetworkIDUpdated$inboundSchema,
-  WebhookBillingStatementCreated$inboundSchema,
 ]);
 /** @internal */
 export type WebhookData$Outbound =
@@ -349,11 +349,11 @@ export type WebhookData$Outbound =
   | WebhookDataTicketCreated$Outbound
   | WebhookDataTicketMessageAdded$Outbound
   | WebhookDataWalletCreated$Outbound
+  | WebhookBillingStatementCreated$Outbound
   | WebhookDataAccountCreated$Outbound
   | WebhookDataAccountUpdated$Outbound
   | WebhookDataAccountDisconnected$Outbound
-  | WebhookDataNetworkIDUpdated$Outbound
-  | WebhookBillingStatementCreated$Outbound;
+  | WebhookDataNetworkIDUpdated$Outbound;
 
 /** @internal */
 export const WebhookData$outboundSchema: z.ZodType<
@@ -393,11 +393,11 @@ export const WebhookData$outboundSchema: z.ZodType<
   WebhookDataTicketCreated$outboundSchema,
   WebhookDataTicketMessageAdded$outboundSchema,
   WebhookDataWalletCreated$outboundSchema,
+  WebhookBillingStatementCreated$outboundSchema,
   WebhookDataAccountCreated$outboundSchema,
   WebhookDataAccountUpdated$outboundSchema,
   WebhookDataAccountDisconnected$outboundSchema,
   WebhookDataNetworkIDUpdated$outboundSchema,
-  WebhookBillingStatementCreated$outboundSchema,
 ]);
 
 export function webhookDataToJSON(webhookData: WebhookData): string {