@oatfi/oatfi-sdk-ts 0.11.59 → 0.11.62

package/src/lib/files.ts

@@ -80,3 +80,25 @@ export function getContentTypeFromFileName(fileName: string): string | null {
 
   return mimeTypes[ext] || null;
 }
+
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+export function bytesToBlob(
+  content: Uint8Array<ArrayBufferLike> | ArrayBuffer | Blob | string,
+  contentType: string,
+): Blob {
+  if (content instanceof Uint8Array) {
+    return new Blob([new Uint8Array(content)], { type: contentType });
+  }
+  return new Blob([content as BlobPart], { type: contentType });
+}

package/src/lib/sdks.ts

@@ -127,13 +127,15 @@ export class ClientSDK {
     if (!base) {
       return ERR(new InvalidRequestError("No base URL provided for operation"));
     }
-    const reqURL = new URL(base);
-    const inputURL = new URL(path, reqURL);
-
+    const baseURL = new URL(base);
+    let reqURL: URL;
     if (path) {
-      reqURL.pathname += reqURL.pathname.endsWith("/") ? "" : "/";
-      reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
+      baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
+      reqURL = new URL(path, baseURL);
+    } else {
+      reqURL = baseURL;
     }
+    reqURL.hash = "";
 
     let finalQuery = query || "";
 

package/src/lib/url.ts

@@ -13,21 +13,23 @@ export function pathToFunc(
   const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
 
   return function buildURLPath(params: Record<string, unknown> = {}): string {
-    return pathPattern.replace(paramRE, function (_, placeholder) {
-      if (!hasOwn.call(params, placeholder)) {
-        throw new Error(`Parameter '${placeholder}' is required`);
-      }
+    return pathPattern
+      .replace(paramRE, function (_, placeholder) {
+        if (!hasOwn.call(params, placeholder)) {
+          throw new Error(`Parameter '${placeholder}' is required`);
+        }
 
-      const value = params[placeholder];
-      if (typeof value !== "string" && typeof value !== "number") {
-        throw new Error(
-          `Parameter '${placeholder}' must be a string or number`,
-        );
-      }
+        const value = params[placeholder];
+        if (typeof value !== "string" && typeof value !== "number") {
+          throw new Error(
+            `Parameter '${placeholder}' must be a string or number`,
+          );
+        }
 
-      return options?.charEncoding === "percent"
-        ? encodeURIComponent(`${value}`)
-        : `${value}`;
-    });
+        return options?.charEncoding === "percent"
+          ? encodeURIComponent(`${value}`)
+          : `${value}`;
+      })
+      .replace(/^\/+/, "");
   };
 }

package/src/models/accountstatementlistresponse.ts

@@ -7,10 +7,8 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import {
-  IncreaseAccountStatement,
-  IncreaseAccountStatement$inboundSchema,
-} from "./increaseaccountstatement.js";
+
+export type AccountStatementListResponseData = {};
 
 export type AccountStatementListResponse = {
   /**
@@ -20,7 +18,7 @@ export type AccountStatementListResponse = {
   /**
    * Array of account statements
    */
-  data: Array<IncreaseAccountStatement>;
+  data: Array<AccountStatementListResponseData>;
   /**
    * Whether there are more items to fetch
    */
@@ -31,6 +29,23 @@ export type AccountStatementListResponse = {
   total: number;
 };
 
+/** @internal */
+export const AccountStatementListResponseData$inboundSchema: z.ZodType<
+  AccountStatementListResponseData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function accountStatementListResponseDataFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountStatementListResponseData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountStatementListResponseData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountStatementListResponseData' from JSON`,
+  );
+}
+
 /** @internal */
 export const AccountStatementListResponse$inboundSchema: z.ZodType<
   AccountStatementListResponse,
@@ -38,7 +53,7 @@ export const AccountStatementListResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   object: z.string().default("list"),
-  data: z.array(IncreaseAccountStatement$inboundSchema),
+  data: z.array(z.lazy(() => AccountStatementListResponseData$inboundSchema)),
   has_more: z.boolean(),
   total: z.number(),
 }).transform((v) => {

package/src/models/addressdto.ts

@@ -32,7 +32,7 @@ export type AddressDto = {
   /**
    * Country code (2-letter ISO 3166-1 alpha-2)
    */
-  country: string;
+  country?: string | undefined;
 };
 
 /** @internal */
@@ -54,7 +54,39 @@ export const AddressDto$inboundSchema: z.ZodType<
     "postal_code": "postalCode",
   });
 });
+/** @internal */
+export type AddressDto$Outbound = {
+  line_1: string;
+  line_2?: string | undefined;
+  city: string;
+  state: string;
+  postal_code: string;
+  country: string;
+};
+
+/** @internal */
+export const AddressDto$outboundSchema: z.ZodType<
+  AddressDto$Outbound,
+  z.ZodTypeDef,
+  AddressDto
+> = z.object({
+  line1: z.string(),
+  line2: z.string().optional(),
+  city: z.string(),
+  state: z.string(),
+  postalCode: z.string(),
+  country: z.string().default("US"),
+}).transform((v) => {
+  return remap$(v, {
+    line1: "line_1",
+    line2: "line_2",
+    postalCode: "postal_code",
+  });
+});
 
+export function addressDtoToJSON(addressDto: AddressDto): string {
+  return JSON.stringify(AddressDto$outboundSchema.parse(addressDto));
+}
 export function addressDtoFromJSON(
   jsonString: string,
 ): SafeParseResult<AddressDto, SDKValidationError> {

package/src/models/adverseactiondto.ts

@@ -0,0 +1,99 @@
+/*
+ * 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 { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Type of adverse action
+ */
+export const AdverseActionDtoType = {
+  Kyb: "KYB",
+  Kyc: "KYC",
+} as const;
+/**
+ * Type of adverse action
+ */
+export type AdverseActionDtoType = ClosedEnum<typeof AdverseActionDtoType>;
+
+export type AdverseActionDto = {
+  /**
+   * Description of the adverse action
+   */
+  description: string;
+  /**
+   * Type of adverse action
+   */
+  type: AdverseActionDtoType;
+  /**
+   * ID of the entity (e.g., person ID from persons_information) this adverse action relates to. Required if type is KYC.
+   */
+  entityId?: string | undefined;
+};
+
+/** @internal */
+export const AdverseActionDtoType$inboundSchema: z.ZodNativeEnum<
+  typeof AdverseActionDtoType
+> = z.nativeEnum(AdverseActionDtoType);
+/** @internal */
+export const AdverseActionDtoType$outboundSchema: z.ZodNativeEnum<
+  typeof AdverseActionDtoType
+> = AdverseActionDtoType$inboundSchema;
+
+/** @internal */
+export const AdverseActionDto$inboundSchema: z.ZodType<
+  AdverseActionDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  description: z.string(),
+  type: AdverseActionDtoType$inboundSchema,
+  entity_id: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "entity_id": "entityId",
+  });
+});
+/** @internal */
+export type AdverseActionDto$Outbound = {
+  description: string;
+  type: string;
+  entity_id?: string | undefined;
+};
+
+/** @internal */
+export const AdverseActionDto$outboundSchema: z.ZodType<
+  AdverseActionDto$Outbound,
+  z.ZodTypeDef,
+  AdverseActionDto
+> = z.object({
+  description: z.string(),
+  type: AdverseActionDtoType$outboundSchema,
+  entityId: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    entityId: "entity_id",
+  });
+});
+
+export function adverseActionDtoToJSON(
+  adverseActionDto: AdverseActionDto,
+): string {
+  return JSON.stringify(
+    AdverseActionDto$outboundSchema.parse(adverseActionDto),
+  );
+}
+export function adverseActionDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<AdverseActionDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AdverseActionDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AdverseActionDto' from JSON`,
+  );
+}

package/src/models/apikeydto.ts

@@ -8,11 +8,6 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-/**
- * Additional metadata
- */
-export type ApiKeyDtoMetadata = {};
-
 export type ApiKeyDto = {
   /**
    * Unique identifier for the API key
@@ -61,26 +56,9 @@ export type ApiKeyDto = {
   /**
    * Additional metadata
    */
-  metadata: ApiKeyDtoMetadata;
+  metadata: { [k: string]: any };
 };
 
-/** @internal */
-export const ApiKeyDtoMetadata$inboundSchema: z.ZodType<
-  ApiKeyDtoMetadata,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function apiKeyDtoMetadataFromJSON(
-  jsonString: string,
-): SafeParseResult<ApiKeyDtoMetadata, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ApiKeyDtoMetadata$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ApiKeyDtoMetadata' from JSON`,
-  );
-}
-
 /** @internal */
 export const ApiKeyDto$inboundSchema: z.ZodType<
   ApiKeyDto,
@@ -98,7 +76,7 @@ export const ApiKeyDto$inboundSchema: z.ZodType<
   prod_priv_key_viewed_at: z.number().optional(),
   created_at: z.string(),
   updated_at: z.string(),
-  metadata: z.lazy(() => ApiKeyDtoMetadata$inboundSchema),
+  metadata: z.record(z.any()),
 }).transform((v) => {
   return remap$(v, {
     "sandbox_pub_key": "sandboxPubKey",

package/src/models/apikeysenvironment.ts

@@ -6,14 +6,14 @@ import * as z from "zod/v3";
 import { ClosedEnum } from "../types/enums.js";
 
 /**
- * Environment to update view date for
+ * Environment to rotate keys for
  */
 export const ApiKeysEnvironment = {
   Prod: "prod",
   Sandbox: "sandbox",
 } as const;
 /**
- * Environment to update view date for
+ * Environment to rotate keys for
  */
 export type ApiKeysEnvironment = ClosedEnum<typeof ApiKeysEnvironment>;
 

package/src/models/applicationresponsedto.ts

@@ -0,0 +1,174 @@
+/*
+ * 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 { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  AdverseActionDto,
+  AdverseActionDto$inboundSchema,
+} from "./adverseactiondto.js";
+import { AttachmentDto, AttachmentDto$inboundSchema } from "./attachmentdto.js";
+import {
+  BusinessInformationDto,
+  BusinessInformationDto$inboundSchema,
+} from "./businessinformationdto.js";
+import { ConsentsDto, ConsentsDto$inboundSchema } from "./consentsdto.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  ExpectedUsageDto,
+  ExpectedUsageDto$inboundSchema,
+} from "./expectedusagedto.js";
+import {
+  PersonInformationDto,
+  PersonInformationDto$inboundSchema,
+} from "./personinformationdto.js";
+
+/**
+ * Current status of the application.
+ */
+export const ApplicationResponseDtoStatus = {
+  Draft: "DRAFT",
+  Submitted: "SUBMITTED",
+  Failed: "FAILED",
+  Error: "ERROR",
+  ActionRequired: "ACTION_REQUIRED",
+  ManualReview: "MANUAL_REVIEW",
+  Approved: "APPROVED",
+  Processed: "PROCESSED",
+} as const;
+/**
+ * Current status of the application.
+ */
+export type ApplicationResponseDtoStatus = ClosedEnum<
+  typeof ApplicationResponseDtoStatus
+>;
+
+/**
+ * Current KYB status of the application.
+ */
+export const KybStatus = {
+  NotStarted: "NOT_STARTED",
+  Started: "STARTED",
+  Failed: "FAILED",
+  ActionRequired: "ACTION_REQUIRED",
+  ManualReview: "MANUAL_REVIEW",
+  Approved: "APPROVED",
+} as const;
+/**
+ * Current KYB status of the application.
+ */
+export type KybStatus = ClosedEnum<typeof KybStatus>;
+
+export type ApplicationResponseDto = {
+  /**
+   * Object type, always 'application'.
+   */
+  object: string;
+  /**
+   * Unique identifier for the application.
+   */
+  id: string;
+  /**
+   * Platform ID associated with the application.
+   */
+  platform?: string | undefined;
+  /**
+   * Current status of the application.
+   */
+  status?: ApplicationResponseDtoStatus | undefined;
+  /**
+   * Current KYB status of the application.
+   */
+  kybStatus?: KybStatus | undefined;
+  /**
+   * Timestamp of when the application was submitted.
+   */
+  submittedAt?: Date | undefined;
+  /**
+   * Timestamp of when a decision was made on the application.
+   */
+  decisionedAt?: Date | undefined;
+  businessInformation?: BusinessInformationDto | undefined;
+  personsInformation?: Array<PersonInformationDto> | undefined;
+  expectedUsage?: ExpectedUsageDto | undefined;
+  consents?: ConsentsDto | undefined;
+  adverseActions?: Array<AdverseActionDto> | undefined;
+  attachments?: Array<AttachmentDto> | undefined;
+  /**
+   * Additional metadata.
+   */
+  metadata?: { [k: string]: any } | undefined;
+  /**
+   * Timestamp of when the application was created.
+   */
+  createdAt?: Date | undefined;
+  /**
+   * Timestamp of when the application was last updated.
+   */
+  updatedAt?: Date | undefined;
+};
+
+/** @internal */
+export const ApplicationResponseDtoStatus$inboundSchema: z.ZodNativeEnum<
+  typeof ApplicationResponseDtoStatus
+> = z.nativeEnum(ApplicationResponseDtoStatus);
+
+/** @internal */
+export const KybStatus$inboundSchema: z.ZodNativeEnum<typeof KybStatus> = z
+  .nativeEnum(KybStatus);
+
+/** @internal */
+export const ApplicationResponseDto$inboundSchema: z.ZodType<
+  ApplicationResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: z.string(),
+  id: z.string(),
+  platform: z.string().optional(),
+  status: ApplicationResponseDtoStatus$inboundSchema.optional(),
+  kyb_status: KybStatus$inboundSchema.optional(),
+  submitted_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ).optional(),
+  decisioned_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ).optional(),
+  business_information: BusinessInformationDto$inboundSchema.optional(),
+  persons_information: z.array(PersonInformationDto$inboundSchema).optional(),
+  expected_usage: ExpectedUsageDto$inboundSchema.optional(),
+  consents: ConsentsDto$inboundSchema.optional(),
+  adverse_actions: z.array(AdverseActionDto$inboundSchema).optional(),
+  attachments: z.array(AttachmentDto$inboundSchema).optional(),
+  metadata: z.record(z.any()).optional(),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "kyb_status": "kybStatus",
+    "submitted_at": "submittedAt",
+    "decisioned_at": "decisionedAt",
+    "business_information": "businessInformation",
+    "persons_information": "personsInformation",
+    "expected_usage": "expectedUsage",
+    "adverse_actions": "adverseActions",
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
+  });
+});
+
+export function applicationResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<ApplicationResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ApplicationResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ApplicationResponseDto' from JSON`,
+  );
+}

package/src/models/approveapplicationdto.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
+
+export type ApproveApplicationDto = {
+  /**
+   * Capital source portfolio ID
+   */
+  capitalSource: string;
+};
+
+/** @internal */
+export type ApproveApplicationDto$Outbound = {
+  capital_source: string;
+};
+
+/** @internal */
+export const ApproveApplicationDto$outboundSchema: z.ZodType<
+  ApproveApplicationDto$Outbound,
+  z.ZodTypeDef,
+  ApproveApplicationDto
+> = z.object({
+  capitalSource: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    capitalSource: "capital_source",
+  });
+});
+
+export function approveApplicationDtoToJSON(
+  approveApplicationDto: ApproveApplicationDto,
+): string {
+  return JSON.stringify(
+    ApproveApplicationDto$outboundSchema.parse(approveApplicationDto),
+  );
+}

package/src/models/attachmentdto.ts

@@ -0,0 +1,75 @@
+/*
+ * 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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type AttachmentDto = {
+  /**
+   * Type of document
+   */
+  documentType: string;
+  /**
+   * File ID from a file service
+   */
+  fileId: string;
+  /**
+   * Optional description of the attachment
+   */
+  description?: string | undefined;
+};
+
+/** @internal */
+export const AttachmentDto$inboundSchema: z.ZodType<
+  AttachmentDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  document_type: z.string(),
+  file_id: z.string(),
+  description: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "document_type": "documentType",
+    "file_id": "fileId",
+  });
+});
+/** @internal */
+export type AttachmentDto$Outbound = {
+  document_type: string;
+  file_id: string;
+  description?: string | undefined;
+};
+
+/** @internal */
+export const AttachmentDto$outboundSchema: z.ZodType<
+  AttachmentDto$Outbound,
+  z.ZodTypeDef,
+  AttachmentDto
+> = z.object({
+  documentType: z.string(),
+  fileId: z.string(),
+  description: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    documentType: "document_type",
+    fileId: "file_id",
+  });
+});
+
+export function attachmentDtoToJSON(attachmentDto: AttachmentDto): string {
+  return JSON.stringify(AttachmentDto$outboundSchema.parse(attachmentDto));
+}
+export function attachmentDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<AttachmentDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AttachmentDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AttachmentDto' from JSON`,
+  );
+}