@unified-api/typescript-sdk 2.10.0 → 2.10.2

package/src/sdk/models/shared/accountinginvoice.ts

@@ -23,6 +23,8 @@ export type PaymentCollectionMethod = ClosedEnum<
   typeof PaymentCollectionMethod
 >;
 
+export type AccountingInvoiceRaw = {};
+
 export const AccountingInvoiceStatus = {
   Draft: "DRAFT",
   Voided: "VOIDED",
@@ -58,7 +60,7 @@ export type AccountingInvoice = {
   paidAmount?: number | undefined;
   paidAt?: Date | undefined;
   paymentCollectionMethod?: PaymentCollectionMethod | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingInvoiceRaw | undefined;
   refundAmount?: number | undefined;
   refundReason?: string | undefined;
   refundedAt?: Date | undefined;
@@ -91,6 +93,54 @@ export namespace PaymentCollectionMethod$ {
   export const outboundSchema = PaymentCollectionMethod$outboundSchema;
 }
 
+/** @internal */
+export const AccountingInvoiceRaw$inboundSchema: z.ZodType<
+  AccountingInvoiceRaw,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type AccountingInvoiceRaw$Outbound = {};
+
+/** @internal */
+export const AccountingInvoiceRaw$outboundSchema: z.ZodType<
+  AccountingInvoiceRaw$Outbound,
+  z.ZodTypeDef,
+  AccountingInvoiceRaw
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountingInvoiceRaw$ {
+  /** @deprecated use `AccountingInvoiceRaw$inboundSchema` instead. */
+  export const inboundSchema = AccountingInvoiceRaw$inboundSchema;
+  /** @deprecated use `AccountingInvoiceRaw$outboundSchema` instead. */
+  export const outboundSchema = AccountingInvoiceRaw$outboundSchema;
+  /** @deprecated use `AccountingInvoiceRaw$Outbound` instead. */
+  export type Outbound = AccountingInvoiceRaw$Outbound;
+}
+
+export function accountingInvoiceRawToJSON(
+  accountingInvoiceRaw: AccountingInvoiceRaw,
+): string {
+  return JSON.stringify(
+    AccountingInvoiceRaw$outboundSchema.parse(accountingInvoiceRaw),
+  );
+}
+
+export function accountingInvoiceRawFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountingInvoiceRaw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountingInvoiceRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountingInvoiceRaw' from JSON`,
+  );
+}
+
 /** @internal */
 export const AccountingInvoiceStatus$inboundSchema: z.ZodNativeEnum<
   typeof AccountingInvoiceStatus
@@ -160,7 +210,7 @@ export const AccountingInvoice$inboundSchema: z.ZodType<
   paid_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   payment_collection_method: PaymentCollectionMethod$inboundSchema.optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingInvoiceRaw$inboundSchema).optional(),
   refund_amount: z.number().optional(),
   refund_reason: z.string().optional(),
   refunded_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
@@ -211,7 +261,7 @@ export type AccountingInvoice$Outbound = {
   paid_amount?: number | undefined;
   paid_at?: string | undefined;
   payment_collection_method?: string | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingInvoiceRaw$Outbound | undefined;
   refund_amount?: number | undefined;
   refund_reason?: string | undefined;
   refunded_at?: string | undefined;
@@ -244,7 +294,7 @@ export const AccountingInvoice$outboundSchema: z.ZodType<
   paidAmount: z.number().optional(),
   paidAt: z.date().transform(v => v.toISOString()).optional(),
   paymentCollectionMethod: PaymentCollectionMethod$outboundSchema.optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingInvoiceRaw$outboundSchema).optional(),
   refundAmount: z.number().optional(),
   refundReason: z.string().optional(),
   refundedAt: z.date().transform(v => v.toISOString()).optional(),

package/src/sdk/models/shared/accountingjournal.ts

@@ -14,6 +14,8 @@ import {
   AccountingJournalLineitem$outboundSchema,
 } from "./accountingjournallineitem.js";
 
+export type AccountingJournalRaw = {};
+
 export type AccountingJournal = {
   createdAt?: Date | undefined;
   currency?: string | undefined;
@@ -23,13 +25,61 @@ export type AccountingJournal = {
    * new field name
    */
   lineitems?: Array<AccountingJournalLineitem> | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingJournalRaw | undefined;
   reference?: string | undefined;
   taxAmount?: number | undefined;
   taxrateId?: string | undefined;
   updatedAt?: Date | undefined;
 };
 
+/** @internal */
+export const AccountingJournalRaw$inboundSchema: z.ZodType<
+  AccountingJournalRaw,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type AccountingJournalRaw$Outbound = {};
+
+/** @internal */
+export const AccountingJournalRaw$outboundSchema: z.ZodType<
+  AccountingJournalRaw$Outbound,
+  z.ZodTypeDef,
+  AccountingJournalRaw
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountingJournalRaw$ {
+  /** @deprecated use `AccountingJournalRaw$inboundSchema` instead. */
+  export const inboundSchema = AccountingJournalRaw$inboundSchema;
+  /** @deprecated use `AccountingJournalRaw$outboundSchema` instead. */
+  export const outboundSchema = AccountingJournalRaw$outboundSchema;
+  /** @deprecated use `AccountingJournalRaw$Outbound` instead. */
+  export type Outbound = AccountingJournalRaw$Outbound;
+}
+
+export function accountingJournalRawToJSON(
+  accountingJournalRaw: AccountingJournalRaw,
+): string {
+  return JSON.stringify(
+    AccountingJournalRaw$outboundSchema.parse(accountingJournalRaw),
+  );
+}
+
+export function accountingJournalRawFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountingJournalRaw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountingJournalRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountingJournalRaw' from JSON`,
+  );
+}
+
 /** @internal */
 export const AccountingJournal$inboundSchema: z.ZodType<
   AccountingJournal,
@@ -42,7 +92,7 @@ export const AccountingJournal$inboundSchema: z.ZodType<
   description: z.string().optional(),
   id: z.string().optional(),
   lineitems: z.array(AccountingJournalLineitem$inboundSchema).optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingJournalRaw$inboundSchema).optional(),
   reference: z.string().optional(),
   tax_amount: z.number().optional(),
   taxrate_id: z.string().optional(),
@@ -64,7 +114,7 @@ export type AccountingJournal$Outbound = {
   description?: string | undefined;
   id?: string | undefined;
   lineitems?: Array<AccountingJournalLineitem$Outbound> | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingJournalRaw$Outbound | undefined;
   reference?: string | undefined;
   tax_amount?: number | undefined;
   taxrate_id?: string | undefined;
@@ -82,7 +132,7 @@ export const AccountingJournal$outboundSchema: z.ZodType<
   description: z.string().optional(),
   id: z.string().optional(),
   lineitems: z.array(AccountingJournalLineitem$outboundSchema).optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingJournalRaw$outboundSchema).optional(),
   reference: z.string().optional(),
   taxAmount: z.number().optional(),
   taxrateId: z.string().optional(),

package/src/sdk/models/shared/accountingorder.ts

@@ -27,6 +27,8 @@ import {
   PropertyAccountingOrderShippingAddress$outboundSchema,
 } from "./propertyaccountingordershippingaddress.js";
 
+export type AccountingOrderRaw = {};
+
 export const AccountingOrderStatus = {
   Draft: "DRAFT",
   Voided: "VOIDED",
@@ -52,7 +54,7 @@ export type AccountingOrder = {
   currency?: string | undefined;
   id?: string | undefined;
   lineitems?: Array<AccountingLineitem> | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingOrderRaw | undefined;
   shippingAddress?: PropertyAccountingOrderShippingAddress | undefined;
   status?: AccountingOrderStatus | undefined;
   totalAmount?: number | undefined;
@@ -60,6 +62,54 @@ export type AccountingOrder = {
   updatedAt?: Date | undefined;
 };
 
+/** @internal */
+export const AccountingOrderRaw$inboundSchema: z.ZodType<
+  AccountingOrderRaw,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type AccountingOrderRaw$Outbound = {};
+
+/** @internal */
+export const AccountingOrderRaw$outboundSchema: z.ZodType<
+  AccountingOrderRaw$Outbound,
+  z.ZodTypeDef,
+  AccountingOrderRaw
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountingOrderRaw$ {
+  /** @deprecated use `AccountingOrderRaw$inboundSchema` instead. */
+  export const inboundSchema = AccountingOrderRaw$inboundSchema;
+  /** @deprecated use `AccountingOrderRaw$outboundSchema` instead. */
+  export const outboundSchema = AccountingOrderRaw$outboundSchema;
+  /** @deprecated use `AccountingOrderRaw$Outbound` instead. */
+  export type Outbound = AccountingOrderRaw$Outbound;
+}
+
+export function accountingOrderRawToJSON(
+  accountingOrderRaw: AccountingOrderRaw,
+): string {
+  return JSON.stringify(
+    AccountingOrderRaw$outboundSchema.parse(accountingOrderRaw),
+  );
+}
+
+export function accountingOrderRawFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountingOrderRaw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountingOrderRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountingOrderRaw' from JSON`,
+  );
+}
+
 /** @internal */
 export const AccountingOrderStatus$inboundSchema: z.ZodNativeEnum<
   typeof AccountingOrderStatus
@@ -117,7 +167,7 @@ export const AccountingOrder$inboundSchema: z.ZodType<
   currency: z.string().optional(),
   id: z.string().optional(),
   lineitems: z.array(AccountingLineitem$inboundSchema).optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingOrderRaw$inboundSchema).optional(),
   shipping_address: PropertyAccountingOrderShippingAddress$inboundSchema
     .optional(),
   status: AccountingOrderStatus$inboundSchema.optional(),
@@ -146,7 +196,7 @@ export type AccountingOrder$Outbound = {
   currency?: string | undefined;
   id?: string | undefined;
   lineitems?: Array<AccountingLineitem$Outbound> | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingOrderRaw$Outbound | undefined;
   shipping_address?:
     | PropertyAccountingOrderShippingAddress$Outbound
     | undefined;
@@ -170,7 +220,7 @@ export const AccountingOrder$outboundSchema: z.ZodType<
   currency: z.string().optional(),
   id: z.string().optional(),
   lineitems: z.array(AccountingLineitem$outboundSchema).optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingOrderRaw$outboundSchema).optional(),
   shippingAddress: PropertyAccountingOrderShippingAddress$outboundSchema
     .optional(),
   status: AccountingOrderStatus$outboundSchema.optional(),

package/src/sdk/models/shared/accountingorganization.ts

@@ -14,6 +14,8 @@ import {
   PropertyAccountingOrganizationAddress$outboundSchema,
 } from "./propertyaccountingorganizationaddress.js";
 
+export type AccountingOrganizationRaw = {};
+
 export type AccountingOrganization = {
   address?: PropertyAccountingOrganizationAddress | undefined;
   createdAt?: Date | undefined;
@@ -23,13 +25,61 @@ export type AccountingOrganization = {
   legalName?: string | undefined;
   name: string;
   organizationCode?: string | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingOrganizationRaw | undefined;
   taxNumber?: string | undefined;
   timezone?: string | undefined;
   updatedAt?: Date | undefined;
   website?: string | undefined;
 };
 
+/** @internal */
+export const AccountingOrganizationRaw$inboundSchema: z.ZodType<
+  AccountingOrganizationRaw,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type AccountingOrganizationRaw$Outbound = {};
+
+/** @internal */
+export const AccountingOrganizationRaw$outboundSchema: z.ZodType<
+  AccountingOrganizationRaw$Outbound,
+  z.ZodTypeDef,
+  AccountingOrganizationRaw
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountingOrganizationRaw$ {
+  /** @deprecated use `AccountingOrganizationRaw$inboundSchema` instead. */
+  export const inboundSchema = AccountingOrganizationRaw$inboundSchema;
+  /** @deprecated use `AccountingOrganizationRaw$outboundSchema` instead. */
+  export const outboundSchema = AccountingOrganizationRaw$outboundSchema;
+  /** @deprecated use `AccountingOrganizationRaw$Outbound` instead. */
+  export type Outbound = AccountingOrganizationRaw$Outbound;
+}
+
+export function accountingOrganizationRawToJSON(
+  accountingOrganizationRaw: AccountingOrganizationRaw,
+): string {
+  return JSON.stringify(
+    AccountingOrganizationRaw$outboundSchema.parse(accountingOrganizationRaw),
+  );
+}
+
+export function accountingOrganizationRawFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountingOrganizationRaw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountingOrganizationRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountingOrganizationRaw' from JSON`,
+  );
+}
+
 /** @internal */
 export const AccountingOrganization$inboundSchema: z.ZodType<
   AccountingOrganization,
@@ -45,7 +95,7 @@ export const AccountingOrganization$inboundSchema: z.ZodType<
   legal_name: z.string().optional(),
   name: z.string(),
   organization_code: z.string().optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingOrganizationRaw$inboundSchema).optional(),
   tax_number: z.string().optional(),
   timezone: z.string().optional(),
   updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
@@ -72,7 +122,7 @@ export type AccountingOrganization$Outbound = {
   legal_name?: string | undefined;
   name: string;
   organization_code?: string | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingOrganizationRaw$Outbound | undefined;
   tax_number?: string | undefined;
   timezone?: string | undefined;
   updated_at?: string | undefined;
@@ -93,7 +143,7 @@ export const AccountingOrganization$outboundSchema: z.ZodType<
   legalName: z.string().optional(),
   name: z.string(),
   organizationCode: z.string().optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingOrganizationRaw$outboundSchema).optional(),
   taxNumber: z.string().optional(),
   timezone: z.string().optional(),
   updatedAt: z.date().transform(v => v.toISOString()).optional(),

package/src/sdk/models/shared/accountingtaxrate.ts

@@ -8,6 +8,8 @@ import { safeParse } from "../../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+export type AccountingTaxrateRaw = {};
+
 export type AccountingTaxrate = {
   createdAt?: Date | undefined;
   description?: string | undefined;
@@ -15,10 +17,58 @@ export type AccountingTaxrate = {
   isActive?: boolean | undefined;
   name?: string | undefined;
   rate?: number | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingTaxrateRaw | undefined;
   updatedAt?: Date | undefined;
 };
 
+/** @internal */
+export const AccountingTaxrateRaw$inboundSchema: z.ZodType<
+  AccountingTaxrateRaw,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type AccountingTaxrateRaw$Outbound = {};
+
+/** @internal */
+export const AccountingTaxrateRaw$outboundSchema: z.ZodType<
+  AccountingTaxrateRaw$Outbound,
+  z.ZodTypeDef,
+  AccountingTaxrateRaw
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountingTaxrateRaw$ {
+  /** @deprecated use `AccountingTaxrateRaw$inboundSchema` instead. */
+  export const inboundSchema = AccountingTaxrateRaw$inboundSchema;
+  /** @deprecated use `AccountingTaxrateRaw$outboundSchema` instead. */
+  export const outboundSchema = AccountingTaxrateRaw$outboundSchema;
+  /** @deprecated use `AccountingTaxrateRaw$Outbound` instead. */
+  export type Outbound = AccountingTaxrateRaw$Outbound;
+}
+
+export function accountingTaxrateRawToJSON(
+  accountingTaxrateRaw: AccountingTaxrateRaw,
+): string {
+  return JSON.stringify(
+    AccountingTaxrateRaw$outboundSchema.parse(accountingTaxrateRaw),
+  );
+}
+
+export function accountingTaxrateRawFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountingTaxrateRaw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountingTaxrateRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountingTaxrateRaw' from JSON`,
+  );
+}
+
 /** @internal */
 export const AccountingTaxrate$inboundSchema: z.ZodType<
   AccountingTaxrate,
@@ -32,7 +82,7 @@ export const AccountingTaxrate$inboundSchema: z.ZodType<
   is_active: z.boolean().optional(),
   name: z.string().optional(),
   rate: z.number().optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingTaxrateRaw$inboundSchema).optional(),
   updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
 }).transform((v) => {
@@ -51,7 +101,7 @@ export type AccountingTaxrate$Outbound = {
   is_active?: boolean | undefined;
   name?: string | undefined;
   rate?: number | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingTaxrateRaw$Outbound | undefined;
   updated_at?: string | undefined;
 };
 
@@ -67,7 +117,7 @@ export const AccountingTaxrate$outboundSchema: z.ZodType<
   isActive: z.boolean().optional(),
   name: z.string().optional(),
   rate: z.number().optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingTaxrateRaw$outboundSchema).optional(),
   updatedAt: z.date().transform(v => v.toISOString()).optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/sdk/models/shared/accountingtransaction.ts

@@ -20,6 +20,8 @@ import {
   AccountingTransactionLineItem$outboundSchema,
 } from "./accountingtransactionlineitem.js";
 
+export type AccountingTransactionRaw = {};
+
 export type AccountingTransaction = {
   accountId?: string | undefined;
   contactId?: string | undefined;
@@ -32,7 +34,7 @@ export type AccountingTransaction = {
   memo?: string | undefined;
   paymentMethod?: string | undefined;
   paymentTerms?: string | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingTransactionRaw | undefined;
   reference?: string | undefined;
   splitAccountId?: string | undefined;
   subTotalAmount?: number | undefined;
@@ -42,6 +44,54 @@ export type AccountingTransaction = {
   updatedAt?: Date | undefined;
 };
 
+/** @internal */
+export const AccountingTransactionRaw$inboundSchema: z.ZodType<
+  AccountingTransactionRaw,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type AccountingTransactionRaw$Outbound = {};
+
+/** @internal */
+export const AccountingTransactionRaw$outboundSchema: z.ZodType<
+  AccountingTransactionRaw$Outbound,
+  z.ZodTypeDef,
+  AccountingTransactionRaw
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountingTransactionRaw$ {
+  /** @deprecated use `AccountingTransactionRaw$inboundSchema` instead. */
+  export const inboundSchema = AccountingTransactionRaw$inboundSchema;
+  /** @deprecated use `AccountingTransactionRaw$outboundSchema` instead. */
+  export const outboundSchema = AccountingTransactionRaw$outboundSchema;
+  /** @deprecated use `AccountingTransactionRaw$Outbound` instead. */
+  export type Outbound = AccountingTransactionRaw$Outbound;
+}
+
+export function accountingTransactionRawToJSON(
+  accountingTransactionRaw: AccountingTransactionRaw,
+): string {
+  return JSON.stringify(
+    AccountingTransactionRaw$outboundSchema.parse(accountingTransactionRaw),
+  );
+}
+
+export function accountingTransactionRawFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountingTransactionRaw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountingTransactionRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountingTransactionRaw' from JSON`,
+  );
+}
+
 /** @internal */
 export const AccountingTransaction$inboundSchema: z.ZodType<
   AccountingTransaction,
@@ -60,7 +110,7 @@ export const AccountingTransaction$inboundSchema: z.ZodType<
   memo: z.string().optional(),
   payment_method: z.string().optional(),
   payment_terms: z.string().optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingTransactionRaw$inboundSchema).optional(),
   reference: z.string().optional(),
   split_account_id: z.string().optional(),
   sub_total_amount: z.number().optional(),
@@ -98,7 +148,7 @@ export type AccountingTransaction$Outbound = {
   memo?: string | undefined;
   payment_method?: string | undefined;
   payment_terms?: string | undefined;
-  raw?: { [k: string]: any } | undefined;
+  raw?: AccountingTransactionRaw$Outbound | undefined;
   reference?: string | undefined;
   split_account_id?: string | undefined;
   sub_total_amount?: number | undefined;
@@ -125,7 +175,7 @@ export const AccountingTransaction$outboundSchema: z.ZodType<
   memo: z.string().optional(),
   paymentMethod: z.string().optional(),
   paymentTerms: z.string().optional(),
-  raw: z.record(z.any()).optional(),
+  raw: z.lazy(() => AccountingTransactionRaw$outboundSchema).optional(),
   reference: z.string().optional(),
   splitAccountId: z.string().optional(),
   subTotalAmount: z.number().optional(),

package/src/sdk/models/shared/accountingtransactioncontact.ts

@@ -3,28 +3,55 @@
  */
 
 import * as z from "zod";
+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 AccountingTransactionContact = {};
+export type AccountingTransactionContact = {
+  id: string;
+  isCustomer?: boolean | undefined;
+  isSupplier?: boolean | undefined;
+};
 
 /** @internal */
 export const AccountingTransactionContact$inboundSchema: z.ZodType<
   AccountingTransactionContact,
   z.ZodTypeDef,
   unknown
-> = z.object({});
+> = z.object({
+  id: z.string(),
+  is_customer: z.boolean().optional(),
+  is_supplier: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "is_customer": "isCustomer",
+    "is_supplier": "isSupplier",
+  });
+});
 
 /** @internal */
-export type AccountingTransactionContact$Outbound = {};
+export type AccountingTransactionContact$Outbound = {
+  id: string;
+  is_customer?: boolean | undefined;
+  is_supplier?: boolean | undefined;
+};
 
 /** @internal */
 export const AccountingTransactionContact$outboundSchema: z.ZodType<
   AccountingTransactionContact$Outbound,
   z.ZodTypeDef,
   AccountingTransactionContact
-> = z.object({});
+> = z.object({
+  id: z.string(),
+  isCustomer: z.boolean().optional(),
+  isSupplier: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    isCustomer: "is_customer",
+    isSupplier: "is_supplier",
+  });
+});
 
 /**
  * @internal