@unified-api/typescript-sdk 2.10.0 → 2.10.1

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

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

@@ -21,7 +21,7 @@ import {
   PropertyAtsActivityFrom$outboundSchema,
 } from "./propertyatsactivityfrom.js";
 
-export type Raw = {};
+export type AtsActivityRaw = {};
 
 export const AtsActivityType = {
   Note: "NOTE",
@@ -43,7 +43,7 @@ export type AtsActivity = {
   interviewId?: string | undefined;
   isPrivate?: boolean | undefined;
   jobId?: string | undefined;
-  raw?: Raw | undefined;
+  raw?: AtsActivityRaw | undefined;
   subType?: string | undefined;
   title?: string | undefined;
   to?: Array<AtsEmail> | undefined;
@@ -56,40 +56,46 @@ export type AtsActivity = {
 };
 
 /** @internal */
-export const Raw$inboundSchema: z.ZodType<Raw, z.ZodTypeDef, unknown> = z
-  .object({});
+export const AtsActivityRaw$inboundSchema: z.ZodType<
+  AtsActivityRaw,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
 
 /** @internal */
-export type Raw$Outbound = {};
+export type AtsActivityRaw$Outbound = {};
 
 /** @internal */
-export const Raw$outboundSchema: z.ZodType<Raw$Outbound, z.ZodTypeDef, Raw> = z
-  .object({});
+export const AtsActivityRaw$outboundSchema: z.ZodType<
+  AtsActivityRaw$Outbound,
+  z.ZodTypeDef,
+  AtsActivityRaw
+> = 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 Raw$ {
-  /** @deprecated use `Raw$inboundSchema` instead. */
-  export const inboundSchema = Raw$inboundSchema;
-  /** @deprecated use `Raw$outboundSchema` instead. */
-  export const outboundSchema = Raw$outboundSchema;
-  /** @deprecated use `Raw$Outbound` instead. */
-  export type Outbound = Raw$Outbound;
+export namespace AtsActivityRaw$ {
+  /** @deprecated use `AtsActivityRaw$inboundSchema` instead. */
+  export const inboundSchema = AtsActivityRaw$inboundSchema;
+  /** @deprecated use `AtsActivityRaw$outboundSchema` instead. */
+  export const outboundSchema = AtsActivityRaw$outboundSchema;
+  /** @deprecated use `AtsActivityRaw$Outbound` instead. */
+  export type Outbound = AtsActivityRaw$Outbound;
 }
 
-export function rawToJSON(raw: Raw): string {
-  return JSON.stringify(Raw$outboundSchema.parse(raw));
+export function atsActivityRawToJSON(atsActivityRaw: AtsActivityRaw): string {
+  return JSON.stringify(AtsActivityRaw$outboundSchema.parse(atsActivityRaw));
 }
 
-export function rawFromJSON(
+export function atsActivityRawFromJSON(
   jsonString: string,
-): SafeParseResult<Raw, SDKValidationError> {
+): SafeParseResult<AtsActivityRaw, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Raw$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Raw' from JSON`,
+    (x) => AtsActivityRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AtsActivityRaw' from JSON`,
   );
 }
 
@@ -133,7 +139,7 @@ export const AtsActivity$inboundSchema: z.ZodType<
   interview_id: z.string().optional(),
   is_private: z.boolean().optional(),
   job_id: z.string().optional(),
-  raw: z.lazy(() => Raw$inboundSchema).optional(),
+  raw: z.lazy(() => AtsActivityRaw$inboundSchema).optional(),
   sub_type: z.string().optional(),
   title: z.string().optional(),
   to: z.array(AtsEmail$inboundSchema).optional(),
@@ -170,7 +176,7 @@ export type AtsActivity$Outbound = {
   interview_id?: string | undefined;
   is_private?: boolean | undefined;
   job_id?: string | undefined;
-  raw?: Raw$Outbound | undefined;
+  raw?: AtsActivityRaw$Outbound | undefined;
   sub_type?: string | undefined;
   title?: string | undefined;
   to?: Array<AtsEmail$Outbound> | undefined;
@@ -197,7 +203,7 @@ export const AtsActivity$outboundSchema: z.ZodType<
   interviewId: z.string().optional(),
   isPrivate: z.boolean().optional(),
   jobId: z.string().optional(),
-  raw: z.lazy(() => Raw$outboundSchema).optional(),
+  raw: z.lazy(() => AtsActivityRaw$outboundSchema).optional(),
   subType: z.string().optional(),
   title: z.string().optional(),
   to: z.array(AtsEmail$outboundSchema).optional(),