@financeable/aggregation 0.5.1 → 0.6.1

package/src/funcs/{oauthTokenGet.ts → oauthTokenOauthToken.ts}

@@ -26,7 +26,7 @@ import { Result } from "../types/fp.js";
 /**
  * Obtain an OAuth client_credentials token
  */
-export function oauthTokenGet(
+export function oauthTokenOauthToken(
   client: FinanceableCore,
   request: components.TokenRequest,
   options?: RequestOptions,

package/src/funcs/{applicationsList.ts → supportingDocumentsCreate.ts}

@@ -3,7 +3,7 @@
  */
 
 import { FinanceableCore } from "../core.js";
-import { encodeFormQuery } from "../lib/encodings.js";
+import { encodeFormQuery, encodeJSON } from "../lib/encodings.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
@@ -25,16 +25,17 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Retrieve a list of applications
+ * Create a supporting document record in Financeable, and returns a pre-signed URL to upload this document with.
  */
-export function applicationsList(
+export function supportingDocumentsCreate(
   client: FinanceableCore,
-  request: operations.GetApplicationsRequest,
+  request: operations.SupportingDocumentsCreateRequest,
   options?: RequestOptions,
 ): APIPromise<
   Result<
-    operations.GetApplicationsResponseBody,
-    | errors.ResponseBody
+    operations.SupportingDocumentsCreateResponseBody,
+    | errors.SupportingDocumentsCreateResponseBody
+    | errors.SupportingDocumentsCreateSupportingDocumentsResponseBody
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -53,13 +54,14 @@ export function applicationsList(
 
 async function $do(
   client: FinanceableCore,
-  request: operations.GetApplicationsRequest,
+  request: operations.SupportingDocumentsCreateRequest,
   options?: RequestOptions,
 ): Promise<
   [
     Result<
-      operations.GetApplicationsResponseBody,
-      | errors.ResponseBody
+      operations.SupportingDocumentsCreateResponseBody,
+      | errors.SupportingDocumentsCreateResponseBody
+      | errors.SupportingDocumentsCreateSupportingDocumentsResponseBody
       | APIError
       | SDKValidationError
       | UnexpectedClientError
@@ -73,22 +75,24 @@ async function $do(
 > {
   const parsed = safeParse(
     request,
-    (value) => operations.GetApplicationsRequest$outboundSchema.parse(value),
+    (value) =>
+      operations.SupportingDocumentsCreateRequest$outboundSchema.parse(value),
     "Input validation failed",
   );
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = encodeJSON("body", payload.RequestBody, { explode: true });
 
-  const path = pathToFunc("/applications")();
+  const path = pathToFunc("/")();
 
   const query = encodeFormQuery({
-    "humanId": payload.humanId,
+    "mimeType": payload.mimeType,
   }, { explode: false });
 
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/json",
   }));
 
@@ -100,7 +104,7 @@ async function $do(
 
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getApplications",
+    operationID: "SupportingDocuments_create",
     oAuth2Scopes: [],
 
     resolvedSecurity: requestSecurity,
@@ -114,7 +118,7 @@ async function $do(
 
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path: path,
     headers: headers,
@@ -129,7 +133,7 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["403", "4XX", "5XX"],
+    errorCodes: ["400", "404", "4XX", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -143,8 +147,9 @@ async function $do(
   };
 
   const [result] = await M.match<
-    operations.GetApplicationsResponseBody,
-    | errors.ResponseBody
+    operations.SupportingDocumentsCreateResponseBody,
+    | errors.SupportingDocumentsCreateResponseBody
+    | errors.SupportingDocumentsCreateSupportingDocumentsResponseBody
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -153,8 +158,13 @@ async function $do(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, operations.GetApplicationsResponseBody$inboundSchema),
-    M.jsonErr(403, errors.ResponseBody$inboundSchema),
+    M.json(201, operations.SupportingDocumentsCreateResponseBody$inboundSchema),
+    M.jsonErr(400, errors.SupportingDocumentsCreateResponseBody$inboundSchema),
+    M.jsonErr(
+      404,
+      errors
+        .SupportingDocumentsCreateSupportingDocumentsResponseBody$inboundSchema,
+    ),
     M.fail("4XX"),
     M.fail("5XX"),
   )(response, { extraFields: responseFields });

package/src/lib/config.ts

@@ -11,10 +11,7 @@ import { Params, pathToFunc } from "./url.js";
  * Contains the list of servers available to the SDK
  */
 export const ServerList = [
-  /**
-   * Production Server
-   */
-  "https://api.financeable.com.au",
+  "https://server.api.financeable.com.au",
 ] as const;
 
 export type SDKOptions = {
@@ -57,8 +54,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.4.0",
-  sdkVersion: "0.5.1",
-  genVersion: "2.563.0",
+  sdkVersion: "0.6.1",
+  genVersion: "2.599.0",
   userAgent:
-    "speakeasy-sdk/typescript 0.5.1 2.563.0 0.4.0 @financeable/aggregation",
+    "speakeasy-sdk/typescript 0.6.1 2.599.0 0.4.0 @financeable/aggregation",
 } as const;

package/src/lib/matchers.ts

@@ -10,6 +10,7 @@ import { isPlainObject } from "./is-plain-object.js";
 import { safeParse } from "./schemas.js";
 
 export type Encoding =
+  | "jsonl"
   | "json"
   | "text"
   | "bytes"
@@ -19,6 +20,7 @@ export type Encoding =
   | "fail";
 
 const DEFAULT_CONTENT_TYPES: Record<Encoding, string> = {
+  jsonl: "application/jsonl",
   json: "application/json",
   text: "text/plain",
   bytes: "application/octet-stream",
@@ -72,6 +74,21 @@ export function json<T>(
   return { ...options, enc: "json", codes, schema };
 }
 
+export function jsonl<T>(
+  codes: StatusCodePredicate,
+  schema: Schema<T>,
+  options?: MatchOptions,
+): ValueMatcher<T> {
+  return { ...options, enc: "jsonl", codes, schema };
+}
+
+export function jsonlErr<E>(
+  codes: StatusCodePredicate,
+  schema: Schema<E>,
+  options?: MatchOptions,
+): ErrorMatcher<E> {
+  return { ...options, err: true, enc: "jsonl", codes, schema };
+}
 export function textErr<E>(
   codes: StatusCodePredicate,
   schema: Schema<E>,
@@ -204,6 +221,9 @@ export function match<T, E>(
       case "json":
         raw = await response.json();
         break;
+      case "jsonl":
+        raw = response.body;
+        break;
       case "bytes":
         raw = new Uint8Array(await response.arrayBuffer());
         break;

package/src/lib/sdks.ts

@@ -47,12 +47,14 @@ export type RequestOptions = {
    */
   serverURL?: string | URL;
   /**
+   * @deprecated `fetchOptions` has been flattened into `RequestOptions`.
+   *
    * Sets various request options on the `fetch` call made by an SDK method.
    *
    * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options|Request}
    */
   fetchOptions?: Omit<RequestInit, "method" | "body">;
-};
+} & Omit<RequestInit, "method" | "body">;
 
 type RequestConfig = {
   method: string;
@@ -172,7 +174,9 @@ export class ClientSDK {
     cookie = cookie.startsWith("; ") ? cookie.slice(2) : cookie;
     headers.set("cookie", cookie);
 
-    const userHeaders = new Headers(options?.fetchOptions?.headers);
+    const userHeaders = new Headers(
+      options?.headers ?? options?.fetchOptions?.headers,
+    );
     for (const [k, v] of userHeaders) {
       headers.set(k, v);
     }
@@ -183,20 +187,16 @@ export class ClientSDK {
       headers.set(conf.uaHeader ?? "user-agent", SDK_METADATA.userAgent);
     }
 
-    let fetchOptions = options?.fetchOptions;
+    const fetchOptions: Omit<RequestInit, "method" | "body"> = {
+      ...options?.fetchOptions,
+      ...options,
+    };
     if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
       const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      if (!fetchOptions) {
-        fetchOptions = { signal: timeoutSignal };
-      } else {
-        fetchOptions.signal = timeoutSignal;
-      }
+      fetchOptions.signal = timeoutSignal;
     }
 
     if (conf.body instanceof ReadableStream) {
-      if (!fetchOptions) {
-        fetchOptions = {};
-      }
       Object.assign(fetchOptions, { duplex: "half" });
     }
 
@@ -302,7 +302,9 @@ export class ClientSDK {
   }
 }
 
-const jsonLikeContentTypeRE = /^application\/(?:.{0,100}\+)?json/;
+const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
+const jsonlLikeContentTypeRE =
+  /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
 async function logRequest(logger: Logger | undefined, req: Request) {
   if (!logger) {
     return;
@@ -368,9 +370,13 @@ async function logResponse(
   logger.group("Body:");
   switch (true) {
     case matchContentType(res, "application/json")
-      || jsonLikeContentTypeRE.test(ct):
+      || jsonLikeContentTypeRE.test(ct) && !jsonlLikeContentTypeRE.test(ct):
       logger.log(await res.clone().json());
       break;
+    case matchContentType(res, "application/jsonl")
+      || jsonlLikeContentTypeRE.test(ct):
+      logger.log(await res.clone().text());
+      break;
     case matchContentType(res, "text/event-stream"):
       logger.log(`<${contentType}>`);
       break;

package/src/models/components/addressattributes.ts

@@ -13,13 +13,16 @@ import {
   AustralianStatesAndTerritories$outboundSchema,
 } from "./australianstatesandterritories.js";
 
-export const Status = {
+export const AddressAttributesStatus = {
   Current: "current",
   Previous: "previous",
 } as const;
-export type Status = ClosedEnum<typeof Status>;
+export type AddressAttributesStatus = ClosedEnum<
+  typeof AddressAttributesStatus
+>;
 
 export type AddressAttributes = {
+  id: string;
   unitNumber?: number | undefined;
   addressType: string;
   fullAddress: string;
@@ -32,28 +35,30 @@ export type AddressAttributes = {
   street: string;
   state: AustralianStatesAndTerritories;
   country: string;
-  status: Status;
+  status: AddressAttributesStatus;
   monthsAt?: number | undefined;
   yearsAt?: number | undefined;
 };
 
 /** @internal */
-export const Status$inboundSchema: z.ZodNativeEnum<typeof Status> = z
-  .nativeEnum(Status);
+export const AddressAttributesStatus$inboundSchema: z.ZodNativeEnum<
+  typeof AddressAttributesStatus
+> = z.nativeEnum(AddressAttributesStatus);
 
 /** @internal */
-export const Status$outboundSchema: z.ZodNativeEnum<typeof Status> =
-  Status$inboundSchema;
+export const AddressAttributesStatus$outboundSchema: z.ZodNativeEnum<
+  typeof AddressAttributesStatus
+> = AddressAttributesStatus$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Status$ {
-  /** @deprecated use `Status$inboundSchema` instead. */
-  export const inboundSchema = Status$inboundSchema;
-  /** @deprecated use `Status$outboundSchema` instead. */
-  export const outboundSchema = Status$outboundSchema;
+export namespace AddressAttributesStatus$ {
+  /** @deprecated use `AddressAttributesStatus$inboundSchema` instead. */
+  export const inboundSchema = AddressAttributesStatus$inboundSchema;
+  /** @deprecated use `AddressAttributesStatus$outboundSchema` instead. */
+  export const outboundSchema = AddressAttributesStatus$outboundSchema;
 }
 
 /** @internal */
@@ -62,6 +67,7 @@ export const AddressAttributes$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  id: z.string(),
   unitNumber: z.number().int().optional(),
   addressType: z.string(),
   fullAddress: z.string(),
@@ -74,13 +80,14 @@ export const AddressAttributes$inboundSchema: z.ZodType<
   street: z.string(),
   state: AustralianStatesAndTerritories$inboundSchema,
   country: z.string(),
-  status: Status$inboundSchema,
+  status: AddressAttributesStatus$inboundSchema,
   monthsAt: z.number().int().optional(),
   yearsAt: z.number().int().optional(),
 });
 
 /** @internal */
 export type AddressAttributes$Outbound = {
+  id: string;
   unitNumber?: number | undefined;
   addressType: string;
   fullAddress: string;
@@ -104,6 +111,7 @@ export const AddressAttributes$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AddressAttributes
 > = z.object({
+  id: z.string(),
   unitNumber: z.number().int().optional(),
   addressType: z.string(),
   fullAddress: z.string(),
@@ -116,7 +124,7 @@ export const AddressAttributes$outboundSchema: z.ZodType<
   street: z.string(),
   state: AustralianStatesAndTerritories$outboundSchema,
   country: z.string(),
-  status: Status$outboundSchema,
+  status: AddressAttributesStatus$outboundSchema,
   monthsAt: z.number().int().optional(),
   yearsAt: z.number().int().optional(),
 });

package/src/models/components/applicationresource.ts

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  CommercialSecuredApplicationResource,
+  CommercialSecuredApplicationResource$inboundSchema,
+  CommercialSecuredApplicationResource$Outbound,
+  CommercialSecuredApplicationResource$outboundSchema,
+} from "./commercialsecuredapplicationresource.js";
+import {
+  ConsumerSecuredApplicationResource,
+  ConsumerSecuredApplicationResource$inboundSchema,
+  ConsumerSecuredApplicationResource$Outbound,
+  ConsumerSecuredApplicationResource$outboundSchema,
+} from "./consumersecuredapplicationresource.js";
+
+/**
+ * Represents either a Consumer or Commercial Application resource
+ */
+export type ApplicationResource =
+  | ConsumerSecuredApplicationResource
+  | CommercialSecuredApplicationResource;
+
+/** @internal */
+export const ApplicationResource$inboundSchema: z.ZodType<
+  ApplicationResource,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  ConsumerSecuredApplicationResource$inboundSchema,
+  CommercialSecuredApplicationResource$inboundSchema,
+]);
+
+/** @internal */
+export type ApplicationResource$Outbound =
+  | ConsumerSecuredApplicationResource$Outbound
+  | CommercialSecuredApplicationResource$Outbound;
+
+/** @internal */
+export const ApplicationResource$outboundSchema: z.ZodType<
+  ApplicationResource$Outbound,
+  z.ZodTypeDef,
+  ApplicationResource
+> = z.union([
+  ConsumerSecuredApplicationResource$outboundSchema,
+  CommercialSecuredApplicationResource$outboundSchema,
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ApplicationResource$ {
+  /** @deprecated use `ApplicationResource$inboundSchema` instead. */
+  export const inboundSchema = ApplicationResource$inboundSchema;
+  /** @deprecated use `ApplicationResource$outboundSchema` instead. */
+  export const outboundSchema = ApplicationResource$outboundSchema;
+  /** @deprecated use `ApplicationResource$Outbound` instead. */
+  export type Outbound = ApplicationResource$Outbound;
+}
+
+export function applicationResourceToJSON(
+  applicationResource: ApplicationResource,
+): string {
+  return JSON.stringify(
+    ApplicationResource$outboundSchema.parse(applicationResource),
+  );
+}
+
+export function applicationResourceFromJSON(
+  jsonString: string,
+): SafeParseResult<ApplicationResource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ApplicationResource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ApplicationResource' from JSON`,
+  );
+}

package/src/models/components/badrequesterror.ts

@@ -0,0 +1,182 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+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";
+import {
+  APIErrorLinks,
+  APIErrorLinks$inboundSchema,
+  APIErrorLinks$Outbound,
+  APIErrorLinks$outboundSchema,
+} from "./apierrorlinks.js";
+import {
+  ErrorSource,
+  ErrorSource$inboundSchema,
+  ErrorSource$Outbound,
+  ErrorSource$outboundSchema,
+} from "./errorsource.js";
+
+export const Status = {
+  FourHundred: "400",
+} as const;
+export type Status = ClosedEnum<typeof Status>;
+
+export const Code = {
+  BadRequest: "BadRequest",
+} as const;
+export type Code = ClosedEnum<typeof Code>;
+
+export const Title = {
+  BadRequest: "Bad Request",
+} as const;
+export type Title = ClosedEnum<typeof Title>;
+
+export type BadRequestError = {
+  id?: string | undefined;
+  links?: APIErrorLinks | undefined;
+  status: Status;
+  code: Code;
+  title: Title;
+  detail: string;
+  /**
+   * An object describing the source of the error from the request
+   */
+  source?: ErrorSource | undefined;
+  meta?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Status$inboundSchema: z.ZodNativeEnum<typeof Status> = z
+  .nativeEnum(Status);
+
+/** @internal */
+export const Status$outboundSchema: z.ZodNativeEnum<typeof Status> =
+  Status$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Status$ {
+  /** @deprecated use `Status$inboundSchema` instead. */
+  export const inboundSchema = Status$inboundSchema;
+  /** @deprecated use `Status$outboundSchema` instead. */
+  export const outboundSchema = Status$outboundSchema;
+}
+
+/** @internal */
+export const Code$inboundSchema: z.ZodNativeEnum<typeof Code> = z.nativeEnum(
+  Code,
+);
+
+/** @internal */
+export const Code$outboundSchema: z.ZodNativeEnum<typeof Code> =
+  Code$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Code$ {
+  /** @deprecated use `Code$inboundSchema` instead. */
+  export const inboundSchema = Code$inboundSchema;
+  /** @deprecated use `Code$outboundSchema` instead. */
+  export const outboundSchema = Code$outboundSchema;
+}
+
+/** @internal */
+export const Title$inboundSchema: z.ZodNativeEnum<typeof Title> = z.nativeEnum(
+  Title,
+);
+
+/** @internal */
+export const Title$outboundSchema: z.ZodNativeEnum<typeof Title> =
+  Title$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Title$ {
+  /** @deprecated use `Title$inboundSchema` instead. */
+  export const inboundSchema = Title$inboundSchema;
+  /** @deprecated use `Title$outboundSchema` instead. */
+  export const outboundSchema = Title$outboundSchema;
+}
+
+/** @internal */
+export const BadRequestError$inboundSchema: z.ZodType<
+  BadRequestError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  links: APIErrorLinks$inboundSchema.optional(),
+  status: Status$inboundSchema,
+  code: Code$inboundSchema,
+  title: Title$inboundSchema,
+  detail: z.string(),
+  source: ErrorSource$inboundSchema.optional(),
+  meta: z.record(z.any()).optional(),
+});
+
+/** @internal */
+export type BadRequestError$Outbound = {
+  id?: string | undefined;
+  links?: APIErrorLinks$Outbound | undefined;
+  status: string;
+  code: string;
+  title: string;
+  detail: string;
+  source?: ErrorSource$Outbound | undefined;
+  meta?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const BadRequestError$outboundSchema: z.ZodType<
+  BadRequestError$Outbound,
+  z.ZodTypeDef,
+  BadRequestError
+> = z.object({
+  id: z.string().optional(),
+  links: APIErrorLinks$outboundSchema.optional(),
+  status: Status$outboundSchema,
+  code: Code$outboundSchema,
+  title: Title$outboundSchema,
+  detail: z.string(),
+  source: ErrorSource$outboundSchema.optional(),
+  meta: z.record(z.any()).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace BadRequestError$ {
+  /** @deprecated use `BadRequestError$inboundSchema` instead. */
+  export const inboundSchema = BadRequestError$inboundSchema;
+  /** @deprecated use `BadRequestError$outboundSchema` instead. */
+  export const outboundSchema = BadRequestError$outboundSchema;
+  /** @deprecated use `BadRequestError$Outbound` instead. */
+  export type Outbound = BadRequestError$Outbound;
+}
+
+export function badRequestErrorToJSON(
+  badRequestError: BadRequestError,
+): string {
+  return JSON.stringify(BadRequestError$outboundSchema.parse(badRequestError));
+}
+
+export function badRequestErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<BadRequestError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BadRequestError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BadRequestError' from JSON`,
+  );
+}