@oatfi/oatfi-sdk-ts 0.12.5 → 0.12.7

package/src/funcs/{networkLedgerUpdateHold.ts → purchasesPurchasesControllerUpdate.ts}

@@ -9,7 +9,7 @@ import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { RequestOptions } from "../lib/sdks.js";
-import { resolveSecurity } from "../lib/security.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
 import {
   ConnectionError,
@@ -27,16 +27,17 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Patch hold — amend outstanding_amount down (patchHold).
+ * Update a scheduled purchase
+ *
+ * If set, this operation will use {@link Security.bearer} from the global security.
  */
-export function networkLedgerUpdateHold(
+export function purchasesPurchasesControllerUpdate(
   client: OatFiSDKCore,
-  security: operations.NetworkControllerPatchHoldSecurity,
-  request: operations.NetworkControllerPatchHoldRequest,
+  request: operations.PurchasesControllerUpdateRequest,
   options?: RequestOptions,
 ): APIPromise<
   Result<
-    models.OkEnvelopeDto,
+    models.PurchaseResponseDto,
     | OatFiSDKError
     | ResponseValidationError
     | ConnectionError
@@ -49,7 +50,6 @@ export function networkLedgerUpdateHold(
 > {
   return new APIPromise($do(
     client,
-    security,
     request,
     options,
   ));
@@ -57,13 +57,12 @@ export function networkLedgerUpdateHold(
 
 async function $do(
   client: OatFiSDKCore,
-  security: operations.NetworkControllerPatchHoldSecurity,
-  request: operations.NetworkControllerPatchHoldRequest,
+  request: operations.PurchasesControllerUpdateRequest,
   options?: RequestOptions,
 ): Promise<
   [
     Result<
-      models.OkEnvelopeDto,
+      models.PurchaseResponseDto,
       | OatFiSDKError
       | ResponseValidationError
       | ConnectionError
@@ -79,24 +78,22 @@ async function $do(
   const parsed = safeParse(
     request,
     (value) =>
-      operations.NetworkControllerPatchHoldRequest$outboundSchema.parse(value),
+      operations.PurchasesControllerUpdateRequest$outboundSchema.parse(value),
     "Input validation failed",
   );
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.PatchHoldRequestDto, {
-    explode: true,
-  });
+  const body = encodeJSON("body", payload.UpdatePurchaseDto, { explode: true });
 
   const pathParams = {
-    hold_id: encodeSimple("hold_id", payload.hold_id, {
+    id: encodeSimple("id", payload.id, {
       explode: false,
       charEncoding: "percent",
     }),
   };
-  const path = pathToFunc("/v3/network/holds/{hold_id}")(pathParams);
+  const path = pathToFunc("/v3/purchases/{id}")(pathParams);
 
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
@@ -106,40 +103,21 @@ async function $do(
       payload["Idempotency-Key"],
       { explode: false, charEncoding: "none" },
     ),
-    "User-Agent": encodeSimple("User-Agent", payload["User-Agent"], {
-      explode: false,
-      charEncoding: "none",
-    }),
-    "X-Network-Request-Id": encodeSimple(
-      "X-Network-Request-Id",
-      payload["X-Network-Request-Id"],
-      { explode: false, charEncoding: "none" },
-    ),
-    "X-Network-Role": encodeSimple(
-      "X-Network-Role",
-      payload["X-Network-Role"],
-      { explode: false, charEncoding: "none" },
-    ),
   }));
 
-  const requestSecurity = resolveSecurity(
-    [
-      {
-        type: "http:basic",
-        value: { username: security?.username, password: security?.password },
-      },
-    ],
-  );
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput, [0]);
 
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "NetworkController_patchHold",
+    operationID: "PurchasesController_update",
     oAuth2Scopes: null,
 
     resolvedSecurity: requestSecurity,
 
-    securitySource: security,
+    securitySource: client._options.bearer,
     retryConfig: options?.retries
       || client._options.retryConfig
       || {
@@ -185,7 +163,7 @@ async function $do(
   const response = doResult.value;
 
   const [result] = await M.match<
-    models.OkEnvelopeDto,
+    models.PurchaseResponseDto,
     | OatFiSDKError
     | ResponseValidationError
     | ConnectionError
@@ -195,7 +173,7 @@ async function $do(
     | UnexpectedClientError
     | SDKValidationError
   >(
-    M.json(200, models.OkEnvelopeDto$inboundSchema),
+    M.json(200, models.PurchaseResponseDto$inboundSchema),
     M.fail([400, 401, 404, 409, 422, 429, "4XX"]),
     M.fail("5XX"),
   )(response, req);

package/src/funcs/transactionsTransactionsControllerUpdate.ts

@@ -0,0 +1,187 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { OatFiSDKCore } from "../core.js";
+import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { OatFiSDKError } from "../models/errors/oatfisdkerror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Update a stored transaction
+ *
+ * @remarks
+ * Corrects one or more fields of a previously uploaded transaction owned by the partner.
+ *
+ * If set, this operation will use {@link Security.bearer} from the global security.
+ */
+export function transactionsTransactionsControllerUpdate(
+  client: OatFiSDKCore,
+  request: operations.TransactionsControllerUpdateRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    models.StoredTransactionResponseDto,
+    | OatFiSDKError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: OatFiSDKCore,
+  request: operations.TransactionsControllerUpdateRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      models.StoredTransactionResponseDto,
+      | OatFiSDKError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) =>
+      operations.TransactionsControllerUpdateRequest$outboundSchema.parse(
+        value,
+      ),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.UpdateTransactionDto, {
+    explode: true,
+  });
+
+  const pathParams = {
+    transactionId: encodeSimple("transactionId", payload.transactionId, {
+      explode: false,
+      charEncoding: "percent",
+    }),
+  };
+  const path = pathToFunc("/v3/transactions/{transactionId}")(pathParams);
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.bearer);
+  const securityInput = secConfig == null ? {} : { bearer: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput, [0]);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "TransactionsController_update",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.bearer,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 60000,
+          exponent: 1.5,
+          maxElapsedTime: 120000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["5XX"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PATCH",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    uaHeader: "x-speakeasy-user-agent",
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const [result] = await M.match<
+    models.StoredTransactionResponseDto,
+    | OatFiSDKError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, models.StoredTransactionResponseDto$inboundSchema),
+    M.fail([400, 403, 404, 429, "4XX"]),
+    M.fail("5XX"),
+  )(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/lib/config.ts

@@ -69,8 +69,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "3.0.0",
-  sdkVersion: "0.12.5",
-  genVersion: "2.912.1",
+  sdkVersion: "0.12.7",
+  genVersion: "2.918.1",
   userAgent:
-    "speakeasy-sdk/typescript 0.12.5 2.912.1 3.0.0 @oatfi/oatfi-sdk-ts",
+    "speakeasy-sdk/typescript 0.12.7 2.918.1 3.0.0 @oatfi/oatfi-sdk-ts",
 } as const;

package/src/lib/http.ts

@@ -45,8 +45,10 @@ export class HTTPClient {
   private requestHooks: BeforeRequestHook[] = [];
   private requestErrorHooks: RequestErrorHook[] = [];
   private responseHooks: ResponseHook[] = [];
+  private options: HTTPClientOptions;
 
-  constructor(private options: HTTPClientOptions = {}) {
+  constructor(options: HTTPClientOptions = {}) {
+    this.options = options;
     this.fetcher = options.fetcher || DEFAULT_FETCHER;
   }
 

package/src/lib/security.ts

@@ -13,17 +13,22 @@ type OAuth2PasswordFlow = {
   tokenURL: string;
 };
 
-export enum SecurityErrorCode {
-  Incomplete = "incomplete",
-  UnrecognisedSecurityType = "unrecognized_security_type",
-}
+export const SecurityErrorCode = {
+  Incomplete: "incomplete",
+  UnrecognisedSecurityType: "unrecognized_security_type",
+} as const;
+export type SecurityErrorCode =
+  (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
 
 export class SecurityError extends Error {
+  public code: SecurityErrorCode;
+
   constructor(
-    public code: SecurityErrorCode,
+    code: SecurityErrorCode,
     message: string,
   ) {
     super(message);
+    this.code = code;
     this.name = "SecurityError";
   }
 

package/src/models/adjustmentresponsedto.ts

@@ -10,9 +10,6 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-/**
- * Adjustment classification. Mirrors the partner-side CreateAdjustmentDto.type enum.
- */
 export const AdjustmentResponseDtoType = {
   Reward: "REWARD",
   Return: "RETURN",
@@ -25,9 +22,6 @@ export const AdjustmentResponseDtoType = {
   FeeOther: "FEE_OTHER",
   Other: "OTHER",
 } as const;
-/**
- * Adjustment classification. Mirrors the partner-side CreateAdjustmentDto.type enum.
- */
 export type AdjustmentResponseDtoType = ClosedEnum<
   typeof AdjustmentResponseDtoType
 >;

package/src/models/authorizerequestdto.ts

@@ -9,7 +9,7 @@ export type AuthorizeRequestDto = {
   /**
    * Role-specific program id (lms_program_id when called on LMS, ipp_program_id when called on IPP).
    */
-  programId: string;
+  programExternalId: string;
   /**
    * The counterparty's partner-assigned external id — buyer.external_id when calling LMS, vendor.external_id when calling IPP. Lets the lender correlate the request to its own onboarded-business record.
    */
@@ -22,7 +22,7 @@ export type AuthorizeRequestDto = {
 
 /** @internal */
 export type AuthorizeRequestDto$Outbound = {
-  program_id: string;
+  program_external_id: string;
   business_external_id: string;
   amount: number;
 };
@@ -33,12 +33,12 @@ export const AuthorizeRequestDto$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AuthorizeRequestDto
 > = z.object({
-  programId: z.string(),
+  programExternalId: z.string(),
   businessExternalId: z.string(),
   amount: z.number(),
 }).transform((v) => {
   return remap$(v, {
-    programId: "program_id",
+    programExternalId: "program_external_id",
     businessExternalId: "business_external_id",
   });
 });

package/src/models/businesscheckunderwritingdto.ts

@@ -0,0 +1,87 @@
+/*
+ * 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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * The current underwriting status for the business under the program.
+ */
+export const BusinessCheckUnderwritingDtoStatus = {
+  Approved: "APPROVED",
+  ManualReview: "MANUAL_REVIEW",
+  ClosedNoDecision: "CLOSED_NO_DECISION",
+  ManualReviewDeclined: "MANUAL_REVIEW_DECLINED",
+  Rejected: "REJECTED",
+  Declined: "DECLINED",
+  Processing: "PROCESSING",
+  Error: "ERROR",
+  NotExecuted: "NOT_EXECUTED",
+  NA: "N/A",
+  Denied: "DENIED",
+} as const;
+/**
+ * The current underwriting status for the business under the program.
+ */
+export type BusinessCheckUnderwritingDtoStatus = ClosedEnum<
+  typeof BusinessCheckUnderwritingDtoStatus
+>;
+
+export type BusinessCheckUnderwritingDto = {
+  object: string;
+  /**
+   * The current underwriting status for the business under the program.
+   */
+  status: BusinessCheckUnderwritingDtoStatus;
+  /**
+   * Credit limit amount (only present when status is approved).
+   */
+  creditLimit?: number | undefined;
+  /**
+   * Adverse actions (only present for declined status).
+   */
+  adverseAction?: Array<any> | undefined;
+  /**
+   * Additional message from the underwriting process.
+   */
+  message?: string | undefined;
+};
+
+/** @internal */
+export const BusinessCheckUnderwritingDtoStatus$inboundSchema: z.ZodNativeEnum<
+  typeof BusinessCheckUnderwritingDtoStatus
+> = z.nativeEnum(BusinessCheckUnderwritingDtoStatus);
+
+/** @internal */
+export const BusinessCheckUnderwritingDto$inboundSchema: z.ZodType<
+  BusinessCheckUnderwritingDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: types.string().default("underwriting_status"),
+  status: BusinessCheckUnderwritingDtoStatus$inboundSchema,
+  credit_limit: types.optional(types.number()),
+  adverse_action: types.optional(z.array(z.any())),
+  message: types.optional(types.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "credit_limit": "creditLimit",
+    "adverse_action": "adverseAction",
+  });
+});
+
+export function businessCheckUnderwritingDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<BusinessCheckUnderwritingDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BusinessCheckUnderwritingDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BusinessCheckUnderwritingDto' from JSON`,
+  );
+}

package/src/models/businessrefdto.ts

@@ -10,11 +10,16 @@ export type BusinessRefDto = {
    * Partner-assigned external id — the lender's natural key for the business.
    */
   externalId: string;
+  /**
+   * The program's id — OatFi's LmsLoanProgram Mongo _id (ObjectId string); the Network sends it as external_program_id, i.e. not the Network's own internal UUID. Role-scoped: the LMS program in a buyer block, the IPP program in a vendor block.
+   */
+  programExternalId: string;
 };
 
 /** @internal */
 export type BusinessRefDto$Outbound = {
   external_id: string;
+  program_external_id: string;
 };
 
 /** @internal */
@@ -24,9 +29,11 @@ export const BusinessRefDto$outboundSchema: z.ZodType<
   BusinessRefDto
 > = z.object({
   externalId: z.string(),
+  programExternalId: z.string(),
 }).transform((v) => {
   return remap$(v, {
     externalId: "external_id",
+    programExternalId: "program_external_id",
   });
 });
 

package/src/models/cancelpurchasedto.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type CancelPurchaseDto = {
+  /**
+   * Reason recorded when canceling the purchase.
+   */
+  reason: string;
+};
+
+/** @internal */
+export type CancelPurchaseDto$Outbound = {
+  reason: string;
+};
+
+/** @internal */
+export const CancelPurchaseDto$outboundSchema: z.ZodType<
+  CancelPurchaseDto$Outbound,
+  z.ZodTypeDef,
+  CancelPurchaseDto
+> = z.object({
+  reason: z.string(),
+});
+
+export function cancelPurchaseDtoToJSON(
+  cancelPurchaseDto: CancelPurchaseDto,
+): string {
+  return JSON.stringify(
+    CancelPurchaseDto$outboundSchema.parse(cancelPurchaseDto),
+  );
+}

package/src/models/cancelrequestdto.ts

@@ -19,9 +19,9 @@ export type CancelRequestDtoReason = ClosedEnum<typeof CancelRequestDtoReason>;
 
 export type CancelRequestDto = {
   /**
-   * lms_program_id — the buyer's active LMS program (cancel is buyer-role / LMS-only). Supports multi-program routing on the LMS side.
+   * lms_program_id (OatFi program id, Mongo ObjectId) — the buyer's active LMS program (cancel is buyer-role / LMS-only). Supports multi-program routing on the LMS side.
    */
-  programId: string;
+  programExternalId: string;
   /**
    * The buyer's partner-assigned external id — lets the LMS link the cancellation to its onboarded business record.
    */
@@ -43,7 +43,7 @@ export const CancelRequestDtoReason$outboundSchema: z.ZodNativeEnum<
 
 /** @internal */
 export type CancelRequestDto$Outbound = {
-  program_id: string;
+  program_external_id: string;
   business_external_id: string;
   reason: string;
   cancelled_at: number;
@@ -55,13 +55,13 @@ export const CancelRequestDto$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CancelRequestDto
 > = z.object({
-  programId: z.string(),
+  programExternalId: z.string(),
   businessExternalId: z.string(),
   reason: CancelRequestDtoReason$outboundSchema,
   cancelledAt: z.number(),
 }).transform((v) => {
   return remap$(v, {
-    programId: "program_id",
+    programExternalId: "program_external_id",
     businessExternalId: "business_external_id",
     cancelledAt: "cancelled_at",
   });

package/src/models/checkbusinessdto.ts

@@ -0,0 +1,52 @@
+/*
+ * 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 CheckBusinessDto = {
+  /**
+   * Tax identification number (e.g., EIN). Must be exactly 9 numeric characters.
+   */
+  taxId: string;
+  /**
+   * Contact email to match against the business's primary user. Compared case-insensitively.
+   */
+  contactEmail: string;
+  /**
+   * The loan program to scope the acceptance and underwriting status to.
+   */
+  program: string;
+};
+
+/** @internal */
+export type CheckBusinessDto$Outbound = {
+  tax_id: string;
+  contact_email: string;
+  program: string;
+};
+
+/** @internal */
+export const CheckBusinessDto$outboundSchema: z.ZodType<
+  CheckBusinessDto$Outbound,
+  z.ZodTypeDef,
+  CheckBusinessDto
+> = z.object({
+  taxId: z.string(),
+  contactEmail: z.string(),
+  program: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    taxId: "tax_id",
+    contactEmail: "contact_email",
+  });
+});
+
+export function checkBusinessDtoToJSON(
+  checkBusinessDto: CheckBusinessDto,
+): string {
+  return JSON.stringify(
+    CheckBusinessDto$outboundSchema.parse(checkBusinessDto),
+  );
+}