@unified-api/typescript-sdk 2.86.1 → 2.86.3

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

@@ -108,11 +108,13 @@ export const HrisEmployeeGender = {
 } as const;
 export type HrisEmployeeGender = OpenEnum<typeof HrisEmployeeGender>;
 
-export const MaritalStatus = {
+export const HrisEmployeeMaritalStatus = {
   Married: "MARRIED",
   Single: "SINGLE",
 } as const;
-export type MaritalStatus = OpenEnum<typeof MaritalStatus>;
+export type HrisEmployeeMaritalStatus = OpenEnum<
+  typeof HrisEmployeeMaritalStatus
+>;
 
 /**
  * how often the employee is paid (eg. BIWEEKLY)
@@ -198,7 +200,7 @@ export type HrisEmployee = {
   lastName?: string | undefined;
   locations?: Array<HrisLocation> | undefined;
   managerId?: string | undefined;
-  maritalStatus?: MaritalStatus | undefined;
+  maritalStatus?: HrisEmployeeMaritalStatus | undefined;
   metadata?: Array<HrisMetadata> | undefined;
   /**
    * The employee's full name
@@ -297,17 +299,17 @@ export const HrisEmployeeGender$outboundSchema: z.ZodType<
 > = openEnums.outboundSchema(HrisEmployeeGender);
 
 /** @internal */
-export const MaritalStatus$inboundSchema: z.ZodType<
-  MaritalStatus,
+export const HrisEmployeeMaritalStatus$inboundSchema: z.ZodType<
+  HrisEmployeeMaritalStatus,
   z.ZodTypeDef,
   unknown
-> = openEnums.inboundSchema(MaritalStatus);
+> = openEnums.inboundSchema(HrisEmployeeMaritalStatus);
 /** @internal */
-export const MaritalStatus$outboundSchema: z.ZodType<
+export const HrisEmployeeMaritalStatus$outboundSchema: z.ZodType<
   string,
   z.ZodTypeDef,
-  MaritalStatus
-> = openEnums.outboundSchema(MaritalStatus);
+  HrisEmployeeMaritalStatus
+> = openEnums.outboundSchema(HrisEmployeeMaritalStatus);
 
 /** @internal */
 export const PayFrequency$inboundSchema: z.ZodType<
@@ -358,7 +360,7 @@ export const HrisEmployee$inboundSchema: z.ZodType<
   last_name: z.string().optional(),
   locations: z.array(HrisLocation$inboundSchema).optional(),
   manager_id: z.string().optional(),
-  marital_status: MaritalStatus$inboundSchema.optional(),
+  marital_status: HrisEmployeeMaritalStatus$inboundSchema.optional(),
   metadata: z.array(HrisMetadata$inboundSchema).optional(),
   name: z.string().optional(),
   pay_frequency: PayFrequency$inboundSchema.optional(),
@@ -493,7 +495,7 @@ export const HrisEmployee$outboundSchema: z.ZodType<
   lastName: z.string().optional(),
   locations: z.array(HrisLocation$outboundSchema).optional(),
   managerId: z.string().optional(),
-  maritalStatus: MaritalStatus$outboundSchema.optional(),
+  maritalStatus: HrisEmployeeMaritalStatus$outboundSchema.optional(),
   metadata: z.array(HrisMetadata$outboundSchema).optional(),
   name: z.string().optional(),
   payFrequency: PayFrequency$outboundSchema.optional(),

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

@@ -234,10 +234,14 @@ export * from "./genaiskill.js";
 export * from "./genaitask.js";
 export * from "./healthcareallergy.js";
 export * from "./healthcareappointment.js";
+export * from "./healthcarecareplan.js";
 export * from "./healthcarecode.js";
 export * from "./healthcarecondition.js";
+export * from "./healthcarecoverage.js";
+export * from "./healthcaredocument.js";
 export * from "./healthcareemail.js";
 export * from "./healthcareencounter.js";
+export * from "./healthcaregoal.js";
 export * from "./healthcareidentifier.js";
 export * from "./healthcareimmunization.js";
 export * from "./healthcarelocation.js";
@@ -246,7 +250,10 @@ export * from "./healthcaremetadata.js";
 export * from "./healthcareobservation.js";
 export * from "./healthcareobservationcomponent.js";
 export * from "./healthcarepatient.js";
+export * from "./healthcarepatientcontact.js";
 export * from "./healthcarepractitioner.js";
+export * from "./healthcareprocedure.js";
+export * from "./healthcarereport.js";
 export * from "./healthcareslot.js";
 export * from "./healthcaretelephone.js";
 export * from "./hrisattendance.js";
@@ -494,6 +501,7 @@ export * from "./propertyenrichpersonaddress.js";
 export * from "./propertyhealthcarelocationaddress.js";
 export * from "./propertyhealthcareobservationreferencerange.js";
 export * from "./propertyhealthcarepatientaddress.js";
+export * from "./propertyhealthcarepatientcontactaddress.js";
 export * from "./propertyhealthcarepractitioneraddress.js";
 export * from "./propertyhrisattendanceaddress.js";
 export * from "./propertyhriscompanyaddress.js";
@@ -539,6 +547,7 @@ export * from "./propertysocialprofileaddress.js";
 export * from "./propertysocialprofilemetrics.js";
 export * from "./propertysocialreviewreply.js";
 export * from "./propertystoragepermissionroles.js";
+export * from "./propertyuccallinstructiontelephone.js";
 export * from "./propertyuccalltelephone.js";
 export * from "./repobranch.js";
 export * from "./repocommit.js";
@@ -603,6 +612,7 @@ export * from "./ticketingnote.js";
 export * from "./ticketingtelephone.js";
 export * from "./ticketingticket.js";
 export * from "./uccall.js";
+export * from "./uccallinstruction.js";
 export * from "./uccomment.js";
 export * from "./uccontact.js";
 export * from "./ucemail.js";

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

@@ -177,6 +177,7 @@ export const PropertyConnectionPermissions = {
   HrisEarningRead: "hris_earning_read",
   HrisEarningWrite: "hris_earning_write",
   UcCallRead: "uc_call_read",
+  UcCallWrite: "uc_call_write",
   UcContactRead: "uc_contact_read",
   UcContactWrite: "uc_contact_write",
   UcCommentRead: "uc_comment_read",
@@ -403,6 +404,18 @@ export const PropertyConnectionPermissions = {
   HealthcareObservationWrite: "healthcare_observation_write",
   HealthcareImmunizationRead: "healthcare_immunization_read",
   HealthcareImmunizationWrite: "healthcare_immunization_write",
+  HealthcareDocumentRead: "healthcare_document_read",
+  HealthcareDocumentWrite: "healthcare_document_write",
+  HealthcareCoverageRead: "healthcare_coverage_read",
+  HealthcareCoverageWrite: "healthcare_coverage_write",
+  HealthcareProcedureRead: "healthcare_procedure_read",
+  HealthcareProcedureWrite: "healthcare_procedure_write",
+  HealthcareReportRead: "healthcare_report_read",
+  HealthcareReportWrite: "healthcare_report_write",
+  HealthcareCareplanRead: "healthcare_careplan_read",
+  HealthcareCareplanWrite: "healthcare_careplan_write",
+  HealthcareGoalRead: "healthcare_goal_read",
+  HealthcareGoalWrite: "healthcare_goal_write",
 } as const;
 export type PropertyConnectionPermissions = OpenEnum<
   typeof PropertyConnectionPermissions

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

@@ -0,0 +1,110 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Postal address of the contact person
+ */
+export type PropertyHealthcarePatientContactAddress = {
+  /**
+   * First line of the street address
+   */
+  address1?: string | undefined;
+  /**
+   * Second line of the street address
+   */
+  address2?: string | undefined;
+  /**
+   * City or locality
+   */
+  city?: string | undefined;
+  /**
+   * Country
+   */
+  country?: string | undefined;
+  /**
+   * Postal or ZIP code
+   */
+  postalCode?: string | undefined;
+  /**
+   * Regional area (e.g., state in the U.S., province in Canada)
+   */
+  region?: string | undefined;
+};
+
+/** @internal */
+export const PropertyHealthcarePatientContactAddress$inboundSchema: z.ZodType<
+  PropertyHealthcarePatientContactAddress,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  address1: z.string().optional(),
+  address2: z.string().optional(),
+  city: z.string().optional(),
+  country: z.string().optional(),
+  postal_code: z.string().optional(),
+  region: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "postal_code": "postalCode",
+  });
+});
+/** @internal */
+export type PropertyHealthcarePatientContactAddress$Outbound = {
+  address1?: string | undefined;
+  address2?: string | undefined;
+  city?: string | undefined;
+  country?: string | undefined;
+  postal_code?: string | undefined;
+  region?: string | undefined;
+};
+
+/** @internal */
+export const PropertyHealthcarePatientContactAddress$outboundSchema: z.ZodType<
+  PropertyHealthcarePatientContactAddress$Outbound,
+  z.ZodTypeDef,
+  PropertyHealthcarePatientContactAddress
+> = z.object({
+  address1: z.string().optional(),
+  address2: z.string().optional(),
+  city: z.string().optional(),
+  country: z.string().optional(),
+  postalCode: z.string().optional(),
+  region: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    postalCode: "postal_code",
+  });
+});
+
+export function propertyHealthcarePatientContactAddressToJSON(
+  propertyHealthcarePatientContactAddress:
+    PropertyHealthcarePatientContactAddress,
+): string {
+  return JSON.stringify(
+    PropertyHealthcarePatientContactAddress$outboundSchema.parse(
+      propertyHealthcarePatientContactAddress,
+    ),
+  );
+}
+export function propertyHealthcarePatientContactAddressFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PropertyHealthcarePatientContactAddress,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PropertyHealthcarePatientContactAddress$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PropertyHealthcarePatientContactAddress' from JSON`,
+  );
+}

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

@@ -0,0 +1,87 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const PropertyUcCallInstructionTelephoneType = {
+  Work: "WORK",
+  Home: "HOME",
+  Other: "OTHER",
+  Fax: "FAX",
+  Mobile: "MOBILE",
+} as const;
+export type PropertyUcCallInstructionTelephoneType = OpenEnum<
+  typeof PropertyUcCallInstructionTelephoneType
+>;
+
+/**
+ * DIAL: number to dial and bridge
+ */
+export type PropertyUcCallInstructionTelephone = {
+  telephone: string;
+  type?: PropertyUcCallInstructionTelephoneType | undefined;
+};
+
+/** @internal */
+export const PropertyUcCallInstructionTelephoneType$inboundSchema: z.ZodType<
+  PropertyUcCallInstructionTelephoneType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PropertyUcCallInstructionTelephoneType);
+/** @internal */
+export const PropertyUcCallInstructionTelephoneType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  PropertyUcCallInstructionTelephoneType
+> = openEnums.outboundSchema(PropertyUcCallInstructionTelephoneType);
+
+/** @internal */
+export const PropertyUcCallInstructionTelephone$inboundSchema: z.ZodType<
+  PropertyUcCallInstructionTelephone,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  telephone: z.string(),
+  type: PropertyUcCallInstructionTelephoneType$inboundSchema.optional(),
+});
+/** @internal */
+export type PropertyUcCallInstructionTelephone$Outbound = {
+  telephone: string;
+  type?: string | undefined;
+};
+
+/** @internal */
+export const PropertyUcCallInstructionTelephone$outboundSchema: z.ZodType<
+  PropertyUcCallInstructionTelephone$Outbound,
+  z.ZodTypeDef,
+  PropertyUcCallInstructionTelephone
+> = z.object({
+  telephone: z.string(),
+  type: PropertyUcCallInstructionTelephoneType$outboundSchema.optional(),
+});
+
+export function propertyUcCallInstructionTelephoneToJSON(
+  propertyUcCallInstructionTelephone: PropertyUcCallInstructionTelephone,
+): string {
+  return JSON.stringify(
+    PropertyUcCallInstructionTelephone$outboundSchema.parse(
+      propertyUcCallInstructionTelephone,
+    ),
+  );
+}
+export function propertyUcCallInstructionTelephoneFromJSON(
+  jsonString: string,
+): SafeParseResult<PropertyUcCallInstructionTelephone, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PropertyUcCallInstructionTelephone$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyUcCallInstructionTelephone' from JSON`,
+  );
+}

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

@@ -34,6 +34,12 @@ export const PropertyUcCallTelephoneType$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(PropertyUcCallTelephoneType);
+/** @internal */
+export const PropertyUcCallTelephoneType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  PropertyUcCallTelephoneType
+> = openEnums.outboundSchema(PropertyUcCallTelephoneType);
 
 /** @internal */
 export const PropertyUcCallTelephone$inboundSchema: z.ZodType<
@@ -44,7 +50,29 @@ export const PropertyUcCallTelephone$inboundSchema: z.ZodType<
   telephone: z.string(),
   type: PropertyUcCallTelephoneType$inboundSchema.optional(),
 });
+/** @internal */
+export type PropertyUcCallTelephone$Outbound = {
+  telephone: string;
+  type?: string | undefined;
+};
 
+/** @internal */
+export const PropertyUcCallTelephone$outboundSchema: z.ZodType<
+  PropertyUcCallTelephone$Outbound,
+  z.ZodTypeDef,
+  PropertyUcCallTelephone
+> = z.object({
+  telephone: z.string(),
+  type: PropertyUcCallTelephoneType$outboundSchema.optional(),
+});
+
+export function propertyUcCallTelephoneToJSON(
+  propertyUcCallTelephone: PropertyUcCallTelephone,
+): string {
+  return JSON.stringify(
+    PropertyUcCallTelephone$outboundSchema.parse(propertyUcCallTelephone),
+  );
+}
 export function propertyUcCallTelephoneFromJSON(
   jsonString: string,
 ): SafeParseResult<PropertyUcCallTelephone, SDKValidationError> {

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

@@ -12,9 +12,46 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   PropertyUcCallTelephone,
   PropertyUcCallTelephone$inboundSchema,
+  PropertyUcCallTelephone$Outbound,
+  PropertyUcCallTelephone$outboundSchema,
 } from "./propertyuccalltelephone.js";
-import { UcContact, UcContact$inboundSchema } from "./uccontact.js";
-import { UcMetadata, UcMetadata$inboundSchema } from "./ucmetadata.js";
+import {
+  UcCallInstruction,
+  UcCallInstruction$inboundSchema,
+  UcCallInstruction$Outbound,
+  UcCallInstruction$outboundSchema,
+} from "./uccallinstruction.js";
+import {
+  UcContact,
+  UcContact$inboundSchema,
+  UcContact$Outbound,
+  UcContact$outboundSchema,
+} from "./uccontact.js";
+import {
+  UcMetadata,
+  UcMetadata$inboundSchema,
+  UcMetadata$Outbound,
+  UcMetadata$outboundSchema,
+} from "./ucmetadata.js";
+
+/**
+ * The current or final status of the call
+ */
+export const UcCallStatus = {
+  Queued: "QUEUED",
+  Ringing: "RINGING",
+  InProgress: "IN_PROGRESS",
+  Completed: "COMPLETED",
+  Busy: "BUSY",
+  NoAnswer: "NO_ANSWER",
+  Failed: "FAILED",
+  Canceled: "CANCELED",
+  Other: "OTHER",
+} as const;
+/**
+ * The current or final status of the call
+ */
+export type UcCallStatus = OpenEnum<typeof UcCallStatus>;
 
 export const UcCallType = {
   Inbound: "INBOUND",
@@ -23,6 +60,10 @@ export const UcCallType = {
 export type UcCallType = OpenEnum<typeof UcCallType>;
 
 export type UcCall = {
+  /**
+   * When the call was answered (ISO-8601 / YYYY-MM-DDTHH:MM:SSZ format)
+   */
+  answerAt?: Date | undefined;
   /**
    * The contact ID for call (reference to UcContact)
    */
@@ -32,10 +73,22 @@ export type UcCall = {
    * opaque identifier shared across legs of one interaction
    */
   conversationIdentifier?: string | undefined;
+  /**
+   * What the integration charged for the call
+   */
+  costAmount?: number | undefined;
   /**
    * The date that this call object was created (ISO-8601 / YYYY-MM-DDTHH:MM:SSZ format)
    */
   createdAt?: Date | undefined;
+  /**
+   * ISO 4217 currency of cost_amount
+   */
+  currency?: string | undefined;
+  /**
+   * Call length in seconds
+   */
+  durationSeconds?: number | undefined;
   /**
    * The end time of the call (ISO-8601 / YYYY-MM-DDTHH:MM:SSZ format)
    */
@@ -44,8 +97,16 @@ export type UcCall = {
    * Unique identifier for this call object
    */
   id?: string | undefined;
+  /**
+   * Write-only: what the call does once answered (create/update only; never returned)
+   */
+  instructions?: Array<UcCallInstruction> | undefined;
   isPrivate?: boolean | undefined;
   metadata?: Array<UcMetadata> | undefined;
+  /**
+   * The parent call (leg) that this call belongs to
+   */
+  parentId?: string | undefined;
   /**
    * The raw data returned by the integration for this call
    */
@@ -54,6 +115,10 @@ export type UcCall = {
    * The start time of the call (ISO-8601 / YYYY-MM-DDTHH:MM:SSZ format)
    */
   startAt?: Date | undefined;
+  /**
+   * The current or final status of the call
+   */
+  status?: UcCallStatus | undefined;
   /**
    * The telephone number called
    */
@@ -71,30 +136,57 @@ export type UcCall = {
   userPhone?: string | undefined;
 };
 
+/** @internal */
+export const UcCallStatus$inboundSchema: z.ZodType<
+  UcCallStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(UcCallStatus);
+/** @internal */
+export const UcCallStatus$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  UcCallStatus
+> = openEnums.outboundSchema(UcCallStatus);
+
 /** @internal */
 export const UcCallType$inboundSchema: z.ZodType<
   UcCallType,
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(UcCallType);
+/** @internal */
+export const UcCallType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  UcCallType
+> = openEnums.outboundSchema(UcCallType);
 
 /** @internal */
 export const UcCall$inboundSchema: z.ZodType<UcCall, z.ZodTypeDef, unknown> = z
   .object({
+    answer_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+      .optional(),
     contact_id: z.string().optional(),
     contacts: z.array(UcContact$inboundSchema).optional(),
     conversation_identifier: z.string().optional(),
+    cost_amount: z.number().optional(),
     created_at: z.string().datetime({ offset: true }).transform(v =>
       new Date(v)
     ).optional(),
+    currency: z.string().optional(),
+    duration_seconds: z.number().optional(),
     end_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
       .optional(),
     id: z.string().optional(),
+    instructions: z.array(UcCallInstruction$inboundSchema).optional(),
     is_private: z.boolean().optional(),
     metadata: z.array(UcMetadata$inboundSchema).optional(),
+    parent_id: z.string().optional(),
     raw: z.record(z.any()).optional(),
     start_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
       .optional(),
+    status: UcCallStatus$inboundSchema.optional(),
     telephone: PropertyUcCallTelephone$inboundSchema.optional(),
     type: UcCallType$inboundSchema.optional(),
     updated_at: z.string().datetime({ offset: true }).transform(v =>
@@ -105,11 +197,15 @@ export const UcCall$inboundSchema: z.ZodType<UcCall, z.ZodTypeDef, unknown> = z
     user_phone: z.string().optional(),
   }).transform((v) => {
     return remap$(v, {
+      "answer_at": "answerAt",
       "contact_id": "contactId",
       "conversation_identifier": "conversationIdentifier",
+      "cost_amount": "costAmount",
       "created_at": "createdAt",
+      "duration_seconds": "durationSeconds",
       "end_at": "endAt",
       "is_private": "isPrivate",
+      "parent_id": "parentId",
       "start_at": "startAt",
       "updated_at": "updatedAt",
       "user_id": "userId",
@@ -117,7 +213,84 @@ export const UcCall$inboundSchema: z.ZodType<UcCall, z.ZodTypeDef, unknown> = z
       "user_phone": "userPhone",
     });
   });
+/** @internal */
+export type UcCall$Outbound = {
+  answer_at?: string | undefined;
+  contact_id?: string | undefined;
+  contacts?: Array<UcContact$Outbound> | undefined;
+  conversation_identifier?: string | undefined;
+  cost_amount?: number | undefined;
+  created_at?: string | undefined;
+  currency?: string | undefined;
+  duration_seconds?: number | undefined;
+  end_at?: string | undefined;
+  id?: string | undefined;
+  instructions?: Array<UcCallInstruction$Outbound> | undefined;
+  is_private?: boolean | undefined;
+  metadata?: Array<UcMetadata$Outbound> | undefined;
+  parent_id?: string | undefined;
+  raw?: { [k: string]: any } | undefined;
+  start_at?: string | undefined;
+  status?: string | undefined;
+  telephone?: PropertyUcCallTelephone$Outbound | undefined;
+  type?: string | undefined;
+  updated_at?: string | undefined;
+  user_id?: string | undefined;
+  user_name?: string | undefined;
+  user_phone?: string | undefined;
+};
 
+/** @internal */
+export const UcCall$outboundSchema: z.ZodType<
+  UcCall$Outbound,
+  z.ZodTypeDef,
+  UcCall
+> = z.object({
+  answerAt: z.date().transform(v => v.toISOString()).optional(),
+  contactId: z.string().optional(),
+  contacts: z.array(UcContact$outboundSchema).optional(),
+  conversationIdentifier: z.string().optional(),
+  costAmount: z.number().optional(),
+  createdAt: z.date().transform(v => v.toISOString()).optional(),
+  currency: z.string().optional(),
+  durationSeconds: z.number().optional(),
+  endAt: z.date().transform(v => v.toISOString()).optional(),
+  id: z.string().optional(),
+  instructions: z.array(UcCallInstruction$outboundSchema).optional(),
+  isPrivate: z.boolean().optional(),
+  metadata: z.array(UcMetadata$outboundSchema).optional(),
+  parentId: z.string().optional(),
+  raw: z.record(z.any()).optional(),
+  startAt: z.date().transform(v => v.toISOString()).optional(),
+  status: UcCallStatus$outboundSchema.optional(),
+  telephone: PropertyUcCallTelephone$outboundSchema.optional(),
+  type: UcCallType$outboundSchema.optional(),
+  updatedAt: z.date().transform(v => v.toISOString()).optional(),
+  userId: z.string().optional(),
+  userName: z.string().optional(),
+  userPhone: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    answerAt: "answer_at",
+    contactId: "contact_id",
+    conversationIdentifier: "conversation_identifier",
+    costAmount: "cost_amount",
+    createdAt: "created_at",
+    durationSeconds: "duration_seconds",
+    endAt: "end_at",
+    isPrivate: "is_private",
+    parentId: "parent_id",
+    startAt: "start_at",
+    updatedAt: "updated_at",
+    userId: "user_id",
+    userName: "user_name",
+    userPhone: "user_phone",
+  });
+});
+
+export function ucCallToJSON(ucCall: UcCall): string {
+  return JSON.stringify(UcCall$outboundSchema.parse(ucCall));
+}
 export function ucCallFromJSON(
   jsonString: string,
 ): SafeParseResult<UcCall, SDKValidationError> {