bereach 1.4.2 → 1.5.0

package/src/models/operations/delete-workspace-invite-response.ts

@@ -0,0 +1,2783 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smart-union.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import {
+  GetByUrlActivity,
+  GetByUrlActivity$inboundSchema,
+  GetByUrlCampaign,
+  GetByUrlCampaign$inboundSchema,
+} from "./get-by-url-campaign.js";
+
+export type GetByUrlContact = {
+  id: string;
+  linkedinUrl: string;
+  /**
+   * LinkedIn profile URN (e.g. urn:li:fsd_profile:ACoAAA...)
+   */
+  profileUrn: string | null;
+  /**
+   * LinkedIn vanity slug (e.g. joshuaau)
+   */
+  publicIdentifier: string | null;
+  name: string;
+  lifecycleStage: string;
+  hotScore: number;
+  qualificationNotes: string | null;
+  notes: string | null;
+  stageChangedAt: string | null;
+  profileData: any | null;
+  profileUpdatedAt: string | null;
+  conversationData: any | null;
+  conversationUpdatedAt: string | null;
+  outreachStatus: string;
+  lastContactedAt: string | null;
+  lastRepliedAt: string | null;
+  nextFollowUpAt: string | null;
+  doNotContact: boolean;
+  tags: Array<string>;
+  createdAt: string;
+  updatedAt: string;
+  activities: Array<GetByUrlActivity>;
+  campaigns: Array<GetByUrlCampaign>;
+};
+
+/**
+ * Contact found
+ */
+export type GetByUrlResponse = {
+  success: true;
+  contact: GetByUrlContact;
+  /**
+   * Credits consumed by this call (always 0 for contacts queries).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait before next call of the same type (always 0 for contacts queries).
+   */
+  retryAfter: number;
+};
+
+export const ListMessagesQueryParamStatus = {
+  Draft: "draft",
+  Scheduled: "scheduled",
+  Sending: "sending",
+  Sent: "sent",
+  Failed: "failed",
+  Cancelled: "cancelled",
+} as const;
+export type ListMessagesQueryParamStatus = ClosedEnum<
+  typeof ListMessagesQueryParamStatus
+>;
+
+export type ListMessagesRequest = {
+  status?: ListMessagesQueryParamStatus | undefined;
+  contactId?: string | undefined;
+  campaignSlug?: string | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+};
+
+export const MessageStatus = {
+  Draft: "draft",
+  Scheduled: "scheduled",
+  Sending: "sending",
+  Sent: "sent",
+  Failed: "failed",
+  Cancelled: "cancelled",
+} as const;
+export type MessageStatus = OpenEnum<typeof MessageStatus>;
+
+export type ListMessagesMessage = {
+  id: string;
+  contactId: string;
+  /**
+   * Contact name (included in list, absent in create)
+   */
+  contactName?: string | null | undefined;
+  /**
+   * Contact LinkedIn URL (included in list, absent in create)
+   */
+  contactLinkedinUrl?: string | null | undefined;
+  message: string;
+  status: MessageStatus;
+  scheduledSendAt: string | null;
+  sentAt: string | null;
+  campaignSlug: string | null;
+  /**
+   * Error message if status is 'failed'
+   */
+  errorMessage?: string | null | undefined;
+  createdAt: string;
+};
+
+/**
+ * Messages list
+ */
+export type ListMessagesResponse = {
+  success: true;
+  messages: Array<ListMessagesMessage>;
+  total: number;
+  limit: number;
+  offset: number;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+/**
+ * Default 'draft'
+ */
+export const CreateStatusRequest = {
+  Draft: "draft",
+  Scheduled: "scheduled",
+} as const;
+/**
+ * Default 'draft'
+ */
+export type CreateStatusRequest = ClosedEnum<typeof CreateStatusRequest>;
+
+export type CreateRequest = {
+  /**
+   * Internal contact ID
+   */
+  contactId: string;
+  /**
+   * DM text
+   */
+  message: string;
+  /**
+   * Default 'draft'
+   */
+  status?: CreateStatusRequest | undefined;
+  /**
+   * ISO datetime for auto-send
+   */
+  scheduledSendAt?: string | undefined;
+  campaignSlug?: string | undefined;
+};
+
+export const ScheduledMessageStatus = {
+  Draft: "draft",
+  Scheduled: "scheduled",
+  Sending: "sending",
+  Sent: "sent",
+  Failed: "failed",
+  Cancelled: "cancelled",
+} as const;
+export type ScheduledMessageStatus = OpenEnum<typeof ScheduledMessageStatus>;
+
+export type ScheduledMessage = {
+  id: string;
+  contactId: string;
+  /**
+   * Contact name (included in list, absent in create)
+   */
+  contactName?: string | null | undefined;
+  /**
+   * Contact LinkedIn URL (included in list, absent in create)
+   */
+  contactLinkedinUrl?: string | null | undefined;
+  message: string;
+  status: ScheduledMessageStatus;
+  scheduledSendAt: string | null;
+  sentAt: string | null;
+  campaignSlug: string | null;
+  /**
+   * Error message if status is 'failed'
+   */
+  errorMessage?: string | null | undefined;
+  createdAt: string;
+};
+
+/**
+ * Message created
+ */
+export type CreateResponse = {
+  success: true;
+  scheduledMessage: ScheduledMessage;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+export type BatchScheduleRequest = {
+  /**
+   * Schedule all drafts for these contacts
+   */
+  contactIds?: Array<string> | undefined;
+  /**
+   * Schedule specific messages
+   */
+  messageIds?: Array<string> | undefined;
+  /**
+   * ISO datetime for sending
+   */
+  scheduledSendAt: string;
+  /**
+   * Map of messageId → new content for last-minute edits before scheduling
+   */
+  editedMessages?: { [k: string]: string } | undefined;
+};
+
+/**
+ * Messages scheduled
+ */
+export type BatchScheduleResponse = {
+  success: true;
+  /**
+   * Number of messages scheduled
+   */
+  scheduled: number;
+  /**
+   * Number of cron trigger failures (messages reverted to draft)
+   */
+  triggerFailures: number;
+  /**
+   * ISO datetime for first send
+   */
+  scheduledSendAt: string;
+  /**
+   * Minutes between staggered sends (0 if single message)
+   */
+  staggerMinutes: number;
+  /**
+   * ISO datetime when last staggered message will be sent
+   */
+  lastSendAt: string;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+export type CancelRequest = {
+  /**
+   * Cancel specific messages
+   */
+  messageIds?: Array<string> | undefined;
+  /**
+   * Cancel all pending for these contacts
+   */
+  contactIds?: Array<string> | undefined;
+};
+
+/**
+ * Messages cancelled
+ */
+export type CancelResponse = {
+  success: true;
+  cancelled: number;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+export type ReviewDraftsRequest = {
+  /**
+   * Campaign ID
+   */
+  campaignId: string;
+  /**
+   * Message IDs to approve and send
+   */
+  approved?: Array<string> | undefined;
+  /**
+   * Message IDs to reject/cancel
+   */
+  rejected?: Array<string> | undefined;
+  /**
+   * Map of messageId to new text (applied before approval)
+   */
+  editedMessages?: { [k: string]: string } | undefined;
+};
+
+/**
+ * Review applied
+ */
+export type ReviewDraftsResponse = {
+  success: true;
+  approved: number;
+  rejected: number;
+};
+
+export type ListEntriesRequest = {
+  /**
+   * Filter by scope (e.g. "campaign:abc", "user")
+   */
+  scope?: string | undefined;
+  /**
+   * Filter by type (e.g. "icp", "tone-voice")
+   */
+  type?: string | undefined;
+};
+
+export type ListEntriesEntry = {
+  /**
+   * Unique entry ID
+   */
+  id: string;
+  type: string;
+  label: string | null;
+  content: string;
+  scope: string;
+  updatedAt: string;
+};
+
+/**
+ * Context entries
+ */
+export type ListEntriesResponse = {
+  success: true;
+  entries: Array<ListEntriesEntry>;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+export type SetRequest = {
+  /**
+   * Context type: "user-profile", "product-pitch", "icp", "tone-voice", "playbook", or "custom:{slug}"
+   */
+  type: string;
+  /**
+   * Markdown content
+   */
+  content: string;
+  /**
+   * Defaults to "user"
+   */
+  scope?: string | undefined;
+  /**
+   * Display label
+   */
+  label?: string | undefined;
+};
+
+export type SetEntry = {
+  /**
+   * Unique entry ID
+   */
+  id: string;
+  type: string;
+  label: string | null;
+  content: string;
+  scope: string;
+  updatedAt: string;
+};
+
+/**
+ * Context saved
+ */
+export type SetResponse = {
+  success: true;
+  entry: SetEntry;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+export type DeleteRequest = {
+  /**
+   * Context type to delete
+   */
+  type: string;
+  /**
+   * Scope (defaults to "user")
+   */
+  scope?: string | undefined;
+};
+
+/**
+ * Context deleted
+ */
+export type DeleteResponse = {
+  success: true;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+export type Schedule = {
+  scheduleId: string;
+  /**
+   * Human-readable schedule name (e.g. 'DM Polling', 'Draft Send')
+   */
+  name: string;
+  cron: string | null;
+  isPaused: boolean;
+  /**
+   * ISO 8601 timestamp of last execution
+   */
+  lastRun: string | null;
+  /**
+   * ISO 8601 timestamp of next scheduled execution
+   */
+  nextRun: string | null;
+  /**
+   * Status of the last execution
+   */
+  lastStatus: any | null;
+  /**
+   * The endpoint URL this schedule invokes
+   */
+  destination: string;
+};
+
+/**
+ * Cron schedules
+ */
+export type ListSchedulesResponse = {
+  success: true;
+  schedules: Array<Schedule>;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+/**
+ * Action to perform
+ */
+export const UpdateScheduleAction = {
+  Pause: "pause",
+  Resume: "resume",
+  Delete: "delete",
+} as const;
+/**
+ * Action to perform
+ */
+export type UpdateScheduleAction = ClosedEnum<typeof UpdateScheduleAction>;
+
+export type UpdateScheduleRequestBody = {
+  /**
+   * Action to perform
+   */
+  action: UpdateScheduleAction;
+};
+
+export type UpdateScheduleRequest = {
+  /**
+   * Schedule ID
+   */
+  scheduleId: string;
+  body: UpdateScheduleRequestBody;
+};
+
+/**
+ * Schedule updated
+ */
+export type UpdateScheduleResponse = {
+  success: true;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+/**
+ * Filter by task status
+ */
+export const ListTasksQueryParamStatus = {
+  Queued: "queued",
+  Dispatched: "dispatched",
+  Accepted: "accepted",
+  Running: "running",
+  Succeeded: "succeeded",
+  Failed: "failed",
+  Cancelled: "cancelled",
+} as const;
+/**
+ * Filter by task status
+ */
+export type ListTasksQueryParamStatus = ClosedEnum<
+  typeof ListTasksQueryParamStatus
+>;
+
+export type ListTasksRequest = {
+  /**
+   * Filter by task status
+   */
+  status?: ListTasksQueryParamStatus | undefined;
+  /**
+   * Filter by task type (e.g. outreach-batch)
+   */
+  type?: string | undefined;
+  /**
+   * Filter by campaign ID
+   */
+  campaignId?: string | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+};
+
+export const TaskStatus = {
+  Queued: "queued",
+  Dispatched: "dispatched",
+  Accepted: "accepted",
+  Running: "running",
+  Succeeded: "succeeded",
+  Failed: "failed",
+  Cancelled: "cancelled",
+} as const;
+export type TaskStatus = OpenEnum<typeof TaskStatus>;
+
+export type ListTasksTask = {
+  id: string;
+  /**
+   * Task type (e.g. lead-gen-qualify, outreach-batch, lm-comments)
+   */
+  type: string;
+  campaignId: string | null;
+  status: TaskStatus;
+  priority: number;
+  model: string | null;
+  /**
+   * Structured task result (after completion)
+   */
+  result: any | null;
+  error: string | null;
+  connectorId: string | null;
+  workflowRunId: string | null;
+  createdAt: string;
+  dispatchedAt: string | null;
+  completedAt: string | null;
+};
+
+/**
+ * Task list
+ */
+export type ListTasksResponse = {
+  tasks: Array<ListTasksTask>;
+  total: number;
+  limit: number;
+  offset: number;
+};
+
+export type CancelTaskRequest = {
+  /**
+   * Task ID
+   */
+  id: string;
+};
+
+/**
+ * Task cancelled or already terminal
+ */
+export type CancelTaskResponse = {
+  success: true;
+  status: string;
+  message?: string | undefined;
+};
+
+export type EventsFeedRequest = {
+  /**
+   * ISO timestamp or epoch ms (default: 2 hours ago)
+   */
+  since?: string | undefined;
+  limit?: number | undefined;
+};
+
+export const EventsFeedType = {
+  TaskCompleted: "task:completed",
+  TaskFailed: "task:failed",
+  ReplyReceived: "reply:received",
+  ConnectionAccepted: "connection:accepted",
+  CampaignTargetReached: "campaign:target_reached",
+  CampaignCompleted: "campaign:completed",
+  CampaignPaused: "campaign:paused",
+} as const;
+export type EventsFeedType = OpenEnum<typeof EventsFeedType>;
+
+export type Event = {
+  id: string;
+  type: EventsFeedType;
+  campaignId?: string | undefined;
+  campaignName?: string | undefined;
+  /**
+   * Human-readable one-line summary
+   */
+  summary: string;
+  metadata: { [k: string]: any };
+  /**
+   * Unix epoch ms
+   */
+  timestamp: number;
+};
+
+/**
+ * Events
+ */
+export type EventsFeedResponse = {
+  events: Array<Event>;
+  /**
+   * Timestamp of most recent event (pass as 'since' for next poll)
+   */
+  cursor?: number | undefined;
+};
+
+export type CancelChainRequest = {
+  /**
+   * Workflow run ID
+   */
+  workflowRunId: string;
+};
+
+/**
+ * Chain cancelled
+ */
+export type CancelChainResponse = {
+  success: true;
+  /**
+   * Number of in-flight tasks cancelled
+   */
+  tasksCancelled: number;
+};
+
+export type PullTaskTask = {
+  id: string;
+  type: string;
+  campaignId: string | null;
+  /**
+   * Task prompt for the agent
+   */
+  message: string;
+  model: string | null;
+  thinking: string | null;
+  timeoutSeconds: number | null;
+  sessionKey: string | null;
+  payload: any | null;
+};
+
+/**
+ * Task pulled (or null)
+ */
+export type PullTaskResponse = {
+  task: PullTaskTask | null;
+  /**
+   * ID of a recently cancelled task the connector should abort
+   */
+  cancelTaskId: string | null;
+  /**
+   * Suggested poll interval in ms (5000 when busy, 30000 when idle)
+   */
+  pollIntervalMs: number;
+};
+
+/**
+ * Intermediate status update (no result yet)
+ */
+export const SubmitTaskResultStatus = {
+  Accepted: "accepted",
+  Running: "running",
+} as const;
+/**
+ * Intermediate status update (no result yet)
+ */
+export type SubmitTaskResultStatus = ClosedEnum<typeof SubmitTaskResultStatus>;
+
+export type SubmitTaskResultRequestBody = {
+  /**
+   * Intermediate status update (no result yet)
+   */
+  status?: SubmitTaskResultStatus | undefined;
+  /**
+   * Structured TaskResult on completion
+   */
+  result?: any | undefined;
+  /**
+   * Error message on failure
+   */
+  error?: string | undefined;
+};
+
+export type SubmitTaskResultRequest = {
+  /**
+   * Task ID
+   */
+  id: string;
+  body: SubmitTaskResultRequestBody;
+};
+
+/**
+ * Result accepted
+ */
+export type SubmitTaskResultResponse = {
+  success: true;
+  status: string;
+  message?: string | undefined;
+};
+
+export type Connector = {
+  id: string;
+  name: string;
+  /**
+   * online, idle, busy, or offline
+   */
+  status: string;
+  credentialsId: string;
+  lastSeenAt: string | null;
+  lastTaskAt: string | null;
+  createdAt: string;
+  /**
+   * True if lastSeenAt < 5 minutes ago
+   */
+  isOnline: boolean;
+};
+
+/**
+ * Connector list
+ */
+export type ListConnectorsResponse = {
+  connectors: Array<Connector>;
+};
+
+export type ConnectorHeartbeatRequest = {
+  /**
+   * ID of currently executing task (sets status to 'busy')
+   */
+  currentTaskId?: string | undefined;
+};
+
+/**
+ * Heartbeat acknowledged
+ */
+export type ConnectorHeartbeatResponse = {
+  success: true;
+  /**
+   * Number of queued tasks for this credential
+   */
+  pendingCount: number;
+  /**
+   * Suggested poll interval (5000 when tasks pending, 30000 when idle)
+   */
+  pollIntervalMs: number;
+};
+
+export type Context = {
+  type: string;
+  label: string | null;
+  content: string;
+  scope: string;
+};
+
+export type ActiveAccount = {
+  id: string;
+  name: string | null;
+  plan: string;
+  headline: string | null;
+  isUnlimited: boolean;
+  creditsLimit: number;
+  creditsCount: number;
+  simulateWrites: boolean;
+  isCurrent: boolean;
+};
+
+export type AgentSnapshotAccount = {
+  id: string;
+  name: string | null;
+  plan: string;
+  headline: string | null;
+  isUnlimited: boolean;
+  creditsLimit: number;
+  creditsCount: number;
+  simulateWrites: boolean;
+  isCurrent: boolean;
+};
+
+export type AgentSnapshotStageCounts = {
+  contact: number;
+  lead: number;
+  qualified: number;
+  approved: number;
+  rejected: number;
+  total: number;
+};
+
+export type ActiveCampaign = {
+  id: string;
+  name: string;
+  type: string;
+  status: string;
+  context: any | null;
+  stageCounts: AgentSnapshotStageCounts;
+};
+
+export const AgentSnapshotType = {
+  TaskCompleted: "task:completed",
+  TaskFailed: "task:failed",
+  ReplyReceived: "reply:received",
+  ConnectionAccepted: "connection:accepted",
+  CampaignTargetReached: "campaign:target_reached",
+  CampaignCompleted: "campaign:completed",
+  CampaignPaused: "campaign:paused",
+} as const;
+export type AgentSnapshotType = OpenEnum<typeof AgentSnapshotType>;
+
+export type RecentEvent = {
+  id: string;
+  type: AgentSnapshotType;
+  campaignId?: string | undefined;
+  campaignName?: string | undefined;
+  /**
+   * Human-readable one-line summary
+   */
+  summary: string;
+  metadata: { [k: string]: any };
+  /**
+   * Unix epoch ms
+   */
+  timestamp: number;
+};
+
+/**
+ * Session snapshot
+ */
+export type AgentSnapshotResponse = {
+  /**
+   * Credit balance and usage
+   */
+  credits: any | null;
+  /**
+   * Contact counts by lifecycle stage
+   */
+  pipeline: { [k: string]: number };
+  contexts: Array<Context>;
+  pendingDrafts: number;
+  failedDrafts: number;
+  unreadDMs: number;
+  pendingSentInvitations: number;
+  activeAccount: ActiveAccount | null;
+  accounts: Array<AgentSnapshotAccount>;
+  leadGenState: any | null;
+  outreachState: any | null;
+  activeCampaigns: Array<ActiveCampaign>;
+  campaignChecks: any;
+  sessionMeta: any | null;
+  onboardingState: any | null;
+  recentEvents: Array<RecentEvent>;
+};
+
+export type GetDmPollingSettingsSettings = {
+  dmPollingEnabled: boolean;
+  dmWebhookUrl: string | null;
+  dmLastPolledAt: string | null;
+  connectionPollingEnabled: boolean;
+  connectionLastPolledAt: string | null;
+};
+
+/**
+ * Polling settings
+ */
+export type GetDmPollingSettingsResponse = {
+  success: true;
+  settings: GetDmPollingSettingsSettings;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+export type PatchDmPollingSettingsRequest = {
+  dmPollingEnabled?: boolean | undefined;
+  /**
+   * Webhook URL for DM events
+   */
+  dmWebhookUrl?: string | null | undefined;
+  /**
+   * Enable polling to detect accepted connections
+   */
+  connectionPollingEnabled?: boolean | undefined;
+};
+
+export type PatchDmPollingSettingsSettings = {
+  dmPollingEnabled: boolean;
+  dmWebhookUrl: string | null;
+  dmLastPolledAt: string | null;
+  connectionPollingEnabled: boolean;
+  connectionLastPolledAt: string | null;
+};
+
+/**
+ * Settings updated
+ */
+export type PatchDmPollingSettingsResponse = {
+  success: true;
+  settings: PatchDmPollingSettingsSettings;
+  /**
+   * Credits consumed (always 0 for workspace operations).
+   */
+  creditsUsed: number;
+  /**
+   * Seconds to wait (always 0 for workspace operations).
+   */
+  retryAfter: number;
+};
+
+export type DeleteWorkspaceAccountRequest = {
+  /**
+   * LinkedIn credentials ID
+   */
+  id: string;
+};
+
+/**
+ * Account removed
+ */
+export type DeleteWorkspaceAccountResponse = {
+  success: true;
+  message: string;
+};
+
+export const UpgradeWorkspaceAccountAction = {
+  Upgrade: "upgrade",
+  Downgrade: "downgrade",
+} as const;
+export type UpgradeWorkspaceAccountAction = ClosedEnum<
+  typeof UpgradeWorkspaceAccountAction
+>;
+
+export type UpgradeWorkspaceAccountRequest = {
+  /**
+   * LinkedIn credentials ID
+   */
+  credentialsId: string;
+  action: UpgradeWorkspaceAccountAction;
+};
+
+/**
+ * Plan changed
+ */
+export type UpgradeWorkspaceAccountResponse = {
+  success: true;
+  message: string;
+  seatsUsed: number;
+  seatsIncluded: number;
+};
+
+/**
+ * "create" to make a new invite, "list" to get existing
+ */
+export const CreateWorkspaceInviteAction = {
+  Create: "create",
+  List: "list",
+} as const;
+/**
+ * "create" to make a new invite, "list" to get existing
+ */
+export type CreateWorkspaceInviteAction = ClosedEnum<
+  typeof CreateWorkspaceInviteAction
+>;
+
+export type CreateWorkspaceInviteRequest = {
+  /**
+   * "create" to make a new invite, "list" to get existing
+   */
+  action: CreateWorkspaceInviteAction;
+  /**
+   * Invitee email (sends invite email)
+   */
+  email?: string | undefined;
+  /**
+   * Invitee name
+   */
+  name?: string | undefined;
+  /**
+   * Max times code can be used
+   */
+  maxUses?: number | undefined;
+};
+
+export type Invite2 = {
+  id: string;
+  email: string | null;
+  name: string | null;
+  code: string;
+  status?: string | undefined;
+  maxUses: number;
+  useCount: number;
+  expiresAt: string | null;
+  createdAt: string;
+};
+
+export type Workspace = {
+  tier: string;
+  proSeatsIncluded: number;
+  proSeatsUsed: number;
+};
+
+export type ResponseBody2 = {
+  success: true;
+  invites: Array<Invite2>;
+  workspace: Workspace;
+};
+
+export type Invite1 = {
+  id: string;
+  email: string | null;
+  name: string | null;
+  code: string;
+  status?: string | undefined;
+  maxUses: number;
+  useCount: number;
+  expiresAt: string | null;
+  createdAt: string;
+};
+
+export type ResponseBody1 = {
+  success: true;
+  invite: Invite1;
+};
+
+/**
+ * Invite created or listed
+ */
+export type CreateWorkspaceInviteResponse = ResponseBody2 | ResponseBody1;
+
+export type DeleteWorkspaceInviteRequest = {
+  /**
+   * Invite ID to delete
+   */
+  inviteId: string;
+};
+
+/**
+ * Invite deleted
+ */
+export type DeleteWorkspaceInviteResponse = {
+  success: true;
+};
+
+/** @internal */
+export const GetByUrlContact$inboundSchema: z.ZodMiniType<
+  GetByUrlContact,
+  unknown
+> = z.object({
+  id: types.string(),
+  linkedinUrl: types.string(),
+  profileUrn: types.nullable(types.string()),
+  publicIdentifier: types.nullable(types.string()),
+  name: types.string(),
+  lifecycleStage: types.string(),
+  hotScore: types.number(),
+  qualificationNotes: types.nullable(types.string()),
+  notes: types.nullable(types.string()),
+  stageChangedAt: types.nullable(types.string()),
+  profileData: types.nullable(z.any()),
+  profileUpdatedAt: types.nullable(types.string()),
+  conversationData: types.nullable(z.any()),
+  conversationUpdatedAt: types.nullable(types.string()),
+  outreachStatus: types.string(),
+  lastContactedAt: types.nullable(types.string()),
+  lastRepliedAt: types.nullable(types.string()),
+  nextFollowUpAt: types.nullable(types.string()),
+  doNotContact: types.boolean(),
+  tags: z.array(types.string()),
+  createdAt: types.string(),
+  updatedAt: types.string(),
+  activities: z.array(GetByUrlActivity$inboundSchema),
+  campaigns: z.array(GetByUrlCampaign$inboundSchema),
+});
+
+export function getByUrlContactFromJSON(
+  jsonString: string,
+): SafeParseResult<GetByUrlContact, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetByUrlContact$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetByUrlContact' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetByUrlResponse$inboundSchema: z.ZodMiniType<
+  GetByUrlResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  contact: z.lazy(() => GetByUrlContact$inboundSchema),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function getByUrlResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetByUrlResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetByUrlResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetByUrlResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListMessagesQueryParamStatus$outboundSchema: z.ZodMiniEnum<
+  typeof ListMessagesQueryParamStatus
+> = z.enum(ListMessagesQueryParamStatus);
+
+/** @internal */
+export type ListMessagesRequest$Outbound = {
+  status?: string | undefined;
+  contactId?: string | undefined;
+  campaignSlug?: string | undefined;
+  limit: number;
+  offset: number;
+};
+
+/** @internal */
+export const ListMessagesRequest$outboundSchema: z.ZodMiniType<
+  ListMessagesRequest$Outbound,
+  ListMessagesRequest
+> = z.object({
+  status: z.optional(ListMessagesQueryParamStatus$outboundSchema),
+  contactId: z.optional(z.string()),
+  campaignSlug: z.optional(z.string()),
+  limit: z._default(z.int(), 50),
+  offset: z._default(z.int(), 0),
+});
+
+export function listMessagesRequestToJSON(
+  listMessagesRequest: ListMessagesRequest,
+): string {
+  return JSON.stringify(
+    ListMessagesRequest$outboundSchema.parse(listMessagesRequest),
+  );
+}
+
+/** @internal */
+export const MessageStatus$inboundSchema: z.ZodMiniType<
+  MessageStatus,
+  unknown
+> = openEnums.inboundSchema(MessageStatus);
+
+/** @internal */
+export const ListMessagesMessage$inboundSchema: z.ZodMiniType<
+  ListMessagesMessage,
+  unknown
+> = z.object({
+  id: types.string(),
+  contactId: types.string(),
+  contactName: z.optional(z.nullable(types.string())),
+  contactLinkedinUrl: z.optional(z.nullable(types.string())),
+  message: types.string(),
+  status: MessageStatus$inboundSchema,
+  scheduledSendAt: types.nullable(types.string()),
+  sentAt: types.nullable(types.string()),
+  campaignSlug: types.nullable(types.string()),
+  errorMessage: z.optional(z.nullable(types.string())),
+  createdAt: types.string(),
+});
+
+export function listMessagesMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<ListMessagesMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListMessagesMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListMessagesMessage' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListMessagesResponse$inboundSchema: z.ZodMiniType<
+  ListMessagesResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  messages: z.array(z.lazy(() => ListMessagesMessage$inboundSchema)),
+  total: types.number(),
+  limit: types.number(),
+  offset: types.number(),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function listMessagesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListMessagesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListMessagesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListMessagesResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateStatusRequest$outboundSchema: z.ZodMiniEnum<
+  typeof CreateStatusRequest
+> = z.enum(CreateStatusRequest);
+
+/** @internal */
+export type CreateRequest$Outbound = {
+  contactId: string;
+  message: string;
+  status?: string | undefined;
+  scheduledSendAt?: string | undefined;
+  campaignSlug?: string | undefined;
+};
+
+/** @internal */
+export const CreateRequest$outboundSchema: z.ZodMiniType<
+  CreateRequest$Outbound,
+  CreateRequest
+> = z.object({
+  contactId: z.string(),
+  message: z.string(),
+  status: z.optional(CreateStatusRequest$outboundSchema),
+  scheduledSendAt: z.optional(z.string()),
+  campaignSlug: z.optional(z.string()),
+});
+
+export function createRequestToJSON(createRequest: CreateRequest): string {
+  return JSON.stringify(CreateRequest$outboundSchema.parse(createRequest));
+}
+
+/** @internal */
+export const ScheduledMessageStatus$inboundSchema: z.ZodMiniType<
+  ScheduledMessageStatus,
+  unknown
+> = openEnums.inboundSchema(ScheduledMessageStatus);
+
+/** @internal */
+export const ScheduledMessage$inboundSchema: z.ZodMiniType<
+  ScheduledMessage,
+  unknown
+> = z.object({
+  id: types.string(),
+  contactId: types.string(),
+  contactName: z.optional(z.nullable(types.string())),
+  contactLinkedinUrl: z.optional(z.nullable(types.string())),
+  message: types.string(),
+  status: ScheduledMessageStatus$inboundSchema,
+  scheduledSendAt: types.nullable(types.string()),
+  sentAt: types.nullable(types.string()),
+  campaignSlug: types.nullable(types.string()),
+  errorMessage: z.optional(z.nullable(types.string())),
+  createdAt: types.string(),
+});
+
+export function scheduledMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<ScheduledMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ScheduledMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ScheduledMessage' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateResponse$inboundSchema: z.ZodMiniType<
+  CreateResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  scheduledMessage: z.lazy(() => ScheduledMessage$inboundSchema),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function createResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type BatchScheduleRequest$Outbound = {
+  contactIds?: Array<string> | undefined;
+  messageIds?: Array<string> | undefined;
+  scheduledSendAt: string;
+  editedMessages?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const BatchScheduleRequest$outboundSchema: z.ZodMiniType<
+  BatchScheduleRequest$Outbound,
+  BatchScheduleRequest
+> = z.object({
+  contactIds: z.optional(z.array(z.string())),
+  messageIds: z.optional(z.array(z.string())),
+  scheduledSendAt: z.string(),
+  editedMessages: z.optional(z.record(z.string(), z.string())),
+});
+
+export function batchScheduleRequestToJSON(
+  batchScheduleRequest: BatchScheduleRequest,
+): string {
+  return JSON.stringify(
+    BatchScheduleRequest$outboundSchema.parse(batchScheduleRequest),
+  );
+}
+
+/** @internal */
+export const BatchScheduleResponse$inboundSchema: z.ZodMiniType<
+  BatchScheduleResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  scheduled: types.number(),
+  triggerFailures: types.number(),
+  scheduledSendAt: types.string(),
+  staggerMinutes: types.number(),
+  lastSendAt: types.string(),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function batchScheduleResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<BatchScheduleResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BatchScheduleResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BatchScheduleResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type CancelRequest$Outbound = {
+  messageIds?: Array<string> | undefined;
+  contactIds?: Array<string> | undefined;
+};
+
+/** @internal */
+export const CancelRequest$outboundSchema: z.ZodMiniType<
+  CancelRequest$Outbound,
+  CancelRequest
+> = z.object({
+  messageIds: z.optional(z.array(z.string())),
+  contactIds: z.optional(z.array(z.string())),
+});
+
+export function cancelRequestToJSON(cancelRequest: CancelRequest): string {
+  return JSON.stringify(CancelRequest$outboundSchema.parse(cancelRequest));
+}
+
+/** @internal */
+export const CancelResponse$inboundSchema: z.ZodMiniType<
+  CancelResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  cancelled: types.number(),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function cancelResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CancelResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CancelResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CancelResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type ReviewDraftsRequest$Outbound = {
+  campaignId: string;
+  approved?: Array<string> | undefined;
+  rejected?: Array<string> | undefined;
+  editedMessages?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const ReviewDraftsRequest$outboundSchema: z.ZodMiniType<
+  ReviewDraftsRequest$Outbound,
+  ReviewDraftsRequest
+> = z.object({
+  campaignId: z.string(),
+  approved: z.optional(z.array(z.string())),
+  rejected: z.optional(z.array(z.string())),
+  editedMessages: z.optional(z.record(z.string(), z.string())),
+});
+
+export function reviewDraftsRequestToJSON(
+  reviewDraftsRequest: ReviewDraftsRequest,
+): string {
+  return JSON.stringify(
+    ReviewDraftsRequest$outboundSchema.parse(reviewDraftsRequest),
+  );
+}
+
+/** @internal */
+export const ReviewDraftsResponse$inboundSchema: z.ZodMiniType<
+  ReviewDraftsResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  approved: types.number(),
+  rejected: types.number(),
+});
+
+export function reviewDraftsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ReviewDraftsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReviewDraftsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReviewDraftsResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type ListEntriesRequest$Outbound = {
+  scope?: string | undefined;
+  type?: string | undefined;
+};
+
+/** @internal */
+export const ListEntriesRequest$outboundSchema: z.ZodMiniType<
+  ListEntriesRequest$Outbound,
+  ListEntriesRequest
+> = z.object({
+  scope: z.optional(z.string()),
+  type: z.optional(z.string()),
+});
+
+export function listEntriesRequestToJSON(
+  listEntriesRequest: ListEntriesRequest,
+): string {
+  return JSON.stringify(
+    ListEntriesRequest$outboundSchema.parse(listEntriesRequest),
+  );
+}
+
+/** @internal */
+export const ListEntriesEntry$inboundSchema: z.ZodMiniType<
+  ListEntriesEntry,
+  unknown
+> = z.object({
+  id: types.string(),
+  type: types.string(),
+  label: types.nullable(types.string()),
+  content: types.string(),
+  scope: types.string(),
+  updatedAt: types.string(),
+});
+
+export function listEntriesEntryFromJSON(
+  jsonString: string,
+): SafeParseResult<ListEntriesEntry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListEntriesEntry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListEntriesEntry' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListEntriesResponse$inboundSchema: z.ZodMiniType<
+  ListEntriesResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  entries: z.array(z.lazy(() => ListEntriesEntry$inboundSchema)),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function listEntriesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListEntriesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListEntriesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListEntriesResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type SetRequest$Outbound = {
+  type: string;
+  content: string;
+  scope?: string | undefined;
+  label?: string | undefined;
+};
+
+/** @internal */
+export const SetRequest$outboundSchema: z.ZodMiniType<
+  SetRequest$Outbound,
+  SetRequest
+> = z.object({
+  type: z.string(),
+  content: z.string(),
+  scope: z.optional(z.string()),
+  label: z.optional(z.string()),
+});
+
+export function setRequestToJSON(setRequest: SetRequest): string {
+  return JSON.stringify(SetRequest$outboundSchema.parse(setRequest));
+}
+
+/** @internal */
+export const SetEntry$inboundSchema: z.ZodMiniType<SetEntry, unknown> = z
+  .object({
+    id: types.string(),
+    type: types.string(),
+    label: types.nullable(types.string()),
+    content: types.string(),
+    scope: types.string(),
+    updatedAt: types.string(),
+  });
+
+export function setEntryFromJSON(
+  jsonString: string,
+): SafeParseResult<SetEntry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetEntry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetEntry' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetResponse$inboundSchema: z.ZodMiniType<SetResponse, unknown> = z
+  .object({
+    success: types.literal(true),
+    entry: z.lazy(() => SetEntry$inboundSchema),
+    creditsUsed: types.number(),
+    retryAfter: types.number(),
+  });
+
+export function setResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SetResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type DeleteRequest$Outbound = {
+  type: string;
+  scope?: string | undefined;
+};
+
+/** @internal */
+export const DeleteRequest$outboundSchema: z.ZodMiniType<
+  DeleteRequest$Outbound,
+  DeleteRequest
+> = z.object({
+  type: z.string(),
+  scope: z.optional(z.string()),
+});
+
+export function deleteRequestToJSON(deleteRequest: DeleteRequest): string {
+  return JSON.stringify(DeleteRequest$outboundSchema.parse(deleteRequest));
+}
+
+/** @internal */
+export const DeleteResponse$inboundSchema: z.ZodMiniType<
+  DeleteResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function deleteResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const Schedule$inboundSchema: z.ZodMiniType<Schedule, unknown> = z
+  .object({
+    scheduleId: types.string(),
+    name: types.string(),
+    cron: types.nullable(types.string()),
+    isPaused: types.boolean(),
+    lastRun: types.nullable(types.string()),
+    nextRun: types.nullable(types.string()),
+    lastStatus: types.nullable(z.any()),
+    destination: types.string(),
+  });
+
+export function scheduleFromJSON(
+  jsonString: string,
+): SafeParseResult<Schedule, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Schedule$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Schedule' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListSchedulesResponse$inboundSchema: z.ZodMiniType<
+  ListSchedulesResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  schedules: z.array(z.lazy(() => Schedule$inboundSchema)),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function listSchedulesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListSchedulesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListSchedulesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListSchedulesResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateScheduleAction$outboundSchema: z.ZodMiniEnum<
+  typeof UpdateScheduleAction
+> = z.enum(UpdateScheduleAction);
+
+/** @internal */
+export type UpdateScheduleRequestBody$Outbound = {
+  action: string;
+};
+
+/** @internal */
+export const UpdateScheduleRequestBody$outboundSchema: z.ZodMiniType<
+  UpdateScheduleRequestBody$Outbound,
+  UpdateScheduleRequestBody
+> = z.object({
+  action: UpdateScheduleAction$outboundSchema,
+});
+
+export function updateScheduleRequestBodyToJSON(
+  updateScheduleRequestBody: UpdateScheduleRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateScheduleRequestBody$outboundSchema.parse(updateScheduleRequestBody),
+  );
+}
+
+/** @internal */
+export type UpdateScheduleRequest$Outbound = {
+  scheduleId: string;
+  body: UpdateScheduleRequestBody$Outbound;
+};
+
+/** @internal */
+export const UpdateScheduleRequest$outboundSchema: z.ZodMiniType<
+  UpdateScheduleRequest$Outbound,
+  UpdateScheduleRequest
+> = z.object({
+  scheduleId: z.string(),
+  body: z.lazy(() => UpdateScheduleRequestBody$outboundSchema),
+});
+
+export function updateScheduleRequestToJSON(
+  updateScheduleRequest: UpdateScheduleRequest,
+): string {
+  return JSON.stringify(
+    UpdateScheduleRequest$outboundSchema.parse(updateScheduleRequest),
+  );
+}
+
+/** @internal */
+export const UpdateScheduleResponse$inboundSchema: z.ZodMiniType<
+  UpdateScheduleResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function updateScheduleResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateScheduleResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateScheduleResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateScheduleResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListTasksQueryParamStatus$outboundSchema: z.ZodMiniEnum<
+  typeof ListTasksQueryParamStatus
+> = z.enum(ListTasksQueryParamStatus);
+
+/** @internal */
+export type ListTasksRequest$Outbound = {
+  status?: string | undefined;
+  type?: string | undefined;
+  campaignId?: string | undefined;
+  limit: number;
+  offset: number;
+};
+
+/** @internal */
+export const ListTasksRequest$outboundSchema: z.ZodMiniType<
+  ListTasksRequest$Outbound,
+  ListTasksRequest
+> = z.object({
+  status: z.optional(ListTasksQueryParamStatus$outboundSchema),
+  type: z.optional(z.string()),
+  campaignId: z.optional(z.string()),
+  limit: z._default(z.int(), 50),
+  offset: z._default(z.int(), 0),
+});
+
+export function listTasksRequestToJSON(
+  listTasksRequest: ListTasksRequest,
+): string {
+  return JSON.stringify(
+    ListTasksRequest$outboundSchema.parse(listTasksRequest),
+  );
+}
+
+/** @internal */
+export const TaskStatus$inboundSchema: z.ZodMiniType<TaskStatus, unknown> =
+  openEnums.inboundSchema(TaskStatus);
+
+/** @internal */
+export const ListTasksTask$inboundSchema: z.ZodMiniType<
+  ListTasksTask,
+  unknown
+> = z.object({
+  id: types.string(),
+  type: types.string(),
+  campaignId: types.nullable(types.string()),
+  status: TaskStatus$inboundSchema,
+  priority: types.number(),
+  model: types.nullable(types.string()),
+  result: types.nullable(z.any()),
+  error: types.nullable(types.string()),
+  connectorId: types.nullable(types.string()),
+  workflowRunId: types.nullable(types.string()),
+  createdAt: types.string(),
+  dispatchedAt: types.nullable(types.string()),
+  completedAt: types.nullable(types.string()),
+});
+
+export function listTasksTaskFromJSON(
+  jsonString: string,
+): SafeParseResult<ListTasksTask, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListTasksTask$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListTasksTask' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListTasksResponse$inboundSchema: z.ZodMiniType<
+  ListTasksResponse,
+  unknown
+> = z.object({
+  tasks: z.array(z.lazy(() => ListTasksTask$inboundSchema)),
+  total: types.number(),
+  limit: types.number(),
+  offset: types.number(),
+});
+
+export function listTasksResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListTasksResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListTasksResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListTasksResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type CancelTaskRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const CancelTaskRequest$outboundSchema: z.ZodMiniType<
+  CancelTaskRequest$Outbound,
+  CancelTaskRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function cancelTaskRequestToJSON(
+  cancelTaskRequest: CancelTaskRequest,
+): string {
+  return JSON.stringify(
+    CancelTaskRequest$outboundSchema.parse(cancelTaskRequest),
+  );
+}
+
+/** @internal */
+export const CancelTaskResponse$inboundSchema: z.ZodMiniType<
+  CancelTaskResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  status: types.string(),
+  message: types.optional(types.string()),
+});
+
+export function cancelTaskResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CancelTaskResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CancelTaskResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CancelTaskResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type EventsFeedRequest$Outbound = {
+  since?: string | undefined;
+  limit: number;
+};
+
+/** @internal */
+export const EventsFeedRequest$outboundSchema: z.ZodMiniType<
+  EventsFeedRequest$Outbound,
+  EventsFeedRequest
+> = z.object({
+  since: z.optional(z.string()),
+  limit: z._default(z.int(), 20),
+});
+
+export function eventsFeedRequestToJSON(
+  eventsFeedRequest: EventsFeedRequest,
+): string {
+  return JSON.stringify(
+    EventsFeedRequest$outboundSchema.parse(eventsFeedRequest),
+  );
+}
+
+/** @internal */
+export const EventsFeedType$inboundSchema: z.ZodMiniType<
+  EventsFeedType,
+  unknown
+> = openEnums.inboundSchema(EventsFeedType);
+
+/** @internal */
+export const Event$inboundSchema: z.ZodMiniType<Event, unknown> = z.object({
+  id: types.string(),
+  type: EventsFeedType$inboundSchema,
+  campaignId: types.optional(types.string()),
+  campaignName: types.optional(types.string()),
+  summary: types.string(),
+  metadata: z.record(z.string(), z.any()),
+  timestamp: types.number(),
+});
+
+export function eventFromJSON(
+  jsonString: string,
+): SafeParseResult<Event, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Event$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Event' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventsFeedResponse$inboundSchema: z.ZodMiniType<
+  EventsFeedResponse,
+  unknown
+> = z.object({
+  events: z.array(z.lazy(() => Event$inboundSchema)),
+  cursor: types.optional(types.number()),
+});
+
+export function eventsFeedResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EventsFeedResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventsFeedResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventsFeedResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type CancelChainRequest$Outbound = {
+  workflowRunId: string;
+};
+
+/** @internal */
+export const CancelChainRequest$outboundSchema: z.ZodMiniType<
+  CancelChainRequest$Outbound,
+  CancelChainRequest
+> = z.object({
+  workflowRunId: z.string(),
+});
+
+export function cancelChainRequestToJSON(
+  cancelChainRequest: CancelChainRequest,
+): string {
+  return JSON.stringify(
+    CancelChainRequest$outboundSchema.parse(cancelChainRequest),
+  );
+}
+
+/** @internal */
+export const CancelChainResponse$inboundSchema: z.ZodMiniType<
+  CancelChainResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  tasksCancelled: types.number(),
+});
+
+export function cancelChainResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CancelChainResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CancelChainResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CancelChainResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const PullTaskTask$inboundSchema: z.ZodMiniType<PullTaskTask, unknown> =
+  z.object({
+    id: types.string(),
+    type: types.string(),
+    campaignId: types.nullable(types.string()),
+    message: types.string(),
+    model: types.nullable(types.string()),
+    thinking: types.nullable(types.string()),
+    timeoutSeconds: types.nullable(types.number()),
+    sessionKey: types.nullable(types.string()),
+    payload: types.nullable(z.any()),
+  });
+
+export function pullTaskTaskFromJSON(
+  jsonString: string,
+): SafeParseResult<PullTaskTask, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PullTaskTask$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PullTaskTask' from JSON`,
+  );
+}
+
+/** @internal */
+export const PullTaskResponse$inboundSchema: z.ZodMiniType<
+  PullTaskResponse,
+  unknown
+> = z.object({
+  task: types.nullable(z.lazy(() => PullTaskTask$inboundSchema)),
+  cancelTaskId: types.nullable(types.string()),
+  pollIntervalMs: types.number(),
+});
+
+export function pullTaskResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PullTaskResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PullTaskResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PullTaskResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubmitTaskResultStatus$outboundSchema: z.ZodMiniEnum<
+  typeof SubmitTaskResultStatus
+> = z.enum(SubmitTaskResultStatus);
+
+/** @internal */
+export type SubmitTaskResultRequestBody$Outbound = {
+  status?: string | undefined;
+  result?: any | undefined;
+  error?: string | undefined;
+};
+
+/** @internal */
+export const SubmitTaskResultRequestBody$outboundSchema: z.ZodMiniType<
+  SubmitTaskResultRequestBody$Outbound,
+  SubmitTaskResultRequestBody
+> = z.object({
+  status: z.optional(SubmitTaskResultStatus$outboundSchema),
+  result: z.optional(z.any()),
+  error: z.optional(z.string()),
+});
+
+export function submitTaskResultRequestBodyToJSON(
+  submitTaskResultRequestBody: SubmitTaskResultRequestBody,
+): string {
+  return JSON.stringify(
+    SubmitTaskResultRequestBody$outboundSchema.parse(
+      submitTaskResultRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type SubmitTaskResultRequest$Outbound = {
+  id: string;
+  body: SubmitTaskResultRequestBody$Outbound;
+};
+
+/** @internal */
+export const SubmitTaskResultRequest$outboundSchema: z.ZodMiniType<
+  SubmitTaskResultRequest$Outbound,
+  SubmitTaskResultRequest
+> = z.object({
+  id: z.string(),
+  body: z.lazy(() => SubmitTaskResultRequestBody$outboundSchema),
+});
+
+export function submitTaskResultRequestToJSON(
+  submitTaskResultRequest: SubmitTaskResultRequest,
+): string {
+  return JSON.stringify(
+    SubmitTaskResultRequest$outboundSchema.parse(submitTaskResultRequest),
+  );
+}
+
+/** @internal */
+export const SubmitTaskResultResponse$inboundSchema: z.ZodMiniType<
+  SubmitTaskResultResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  status: types.string(),
+  message: types.optional(types.string()),
+});
+
+export function submitTaskResultResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SubmitTaskResultResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubmitTaskResultResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubmitTaskResultResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const Connector$inboundSchema: z.ZodMiniType<Connector, unknown> = z
+  .object({
+    id: types.string(),
+    name: types.string(),
+    status: types.string(),
+    credentialsId: types.string(),
+    lastSeenAt: types.nullable(types.string()),
+    lastTaskAt: types.nullable(types.string()),
+    createdAt: types.string(),
+    isOnline: types.boolean(),
+  });
+
+export function connectorFromJSON(
+  jsonString: string,
+): SafeParseResult<Connector, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Connector$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Connector' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListConnectorsResponse$inboundSchema: z.ZodMiniType<
+  ListConnectorsResponse,
+  unknown
+> = z.object({
+  connectors: z.array(z.lazy(() => Connector$inboundSchema)),
+});
+
+export function listConnectorsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListConnectorsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListConnectorsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListConnectorsResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type ConnectorHeartbeatRequest$Outbound = {
+  currentTaskId?: string | undefined;
+};
+
+/** @internal */
+export const ConnectorHeartbeatRequest$outboundSchema: z.ZodMiniType<
+  ConnectorHeartbeatRequest$Outbound,
+  ConnectorHeartbeatRequest
+> = z.object({
+  currentTaskId: z.optional(z.string()),
+});
+
+export function connectorHeartbeatRequestToJSON(
+  connectorHeartbeatRequest: ConnectorHeartbeatRequest,
+): string {
+  return JSON.stringify(
+    ConnectorHeartbeatRequest$outboundSchema.parse(connectorHeartbeatRequest),
+  );
+}
+
+/** @internal */
+export const ConnectorHeartbeatResponse$inboundSchema: z.ZodMiniType<
+  ConnectorHeartbeatResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  pendingCount: types.number(),
+  pollIntervalMs: types.number(),
+});
+
+export function connectorHeartbeatResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectorHeartbeatResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectorHeartbeatResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectorHeartbeatResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const Context$inboundSchema: z.ZodMiniType<Context, unknown> = z.object({
+  type: types.string(),
+  label: types.nullable(types.string()),
+  content: types.string(),
+  scope: types.string(),
+});
+
+export function contextFromJSON(
+  jsonString: string,
+): SafeParseResult<Context, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Context$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Context' from JSON`,
+  );
+}
+
+/** @internal */
+export const ActiveAccount$inboundSchema: z.ZodMiniType<
+  ActiveAccount,
+  unknown
+> = z.object({
+  id: types.string(),
+  name: types.nullable(types.string()),
+  plan: types.string(),
+  headline: types.nullable(types.string()),
+  isUnlimited: types.boolean(),
+  creditsLimit: types.number(),
+  creditsCount: types.number(),
+  simulateWrites: types.boolean(),
+  isCurrent: types.boolean(),
+});
+
+export function activeAccountFromJSON(
+  jsonString: string,
+): SafeParseResult<ActiveAccount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ActiveAccount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ActiveAccount' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentSnapshotAccount$inboundSchema: z.ZodMiniType<
+  AgentSnapshotAccount,
+  unknown
+> = z.object({
+  id: types.string(),
+  name: types.nullable(types.string()),
+  plan: types.string(),
+  headline: types.nullable(types.string()),
+  isUnlimited: types.boolean(),
+  creditsLimit: types.number(),
+  creditsCount: types.number(),
+  simulateWrites: types.boolean(),
+  isCurrent: types.boolean(),
+});
+
+export function agentSnapshotAccountFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentSnapshotAccount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentSnapshotAccount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentSnapshotAccount' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentSnapshotStageCounts$inboundSchema: z.ZodMiniType<
+  AgentSnapshotStageCounts,
+  unknown
+> = z.object({
+  contact: types.number(),
+  lead: types.number(),
+  qualified: types.number(),
+  approved: types.number(),
+  rejected: types.number(),
+  total: types.number(),
+});
+
+export function agentSnapshotStageCountsFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentSnapshotStageCounts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentSnapshotStageCounts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentSnapshotStageCounts' from JSON`,
+  );
+}
+
+/** @internal */
+export const ActiveCampaign$inboundSchema: z.ZodMiniType<
+  ActiveCampaign,
+  unknown
+> = z.object({
+  id: types.string(),
+  name: types.string(),
+  type: types.string(),
+  status: types.string(),
+  context: types.nullable(z.any()),
+  stageCounts: z.lazy(() => AgentSnapshotStageCounts$inboundSchema),
+});
+
+export function activeCampaignFromJSON(
+  jsonString: string,
+): SafeParseResult<ActiveCampaign, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ActiveCampaign$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ActiveCampaign' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentSnapshotType$inboundSchema: z.ZodMiniType<
+  AgentSnapshotType,
+  unknown
+> = openEnums.inboundSchema(AgentSnapshotType);
+
+/** @internal */
+export const RecentEvent$inboundSchema: z.ZodMiniType<RecentEvent, unknown> = z
+  .object({
+    id: types.string(),
+    type: AgentSnapshotType$inboundSchema,
+    campaignId: types.optional(types.string()),
+    campaignName: types.optional(types.string()),
+    summary: types.string(),
+    metadata: z.record(z.string(), z.any()),
+    timestamp: types.number(),
+  });
+
+export function recentEventFromJSON(
+  jsonString: string,
+): SafeParseResult<RecentEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RecentEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RecentEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentSnapshotResponse$inboundSchema: z.ZodMiniType<
+  AgentSnapshotResponse,
+  unknown
+> = z.object({
+  credits: types.nullable(z.any()),
+  pipeline: z.record(z.string(), types.number()),
+  contexts: z.array(z.lazy(() => Context$inboundSchema)),
+  pendingDrafts: types.number(),
+  failedDrafts: types.number(),
+  unreadDMs: types.number(),
+  pendingSentInvitations: types.number(),
+  activeAccount: types.nullable(z.lazy(() => ActiveAccount$inboundSchema)),
+  accounts: z.array(z.lazy(() => AgentSnapshotAccount$inboundSchema)),
+  leadGenState: types.nullable(z.any()),
+  outreachState: types.nullable(z.any()),
+  activeCampaigns: z.array(z.lazy(() => ActiveCampaign$inboundSchema)),
+  campaignChecks: z.any(),
+  sessionMeta: types.nullable(z.any()),
+  onboardingState: types.nullable(z.any()),
+  recentEvents: z.array(z.lazy(() => RecentEvent$inboundSchema)),
+});
+
+export function agentSnapshotResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentSnapshotResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentSnapshotResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentSnapshotResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetDmPollingSettingsSettings$inboundSchema: z.ZodMiniType<
+  GetDmPollingSettingsSettings,
+  unknown
+> = z.object({
+  dmPollingEnabled: types.boolean(),
+  dmWebhookUrl: types.nullable(types.string()),
+  dmLastPolledAt: types.nullable(types.string()),
+  connectionPollingEnabled: types.boolean(),
+  connectionLastPolledAt: types.nullable(types.string()),
+});
+
+export function getDmPollingSettingsSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetDmPollingSettingsSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetDmPollingSettingsSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetDmPollingSettingsSettings' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetDmPollingSettingsResponse$inboundSchema: z.ZodMiniType<
+  GetDmPollingSettingsResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  settings: z.lazy(() => GetDmPollingSettingsSettings$inboundSchema),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function getDmPollingSettingsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetDmPollingSettingsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetDmPollingSettingsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetDmPollingSettingsResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type PatchDmPollingSettingsRequest$Outbound = {
+  dmPollingEnabled?: boolean | undefined;
+  dmWebhookUrl?: string | null | undefined;
+  connectionPollingEnabled?: boolean | undefined;
+};
+
+/** @internal */
+export const PatchDmPollingSettingsRequest$outboundSchema: z.ZodMiniType<
+  PatchDmPollingSettingsRequest$Outbound,
+  PatchDmPollingSettingsRequest
+> = z.object({
+  dmPollingEnabled: z.optional(z.boolean()),
+  dmWebhookUrl: z.optional(z.nullable(z.string())),
+  connectionPollingEnabled: z.optional(z.boolean()),
+});
+
+export function patchDmPollingSettingsRequestToJSON(
+  patchDmPollingSettingsRequest: PatchDmPollingSettingsRequest,
+): string {
+  return JSON.stringify(
+    PatchDmPollingSettingsRequest$outboundSchema.parse(
+      patchDmPollingSettingsRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const PatchDmPollingSettingsSettings$inboundSchema: z.ZodMiniType<
+  PatchDmPollingSettingsSettings,
+  unknown
+> = z.object({
+  dmPollingEnabled: types.boolean(),
+  dmWebhookUrl: types.nullable(types.string()),
+  dmLastPolledAt: types.nullable(types.string()),
+  connectionPollingEnabled: types.boolean(),
+  connectionLastPolledAt: types.nullable(types.string()),
+});
+
+export function patchDmPollingSettingsSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDmPollingSettingsSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDmPollingSettingsSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDmPollingSettingsSettings' from JSON`,
+  );
+}
+
+/** @internal */
+export const PatchDmPollingSettingsResponse$inboundSchema: z.ZodMiniType<
+  PatchDmPollingSettingsResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  settings: z.lazy(() => PatchDmPollingSettingsSettings$inboundSchema),
+  creditsUsed: types.number(),
+  retryAfter: types.number(),
+});
+
+export function patchDmPollingSettingsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PatchDmPollingSettingsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchDmPollingSettingsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchDmPollingSettingsResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type DeleteWorkspaceAccountRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const DeleteWorkspaceAccountRequest$outboundSchema: z.ZodMiniType<
+  DeleteWorkspaceAccountRequest$Outbound,
+  DeleteWorkspaceAccountRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function deleteWorkspaceAccountRequestToJSON(
+  deleteWorkspaceAccountRequest: DeleteWorkspaceAccountRequest,
+): string {
+  return JSON.stringify(
+    DeleteWorkspaceAccountRequest$outboundSchema.parse(
+      deleteWorkspaceAccountRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DeleteWorkspaceAccountResponse$inboundSchema: z.ZodMiniType<
+  DeleteWorkspaceAccountResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  message: types.string(),
+});
+
+export function deleteWorkspaceAccountResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteWorkspaceAccountResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteWorkspaceAccountResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteWorkspaceAccountResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpgradeWorkspaceAccountAction$outboundSchema: z.ZodMiniEnum<
+  typeof UpgradeWorkspaceAccountAction
+> = z.enum(UpgradeWorkspaceAccountAction);
+
+/** @internal */
+export type UpgradeWorkspaceAccountRequest$Outbound = {
+  credentialsId: string;
+  action: string;
+};
+
+/** @internal */
+export const UpgradeWorkspaceAccountRequest$outboundSchema: z.ZodMiniType<
+  UpgradeWorkspaceAccountRequest$Outbound,
+  UpgradeWorkspaceAccountRequest
+> = z.object({
+  credentialsId: z.string(),
+  action: UpgradeWorkspaceAccountAction$outboundSchema,
+});
+
+export function upgradeWorkspaceAccountRequestToJSON(
+  upgradeWorkspaceAccountRequest: UpgradeWorkspaceAccountRequest,
+): string {
+  return JSON.stringify(
+    UpgradeWorkspaceAccountRequest$outboundSchema.parse(
+      upgradeWorkspaceAccountRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const UpgradeWorkspaceAccountResponse$inboundSchema: z.ZodMiniType<
+  UpgradeWorkspaceAccountResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  message: types.string(),
+  seatsUsed: types.number(),
+  seatsIncluded: types.number(),
+});
+
+export function upgradeWorkspaceAccountResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UpgradeWorkspaceAccountResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpgradeWorkspaceAccountResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpgradeWorkspaceAccountResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWorkspaceInviteAction$outboundSchema: z.ZodMiniEnum<
+  typeof CreateWorkspaceInviteAction
+> = z.enum(CreateWorkspaceInviteAction);
+
+/** @internal */
+export type CreateWorkspaceInviteRequest$Outbound = {
+  action: string;
+  email?: string | undefined;
+  name?: string | undefined;
+  maxUses: number;
+};
+
+/** @internal */
+export const CreateWorkspaceInviteRequest$outboundSchema: z.ZodMiniType<
+  CreateWorkspaceInviteRequest$Outbound,
+  CreateWorkspaceInviteRequest
+> = z.object({
+  action: CreateWorkspaceInviteAction$outboundSchema,
+  email: z.optional(z.string()),
+  name: z.optional(z.string()),
+  maxUses: z._default(z.int(), 1),
+});
+
+export function createWorkspaceInviteRequestToJSON(
+  createWorkspaceInviteRequest: CreateWorkspaceInviteRequest,
+): string {
+  return JSON.stringify(
+    CreateWorkspaceInviteRequest$outboundSchema.parse(
+      createWorkspaceInviteRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const Invite2$inboundSchema: z.ZodMiniType<Invite2, unknown> = z.object({
+  id: types.string(),
+  email: types.nullable(types.string()),
+  name: types.nullable(types.string()),
+  code: types.string(),
+  status: types.optional(types.string()),
+  maxUses: types.number(),
+  useCount: types.number(),
+  expiresAt: types.nullable(types.string()),
+  createdAt: types.string(),
+});
+
+export function invite2FromJSON(
+  jsonString: string,
+): SafeParseResult<Invite2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Invite2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Invite2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Workspace$inboundSchema: z.ZodMiniType<Workspace, unknown> = z
+  .object({
+    tier: types.string(),
+    proSeatsIncluded: types.number(),
+    proSeatsUsed: types.number(),
+  });
+
+export function workspaceFromJSON(
+  jsonString: string,
+): SafeParseResult<Workspace, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Workspace$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Workspace' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBody2$inboundSchema: z.ZodMiniType<
+  ResponseBody2,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  invites: z.array(z.lazy(() => Invite2$inboundSchema)),
+  workspace: z.lazy(() => Workspace$inboundSchema),
+});
+
+export function responseBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Invite1$inboundSchema: z.ZodMiniType<Invite1, unknown> = z.object({
+  id: types.string(),
+  email: types.nullable(types.string()),
+  name: types.nullable(types.string()),
+  code: types.string(),
+  status: types.optional(types.string()),
+  maxUses: types.number(),
+  useCount: types.number(),
+  expiresAt: types.nullable(types.string()),
+  createdAt: types.string(),
+});
+
+export function invite1FromJSON(
+  jsonString: string,
+): SafeParseResult<Invite1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Invite1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Invite1' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBody1$inboundSchema: z.ZodMiniType<
+  ResponseBody1,
+  unknown
+> = z.object({
+  success: types.literal(true),
+  invite: z.lazy(() => Invite1$inboundSchema),
+});
+
+export function responseBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWorkspaceInviteResponse$inboundSchema: z.ZodMiniType<
+  CreateWorkspaceInviteResponse,
+  unknown
+> = smartUnion([
+  z.lazy(() => ResponseBody2$inboundSchema),
+  z.lazy(() => ResponseBody1$inboundSchema),
+]);
+
+export function createWorkspaceInviteResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWorkspaceInviteResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWorkspaceInviteResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWorkspaceInviteResponse' from JSON`,
+  );
+}
+
+/** @internal */
+export type DeleteWorkspaceInviteRequest$Outbound = {
+  inviteId: string;
+};
+
+/** @internal */
+export const DeleteWorkspaceInviteRequest$outboundSchema: z.ZodMiniType<
+  DeleteWorkspaceInviteRequest$Outbound,
+  DeleteWorkspaceInviteRequest
+> = z.object({
+  inviteId: z.string(),
+});
+
+export function deleteWorkspaceInviteRequestToJSON(
+  deleteWorkspaceInviteRequest: DeleteWorkspaceInviteRequest,
+): string {
+  return JSON.stringify(
+    DeleteWorkspaceInviteRequest$outboundSchema.parse(
+      deleteWorkspaceInviteRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DeleteWorkspaceInviteResponse$inboundSchema: z.ZodMiniType<
+  DeleteWorkspaceInviteResponse,
+  unknown
+> = z.object({
+  success: types.literal(true),
+});
+
+export function deleteWorkspaceInviteResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteWorkspaceInviteResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteWorkspaceInviteResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteWorkspaceInviteResponse' from JSON`,
+  );
+}