@unified-api/typescript-sdk 2.82.4 → 2.82.5

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

@@ -14,11 +14,11 @@ import {
   MessagingAttachment$outboundSchema,
 } from "./messagingattachment.js";
 import {
-  MessagingChannelMessage,
-  MessagingChannelMessage$inboundSchema,
-  MessagingChannelMessage$Outbound,
-  MessagingChannelMessage$outboundSchema,
-} from "./messagingchannelmessage.js";
+  MessagingButton,
+  MessagingButton$inboundSchema,
+  MessagingButton$Outbound,
+  MessagingButton$outboundSchema,
+} from "./messagingbutton.js";
 import {
   MessagingMember,
   MessagingMember$inboundSchema,
@@ -31,6 +31,12 @@ import {
   MessagingReaction$Outbound,
   MessagingReaction$outboundSchema,
 } from "./messagingreaction.js";
+import {
+  MessagingReference,
+  MessagingReference$inboundSchema,
+  MessagingReference$Outbound,
+  MessagingReference$outboundSchema,
+} from "./messagingreference.js";
 import {
   PropertyMessagingMessageAuthorMember,
   PropertyMessagingMessageAuthorMember$inboundSchema,
@@ -41,6 +47,7 @@ import {
 export type MessagingMessage = {
   attachments?: Array<MessagingAttachment> | undefined;
   authorMember?: PropertyMessagingMessageAuthorMember | undefined;
+  buttons?: Array<MessagingButton> | undefined;
   channelId?: string | undefined;
   /**
    * @deprecated; use channels instead
@@ -49,7 +56,7 @@ export type MessagingMessage = {
   /**
    * Represents the names of all channels to which the message is sent. Identifies the channels where the message is posted.
    */
-  channels?: Array<MessagingChannelMessage> | undefined;
+  channels?: Array<MessagingReference> | undefined;
   createdAt?: Date | undefined;
   destinationMembers?: Array<MessagingMember> | undefined;
   hasChildren?: boolean | undefined;
@@ -80,9 +87,10 @@ export const MessagingMessage$inboundSchema: z.ZodType<
 > = z.object({
   attachments: z.array(MessagingAttachment$inboundSchema).optional(),
   author_member: PropertyMessagingMessageAuthorMember$inboundSchema.optional(),
+  buttons: z.array(MessagingButton$inboundSchema).optional(),
   channel_id: z.string().optional(),
   channel_ids: z.array(z.string()).optional(),
-  channels: z.array(MessagingChannelMessage$inboundSchema).optional(),
+  channels: z.array(MessagingReference$inboundSchema).optional(),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   destination_members: z.array(MessagingMember$inboundSchema).optional(),
@@ -130,9 +138,10 @@ export const MessagingMessage$inboundSchema: z.ZodType<
 export type MessagingMessage$Outbound = {
   attachments?: Array<MessagingAttachment$Outbound> | undefined;
   author_member?: PropertyMessagingMessageAuthorMember$Outbound | undefined;
+  buttons?: Array<MessagingButton$Outbound> | undefined;
   channel_id?: string | undefined;
   channel_ids?: Array<string> | undefined;
-  channels?: Array<MessagingChannelMessage$Outbound> | undefined;
+  channels?: Array<MessagingReference$Outbound> | undefined;
   created_at?: string | undefined;
   destination_members?: Array<MessagingMember$Outbound> | undefined;
   has_children?: boolean | undefined;
@@ -163,9 +172,10 @@ export const MessagingMessage$outboundSchema: z.ZodType<
 > = z.object({
   attachments: z.array(MessagingAttachment$outboundSchema).optional(),
   authorMember: PropertyMessagingMessageAuthorMember$outboundSchema.optional(),
+  buttons: z.array(MessagingButton$outboundSchema).optional(),
   channelId: z.string().optional(),
   channelIds: z.array(z.string()).optional(),
-  channels: z.array(MessagingChannelMessage$outboundSchema).optional(),
+  channels: z.array(MessagingReference$outboundSchema).optional(),
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   destinationMembers: z.array(MessagingMember$outboundSchema).optional(),
   hasChildren: z.boolean().optional(),

package/src/sdk/models/shared/{messagingchannelmessage.ts → messagingreference.ts}

@@ -7,14 +7,14 @@ import { safeParse } from "../../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export type MessagingChannelMessage = {
+export type MessagingReference = {
   id?: string | undefined;
   name?: string | undefined;
 };
 
 /** @internal */
-export const MessagingChannelMessage$inboundSchema: z.ZodType<
-  MessagingChannelMessage,
+export const MessagingReference$inboundSchema: z.ZodType<
+  MessagingReference,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -22,34 +22,34 @@ export const MessagingChannelMessage$inboundSchema: z.ZodType<
   name: z.string().optional(),
 });
 /** @internal */
-export type MessagingChannelMessage$Outbound = {
+export type MessagingReference$Outbound = {
   id?: string | undefined;
   name?: string | undefined;
 };
 
 /** @internal */
-export const MessagingChannelMessage$outboundSchema: z.ZodType<
-  MessagingChannelMessage$Outbound,
+export const MessagingReference$outboundSchema: z.ZodType<
+  MessagingReference$Outbound,
   z.ZodTypeDef,
-  MessagingChannelMessage
+  MessagingReference
 > = z.object({
   id: z.string().optional(),
   name: z.string().optional(),
 });
 
-export function messagingChannelMessageToJSON(
-  messagingChannelMessage: MessagingChannelMessage,
+export function messagingReferenceToJSON(
+  messagingReference: MessagingReference,
 ): string {
   return JSON.stringify(
-    MessagingChannelMessage$outboundSchema.parse(messagingChannelMessage),
+    MessagingReference$outboundSchema.parse(messagingReference),
   );
 }
-export function messagingChannelMessageFromJSON(
+export function messagingReferenceFromJSON(
   jsonString: string,
-): SafeParseResult<MessagingChannelMessage, SDKValidationError> {
+): SafeParseResult<MessagingReference, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => MessagingChannelMessage$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MessagingChannelMessage' from JSON`,
+    (x) => MessagingReference$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MessagingReference' from JSON`,
   );
 }

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

@@ -0,0 +1,61 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type PropertyMessagingEventButton = {
+  icon?: string | undefined;
+  id: string;
+  text?: string | undefined;
+};
+
+/** @internal */
+export const PropertyMessagingEventButton$inboundSchema: z.ZodType<
+  PropertyMessagingEventButton,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  icon: z.string().optional(),
+  id: z.string(),
+  text: z.string().optional(),
+});
+/** @internal */
+export type PropertyMessagingEventButton$Outbound = {
+  icon?: string | undefined;
+  id: string;
+  text?: string | undefined;
+};
+
+/** @internal */
+export const PropertyMessagingEventButton$outboundSchema: z.ZodType<
+  PropertyMessagingEventButton$Outbound,
+  z.ZodTypeDef,
+  PropertyMessagingEventButton
+> = z.object({
+  icon: z.string().optional(),
+  id: z.string(),
+  text: z.string().optional(),
+});
+
+export function propertyMessagingEventButtonToJSON(
+  propertyMessagingEventButton: PropertyMessagingEventButton,
+): string {
+  return JSON.stringify(
+    PropertyMessagingEventButton$outboundSchema.parse(
+      propertyMessagingEventButton,
+    ),
+  );
+}
+export function propertyMessagingEventButtonFromJSON(
+  jsonString: string,
+): SafeParseResult<PropertyMessagingEventButton, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PropertyMessagingEventButton$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyMessagingEventButton' from JSON`,
+  );
+}

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

@@ -0,0 +1,132 @@
+/*
+ * 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";
+import {
+  MessagingMember,
+  MessagingMember$inboundSchema,
+  MessagingMember$Outbound,
+  MessagingMember$outboundSchema,
+} from "./messagingmember.js";
+
+export type PropertyMessagingEventChannel = {
+  createdAt?: Date | undefined;
+  description?: string | undefined;
+  hasSubchannels?: boolean | undefined;
+  id?: string | undefined;
+  isActive?: boolean | undefined;
+  isPrivate?: boolean | undefined;
+  members?: Array<MessagingMember> | undefined;
+  name: string;
+  parentChannelId?: string | undefined;
+  parentId?: string | undefined;
+  raw?: { [k: string]: any } | undefined;
+  updatedAt?: Date | undefined;
+  webUrl?: string | undefined;
+};
+
+/** @internal */
+export const PropertyMessagingEventChannel$inboundSchema: z.ZodType<
+  PropertyMessagingEventChannel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  description: z.string().optional(),
+  has_subchannels: z.boolean().optional(),
+  id: z.string().optional(),
+  is_active: z.boolean().optional(),
+  is_private: z.boolean().optional(),
+  members: z.array(MessagingMember$inboundSchema).optional(),
+  name: z.string(),
+  parent_channel_id: z.string().optional(),
+  parent_id: z.string().optional(),
+  raw: z.record(z.any()).optional(),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  web_url: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "created_at": "createdAt",
+    "has_subchannels": "hasSubchannels",
+    "is_active": "isActive",
+    "is_private": "isPrivate",
+    "parent_channel_id": "parentChannelId",
+    "parent_id": "parentId",
+    "updated_at": "updatedAt",
+    "web_url": "webUrl",
+  });
+});
+/** @internal */
+export type PropertyMessagingEventChannel$Outbound = {
+  created_at?: string | undefined;
+  description?: string | undefined;
+  has_subchannels?: boolean | undefined;
+  id?: string | undefined;
+  is_active?: boolean | undefined;
+  is_private?: boolean | undefined;
+  members?: Array<MessagingMember$Outbound> | undefined;
+  name: string;
+  parent_channel_id?: string | undefined;
+  parent_id?: string | undefined;
+  raw?: { [k: string]: any } | undefined;
+  updated_at?: string | undefined;
+  web_url?: string | undefined;
+};
+
+/** @internal */
+export const PropertyMessagingEventChannel$outboundSchema: z.ZodType<
+  PropertyMessagingEventChannel$Outbound,
+  z.ZodTypeDef,
+  PropertyMessagingEventChannel
+> = z.object({
+  createdAt: z.date().transform(v => v.toISOString()).optional(),
+  description: z.string().optional(),
+  hasSubchannels: z.boolean().optional(),
+  id: z.string().optional(),
+  isActive: z.boolean().optional(),
+  isPrivate: z.boolean().optional(),
+  members: z.array(MessagingMember$outboundSchema).optional(),
+  name: z.string(),
+  parentChannelId: z.string().optional(),
+  parentId: z.string().optional(),
+  raw: z.record(z.any()).optional(),
+  updatedAt: z.date().transform(v => v.toISOString()).optional(),
+  webUrl: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    createdAt: "created_at",
+    hasSubchannels: "has_subchannels",
+    isActive: "is_active",
+    isPrivate: "is_private",
+    parentChannelId: "parent_channel_id",
+    parentId: "parent_id",
+    updatedAt: "updated_at",
+    webUrl: "web_url",
+  });
+});
+
+export function propertyMessagingEventChannelToJSON(
+  propertyMessagingEventChannel: PropertyMessagingEventChannel,
+): string {
+  return JSON.stringify(
+    PropertyMessagingEventChannel$outboundSchema.parse(
+      propertyMessagingEventChannel,
+    ),
+  );
+}
+export function propertyMessagingEventChannelFromJSON(
+  jsonString: string,
+): SafeParseResult<PropertyMessagingEventChannel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PropertyMessagingEventChannel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyMessagingEventChannel' from JSON`,
+  );
+}

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

@@ -0,0 +1,242 @@
+/*
+ * 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";
+import {
+  MessagingAttachment,
+  MessagingAttachment$inboundSchema,
+  MessagingAttachment$Outbound,
+  MessagingAttachment$outboundSchema,
+} from "./messagingattachment.js";
+import {
+  MessagingButton,
+  MessagingButton$inboundSchema,
+  MessagingButton$Outbound,
+  MessagingButton$outboundSchema,
+} from "./messagingbutton.js";
+import {
+  MessagingMember,
+  MessagingMember$inboundSchema,
+  MessagingMember$Outbound,
+  MessagingMember$outboundSchema,
+} from "./messagingmember.js";
+import {
+  MessagingReaction,
+  MessagingReaction$inboundSchema,
+  MessagingReaction$Outbound,
+  MessagingReaction$outboundSchema,
+} from "./messagingreaction.js";
+import {
+  MessagingReference,
+  MessagingReference$inboundSchema,
+  MessagingReference$Outbound,
+  MessagingReference$outboundSchema,
+} from "./messagingreference.js";
+import {
+  PropertyMessagingEventMessageAuthorMember,
+  PropertyMessagingEventMessageAuthorMember$inboundSchema,
+  PropertyMessagingEventMessageAuthorMember$Outbound,
+  PropertyMessagingEventMessageAuthorMember$outboundSchema,
+} from "./propertymessagingeventmessageauthormember.js";
+
+export type PropertyMessagingEventMessage = {
+  attachments?: Array<MessagingAttachment> | undefined;
+  authorMember?: PropertyMessagingEventMessageAuthorMember | undefined;
+  buttons?: Array<MessagingButton> | undefined;
+  channelId?: string | undefined;
+  /**
+   * @deprecated; use channels instead
+   */
+  channelIds?: Array<string> | undefined;
+  /**
+   * Represents the names of all channels to which the message is sent. Identifies the channels where the message is posted.
+   */
+  channels?: Array<MessagingReference> | undefined;
+  createdAt?: Date | undefined;
+  destinationMembers?: Array<MessagingMember> | undefined;
+  hasChildren?: boolean | undefined;
+  hiddenMembers?: Array<MessagingMember> | undefined;
+  id?: string | undefined;
+  isUnread?: boolean | undefined;
+  mentionedMembers?: Array<MessagingMember> | undefined;
+  message?: string | undefined;
+  messageHtml?: string | undefined;
+  messageMarkdown?: string | undefined;
+  messageThreadIdentifier?: string | undefined;
+  parentId?: string | undefined;
+  parentMessageId?: string | undefined;
+  raw?: { [k: string]: any } | undefined;
+  reactions?: Array<MessagingReaction> | undefined;
+  reference?: string | undefined;
+  rootMessageId?: string | undefined;
+  subject?: string | undefined;
+  updatedAt?: Date | undefined;
+  webUrl?: string | undefined;
+};
+
+/** @internal */
+export const PropertyMessagingEventMessage$inboundSchema: z.ZodType<
+  PropertyMessagingEventMessage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  attachments: z.array(MessagingAttachment$inboundSchema).optional(),
+  author_member: PropertyMessagingEventMessageAuthorMember$inboundSchema
+    .optional(),
+  buttons: z.array(MessagingButton$inboundSchema).optional(),
+  channel_id: z.string().optional(),
+  channel_ids: z.array(z.string()).optional(),
+  channels: z.array(MessagingReference$inboundSchema).optional(),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  destination_members: z.array(MessagingMember$inboundSchema).optional(),
+  has_children: z.boolean().optional(),
+  hidden_members: z.array(MessagingMember$inboundSchema).optional(),
+  id: z.string().optional(),
+  is_unread: z.boolean().optional(),
+  mentioned_members: z.array(MessagingMember$inboundSchema).optional(),
+  message: z.string().optional(),
+  message_html: z.string().optional(),
+  message_markdown: z.string().optional(),
+  message_thread_identifier: z.string().optional(),
+  parent_id: z.string().optional(),
+  parent_message_id: z.string().optional(),
+  raw: z.record(z.any()).optional(),
+  reactions: z.array(MessagingReaction$inboundSchema).optional(),
+  reference: z.string().optional(),
+  root_message_id: z.string().optional(),
+  subject: z.string().optional(),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  web_url: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "author_member": "authorMember",
+    "channel_id": "channelId",
+    "channel_ids": "channelIds",
+    "created_at": "createdAt",
+    "destination_members": "destinationMembers",
+    "has_children": "hasChildren",
+    "hidden_members": "hiddenMembers",
+    "is_unread": "isUnread",
+    "mentioned_members": "mentionedMembers",
+    "message_html": "messageHtml",
+    "message_markdown": "messageMarkdown",
+    "message_thread_identifier": "messageThreadIdentifier",
+    "parent_id": "parentId",
+    "parent_message_id": "parentMessageId",
+    "root_message_id": "rootMessageId",
+    "updated_at": "updatedAt",
+    "web_url": "webUrl",
+  });
+});
+/** @internal */
+export type PropertyMessagingEventMessage$Outbound = {
+  attachments?: Array<MessagingAttachment$Outbound> | undefined;
+  author_member?:
+    | PropertyMessagingEventMessageAuthorMember$Outbound
+    | undefined;
+  buttons?: Array<MessagingButton$Outbound> | undefined;
+  channel_id?: string | undefined;
+  channel_ids?: Array<string> | undefined;
+  channels?: Array<MessagingReference$Outbound> | undefined;
+  created_at?: string | undefined;
+  destination_members?: Array<MessagingMember$Outbound> | undefined;
+  has_children?: boolean | undefined;
+  hidden_members?: Array<MessagingMember$Outbound> | undefined;
+  id?: string | undefined;
+  is_unread?: boolean | undefined;
+  mentioned_members?: Array<MessagingMember$Outbound> | undefined;
+  message?: string | undefined;
+  message_html?: string | undefined;
+  message_markdown?: string | undefined;
+  message_thread_identifier?: string | undefined;
+  parent_id?: string | undefined;
+  parent_message_id?: string | undefined;
+  raw?: { [k: string]: any } | undefined;
+  reactions?: Array<MessagingReaction$Outbound> | undefined;
+  reference?: string | undefined;
+  root_message_id?: string | undefined;
+  subject?: string | undefined;
+  updated_at?: string | undefined;
+  web_url?: string | undefined;
+};
+
+/** @internal */
+export const PropertyMessagingEventMessage$outboundSchema: z.ZodType<
+  PropertyMessagingEventMessage$Outbound,
+  z.ZodTypeDef,
+  PropertyMessagingEventMessage
+> = z.object({
+  attachments: z.array(MessagingAttachment$outboundSchema).optional(),
+  authorMember: PropertyMessagingEventMessageAuthorMember$outboundSchema
+    .optional(),
+  buttons: z.array(MessagingButton$outboundSchema).optional(),
+  channelId: z.string().optional(),
+  channelIds: z.array(z.string()).optional(),
+  channels: z.array(MessagingReference$outboundSchema).optional(),
+  createdAt: z.date().transform(v => v.toISOString()).optional(),
+  destinationMembers: z.array(MessagingMember$outboundSchema).optional(),
+  hasChildren: z.boolean().optional(),
+  hiddenMembers: z.array(MessagingMember$outboundSchema).optional(),
+  id: z.string().optional(),
+  isUnread: z.boolean().optional(),
+  mentionedMembers: z.array(MessagingMember$outboundSchema).optional(),
+  message: z.string().optional(),
+  messageHtml: z.string().optional(),
+  messageMarkdown: z.string().optional(),
+  messageThreadIdentifier: z.string().optional(),
+  parentId: z.string().optional(),
+  parentMessageId: z.string().optional(),
+  raw: z.record(z.any()).optional(),
+  reactions: z.array(MessagingReaction$outboundSchema).optional(),
+  reference: z.string().optional(),
+  rootMessageId: z.string().optional(),
+  subject: z.string().optional(),
+  updatedAt: z.date().transform(v => v.toISOString()).optional(),
+  webUrl: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    authorMember: "author_member",
+    channelId: "channel_id",
+    channelIds: "channel_ids",
+    createdAt: "created_at",
+    destinationMembers: "destination_members",
+    hasChildren: "has_children",
+    hiddenMembers: "hidden_members",
+    isUnread: "is_unread",
+    mentionedMembers: "mentioned_members",
+    messageHtml: "message_html",
+    messageMarkdown: "message_markdown",
+    messageThreadIdentifier: "message_thread_identifier",
+    parentId: "parent_id",
+    parentMessageId: "parent_message_id",
+    rootMessageId: "root_message_id",
+    updatedAt: "updated_at",
+    webUrl: "web_url",
+  });
+});
+
+export function propertyMessagingEventMessageToJSON(
+  propertyMessagingEventMessage: PropertyMessagingEventMessage,
+): string {
+  return JSON.stringify(
+    PropertyMessagingEventMessage$outboundSchema.parse(
+      propertyMessagingEventMessage,
+    ),
+  );
+}
+export function propertyMessagingEventMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<PropertyMessagingEventMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PropertyMessagingEventMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyMessagingEventMessage' from JSON`,
+  );
+}

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

@@ -0,0 +1,84 @@
+/*
+ * 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";
+
+export type PropertyMessagingEventMessageAuthorMember = {
+  email?: string | undefined;
+  imageUrl?: string | undefined;
+  name?: string | undefined;
+  userId?: string | undefined;
+};
+
+/** @internal */
+export const PropertyMessagingEventMessageAuthorMember$inboundSchema: z.ZodType<
+  PropertyMessagingEventMessageAuthorMember,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  email: z.string().optional(),
+  image_url: z.string().optional(),
+  name: z.string().optional(),
+  user_id: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "image_url": "imageUrl",
+    "user_id": "userId",
+  });
+});
+/** @internal */
+export type PropertyMessagingEventMessageAuthorMember$Outbound = {
+  email?: string | undefined;
+  image_url?: string | undefined;
+  name?: string | undefined;
+  user_id?: string | undefined;
+};
+
+/** @internal */
+export const PropertyMessagingEventMessageAuthorMember$outboundSchema:
+  z.ZodType<
+    PropertyMessagingEventMessageAuthorMember$Outbound,
+    z.ZodTypeDef,
+    PropertyMessagingEventMessageAuthorMember
+  > = z.object({
+    email: z.string().optional(),
+    imageUrl: z.string().optional(),
+    name: z.string().optional(),
+    userId: z.string().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      imageUrl: "image_url",
+      userId: "user_id",
+    });
+  });
+
+export function propertyMessagingEventMessageAuthorMemberToJSON(
+  propertyMessagingEventMessageAuthorMember:
+    PropertyMessagingEventMessageAuthorMember,
+): string {
+  return JSON.stringify(
+    PropertyMessagingEventMessageAuthorMember$outboundSchema.parse(
+      propertyMessagingEventMessageAuthorMember,
+    ),
+  );
+}
+export function propertyMessagingEventMessageAuthorMemberFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PropertyMessagingEventMessageAuthorMember,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PropertyMessagingEventMessageAuthorMember$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PropertyMessagingEventMessageAuthorMember' from JSON`,
+  );
+}