@financeable/aggregation 0.2.0 → 0.2.5

package/src/models/components/applicationresourcebulksubmission.ts

@@ -78,7 +78,6 @@ export type ApplicationResourceBulkSubmissionDataRelationshipsCustomersType =
   >;
 
 export type ApplicationResourceBulkSubmissionDataRelationshipsCustomersData = {
-  id: string;
   type: ApplicationResourceBulkSubmissionDataRelationshipsCustomersType;
   attributes: AddressAttributes;
 };
@@ -92,7 +91,6 @@ export type ApplicationResourceBulkSubmissionRelationships = {
 };
 
 export type ApplicationResourceBulkSubmissionData = {
-  id: string;
   type: ApplicationResourceBulkSubmissionDataType;
   /**
    * A customer of the proposed financing
@@ -113,7 +111,6 @@ export type ApplicationResourceBulkSubmissionDataRelationshipsType = ClosedEnum<
 >;
 
 export type ApplicationResourceBulkSubmissionDataData = {
-  id: string;
   type: ApplicationResourceBulkSubmissionDataRelationshipsType;
   /**
    * The asset to be obtained by the customer, using the proposed loan financing.
@@ -370,7 +367,6 @@ export const ApplicationResourceBulkSubmissionDataRelationshipsCustomersData$inb
     z.ZodTypeDef,
     unknown
   > = z.object({
-    id: z.string(),
     type:
       ApplicationResourceBulkSubmissionDataRelationshipsCustomersType$inboundSchema,
     attributes: AddressAttributes$inboundSchema,
@@ -379,7 +375,6 @@ export const ApplicationResourceBulkSubmissionDataRelationshipsCustomersData$inb
 /** @internal */
 export type ApplicationResourceBulkSubmissionDataRelationshipsCustomersData$Outbound =
   {
-    id: string;
     type: string;
     attributes: AddressAttributes$Outbound;
   };
@@ -391,7 +386,6 @@ export const ApplicationResourceBulkSubmissionDataRelationshipsCustomersData$out
     z.ZodTypeDef,
     ApplicationResourceBulkSubmissionDataRelationshipsCustomersData
   > = z.object({
-    id: z.string(),
     type:
       ApplicationResourceBulkSubmissionDataRelationshipsCustomersType$outboundSchema,
     attributes: AddressAttributes$outboundSchema,
@@ -572,7 +566,6 @@ export const ApplicationResourceBulkSubmissionData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string(),
   type: ApplicationResourceBulkSubmissionDataType$inboundSchema,
   attributes: CustomerAttributes$inboundSchema,
   relationships: z.lazy(() =>
@@ -582,7 +575,6 @@ export const ApplicationResourceBulkSubmissionData$inboundSchema: z.ZodType<
 
 /** @internal */
 export type ApplicationResourceBulkSubmissionData$Outbound = {
-  id: string;
   type: string;
   attributes: CustomerAttributes$Outbound;
   relationships: ApplicationResourceBulkSubmissionRelationships$Outbound;
@@ -594,7 +586,6 @@ export const ApplicationResourceBulkSubmissionData$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ApplicationResourceBulkSubmissionData
 > = z.object({
-  id: z.string(),
   type: ApplicationResourceBulkSubmissionDataType$outboundSchema,
   attributes: CustomerAttributes$outboundSchema,
   relationships: z.lazy(() =>
@@ -723,14 +714,12 @@ export const ApplicationResourceBulkSubmissionDataData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string(),
   type: ApplicationResourceBulkSubmissionDataRelationshipsType$inboundSchema,
   attributes: AssetAttributes$inboundSchema,
 });
 
 /** @internal */
 export type ApplicationResourceBulkSubmissionDataData$Outbound = {
-  id: string;
   type: string;
   attributes: AssetAttributes$Outbound;
 };
@@ -742,7 +731,6 @@ export const ApplicationResourceBulkSubmissionDataData$outboundSchema:
     z.ZodTypeDef,
     ApplicationResourceBulkSubmissionDataData
   > = z.object({
-    id: z.string(),
     type: ApplicationResourceBulkSubmissionDataRelationshipsType$outboundSchema,
     attributes: AssetAttributes$outboundSchema,
   });

package/src/models/components/customerattributes.ts

@@ -3,29 +3,20 @@
  */
 
 import * as z from "zod";
-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";
+import {
+  CustomerIDType,
+  CustomerIDType$inboundSchema,
+  CustomerIDType$outboundSchema,
+} from "./customeridtype.js";
 import {
   CustomerTitle,
   CustomerTitle$inboundSchema,
   CustomerTitle$outboundSchema,
 } from "./customertitle.js";
 
-/**
- * Type of ID, either drivers' license or passport
- */
-export const IDType = {
-  Licence: "licence",
-  Passport: "passport",
-} as const;
-/**
- * Type of ID, either drivers' license or passport
- */
-export type IDType = ClosedEnum<typeof IDType>;
-
 /**
  * A customer of the proposed financing
  */
@@ -57,32 +48,13 @@ export type CustomerAttributes = {
   /**
    * Type of ID, either drivers' license or passport
    */
-  idType?: IDType | undefined;
+  idType?: CustomerIDType | undefined;
   /**
    * Number of the ID
    */
   idNumber?: string | undefined;
 };
 
-/** @internal */
-export const IDType$inboundSchema: z.ZodNativeEnum<typeof IDType> = z
-  .nativeEnum(IDType);
-
-/** @internal */
-export const IDType$outboundSchema: z.ZodNativeEnum<typeof IDType> =
-  IDType$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace IDType$ {
-  /** @deprecated use `IDType$inboundSchema` instead. */
-  export const inboundSchema = IDType$inboundSchema;
-  /** @deprecated use `IDType$outboundSchema` instead. */
-  export const outboundSchema = IDType$outboundSchema;
-}
-
 /** @internal */
 export const CustomerAttributes$inboundSchema: z.ZodType<
   CustomerAttributes,
@@ -94,15 +66,9 @@ export const CustomerAttributes$inboundSchema: z.ZodType<
   middleNames: z.string().optional(),
   lastName: z.string(),
   dateOfBirth: z.string(),
-  IDExpiryDate: z.string(),
-  IDType: IDType$inboundSchema.optional(),
-  IDNumber: z.string().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "IDExpiryDate": "idExpiryDate",
-    "IDType": "idType",
-    "IDNumber": "idNumber",
-  });
+  idExpiryDate: z.string(),
+  idType: CustomerIDType$inboundSchema.optional(),
+  idNumber: z.string().optional(),
 });
 
 /** @internal */
@@ -112,9 +78,9 @@ export type CustomerAttributes$Outbound = {
   middleNames?: string | undefined;
   lastName: string;
   dateOfBirth: string;
-  IDExpiryDate: string;
-  IDType?: string | undefined;
-  IDNumber?: string | undefined;
+  idExpiryDate: string;
+  idType?: string | undefined;
+  idNumber?: string | undefined;
 };
 
 /** @internal */
@@ -129,14 +95,8 @@ export const CustomerAttributes$outboundSchema: z.ZodType<
   lastName: z.string(),
   dateOfBirth: z.string(),
   idExpiryDate: z.string(),
-  idType: IDType$outboundSchema.optional(),
+  idType: CustomerIDType$outboundSchema.optional(),
   idNumber: z.string().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    idExpiryDate: "IDExpiryDate",
-    idType: "IDType",
-    idNumber: "IDNumber",
-  });
 });
 
 /**

package/src/models/components/customeridtype.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const CustomerIDType = {
+  Passport: "passport",
+  Licence: "licence",
+} as const;
+export type CustomerIDType = ClosedEnum<typeof CustomerIDType>;
+
+/** @internal */
+export const CustomerIDType$inboundSchema: z.ZodNativeEnum<
+  typeof CustomerIDType
+> = z.nativeEnum(CustomerIDType);
+
+/** @internal */
+export const CustomerIDType$outboundSchema: z.ZodNativeEnum<
+  typeof CustomerIDType
+> = CustomerIDType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace CustomerIDType$ {
+  /** @deprecated use `CustomerIDType$inboundSchema` instead. */
+  export const inboundSchema = CustomerIDType$inboundSchema;
+  /** @deprecated use `CustomerIDType$outboundSchema` instead. */
+  export const outboundSchema = CustomerIDType$outboundSchema;
+}

package/src/models/components/index.ts

@@ -11,6 +11,7 @@ export * from "./applicationstatus.js";
 export * from "./applicationtype.js";
 export * from "./assetattributes.js";
 export * from "./customerattributes.js";
+export * from "./customeridtype.js";
 export * from "./customertitle.js";
 export * from "./errorsource.js";
 export * from "./forbiddenerror.js";

package/financeable-typescript/.devcontainer/README.md

@@ -1,30 +0,0 @@
-
-> **Remember to shutdown a GitHub Codespace when it is not in use!**
-
-# Dev Containers Quick Start
-
-The default location for usage snippets is the `samples` directory.
-
-## Running a Usage Sample
-
-A sample usage example has been provided in a `root.ts` file. As you work with the SDK, it's expected that you will modify these samples to fit your needs. To execute this particular snippet, use the command below.
-
-```
-ts-node root.ts
-```
-
-## Generating Additional Usage Samples
-
-The speakeasy CLI allows you to generate more usage snippets. Here's how:
-
-- To generate a sample for a specific operation by providing an operation ID, use:
-
-```
-speakeasy generate usage -s ./spec.yaml -l typescript -i {INPUT_OPERATION_ID} -o ./samples
-```
-
-- To generate samples for an entire namespace (like a tag or group name), use:
-
-```
-speakeasy generate usage -s ./spec.yaml -l typescript -n {INPUT_TAG_NAME} -o ./samples
-```

package/financeable-typescript/FUNCTIONS.md

@@ -1,205 +0,0 @@
-# Standalone Functions
-
-> [!NOTE]
-> This section is useful if you are using a bundler and targetting browsers and
-> runtimes where the size of an application affects performance and load times. 
-
-Every method in this SDK is also available as a standalone function. This
-alternative API is suitable when targetting the browser or serverless runtimes
-and using a bundler to build your application since all unused functionality
-will be tree-shaken away. This includes code for unused methods, Zod schemas,
-encoding helpers and response handlers. The result is dramatically smaller
-impact on the application's final bundle size which grows very slowly as you use
-more and more functionality from this SDK.
-
-Calling methods through the main SDK class remains a valid and generally more
-more ergonomic option. Standalone functions represent an optimisation for a
-specific category of applications.
-
-## Example
-
-```typescript
-import { FinanceableCore } from "@financeable/aggregation/core.js";
-import { applicationsCreate } from "@financeable/aggregation/funcs/applicationsCreate.js";
-import { SDKValidationError } from "@financeable/aggregation/models/errors/sdkvalidationerror.js";
-
-// Use `FinanceableCore` for best tree-shaking performance.
-// You can create one instance of it to use across an application.
-const financeable = new FinanceableCore();
-
-async function run() {
-  const res = await applicationsCreate(financeable, {
-    data: {
-      type: "applications",
-      attributes: {
-        purpose: "Purchase of a motor vehicle",
-        applicationType: "consumer",
-      },
-      relationships: {
-        loanDetails: {
-          data: {
-            type: "loan-details",
-            attributes: {
-              repayments: 12,
-              repaymentFrequency: "monthly",
-              repaymentStructure: "group-payments",
-              loanAmount: "10280.95",
-              purpose: "Purchase of a motor vehicle",
-              term: 48,
-              balloon: 5,
-              deposit: "2500",
-              originationFee: 200,
-              rate: "0.15",
-              rateAdjustment: "-0.01",
-            },
-          },
-        },
-        customers: {
-          data: [
-            {
-              id: "<id>",
-              type: "customers",
-              attributes: {
-                title: "Mr",
-                firstName: "John",
-                lastName: "Smith",
-                dateOfBirth: "01-01-1990",
-                idExpiryDate: "01-01-2025",
-                idType: "licence",
-                idNumber: "12345678",
-              },
-              relationships: {
-                addresses: {
-                  data: [
-                    {
-                      id: "<id>",
-                      type: "addresses",
-                      attributes: {
-                        addressType: "residential",
-                        fullAddress: "42 Wallaby Way, Sydney NSW 2000",
-                        city: "Sydney",
-                        postCode: "2000",
-                        streetAddress: "42 Wallaby Way",
-                        addressLine2: "",
-                        streetNumber: "42",
-                        streetType: "Way",
-                        street: "Wallaby",
-                        state: "NSW",
-                        country: "Australia",
-                        status: "current",
-                        monthsAt: 24,
-                        yearsAt: 2,
-                      },
-                    },
-                  ],
-                },
-              },
-            },
-          ],
-        },
-        asset: {
-          data: {
-            id: "<id>",
-            type: "asset",
-            attributes: {
-              ageOfAsset: 3,
-              ageOfAssetAtEnd: 8,
-              condition: "USED",
-              assetType: "MOTOR_VEHICLE_(<4.5_TONNES)",
-              purpose: "VEHICLE",
-              assetValue: "35000.00",
-              make: "Toyota",
-              assetModel: "Camry",
-              registrationNumber: "ABC123",
-              registrationState: "VIC",
-              vin: "1HGCM82633A123456",
-              supplierName: "Mr and Mrs Smith",
-              supplierABN: "12345678901",
-              supplierAddress: "123 Car Street, Melbourne VIC 3000",
-              supplierPhone: "0412345678",
-              supplierContactName: "John Smith",
-              supplierEmail: "john.smith@mrandmrssmith.com.au",
-              privateSale: false,
-              typeOfSale: "DEALER",
-              description: "2020 Toyota Camry Hybrid SL, Silver, 45,000km",
-              netAssetValue: "32000.00",
-              isLuxury: false,
-              additionalFees: "995.00",
-              additionalTaxes: "0.00",
-            },
-          },
-        },
-      },
-    },
-  });
-
-  switch (true) {
-    case res.ok:
-      // The success case will be handled outside of the switch block
-      break;
-    case res.error instanceof SDKValidationError:
-      // Pretty-print validation errors.
-      return console.log(res.error.pretty());
-    case res.error instanceof Error:
-      return console.log(res.error);
-    default:
-      // TypeScript's type checking will fail on the following line if the above
-      // cases were not exhaustive.
-      res.error satisfies never;
-      throw new Error("Assertion failed: expected error checks to be exhaustive: " + res.error);
-  }
-
-
-  const { value: result } = res;
-
-  // Handle the result
-  console.log(result);
-}
-
-run();
-```
-
-## Result types
-
-Standalone functions differ from SDK methods in that they return a
-`Result<Value, Error>` type to capture _known errors_ and document them using
-the type system. By avoiding throwing errors, application code maintains clear
-control flow and error-handling become part of the regular flow of application
-code.
-
-> We use the term "known errors" because standalone functions, and JavaScript
-> code in general, can still throw unexpected errors such as `TypeError`s,
-> `RangeError`s and `DOMException`s. Exhaustively catching all errors may be
-> something this SDK addresses in the future. Nevertheless, there is still a lot
-> of benefit from capturing most errors and turning them into values.
-
-The second reason for this style of programming is because these functions will
-typically be used in front-end applications where exception throwing is
-sometimes discouraged or considered unidiomatic. React and similar ecosystems
-and libraries tend to promote this style of programming so that components
-render useful content under all states (loading, success, error and so on).
-
-The general pattern when calling standalone functions looks like this:
-
-```typescript
-import { Core } from "<sdk-package-name>";
-import { fetchSomething } from "<sdk-package-name>/funcs/fetchSomething.js";
-
-const client = new Core();
-
-async function run() {
-  const result = await fetchSomething(client, { id: "123" });
-  if (!result.ok) {
-    // You can throw the error or handle it. It's your choice now.
-    throw result.error;
-  }
-
-  console.log(result.value);
-}
-
-run();
-```
-
-Notably, `result.error` above will have an explicit type compared to a try-catch
-variation where the error in the catch block can only be of type `unknown` (or
-`any` depending on your TypeScript settings).