bereach 1.4.2 → 1.5.0

package/esm/models/operations/delete-workspace-invite-response.d.ts

@@ -0,0 +1,1374 @@
+import * as z from "zod/v4-mini";
+import { ClosedEnum, OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import { GetByUrlActivity, GetByUrlCampaign } 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 declare const ListMessagesQueryParamStatus: {
+    readonly Draft: "draft";
+    readonly Scheduled: "scheduled";
+    readonly Sending: "sending";
+    readonly Sent: "sent";
+    readonly Failed: "failed";
+    readonly Cancelled: "cancelled";
+};
+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 declare const MessageStatus: {
+    readonly Draft: "draft";
+    readonly Scheduled: "scheduled";
+    readonly Sending: "sending";
+    readonly Sent: "sent";
+    readonly Failed: "failed";
+    readonly Cancelled: "cancelled";
+};
+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 declare const CreateStatusRequest: {
+    readonly Draft: "draft";
+    readonly Scheduled: "scheduled";
+};
+/**
+ * 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 declare const ScheduledMessageStatus: {
+    readonly Draft: "draft";
+    readonly Scheduled: "scheduled";
+    readonly Sending: "sending";
+    readonly Sent: "sent";
+    readonly Failed: "failed";
+    readonly Cancelled: "cancelled";
+};
+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 declare const UpdateScheduleAction: {
+    readonly Pause: "pause";
+    readonly Resume: "resume";
+    readonly Delete: "delete";
+};
+/**
+ * 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 declare const ListTasksQueryParamStatus: {
+    readonly Queued: "queued";
+    readonly Dispatched: "dispatched";
+    readonly Accepted: "accepted";
+    readonly Running: "running";
+    readonly Succeeded: "succeeded";
+    readonly Failed: "failed";
+    readonly Cancelled: "cancelled";
+};
+/**
+ * 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 declare const TaskStatus: {
+    readonly Queued: "queued";
+    readonly Dispatched: "dispatched";
+    readonly Accepted: "accepted";
+    readonly Running: "running";
+    readonly Succeeded: "succeeded";
+    readonly Failed: "failed";
+    readonly Cancelled: "cancelled";
+};
+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 declare const EventsFeedType: {
+    readonly TaskCompleted: "task:completed";
+    readonly TaskFailed: "task:failed";
+    readonly ReplyReceived: "reply:received";
+    readonly ConnectionAccepted: "connection:accepted";
+    readonly CampaignTargetReached: "campaign:target_reached";
+    readonly CampaignCompleted: "campaign:completed";
+    readonly CampaignPaused: "campaign:paused";
+};
+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 declare const SubmitTaskResultStatus: {
+    readonly Accepted: "accepted";
+    readonly Running: "running";
+};
+/**
+ * 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 declare const AgentSnapshotType: {
+    readonly TaskCompleted: "task:completed";
+    readonly TaskFailed: "task:failed";
+    readonly ReplyReceived: "reply:received";
+    readonly ConnectionAccepted: "connection:accepted";
+    readonly CampaignTargetReached: "campaign:target_reached";
+    readonly CampaignCompleted: "campaign:completed";
+    readonly CampaignPaused: "campaign:paused";
+};
+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 declare const UpgradeWorkspaceAccountAction: {
+    readonly Upgrade: "upgrade";
+    readonly Downgrade: "downgrade";
+};
+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 declare const CreateWorkspaceInviteAction: {
+    readonly Create: "create";
+    readonly List: "list";
+};
+/**
+ * "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 declare const GetByUrlContact$inboundSchema: z.ZodMiniType<GetByUrlContact, unknown>;
+export declare function getByUrlContactFromJSON(jsonString: string): SafeParseResult<GetByUrlContact, SDKValidationError>;
+/** @internal */
+export declare const GetByUrlResponse$inboundSchema: z.ZodMiniType<GetByUrlResponse, unknown>;
+export declare function getByUrlResponseFromJSON(jsonString: string): SafeParseResult<GetByUrlResponse, SDKValidationError>;
+/** @internal */
+export declare const ListMessagesQueryParamStatus$outboundSchema: z.ZodMiniEnum<typeof ListMessagesQueryParamStatus>;
+/** @internal */
+export type ListMessagesRequest$Outbound = {
+    status?: string | undefined;
+    contactId?: string | undefined;
+    campaignSlug?: string | undefined;
+    limit: number;
+    offset: number;
+};
+/** @internal */
+export declare const ListMessagesRequest$outboundSchema: z.ZodMiniType<ListMessagesRequest$Outbound, ListMessagesRequest>;
+export declare function listMessagesRequestToJSON(listMessagesRequest: ListMessagesRequest): string;
+/** @internal */
+export declare const MessageStatus$inboundSchema: z.ZodMiniType<MessageStatus, unknown>;
+/** @internal */
+export declare const ListMessagesMessage$inboundSchema: z.ZodMiniType<ListMessagesMessage, unknown>;
+export declare function listMessagesMessageFromJSON(jsonString: string): SafeParseResult<ListMessagesMessage, SDKValidationError>;
+/** @internal */
+export declare const ListMessagesResponse$inboundSchema: z.ZodMiniType<ListMessagesResponse, unknown>;
+export declare function listMessagesResponseFromJSON(jsonString: string): SafeParseResult<ListMessagesResponse, SDKValidationError>;
+/** @internal */
+export declare const CreateStatusRequest$outboundSchema: z.ZodMiniEnum<typeof CreateStatusRequest>;
+/** @internal */
+export type CreateRequest$Outbound = {
+    contactId: string;
+    message: string;
+    status?: string | undefined;
+    scheduledSendAt?: string | undefined;
+    campaignSlug?: string | undefined;
+};
+/** @internal */
+export declare const CreateRequest$outboundSchema: z.ZodMiniType<CreateRequest$Outbound, CreateRequest>;
+export declare function createRequestToJSON(createRequest: CreateRequest): string;
+/** @internal */
+export declare const ScheduledMessageStatus$inboundSchema: z.ZodMiniType<ScheduledMessageStatus, unknown>;
+/** @internal */
+export declare const ScheduledMessage$inboundSchema: z.ZodMiniType<ScheduledMessage, unknown>;
+export declare function scheduledMessageFromJSON(jsonString: string): SafeParseResult<ScheduledMessage, SDKValidationError>;
+/** @internal */
+export declare const CreateResponse$inboundSchema: z.ZodMiniType<CreateResponse, unknown>;
+export declare function createResponseFromJSON(jsonString: string): SafeParseResult<CreateResponse, SDKValidationError>;
+/** @internal */
+export type BatchScheduleRequest$Outbound = {
+    contactIds?: Array<string> | undefined;
+    messageIds?: Array<string> | undefined;
+    scheduledSendAt: string;
+    editedMessages?: {
+        [k: string]: string;
+    } | undefined;
+};
+/** @internal */
+export declare const BatchScheduleRequest$outboundSchema: z.ZodMiniType<BatchScheduleRequest$Outbound, BatchScheduleRequest>;
+export declare function batchScheduleRequestToJSON(batchScheduleRequest: BatchScheduleRequest): string;
+/** @internal */
+export declare const BatchScheduleResponse$inboundSchema: z.ZodMiniType<BatchScheduleResponse, unknown>;
+export declare function batchScheduleResponseFromJSON(jsonString: string): SafeParseResult<BatchScheduleResponse, SDKValidationError>;
+/** @internal */
+export type CancelRequest$Outbound = {
+    messageIds?: Array<string> | undefined;
+    contactIds?: Array<string> | undefined;
+};
+/** @internal */
+export declare const CancelRequest$outboundSchema: z.ZodMiniType<CancelRequest$Outbound, CancelRequest>;
+export declare function cancelRequestToJSON(cancelRequest: CancelRequest): string;
+/** @internal */
+export declare const CancelResponse$inboundSchema: z.ZodMiniType<CancelResponse, unknown>;
+export declare function cancelResponseFromJSON(jsonString: string): SafeParseResult<CancelResponse, SDKValidationError>;
+/** @internal */
+export type ReviewDraftsRequest$Outbound = {
+    campaignId: string;
+    approved?: Array<string> | undefined;
+    rejected?: Array<string> | undefined;
+    editedMessages?: {
+        [k: string]: string;
+    } | undefined;
+};
+/** @internal */
+export declare const ReviewDraftsRequest$outboundSchema: z.ZodMiniType<ReviewDraftsRequest$Outbound, ReviewDraftsRequest>;
+export declare function reviewDraftsRequestToJSON(reviewDraftsRequest: ReviewDraftsRequest): string;
+/** @internal */
+export declare const ReviewDraftsResponse$inboundSchema: z.ZodMiniType<ReviewDraftsResponse, unknown>;
+export declare function reviewDraftsResponseFromJSON(jsonString: string): SafeParseResult<ReviewDraftsResponse, SDKValidationError>;
+/** @internal */
+export type ListEntriesRequest$Outbound = {
+    scope?: string | undefined;
+    type?: string | undefined;
+};
+/** @internal */
+export declare const ListEntriesRequest$outboundSchema: z.ZodMiniType<ListEntriesRequest$Outbound, ListEntriesRequest>;
+export declare function listEntriesRequestToJSON(listEntriesRequest: ListEntriesRequest): string;
+/** @internal */
+export declare const ListEntriesEntry$inboundSchema: z.ZodMiniType<ListEntriesEntry, unknown>;
+export declare function listEntriesEntryFromJSON(jsonString: string): SafeParseResult<ListEntriesEntry, SDKValidationError>;
+/** @internal */
+export declare const ListEntriesResponse$inboundSchema: z.ZodMiniType<ListEntriesResponse, unknown>;
+export declare function listEntriesResponseFromJSON(jsonString: string): SafeParseResult<ListEntriesResponse, SDKValidationError>;
+/** @internal */
+export type SetRequest$Outbound = {
+    type: string;
+    content: string;
+    scope?: string | undefined;
+    label?: string | undefined;
+};
+/** @internal */
+export declare const SetRequest$outboundSchema: z.ZodMiniType<SetRequest$Outbound, SetRequest>;
+export declare function setRequestToJSON(setRequest: SetRequest): string;
+/** @internal */
+export declare const SetEntry$inboundSchema: z.ZodMiniType<SetEntry, unknown>;
+export declare function setEntryFromJSON(jsonString: string): SafeParseResult<SetEntry, SDKValidationError>;
+/** @internal */
+export declare const SetResponse$inboundSchema: z.ZodMiniType<SetResponse, unknown>;
+export declare function setResponseFromJSON(jsonString: string): SafeParseResult<SetResponse, SDKValidationError>;
+/** @internal */
+export type DeleteRequest$Outbound = {
+    type: string;
+    scope?: string | undefined;
+};
+/** @internal */
+export declare const DeleteRequest$outboundSchema: z.ZodMiniType<DeleteRequest$Outbound, DeleteRequest>;
+export declare function deleteRequestToJSON(deleteRequest: DeleteRequest): string;
+/** @internal */
+export declare const DeleteResponse$inboundSchema: z.ZodMiniType<DeleteResponse, unknown>;
+export declare function deleteResponseFromJSON(jsonString: string): SafeParseResult<DeleteResponse, SDKValidationError>;
+/** @internal */
+export declare const Schedule$inboundSchema: z.ZodMiniType<Schedule, unknown>;
+export declare function scheduleFromJSON(jsonString: string): SafeParseResult<Schedule, SDKValidationError>;
+/** @internal */
+export declare const ListSchedulesResponse$inboundSchema: z.ZodMiniType<ListSchedulesResponse, unknown>;
+export declare function listSchedulesResponseFromJSON(jsonString: string): SafeParseResult<ListSchedulesResponse, SDKValidationError>;
+/** @internal */
+export declare const UpdateScheduleAction$outboundSchema: z.ZodMiniEnum<typeof UpdateScheduleAction>;
+/** @internal */
+export type UpdateScheduleRequestBody$Outbound = {
+    action: string;
+};
+/** @internal */
+export declare const UpdateScheduleRequestBody$outboundSchema: z.ZodMiniType<UpdateScheduleRequestBody$Outbound, UpdateScheduleRequestBody>;
+export declare function updateScheduleRequestBodyToJSON(updateScheduleRequestBody: UpdateScheduleRequestBody): string;
+/** @internal */
+export type UpdateScheduleRequest$Outbound = {
+    scheduleId: string;
+    body: UpdateScheduleRequestBody$Outbound;
+};
+/** @internal */
+export declare const UpdateScheduleRequest$outboundSchema: z.ZodMiniType<UpdateScheduleRequest$Outbound, UpdateScheduleRequest>;
+export declare function updateScheduleRequestToJSON(updateScheduleRequest: UpdateScheduleRequest): string;
+/** @internal */
+export declare const UpdateScheduleResponse$inboundSchema: z.ZodMiniType<UpdateScheduleResponse, unknown>;
+export declare function updateScheduleResponseFromJSON(jsonString: string): SafeParseResult<UpdateScheduleResponse, SDKValidationError>;
+/** @internal */
+export declare const ListTasksQueryParamStatus$outboundSchema: z.ZodMiniEnum<typeof ListTasksQueryParamStatus>;
+/** @internal */
+export type ListTasksRequest$Outbound = {
+    status?: string | undefined;
+    type?: string | undefined;
+    campaignId?: string | undefined;
+    limit: number;
+    offset: number;
+};
+/** @internal */
+export declare const ListTasksRequest$outboundSchema: z.ZodMiniType<ListTasksRequest$Outbound, ListTasksRequest>;
+export declare function listTasksRequestToJSON(listTasksRequest: ListTasksRequest): string;
+/** @internal */
+export declare const TaskStatus$inboundSchema: z.ZodMiniType<TaskStatus, unknown>;
+/** @internal */
+export declare const ListTasksTask$inboundSchema: z.ZodMiniType<ListTasksTask, unknown>;
+export declare function listTasksTaskFromJSON(jsonString: string): SafeParseResult<ListTasksTask, SDKValidationError>;
+/** @internal */
+export declare const ListTasksResponse$inboundSchema: z.ZodMiniType<ListTasksResponse, unknown>;
+export declare function listTasksResponseFromJSON(jsonString: string): SafeParseResult<ListTasksResponse, SDKValidationError>;
+/** @internal */
+export type CancelTaskRequest$Outbound = {
+    id: string;
+};
+/** @internal */
+export declare const CancelTaskRequest$outboundSchema: z.ZodMiniType<CancelTaskRequest$Outbound, CancelTaskRequest>;
+export declare function cancelTaskRequestToJSON(cancelTaskRequest: CancelTaskRequest): string;
+/** @internal */
+export declare const CancelTaskResponse$inboundSchema: z.ZodMiniType<CancelTaskResponse, unknown>;
+export declare function cancelTaskResponseFromJSON(jsonString: string): SafeParseResult<CancelTaskResponse, SDKValidationError>;
+/** @internal */
+export type EventsFeedRequest$Outbound = {
+    since?: string | undefined;
+    limit: number;
+};
+/** @internal */
+export declare const EventsFeedRequest$outboundSchema: z.ZodMiniType<EventsFeedRequest$Outbound, EventsFeedRequest>;
+export declare function eventsFeedRequestToJSON(eventsFeedRequest: EventsFeedRequest): string;
+/** @internal */
+export declare const EventsFeedType$inboundSchema: z.ZodMiniType<EventsFeedType, unknown>;
+/** @internal */
+export declare const Event$inboundSchema: z.ZodMiniType<Event, unknown>;
+export declare function eventFromJSON(jsonString: string): SafeParseResult<Event, SDKValidationError>;
+/** @internal */
+export declare const EventsFeedResponse$inboundSchema: z.ZodMiniType<EventsFeedResponse, unknown>;
+export declare function eventsFeedResponseFromJSON(jsonString: string): SafeParseResult<EventsFeedResponse, SDKValidationError>;
+/** @internal */
+export type CancelChainRequest$Outbound = {
+    workflowRunId: string;
+};
+/** @internal */
+export declare const CancelChainRequest$outboundSchema: z.ZodMiniType<CancelChainRequest$Outbound, CancelChainRequest>;
+export declare function cancelChainRequestToJSON(cancelChainRequest: CancelChainRequest): string;
+/** @internal */
+export declare const CancelChainResponse$inboundSchema: z.ZodMiniType<CancelChainResponse, unknown>;
+export declare function cancelChainResponseFromJSON(jsonString: string): SafeParseResult<CancelChainResponse, SDKValidationError>;
+/** @internal */
+export declare const PullTaskTask$inboundSchema: z.ZodMiniType<PullTaskTask, unknown>;
+export declare function pullTaskTaskFromJSON(jsonString: string): SafeParseResult<PullTaskTask, SDKValidationError>;
+/** @internal */
+export declare const PullTaskResponse$inboundSchema: z.ZodMiniType<PullTaskResponse, unknown>;
+export declare function pullTaskResponseFromJSON(jsonString: string): SafeParseResult<PullTaskResponse, SDKValidationError>;
+/** @internal */
+export declare const SubmitTaskResultStatus$outboundSchema: z.ZodMiniEnum<typeof SubmitTaskResultStatus>;
+/** @internal */
+export type SubmitTaskResultRequestBody$Outbound = {
+    status?: string | undefined;
+    result?: any | undefined;
+    error?: string | undefined;
+};
+/** @internal */
+export declare const SubmitTaskResultRequestBody$outboundSchema: z.ZodMiniType<SubmitTaskResultRequestBody$Outbound, SubmitTaskResultRequestBody>;
+export declare function submitTaskResultRequestBodyToJSON(submitTaskResultRequestBody: SubmitTaskResultRequestBody): string;
+/** @internal */
+export type SubmitTaskResultRequest$Outbound = {
+    id: string;
+    body: SubmitTaskResultRequestBody$Outbound;
+};
+/** @internal */
+export declare const SubmitTaskResultRequest$outboundSchema: z.ZodMiniType<SubmitTaskResultRequest$Outbound, SubmitTaskResultRequest>;
+export declare function submitTaskResultRequestToJSON(submitTaskResultRequest: SubmitTaskResultRequest): string;
+/** @internal */
+export declare const SubmitTaskResultResponse$inboundSchema: z.ZodMiniType<SubmitTaskResultResponse, unknown>;
+export declare function submitTaskResultResponseFromJSON(jsonString: string): SafeParseResult<SubmitTaskResultResponse, SDKValidationError>;
+/** @internal */
+export declare const Connector$inboundSchema: z.ZodMiniType<Connector, unknown>;
+export declare function connectorFromJSON(jsonString: string): SafeParseResult<Connector, SDKValidationError>;
+/** @internal */
+export declare const ListConnectorsResponse$inboundSchema: z.ZodMiniType<ListConnectorsResponse, unknown>;
+export declare function listConnectorsResponseFromJSON(jsonString: string): SafeParseResult<ListConnectorsResponse, SDKValidationError>;
+/** @internal */
+export type ConnectorHeartbeatRequest$Outbound = {
+    currentTaskId?: string | undefined;
+};
+/** @internal */
+export declare const ConnectorHeartbeatRequest$outboundSchema: z.ZodMiniType<ConnectorHeartbeatRequest$Outbound, ConnectorHeartbeatRequest>;
+export declare function connectorHeartbeatRequestToJSON(connectorHeartbeatRequest: ConnectorHeartbeatRequest): string;
+/** @internal */
+export declare const ConnectorHeartbeatResponse$inboundSchema: z.ZodMiniType<ConnectorHeartbeatResponse, unknown>;
+export declare function connectorHeartbeatResponseFromJSON(jsonString: string): SafeParseResult<ConnectorHeartbeatResponse, SDKValidationError>;
+/** @internal */
+export declare const Context$inboundSchema: z.ZodMiniType<Context, unknown>;
+export declare function contextFromJSON(jsonString: string): SafeParseResult<Context, SDKValidationError>;
+/** @internal */
+export declare const ActiveAccount$inboundSchema: z.ZodMiniType<ActiveAccount, unknown>;
+export declare function activeAccountFromJSON(jsonString: string): SafeParseResult<ActiveAccount, SDKValidationError>;
+/** @internal */
+export declare const AgentSnapshotAccount$inboundSchema: z.ZodMiniType<AgentSnapshotAccount, unknown>;
+export declare function agentSnapshotAccountFromJSON(jsonString: string): SafeParseResult<AgentSnapshotAccount, SDKValidationError>;
+/** @internal */
+export declare const AgentSnapshotStageCounts$inboundSchema: z.ZodMiniType<AgentSnapshotStageCounts, unknown>;
+export declare function agentSnapshotStageCountsFromJSON(jsonString: string): SafeParseResult<AgentSnapshotStageCounts, SDKValidationError>;
+/** @internal */
+export declare const ActiveCampaign$inboundSchema: z.ZodMiniType<ActiveCampaign, unknown>;
+export declare function activeCampaignFromJSON(jsonString: string): SafeParseResult<ActiveCampaign, SDKValidationError>;
+/** @internal */
+export declare const AgentSnapshotType$inboundSchema: z.ZodMiniType<AgentSnapshotType, unknown>;
+/** @internal */
+export declare const RecentEvent$inboundSchema: z.ZodMiniType<RecentEvent, unknown>;
+export declare function recentEventFromJSON(jsonString: string): SafeParseResult<RecentEvent, SDKValidationError>;
+/** @internal */
+export declare const AgentSnapshotResponse$inboundSchema: z.ZodMiniType<AgentSnapshotResponse, unknown>;
+export declare function agentSnapshotResponseFromJSON(jsonString: string): SafeParseResult<AgentSnapshotResponse, SDKValidationError>;
+/** @internal */
+export declare const GetDmPollingSettingsSettings$inboundSchema: z.ZodMiniType<GetDmPollingSettingsSettings, unknown>;
+export declare function getDmPollingSettingsSettingsFromJSON(jsonString: string): SafeParseResult<GetDmPollingSettingsSettings, SDKValidationError>;
+/** @internal */
+export declare const GetDmPollingSettingsResponse$inboundSchema: z.ZodMiniType<GetDmPollingSettingsResponse, unknown>;
+export declare function getDmPollingSettingsResponseFromJSON(jsonString: string): SafeParseResult<GetDmPollingSettingsResponse, SDKValidationError>;
+/** @internal */
+export type PatchDmPollingSettingsRequest$Outbound = {
+    dmPollingEnabled?: boolean | undefined;
+    dmWebhookUrl?: string | null | undefined;
+    connectionPollingEnabled?: boolean | undefined;
+};
+/** @internal */
+export declare const PatchDmPollingSettingsRequest$outboundSchema: z.ZodMiniType<PatchDmPollingSettingsRequest$Outbound, PatchDmPollingSettingsRequest>;
+export declare function patchDmPollingSettingsRequestToJSON(patchDmPollingSettingsRequest: PatchDmPollingSettingsRequest): string;
+/** @internal */
+export declare const PatchDmPollingSettingsSettings$inboundSchema: z.ZodMiniType<PatchDmPollingSettingsSettings, unknown>;
+export declare function patchDmPollingSettingsSettingsFromJSON(jsonString: string): SafeParseResult<PatchDmPollingSettingsSettings, SDKValidationError>;
+/** @internal */
+export declare const PatchDmPollingSettingsResponse$inboundSchema: z.ZodMiniType<PatchDmPollingSettingsResponse, unknown>;
+export declare function patchDmPollingSettingsResponseFromJSON(jsonString: string): SafeParseResult<PatchDmPollingSettingsResponse, SDKValidationError>;
+/** @internal */
+export type DeleteWorkspaceAccountRequest$Outbound = {
+    id: string;
+};
+/** @internal */
+export declare const DeleteWorkspaceAccountRequest$outboundSchema: z.ZodMiniType<DeleteWorkspaceAccountRequest$Outbound, DeleteWorkspaceAccountRequest>;
+export declare function deleteWorkspaceAccountRequestToJSON(deleteWorkspaceAccountRequest: DeleteWorkspaceAccountRequest): string;
+/** @internal */
+export declare const DeleteWorkspaceAccountResponse$inboundSchema: z.ZodMiniType<DeleteWorkspaceAccountResponse, unknown>;
+export declare function deleteWorkspaceAccountResponseFromJSON(jsonString: string): SafeParseResult<DeleteWorkspaceAccountResponse, SDKValidationError>;
+/** @internal */
+export declare const UpgradeWorkspaceAccountAction$outboundSchema: z.ZodMiniEnum<typeof UpgradeWorkspaceAccountAction>;
+/** @internal */
+export type UpgradeWorkspaceAccountRequest$Outbound = {
+    credentialsId: string;
+    action: string;
+};
+/** @internal */
+export declare const UpgradeWorkspaceAccountRequest$outboundSchema: z.ZodMiniType<UpgradeWorkspaceAccountRequest$Outbound, UpgradeWorkspaceAccountRequest>;
+export declare function upgradeWorkspaceAccountRequestToJSON(upgradeWorkspaceAccountRequest: UpgradeWorkspaceAccountRequest): string;
+/** @internal */
+export declare const UpgradeWorkspaceAccountResponse$inboundSchema: z.ZodMiniType<UpgradeWorkspaceAccountResponse, unknown>;
+export declare function upgradeWorkspaceAccountResponseFromJSON(jsonString: string): SafeParseResult<UpgradeWorkspaceAccountResponse, SDKValidationError>;
+/** @internal */
+export declare const CreateWorkspaceInviteAction$outboundSchema: z.ZodMiniEnum<typeof CreateWorkspaceInviteAction>;
+/** @internal */
+export type CreateWorkspaceInviteRequest$Outbound = {
+    action: string;
+    email?: string | undefined;
+    name?: string | undefined;
+    maxUses: number;
+};
+/** @internal */
+export declare const CreateWorkspaceInviteRequest$outboundSchema: z.ZodMiniType<CreateWorkspaceInviteRequest$Outbound, CreateWorkspaceInviteRequest>;
+export declare function createWorkspaceInviteRequestToJSON(createWorkspaceInviteRequest: CreateWorkspaceInviteRequest): string;
+/** @internal */
+export declare const Invite2$inboundSchema: z.ZodMiniType<Invite2, unknown>;
+export declare function invite2FromJSON(jsonString: string): SafeParseResult<Invite2, SDKValidationError>;
+/** @internal */
+export declare const Workspace$inboundSchema: z.ZodMiniType<Workspace, unknown>;
+export declare function workspaceFromJSON(jsonString: string): SafeParseResult<Workspace, SDKValidationError>;
+/** @internal */
+export declare const ResponseBody2$inboundSchema: z.ZodMiniType<ResponseBody2, unknown>;
+export declare function responseBody2FromJSON(jsonString: string): SafeParseResult<ResponseBody2, SDKValidationError>;
+/** @internal */
+export declare const Invite1$inboundSchema: z.ZodMiniType<Invite1, unknown>;
+export declare function invite1FromJSON(jsonString: string): SafeParseResult<Invite1, SDKValidationError>;
+/** @internal */
+export declare const ResponseBody1$inboundSchema: z.ZodMiniType<ResponseBody1, unknown>;
+export declare function responseBody1FromJSON(jsonString: string): SafeParseResult<ResponseBody1, SDKValidationError>;
+/** @internal */
+export declare const CreateWorkspaceInviteResponse$inboundSchema: z.ZodMiniType<CreateWorkspaceInviteResponse, unknown>;
+export declare function createWorkspaceInviteResponseFromJSON(jsonString: string): SafeParseResult<CreateWorkspaceInviteResponse, SDKValidationError>;
+/** @internal */
+export type DeleteWorkspaceInviteRequest$Outbound = {
+    inviteId: string;
+};
+/** @internal */
+export declare const DeleteWorkspaceInviteRequest$outboundSchema: z.ZodMiniType<DeleteWorkspaceInviteRequest$Outbound, DeleteWorkspaceInviteRequest>;
+export declare function deleteWorkspaceInviteRequestToJSON(deleteWorkspaceInviteRequest: DeleteWorkspaceInviteRequest): string;
+/** @internal */
+export declare const DeleteWorkspaceInviteResponse$inboundSchema: z.ZodMiniType<DeleteWorkspaceInviteResponse, unknown>;
+export declare function deleteWorkspaceInviteResponseFromJSON(jsonString: string): SafeParseResult<DeleteWorkspaceInviteResponse, SDKValidationError>;
+//# sourceMappingURL=delete-workspace-invite-response.d.ts.map