bereach 0.1.1

package/esm/models/operations/get-campaign-stats-response.d.ts

@@ -0,0 +1,1627 @@
+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";
+export type ReplyToLinkedInCommentRequest = {
+    /**
+     * LinkedIn comment URN (e.g., 'urn:li:comment:(activity:7399026485694537728,7399230513867026433)')
+     */
+    commentUrn: string;
+    /**
+     * Reply message text
+     */
+    message: string;
+    /**
+     * Campaign identifier for deduplication. Dedup by commentUrn automatically.
+     */
+    campaignSlug?: string | undefined;
+    /**
+     * Deprecated. Use campaignSlug only.
+     *
+     * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+     */
+    actionSlug?: string | undefined;
+};
+/**
+ * Reply sent successfully
+ */
+export type ReplyToLinkedInCommentResponse = {
+    success: boolean;
+    /**
+     * URN of the created reply comment
+     */
+    replyUrn?: string | undefined;
+    /**
+     * True if this action was already executed for the given campaignSlug + target.
+     */
+    duplicate?: boolean | undefined;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+/**
+ * Reaction type (default: LIKE)
+ */
+export declare const ReactionType: {
+    readonly Like: "LIKE";
+    readonly Love: "LOVE";
+    readonly Celebrate: "CELEBRATE";
+    readonly Support: "SUPPORT";
+    readonly Funny: "FUNNY";
+    readonly Insightful: "INSIGHTFUL";
+};
+/**
+ * Reaction type (default: LIKE)
+ */
+export type ReactionType = ClosedEnum<typeof ReactionType>;
+export type LikeLinkedInCommentRequest = {
+    /**
+     * LinkedIn comment URN (e.g., 'urn:li:comment:(activity:7399026485694537728,7399230513867026433)')
+     */
+    commentUrn: string;
+    /**
+     * Reaction type (default: LIKE)
+     */
+    reactionType?: ReactionType | undefined;
+    /**
+     * Campaign identifier for deduplication. Dedup by commentUrn automatically.
+     */
+    campaignSlug?: string | undefined;
+    /**
+     * Deprecated. Use campaignSlug only.
+     *
+     * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+     */
+    actionSlug?: string | undefined;
+};
+/**
+ * Comment liked successfully
+ */
+export type LikeLinkedInCommentResponse = {
+    success: boolean;
+    /**
+     * Resource key of the created reaction
+     */
+    resourceKey?: string | undefined;
+    /**
+     * True if this action was already executed for the given campaignSlug + target.
+     */
+    duplicate?: boolean | undefined;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+/**
+ * Publish mode: 'instant' publishes immediately, 'scheduled' schedules for later
+ */
+export declare const Mode: {
+    readonly Scheduled: "scheduled";
+    readonly Instant: "instant";
+};
+/**
+ * Publish mode: 'instant' publishes immediately, 'scheduled' schedules for later
+ */
+export type Mode = ClosedEnum<typeof Mode>;
+/**
+ * Post visibility
+ */
+export declare const Visibility: {
+    readonly Anyone: "ANYONE";
+    readonly Connections: "CONNECTIONS";
+};
+/**
+ * Post visibility
+ */
+export type Visibility = ClosedEnum<typeof Visibility>;
+export type Mention = {
+    /**
+     * LinkedIn profile URN of the mentioned person (e.g., 'urn:li:fsd_profile:ACoAABZ0Qo4B...')
+     */
+    profileUrn: string;
+    /**
+     * Start character offset in the text where the mention begins
+     */
+    start: number;
+    /**
+     * Length of the mention text in characters
+     */
+    length: number;
+};
+export type PublishLinkedInPostRequest = {
+    /**
+     * Post commentary text
+     */
+    text: string;
+    /**
+     * Publish mode: 'instant' publishes immediately, 'scheduled' schedules for later
+     */
+    mode: Mode;
+    /**
+     * Timestamp in milliseconds for scheduled posts (required when mode='scheduled')
+     */
+    scheduledAt?: number | undefined;
+    /**
+     * URL of an image to attach to the post
+     */
+    imageUrl?: string | undefined;
+    /**
+     * Post visibility
+     */
+    visibility?: Visibility | undefined;
+    /**
+     * Profile mentions with text positions
+     */
+    mentions?: Array<Mention> | undefined;
+    /**
+     * Campaign identifier for deduplication.
+     */
+    campaignSlug?: string | undefined;
+    /**
+     * Deprecated. Use campaignSlug only.
+     *
+     * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+     */
+    actionSlug?: string | undefined;
+};
+/**
+ * Post published or scheduled successfully
+ */
+export type PublishLinkedInPostResponse = {
+    success: boolean;
+    /**
+     * URN of the created share (e.g., 'urn:li:fsd_share:urn:li:share:123...')
+     */
+    shareUrn: string;
+    /**
+     * Activity URN (only available for instant mode)
+     */
+    activityUrn: string | null;
+    /**
+     * True if this action was already executed for the given campaignSlug + target.
+     */
+    duplicate?: boolean | undefined;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type GetMyLinkedInProfilePositionStartDate = {
+    month: number | null;
+    year: number;
+};
+export type GetMyLinkedInProfilePositionEndDate = {
+    month: number | null;
+    year: number;
+};
+export type GetMyLinkedInProfilePosition = {
+    companyName: string | null;
+    title: string | null;
+    companyUrl: string | null;
+    companyLogo: string | null;
+    startDate: GetMyLinkedInProfilePositionStartDate | null;
+    endDate: GetMyLinkedInProfilePositionEndDate | null;
+    isCurrent: boolean;
+};
+export type GetMyLinkedInProfileEducationStartDate = {
+    month: number | null;
+    year: number;
+};
+export type GetMyLinkedInProfileEducationEndDate = {
+    month: number | null;
+    year: number;
+};
+export type GetMyLinkedInProfileEducation = {
+    schoolName: string | null;
+    degreeName: string | null;
+    fieldOfStudy: string | null;
+    schoolUrl: string | null;
+    schoolLogo: string | null;
+    startDate: GetMyLinkedInProfileEducationStartDate | null;
+    endDate: GetMyLinkedInProfileEducationEndDate | null;
+};
+/**
+ * Profile location
+ */
+export type GetMyLinkedInProfileLocation = {
+    countryCode: string;
+    postalCode?: string | undefined;
+};
+export declare const GetMyLinkedInProfileType: {
+    readonly Activity: "activity";
+    readonly UgcPost: "ugcPost";
+    readonly Share: "share";
+};
+export type GetMyLinkedInProfileType = OpenEnum<typeof GetMyLinkedInProfileType>;
+export type GetMyLinkedInProfileLastPost = {
+    postUrl: string;
+    text: string;
+    date: number;
+    likesCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    postUrn: string;
+    postId: string;
+    type: GetMyLinkedInProfileType;
+};
+/**
+ * Stored LinkedIn profile data
+ */
+export type GetMyLinkedInProfileResponse = {
+    success: boolean;
+    /**
+     * LinkedIn vanity name (e.g., 'alexandre-sarfati')
+     */
+    linkedinProfileId: string | null;
+    /**
+     * Full name from LinkedIn
+     */
+    linkedinName: string | null;
+    /**
+     * Email from LinkedIn profile
+     */
+    linkedinEmail: string | null;
+    /**
+     * LinkedIn profile URN
+     */
+    profileUrn: string | null;
+    /**
+     * LinkedIn headline
+     */
+    headline: string | null;
+    /**
+     * Profile picture URL
+     */
+    profilePic: string | null;
+    /**
+     * Full LinkedIn profile URL
+     */
+    profileUrl: string | null;
+    /**
+     * Work positions (populated after /refresh)
+     */
+    positions?: Array<GetMyLinkedInProfilePosition> | undefined;
+    /**
+     * Education entries (populated after /refresh)
+     */
+    educations?: Array<GetMyLinkedInProfileEducation> | undefined;
+    /**
+     * Total LinkedIn connections
+     */
+    connectionsCount?: number | null | undefined;
+    /**
+     * Profile location
+     */
+    location?: GetMyLinkedInProfileLocation | null | undefined;
+    /**
+     * LinkedIn verification status
+     */
+    isVerified?: boolean | undefined;
+    /**
+     * Last 5 posts (populated when posts have been fetched via /me/linkedin/posts)
+     */
+    lastPosts?: Array<GetMyLinkedInProfileLastPost> | undefined;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type RefreshMyLinkedInProfilePositionStartDate = {
+    month: number | null;
+    year: number;
+};
+export type RefreshMyLinkedInProfilePositionEndDate = {
+    month: number | null;
+    year: number;
+};
+export type RefreshMyLinkedInProfilePosition = {
+    companyName: string | null;
+    title: string | null;
+    companyUrl: string | null;
+    companyLogo: string | null;
+    startDate: RefreshMyLinkedInProfilePositionStartDate | null;
+    endDate: RefreshMyLinkedInProfilePositionEndDate | null;
+    isCurrent: boolean;
+};
+export type RefreshMyLinkedInProfileEducationStartDate = {
+    month: number | null;
+    year: number;
+};
+export type RefreshMyLinkedInProfileEducationEndDate = {
+    month: number | null;
+    year: number;
+};
+export type RefreshMyLinkedInProfileEducation = {
+    schoolName: string | null;
+    degreeName: string | null;
+    fieldOfStudy: string | null;
+    schoolUrl: string | null;
+    schoolLogo: string | null;
+    startDate: RefreshMyLinkedInProfileEducationStartDate | null;
+    endDate: RefreshMyLinkedInProfileEducationEndDate | null;
+};
+/**
+ * Profile location
+ */
+export type RefreshMyLinkedInProfileLocation = {
+    countryCode: string;
+    postalCode?: string | undefined;
+};
+export declare const RefreshMyLinkedInProfileType: {
+    readonly Activity: "activity";
+    readonly UgcPost: "ugcPost";
+    readonly Share: "share";
+};
+export type RefreshMyLinkedInProfileType = OpenEnum<typeof RefreshMyLinkedInProfileType>;
+export type RefreshMyLinkedInProfileLastPost = {
+    postUrl: string;
+    text: string;
+    date: number;
+    likesCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    postUrn: string;
+    postId: string;
+    type: RefreshMyLinkedInProfileType;
+};
+/**
+ * Refreshed LinkedIn profile data
+ */
+export type RefreshMyLinkedInProfileResponse = {
+    success: boolean;
+    /**
+     * LinkedIn vanity name (e.g., 'alexandre-sarfati')
+     */
+    linkedinProfileId: string | null;
+    /**
+     * Full name from LinkedIn
+     */
+    linkedinName: string | null;
+    /**
+     * Email from LinkedIn profile
+     */
+    linkedinEmail: string | null;
+    /**
+     * LinkedIn profile URN
+     */
+    profileUrn: string | null;
+    /**
+     * LinkedIn headline
+     */
+    headline: string | null;
+    /**
+     * Profile picture URL
+     */
+    profilePic: string | null;
+    /**
+     * Full LinkedIn profile URL
+     */
+    profileUrl: string | null;
+    /**
+     * Work positions (populated after /refresh)
+     */
+    positions?: Array<RefreshMyLinkedInProfilePosition> | undefined;
+    /**
+     * Education entries (populated after /refresh)
+     */
+    educations?: Array<RefreshMyLinkedInProfileEducation> | undefined;
+    /**
+     * Total LinkedIn connections
+     */
+    connectionsCount?: number | null | undefined;
+    /**
+     * Profile location
+     */
+    location?: RefreshMyLinkedInProfileLocation | null | undefined;
+    /**
+     * LinkedIn verification status
+     */
+    isVerified?: boolean | undefined;
+    /**
+     * Last 5 posts (populated when posts have been fetched via /me/linkedin/posts)
+     */
+    lastPosts?: Array<RefreshMyLinkedInProfileLastPost> | undefined;
+    refreshed: boolean;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type GetMyLinkedInPostsRequest = {
+    /**
+     * Number of posts to fetch (default 20, max 100).
+     */
+    count?: number | undefined;
+    /**
+     * Pagination offset (default 0).
+     */
+    start?: number | undefined;
+    /**
+     * Pagination token from a previous response to fetch the next page.
+     */
+    paginationToken?: string | undefined;
+};
+export declare const GetMyLinkedInPostsType: {
+    readonly Activity: "activity";
+    readonly UgcPost: "ugcPost";
+    readonly Share: "share";
+};
+export type GetMyLinkedInPostsType = OpenEnum<typeof GetMyLinkedInPostsType>;
+export type GetMyLinkedInPostsPost = {
+    postUrl: string;
+    text: string;
+    date: number;
+    likesCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    postUrn: string;
+    postId: string;
+    type: GetMyLinkedInPostsType;
+};
+/**
+ * Paginated list of the user's own posts
+ */
+export type GetMyLinkedInPostsResponse = {
+    success: boolean;
+    posts: Array<GetMyLinkedInPostsPost>;
+    count: number;
+    total: number;
+    start: number;
+    hasMore: boolean;
+    paginationToken: string | null;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type GetMyLinkedInFollowersRequest = {
+    /**
+     * Pagination offset (default 0).
+     */
+    start?: number | undefined;
+    /**
+     * Number of followers to fetch per page (default 10, max 50).
+     */
+    count?: number | undefined;
+};
+export type Follower = {
+    name: string;
+    headline: string | null;
+    profileUrl: string | null;
+    profilePicture: string | null;
+    followerCount: number | null;
+    /**
+     * Whether you follow this person back
+     */
+    following: boolean;
+};
+/**
+ * Paginated list of followers
+ */
+export type GetMyLinkedInFollowersResponse = {
+    success: boolean;
+    followers: Array<Follower>;
+    count: number;
+    /**
+     * Total reported by LinkedIn (capped at ~1000)
+     */
+    totalFollowers: number;
+    start: number;
+    hasMore: boolean;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+/**
+ * Daily usage counter (resets at midnight UTC)
+ */
+export type ConnectionRequestDaily = {
+    /**
+     * Number of actions used in this window
+     */
+    current: number;
+    /**
+     * Maximum allowed actions in this window (with multiplier applied)
+     */
+    limit: number;
+    /**
+     * Actions remaining before hitting the limit
+     */
+    remaining: number;
+};
+/**
+ * Weekly usage counter (resets Monday 00:00 UTC). Null if no weekly cap for this action type.
+ */
+export type ConnectionRequestWeekly = {
+    /**
+     * Number of actions used in this window
+     */
+    current: number;
+    /**
+     * Maximum allowed actions in this window (with multiplier applied)
+     */
+    limit: number;
+    /**
+     * Actions remaining before hitting the limit
+     */
+    remaining: number;
+};
+/**
+ * Limits for sending LinkedIn connection requests
+ */
+export type ConnectionRequest = {
+    /**
+     * Daily usage counter (resets at midnight UTC)
+     */
+    daily: ConnectionRequestDaily;
+    /**
+     * Weekly usage counter (resets Monday 00:00 UTC). Null if no weekly cap for this action type.
+     */
+    weekly: ConnectionRequestWeekly | null;
+    /**
+     * Minimum delay in seconds required between two consecutive actions of this type
+     */
+    minIntervalSeconds: number;
+    /**
+     * ISO 8601 timestamp of the next daily counter reset
+     */
+    nextResetDaily: Date;
+    /**
+     * ISO 8601 timestamp of the next weekly counter reset. Null if no weekly cap.
+     */
+    nextResetWeekly: Date | null;
+};
+/**
+ * Daily usage counter (resets at midnight UTC)
+ */
+export type MessageDaily = {
+    /**
+     * Number of actions used in this window
+     */
+    current: number;
+    /**
+     * Maximum allowed actions in this window (with multiplier applied)
+     */
+    limit: number;
+    /**
+     * Actions remaining before hitting the limit
+     */
+    remaining: number;
+};
+/**
+ * Weekly usage counter (resets Monday 00:00 UTC). Null if no weekly cap for this action type.
+ */
+export type MessageWeekly = {
+    /**
+     * Number of actions used in this window
+     */
+    current: number;
+    /**
+     * Maximum allowed actions in this window (with multiplier applied)
+     */
+    limit: number;
+    /**
+     * Actions remaining before hitting the limit
+     */
+    remaining: number;
+};
+/**
+ * Limits for social engagement actions: sending messages, publishing posts, replying to comments, liking comments
+ */
+export type GetMyLimitsMessage = {
+    /**
+     * Daily usage counter (resets at midnight UTC)
+     */
+    daily: MessageDaily;
+    /**
+     * Weekly usage counter (resets Monday 00:00 UTC). Null if no weekly cap for this action type.
+     */
+    weekly: MessageWeekly | null;
+    /**
+     * Minimum delay in seconds required between two consecutive actions of this type
+     */
+    minIntervalSeconds: number;
+    /**
+     * ISO 8601 timestamp of the next daily counter reset
+     */
+    nextResetDaily: Date;
+    /**
+     * ISO 8601 timestamp of the next weekly counter reset. Null if no weekly cap.
+     */
+    nextResetWeekly: Date | null;
+};
+/**
+ * Daily usage counter (resets at midnight UTC)
+ */
+export type ProfileVisitDaily = {
+    /**
+     * Number of actions used in this window
+     */
+    current: number;
+    /**
+     * Maximum allowed actions in this window (with multiplier applied)
+     */
+    limit: number;
+    /**
+     * Actions remaining before hitting the limit
+     */
+    remaining: number;
+};
+/**
+ * Weekly usage counter (resets Monday 00:00 UTC). Null if no weekly cap for this action type.
+ */
+export type ProfileVisitWeekly = {
+    /**
+     * Number of actions used in this window
+     */
+    current: number;
+    /**
+     * Maximum allowed actions in this window (with multiplier applied)
+     */
+    limit: number;
+    /**
+     * Actions remaining before hitting the limit
+     */
+    remaining: number;
+};
+/**
+ * Limits for visiting LinkedIn profiles and company pages
+ */
+export type ProfileVisit = {
+    /**
+     * Daily usage counter (resets at midnight UTC)
+     */
+    daily: ProfileVisitDaily;
+    /**
+     * Weekly usage counter (resets Monday 00:00 UTC). Null if no weekly cap for this action type.
+     */
+    weekly: ProfileVisitWeekly | null;
+    /**
+     * Minimum delay in seconds required between two consecutive actions of this type
+     */
+    minIntervalSeconds: number;
+    /**
+     * ISO 8601 timestamp of the next daily counter reset
+     */
+    nextResetDaily: Date;
+    /**
+     * ISO 8601 timestamp of the next weekly counter reset. Null if no weekly cap.
+     */
+    nextResetWeekly: Date | null;
+};
+/**
+ * Daily usage counter (resets at midnight UTC)
+ */
+export type ScrapingDaily = {
+    /**
+     * Number of actions used in this window
+     */
+    current: number;
+    /**
+     * Maximum allowed actions in this window (with multiplier applied)
+     */
+    limit: number;
+    /**
+     * Actions remaining before hitting the limit
+     */
+    remaining: number;
+};
+/**
+ * Weekly usage counter (resets Monday 00:00 UTC). Null if no weekly cap for this action type.
+ */
+export type ScrapingWeekly = {
+    /**
+     * Number of actions used in this window
+     */
+    current: number;
+    /**
+     * Maximum allowed actions in this window (with multiplier applied)
+     */
+    limit: number;
+    /**
+     * Actions remaining before hitting the limit
+     */
+    remaining: number;
+};
+/**
+ * Limits for data collection: search, collecting posts/likes/comments, fetching followers, listing chats
+ */
+export type Scraping = {
+    /**
+     * Daily usage counter (resets at midnight UTC)
+     */
+    daily: ScrapingDaily;
+    /**
+     * Weekly usage counter (resets Monday 00:00 UTC). Null if no weekly cap for this action type.
+     */
+    weekly: ScrapingWeekly | null;
+    /**
+     * Minimum delay in seconds required between two consecutive actions of this type
+     */
+    minIntervalSeconds: number;
+    /**
+     * ISO 8601 timestamp of the next daily counter reset
+     */
+    nextResetDaily: Date;
+    /**
+     * ISO 8601 timestamp of the next weekly counter reset. Null if no weekly cap.
+     */
+    nextResetWeekly: Date | null;
+};
+export type Limits = {
+    /**
+     * Limits for sending LinkedIn connection requests
+     */
+    connectionRequest: ConnectionRequest;
+    /**
+     * Limits for social engagement actions: sending messages, publishing posts, replying to comments, liking comments
+     */
+    message: GetMyLimitsMessage;
+    /**
+     * Limits for visiting LinkedIn profiles and company pages
+     */
+    profileVisit: ProfileVisit;
+    /**
+     * Limits for data collection: search, collecting posts/likes/comments, fetching followers, listing chats
+     */
+    scraping: Scraping;
+};
+/**
+ * Rate limit status for all action types
+ */
+export type GetMyLimitsResponse = {
+    success: boolean;
+    /**
+     * Workspace limit multiplier applied to all base limits (default 1.0)
+     */
+    multiplier: number;
+    limits: Limits;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type Credits = {
+    /**
+     * Number of credits used in the current billing period
+     */
+    current: number;
+    /**
+     * Maximum credits available for the workspace
+     */
+    limit: number;
+    /**
+     * Credits remaining before hitting the limit
+     */
+    remaining: number;
+    /**
+     * Percentage of credits used (0-100, rounded to 2 decimal places)
+     */
+    percentage: number;
+};
+/**
+ * Credit balance for the workspace
+ */
+export type GetMyCreditsResponse = {
+    success: boolean;
+    credits: Credits;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type ListInboxConversationsRequest = {
+    /**
+     * Pagination cursor from a previous response
+     */
+    nextCursor?: string | undefined;
+};
+export type ListInboxConversationsParticipant = {
+    profileUrn: string;
+    firstName: string;
+    lastName: string;
+    profileUrl: string;
+    headline: string | null;
+    profilePicture: string | null;
+};
+export type ListInboxConversationsLastMessage = {
+    text: string;
+    deliveredAt: number;
+    senderProfileUrn: string;
+};
+export type ListInboxConversationsConversation = {
+    conversationUrn: string;
+    conversationUrl: string;
+    lastActivityAt: number;
+    createdAt: number;
+    read: boolean;
+    unreadCount: number;
+    groupChat: boolean;
+    participants: Array<ListInboxConversationsParticipant>;
+    lastMessage: ListInboxConversationsLastMessage | null;
+};
+/**
+ * Inbox conversations
+ */
+export type ListInboxConversationsResponse = {
+    success: boolean;
+    conversations: Array<ListInboxConversationsConversation>;
+    /**
+     * Cursor for fetching next page
+     */
+    nextCursor: string | null;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type SearchLinkedInConversationsRequest = {
+    /**
+     * Search keywords
+     */
+    keywords: string;
+    /**
+     * Pagination cursor from a previous response
+     */
+    nextCursor?: string | undefined;
+};
+export type SearchLinkedInConversationsParticipant = {
+    profileUrn: string;
+    firstName: string;
+    lastName: string;
+    profileUrl: string;
+    headline: string | null;
+    profilePicture: string | null;
+};
+export type SearchLinkedInConversationsLastMessage = {
+    text: string;
+    deliveredAt: number;
+    senderProfileUrn: string;
+};
+export type SearchLinkedInConversationsConversation = {
+    conversationUrn: string;
+    conversationUrl: string;
+    lastActivityAt: number;
+    createdAt: number;
+    read: boolean;
+    unreadCount: number;
+    groupChat: boolean;
+    participants: Array<SearchLinkedInConversationsParticipant>;
+    lastMessage: SearchLinkedInConversationsLastMessage | null;
+};
+/**
+ * Matching conversations
+ */
+export type SearchLinkedInConversationsResponse = {
+    success: boolean;
+    conversations: Array<SearchLinkedInConversationsConversation>;
+    /**
+     * Cursor for fetching next page
+     */
+    nextCursor: string | null;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type FindLinkedInConversationRequest = {
+    /**
+     * Profile URL or URN (e.g. 'https://linkedin.com/in/marie-sandre' or 'urn:li:fsd_profile:ACoAA...'). Direct O(1) conversation lookup via LinkedIn's compose API — no search, no inbox scan. 0 credits.
+     */
+    profile: string;
+    /**
+     * If true, also return the conversation's recent messages (0 extra credits).
+     */
+    includeMessages?: boolean | undefined;
+};
+export type FindLinkedInConversationParticipant = {
+    profileUrn: string;
+    firstName: string;
+    lastName: string;
+    profileUrl: string;
+    headline: string | null;
+    profilePicture: string | null;
+};
+export type FindLinkedInConversationLastMessage = {
+    text: string;
+    deliveredAt: number;
+    senderProfileUrn: string;
+};
+export type FindLinkedInConversationConversation = {
+    conversationUrn: string;
+    conversationUrl: string;
+    lastActivityAt: number;
+    createdAt: number;
+    read: boolean;
+    unreadCount: number;
+    groupChat: boolean;
+    participants: Array<FindLinkedInConversationParticipant>;
+    lastMessage: FindLinkedInConversationLastMessage | null;
+};
+export type FindLinkedInConversationSender = {
+    firstName: string;
+    lastName: string;
+    profileUrl: string;
+    headline: string | null;
+    profilePicture: string | null;
+};
+export declare const FindLinkedInConversationType: {
+    readonly Audio: "audio";
+    readonly SharedPost: "shared_post";
+    readonly RepliedMessage: "replied_message";
+    readonly Image: "image";
+    readonly File: "file";
+    readonly Unknown: "unknown";
+};
+export type FindLinkedInConversationType = OpenEnum<typeof FindLinkedInConversationType>;
+export type FindLinkedInConversationAttachment = {
+    type: FindLinkedInConversationType;
+    audioUrl?: string | undefined;
+    audioDuration?: number | undefined;
+    hostUrn?: string | undefined;
+    repliedText?: string | undefined;
+    repliedSenderName?: string | undefined;
+    imageUrl?: string | undefined;
+    fileName?: string | undefined;
+    fileUrl?: string | undefined;
+};
+export type FindLinkedInConversationMessage = {
+    messageUrn: string;
+    text: string;
+    deliveredAt: number;
+    senderProfileUrn: string;
+    sender: FindLinkedInConversationSender;
+    attachments: Array<FindLinkedInConversationAttachment>;
+};
+/**
+ * Conversation found (or not)
+ */
+export type FindLinkedInConversationResponse = {
+    success: boolean;
+    found: boolean;
+    conversation: FindLinkedInConversationConversation | null;
+    messages: Array<FindLinkedInConversationMessage> | null;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type GetConversationMessagesRequest = {
+    /**
+     * Full conversation URN as returned by /chats/linkedin (e.g. 'urn:li:msg_conversation:(urn:li:fsd_profile:ACoAAXXX,2-YWUx...)')
+     */
+    conversationUrn: string;
+    /**
+     * Timestamp (ms) of the oldest message from previous page — pass this to load older messages
+     */
+    deliveredAt?: number | undefined;
+};
+export type GetConversationMessagesSender = {
+    firstName: string;
+    lastName: string;
+    profileUrl: string;
+    headline: string | null;
+    profilePicture: string | null;
+};
+export declare const GetConversationMessagesType: {
+    readonly Audio: "audio";
+    readonly SharedPost: "shared_post";
+    readonly RepliedMessage: "replied_message";
+    readonly Image: "image";
+    readonly File: "file";
+    readonly Unknown: "unknown";
+};
+export type GetConversationMessagesType = OpenEnum<typeof GetConversationMessagesType>;
+export type GetConversationMessagesAttachment = {
+    type: GetConversationMessagesType;
+    audioUrl?: string | undefined;
+    audioDuration?: number | undefined;
+    hostUrn?: string | undefined;
+    repliedText?: string | undefined;
+    repliedSenderName?: string | undefined;
+    imageUrl?: string | undefined;
+    fileName?: string | undefined;
+    fileUrl?: string | undefined;
+};
+export type GetConversationMessagesMessage = {
+    messageUrn: string;
+    text: string;
+    deliveredAt: number;
+    senderProfileUrn: string;
+    sender: GetConversationMessagesSender;
+    attachments: Array<GetConversationMessagesAttachment>;
+};
+/**
+ * Conversation messages
+ */
+export type GetConversationMessagesResponse = {
+    success: boolean;
+    messages: Array<GetConversationMessagesMessage>;
+    /**
+     * deliveredAt timestamp (ms) of the oldest message — pass as 'deliveredAt' to load older messages. Null when no more messages.
+     */
+    prevCursor: number | null;
+    /**
+     * Credits consumed by this call (0 for free endpoints, cached results, or duplicates).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before making another call of the same type. 0 means no wait needed.
+     */
+    retryAfter: number;
+};
+export type FilterCampaignRequest = {
+    /**
+     * Unique identifier for the automation campaign (e.g., 'lead-magnet-post-12345', 'outreach-webinar-feb')
+     */
+    campaignSlug: string;
+    /**
+     * Comma-separated list of action slugs to check (e.g., 'send-mp-john-doe,like-comment-abc123')
+     */
+    actionSlugs: string;
+};
+export type CheckedSlug = {
+    actionSlug: string;
+    completed: boolean;
+};
+/**
+ * Filter status with checked slugs
+ */
+export type FilterCampaignResponse = {
+    /**
+     * True if all actionSlugs have been completed for this campaign, meaning the entire flow can be skipped
+     */
+    filtered: boolean;
+    /**
+     * Status of each action slug — completed means the action was already executed for this campaign
+     */
+    checkedSlugs: Array<CheckedSlug>;
+    /**
+     * Credits consumed by this call (always 0 for campaign queries).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before next call of the same type (always 0 for campaign queries).
+     */
+    retryAfter: number;
+};
+export type GetCampaignStatusRequestBody = {
+    /**
+     * LinkedIn profile URLs or URNs to check status for within this campaign.
+     */
+    profiles: Array<string>;
+};
+export type GetCampaignStatusRequest = {
+    /**
+     * Campaign identifier
+     */
+    campaignSlug: string;
+    body: GetCampaignStatusRequestBody;
+};
+export type GetCampaignStatusProfile = {
+    profile: string;
+    message: boolean;
+    reply: boolean;
+    like: boolean;
+    visit: boolean;
+    connect: boolean;
+};
+/**
+ * Per-profile action completion status
+ */
+export type GetCampaignStatusResponse = {
+    success: boolean;
+    profiles: Array<GetCampaignStatusProfile>;
+    /**
+     * Credits consumed by this call (always 0 for campaign queries).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before next call of the same type (always 0 for campaign queries).
+     */
+    retryAfter: number;
+};
+export declare const Action: {
+    readonly Message: "message";
+    readonly Reply: "reply";
+    readonly Like: "like";
+    readonly Visit: "visit";
+    readonly Connect: "connect";
+};
+export type Action = ClosedEnum<typeof Action>;
+export type SyncCampaignActionsProfile = {
+    /**
+     * LinkedIn profile URL or URN
+     */
+    profile: string;
+    /**
+     * Action types to mark as completed
+     */
+    actions: Array<Action>;
+};
+export type SyncCampaignActionsRequestBody = {
+    /**
+     * Profiles and actions to mark as completed without performing them on LinkedIn.
+     */
+    profiles: Array<SyncCampaignActionsProfile>;
+};
+export type SyncCampaignActionsRequest = {
+    /**
+     * Campaign identifier
+     */
+    campaignSlug: string;
+    body: SyncCampaignActionsRequestBody;
+};
+export type Synced = {
+    profile: string;
+    actions: {
+        [k: string]: boolean;
+    };
+};
+/**
+ * Actions marked as completed
+ */
+export type SyncCampaignActionsResponse = {
+    success: boolean;
+    synced: Array<Synced>;
+    /**
+     * Credits consumed by this call (always 0 for campaign queries).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before next call of the same type (always 0 for campaign queries).
+     */
+    retryAfter: number;
+};
+export type GetCampaignStatsRequestBody = {};
+export type GetCampaignStatsRequest = {
+    /**
+     * Campaign identifier
+     */
+    campaignSlug: string;
+    body?: GetCampaignStatsRequestBody | undefined;
+};
+/**
+ * Aggregate campaign statistics
+ */
+export type GetCampaignStatsResponse = {
+    success: boolean;
+    /**
+     * Per-action-type counts (e.g. message: 45, reply: 120)
+     */
+    stats: {
+        [k: string]: number;
+    };
+    /**
+     * Unique profiles processed in this campaign
+     */
+    totalProfiles: number;
+    /**
+     * Total credits consumed by this campaign (sum of action counts). Also serves as the per-call creditsUsed (always 0 for this endpoint).
+     */
+    creditsUsed: number;
+    /**
+     * Seconds to wait before next call of the same type (always 0 for campaign queries).
+     */
+    retryAfter: number;
+};
+/** @internal */
+export type ReplyToLinkedInCommentRequest$Outbound = {
+    commentUrn: string;
+    message: string;
+    campaignSlug?: string | undefined;
+    actionSlug?: string | undefined;
+};
+/** @internal */
+export declare const ReplyToLinkedInCommentRequest$outboundSchema: z.ZodMiniType<ReplyToLinkedInCommentRequest$Outbound, ReplyToLinkedInCommentRequest>;
+export declare function replyToLinkedInCommentRequestToJSON(replyToLinkedInCommentRequest: ReplyToLinkedInCommentRequest): string;
+/** @internal */
+export declare const ReplyToLinkedInCommentResponse$inboundSchema: z.ZodMiniType<ReplyToLinkedInCommentResponse, unknown>;
+export declare function replyToLinkedInCommentResponseFromJSON(jsonString: string): SafeParseResult<ReplyToLinkedInCommentResponse, SDKValidationError>;
+/** @internal */
+export declare const ReactionType$outboundSchema: z.ZodMiniEnum<typeof ReactionType>;
+/** @internal */
+export type LikeLinkedInCommentRequest$Outbound = {
+    commentUrn: string;
+    reactionType: string;
+    campaignSlug?: string | undefined;
+    actionSlug?: string | undefined;
+};
+/** @internal */
+export declare const LikeLinkedInCommentRequest$outboundSchema: z.ZodMiniType<LikeLinkedInCommentRequest$Outbound, LikeLinkedInCommentRequest>;
+export declare function likeLinkedInCommentRequestToJSON(likeLinkedInCommentRequest: LikeLinkedInCommentRequest): string;
+/** @internal */
+export declare const LikeLinkedInCommentResponse$inboundSchema: z.ZodMiniType<LikeLinkedInCommentResponse, unknown>;
+export declare function likeLinkedInCommentResponseFromJSON(jsonString: string): SafeParseResult<LikeLinkedInCommentResponse, SDKValidationError>;
+/** @internal */
+export declare const Mode$outboundSchema: z.ZodMiniEnum<typeof Mode>;
+/** @internal */
+export declare const Visibility$outboundSchema: z.ZodMiniEnum<typeof Visibility>;
+/** @internal */
+export type Mention$Outbound = {
+    profileUrn: string;
+    start: number;
+    length: number;
+};
+/** @internal */
+export declare const Mention$outboundSchema: z.ZodMiniType<Mention$Outbound, Mention>;
+export declare function mentionToJSON(mention: Mention): string;
+/** @internal */
+export type PublishLinkedInPostRequest$Outbound = {
+    text: string;
+    mode: string;
+    scheduledAt?: number | undefined;
+    imageUrl?: string | undefined;
+    visibility: string;
+    mentions?: Array<Mention$Outbound> | undefined;
+    campaignSlug?: string | undefined;
+    actionSlug?: string | undefined;
+};
+/** @internal */
+export declare const PublishLinkedInPostRequest$outboundSchema: z.ZodMiniType<PublishLinkedInPostRequest$Outbound, PublishLinkedInPostRequest>;
+export declare function publishLinkedInPostRequestToJSON(publishLinkedInPostRequest: PublishLinkedInPostRequest): string;
+/** @internal */
+export declare const PublishLinkedInPostResponse$inboundSchema: z.ZodMiniType<PublishLinkedInPostResponse, unknown>;
+export declare function publishLinkedInPostResponseFromJSON(jsonString: string): SafeParseResult<PublishLinkedInPostResponse, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfilePositionStartDate$inboundSchema: z.ZodMiniType<GetMyLinkedInProfilePositionStartDate, unknown>;
+export declare function getMyLinkedInProfilePositionStartDateFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfilePositionStartDate, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfilePositionEndDate$inboundSchema: z.ZodMiniType<GetMyLinkedInProfilePositionEndDate, unknown>;
+export declare function getMyLinkedInProfilePositionEndDateFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfilePositionEndDate, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfilePosition$inboundSchema: z.ZodMiniType<GetMyLinkedInProfilePosition, unknown>;
+export declare function getMyLinkedInProfilePositionFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfilePosition, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfileEducationStartDate$inboundSchema: z.ZodMiniType<GetMyLinkedInProfileEducationStartDate, unknown>;
+export declare function getMyLinkedInProfileEducationStartDateFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfileEducationStartDate, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfileEducationEndDate$inboundSchema: z.ZodMiniType<GetMyLinkedInProfileEducationEndDate, unknown>;
+export declare function getMyLinkedInProfileEducationEndDateFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfileEducationEndDate, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfileEducation$inboundSchema: z.ZodMiniType<GetMyLinkedInProfileEducation, unknown>;
+export declare function getMyLinkedInProfileEducationFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfileEducation, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfileLocation$inboundSchema: z.ZodMiniType<GetMyLinkedInProfileLocation, unknown>;
+export declare function getMyLinkedInProfileLocationFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfileLocation, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfileType$inboundSchema: z.ZodMiniType<GetMyLinkedInProfileType, unknown>;
+/** @internal */
+export declare const GetMyLinkedInProfileLastPost$inboundSchema: z.ZodMiniType<GetMyLinkedInProfileLastPost, unknown>;
+export declare function getMyLinkedInProfileLastPostFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfileLastPost, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInProfileResponse$inboundSchema: z.ZodMiniType<GetMyLinkedInProfileResponse, unknown>;
+export declare function getMyLinkedInProfileResponseFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInProfileResponse, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfilePositionStartDate$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfilePositionStartDate, unknown>;
+export declare function refreshMyLinkedInProfilePositionStartDateFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfilePositionStartDate, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfilePositionEndDate$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfilePositionEndDate, unknown>;
+export declare function refreshMyLinkedInProfilePositionEndDateFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfilePositionEndDate, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfilePosition$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfilePosition, unknown>;
+export declare function refreshMyLinkedInProfilePositionFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfilePosition, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfileEducationStartDate$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfileEducationStartDate, unknown>;
+export declare function refreshMyLinkedInProfileEducationStartDateFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfileEducationStartDate, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfileEducationEndDate$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfileEducationEndDate, unknown>;
+export declare function refreshMyLinkedInProfileEducationEndDateFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfileEducationEndDate, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfileEducation$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfileEducation, unknown>;
+export declare function refreshMyLinkedInProfileEducationFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfileEducation, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfileLocation$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfileLocation, unknown>;
+export declare function refreshMyLinkedInProfileLocationFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfileLocation, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfileType$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfileType, unknown>;
+/** @internal */
+export declare const RefreshMyLinkedInProfileLastPost$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfileLastPost, unknown>;
+export declare function refreshMyLinkedInProfileLastPostFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfileLastPost, SDKValidationError>;
+/** @internal */
+export declare const RefreshMyLinkedInProfileResponse$inboundSchema: z.ZodMiniType<RefreshMyLinkedInProfileResponse, unknown>;
+export declare function refreshMyLinkedInProfileResponseFromJSON(jsonString: string): SafeParseResult<RefreshMyLinkedInProfileResponse, SDKValidationError>;
+/** @internal */
+export type GetMyLinkedInPostsRequest$Outbound = {
+    count?: number | undefined;
+    start?: number | undefined;
+    paginationToken?: string | undefined;
+};
+/** @internal */
+export declare const GetMyLinkedInPostsRequest$outboundSchema: z.ZodMiniType<GetMyLinkedInPostsRequest$Outbound, GetMyLinkedInPostsRequest>;
+export declare function getMyLinkedInPostsRequestToJSON(getMyLinkedInPostsRequest: GetMyLinkedInPostsRequest): string;
+/** @internal */
+export declare const GetMyLinkedInPostsType$inboundSchema: z.ZodMiniType<GetMyLinkedInPostsType, unknown>;
+/** @internal */
+export declare const GetMyLinkedInPostsPost$inboundSchema: z.ZodMiniType<GetMyLinkedInPostsPost, unknown>;
+export declare function getMyLinkedInPostsPostFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInPostsPost, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInPostsResponse$inboundSchema: z.ZodMiniType<GetMyLinkedInPostsResponse, unknown>;
+export declare function getMyLinkedInPostsResponseFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInPostsResponse, SDKValidationError>;
+/** @internal */
+export type GetMyLinkedInFollowersRequest$Outbound = {
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const GetMyLinkedInFollowersRequest$outboundSchema: z.ZodMiniType<GetMyLinkedInFollowersRequest$Outbound, GetMyLinkedInFollowersRequest>;
+export declare function getMyLinkedInFollowersRequestToJSON(getMyLinkedInFollowersRequest: GetMyLinkedInFollowersRequest): string;
+/** @internal */
+export declare const Follower$inboundSchema: z.ZodMiniType<Follower, unknown>;
+export declare function followerFromJSON(jsonString: string): SafeParseResult<Follower, SDKValidationError>;
+/** @internal */
+export declare const GetMyLinkedInFollowersResponse$inboundSchema: z.ZodMiniType<GetMyLinkedInFollowersResponse, unknown>;
+export declare function getMyLinkedInFollowersResponseFromJSON(jsonString: string): SafeParseResult<GetMyLinkedInFollowersResponse, SDKValidationError>;
+/** @internal */
+export declare const ConnectionRequestDaily$inboundSchema: z.ZodMiniType<ConnectionRequestDaily, unknown>;
+export declare function connectionRequestDailyFromJSON(jsonString: string): SafeParseResult<ConnectionRequestDaily, SDKValidationError>;
+/** @internal */
+export declare const ConnectionRequestWeekly$inboundSchema: z.ZodMiniType<ConnectionRequestWeekly, unknown>;
+export declare function connectionRequestWeeklyFromJSON(jsonString: string): SafeParseResult<ConnectionRequestWeekly, SDKValidationError>;
+/** @internal */
+export declare const ConnectionRequest$inboundSchema: z.ZodMiniType<ConnectionRequest, unknown>;
+export declare function connectionRequestFromJSON(jsonString: string): SafeParseResult<ConnectionRequest, SDKValidationError>;
+/** @internal */
+export declare const MessageDaily$inboundSchema: z.ZodMiniType<MessageDaily, unknown>;
+export declare function messageDailyFromJSON(jsonString: string): SafeParseResult<MessageDaily, SDKValidationError>;
+/** @internal */
+export declare const MessageWeekly$inboundSchema: z.ZodMiniType<MessageWeekly, unknown>;
+export declare function messageWeeklyFromJSON(jsonString: string): SafeParseResult<MessageWeekly, SDKValidationError>;
+/** @internal */
+export declare const GetMyLimitsMessage$inboundSchema: z.ZodMiniType<GetMyLimitsMessage, unknown>;
+export declare function getMyLimitsMessageFromJSON(jsonString: string): SafeParseResult<GetMyLimitsMessage, SDKValidationError>;
+/** @internal */
+export declare const ProfileVisitDaily$inboundSchema: z.ZodMiniType<ProfileVisitDaily, unknown>;
+export declare function profileVisitDailyFromJSON(jsonString: string): SafeParseResult<ProfileVisitDaily, SDKValidationError>;
+/** @internal */
+export declare const ProfileVisitWeekly$inboundSchema: z.ZodMiniType<ProfileVisitWeekly, unknown>;
+export declare function profileVisitWeeklyFromJSON(jsonString: string): SafeParseResult<ProfileVisitWeekly, SDKValidationError>;
+/** @internal */
+export declare const ProfileVisit$inboundSchema: z.ZodMiniType<ProfileVisit, unknown>;
+export declare function profileVisitFromJSON(jsonString: string): SafeParseResult<ProfileVisit, SDKValidationError>;
+/** @internal */
+export declare const ScrapingDaily$inboundSchema: z.ZodMiniType<ScrapingDaily, unknown>;
+export declare function scrapingDailyFromJSON(jsonString: string): SafeParseResult<ScrapingDaily, SDKValidationError>;
+/** @internal */
+export declare const ScrapingWeekly$inboundSchema: z.ZodMiniType<ScrapingWeekly, unknown>;
+export declare function scrapingWeeklyFromJSON(jsonString: string): SafeParseResult<ScrapingWeekly, SDKValidationError>;
+/** @internal */
+export declare const Scraping$inboundSchema: z.ZodMiniType<Scraping, unknown>;
+export declare function scrapingFromJSON(jsonString: string): SafeParseResult<Scraping, SDKValidationError>;
+/** @internal */
+export declare const Limits$inboundSchema: z.ZodMiniType<Limits, unknown>;
+export declare function limitsFromJSON(jsonString: string): SafeParseResult<Limits, SDKValidationError>;
+/** @internal */
+export declare const GetMyLimitsResponse$inboundSchema: z.ZodMiniType<GetMyLimitsResponse, unknown>;
+export declare function getMyLimitsResponseFromJSON(jsonString: string): SafeParseResult<GetMyLimitsResponse, SDKValidationError>;
+/** @internal */
+export declare const Credits$inboundSchema: z.ZodMiniType<Credits, unknown>;
+export declare function creditsFromJSON(jsonString: string): SafeParseResult<Credits, SDKValidationError>;
+/** @internal */
+export declare const GetMyCreditsResponse$inboundSchema: z.ZodMiniType<GetMyCreditsResponse, unknown>;
+export declare function getMyCreditsResponseFromJSON(jsonString: string): SafeParseResult<GetMyCreditsResponse, SDKValidationError>;
+/** @internal */
+export type ListInboxConversationsRequest$Outbound = {
+    nextCursor?: string | undefined;
+};
+/** @internal */
+export declare const ListInboxConversationsRequest$outboundSchema: z.ZodMiniType<ListInboxConversationsRequest$Outbound, ListInboxConversationsRequest>;
+export declare function listInboxConversationsRequestToJSON(listInboxConversationsRequest: ListInboxConversationsRequest): string;
+/** @internal */
+export declare const ListInboxConversationsParticipant$inboundSchema: z.ZodMiniType<ListInboxConversationsParticipant, unknown>;
+export declare function listInboxConversationsParticipantFromJSON(jsonString: string): SafeParseResult<ListInboxConversationsParticipant, SDKValidationError>;
+/** @internal */
+export declare const ListInboxConversationsLastMessage$inboundSchema: z.ZodMiniType<ListInboxConversationsLastMessage, unknown>;
+export declare function listInboxConversationsLastMessageFromJSON(jsonString: string): SafeParseResult<ListInboxConversationsLastMessage, SDKValidationError>;
+/** @internal */
+export declare const ListInboxConversationsConversation$inboundSchema: z.ZodMiniType<ListInboxConversationsConversation, unknown>;
+export declare function listInboxConversationsConversationFromJSON(jsonString: string): SafeParseResult<ListInboxConversationsConversation, SDKValidationError>;
+/** @internal */
+export declare const ListInboxConversationsResponse$inboundSchema: z.ZodMiniType<ListInboxConversationsResponse, unknown>;
+export declare function listInboxConversationsResponseFromJSON(jsonString: string): SafeParseResult<ListInboxConversationsResponse, SDKValidationError>;
+/** @internal */
+export type SearchLinkedInConversationsRequest$Outbound = {
+    keywords: string;
+    nextCursor?: string | undefined;
+};
+/** @internal */
+export declare const SearchLinkedInConversationsRequest$outboundSchema: z.ZodMiniType<SearchLinkedInConversationsRequest$Outbound, SearchLinkedInConversationsRequest>;
+export declare function searchLinkedInConversationsRequestToJSON(searchLinkedInConversationsRequest: SearchLinkedInConversationsRequest): string;
+/** @internal */
+export declare const SearchLinkedInConversationsParticipant$inboundSchema: z.ZodMiniType<SearchLinkedInConversationsParticipant, unknown>;
+export declare function searchLinkedInConversationsParticipantFromJSON(jsonString: string): SafeParseResult<SearchLinkedInConversationsParticipant, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInConversationsLastMessage$inboundSchema: z.ZodMiniType<SearchLinkedInConversationsLastMessage, unknown>;
+export declare function searchLinkedInConversationsLastMessageFromJSON(jsonString: string): SafeParseResult<SearchLinkedInConversationsLastMessage, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInConversationsConversation$inboundSchema: z.ZodMiniType<SearchLinkedInConversationsConversation, unknown>;
+export declare function searchLinkedInConversationsConversationFromJSON(jsonString: string): SafeParseResult<SearchLinkedInConversationsConversation, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInConversationsResponse$inboundSchema: z.ZodMiniType<SearchLinkedInConversationsResponse, unknown>;
+export declare function searchLinkedInConversationsResponseFromJSON(jsonString: string): SafeParseResult<SearchLinkedInConversationsResponse, SDKValidationError>;
+/** @internal */
+export type FindLinkedInConversationRequest$Outbound = {
+    profile: string;
+    includeMessages: boolean;
+};
+/** @internal */
+export declare const FindLinkedInConversationRequest$outboundSchema: z.ZodMiniType<FindLinkedInConversationRequest$Outbound, FindLinkedInConversationRequest>;
+export declare function findLinkedInConversationRequestToJSON(findLinkedInConversationRequest: FindLinkedInConversationRequest): string;
+/** @internal */
+export declare const FindLinkedInConversationParticipant$inboundSchema: z.ZodMiniType<FindLinkedInConversationParticipant, unknown>;
+export declare function findLinkedInConversationParticipantFromJSON(jsonString: string): SafeParseResult<FindLinkedInConversationParticipant, SDKValidationError>;
+/** @internal */
+export declare const FindLinkedInConversationLastMessage$inboundSchema: z.ZodMiniType<FindLinkedInConversationLastMessage, unknown>;
+export declare function findLinkedInConversationLastMessageFromJSON(jsonString: string): SafeParseResult<FindLinkedInConversationLastMessage, SDKValidationError>;
+/** @internal */
+export declare const FindLinkedInConversationConversation$inboundSchema: z.ZodMiniType<FindLinkedInConversationConversation, unknown>;
+export declare function findLinkedInConversationConversationFromJSON(jsonString: string): SafeParseResult<FindLinkedInConversationConversation, SDKValidationError>;
+/** @internal */
+export declare const FindLinkedInConversationSender$inboundSchema: z.ZodMiniType<FindLinkedInConversationSender, unknown>;
+export declare function findLinkedInConversationSenderFromJSON(jsonString: string): SafeParseResult<FindLinkedInConversationSender, SDKValidationError>;
+/** @internal */
+export declare const FindLinkedInConversationType$inboundSchema: z.ZodMiniType<FindLinkedInConversationType, unknown>;
+/** @internal */
+export declare const FindLinkedInConversationAttachment$inboundSchema: z.ZodMiniType<FindLinkedInConversationAttachment, unknown>;
+export declare function findLinkedInConversationAttachmentFromJSON(jsonString: string): SafeParseResult<FindLinkedInConversationAttachment, SDKValidationError>;
+/** @internal */
+export declare const FindLinkedInConversationMessage$inboundSchema: z.ZodMiniType<FindLinkedInConversationMessage, unknown>;
+export declare function findLinkedInConversationMessageFromJSON(jsonString: string): SafeParseResult<FindLinkedInConversationMessage, SDKValidationError>;
+/** @internal */
+export declare const FindLinkedInConversationResponse$inboundSchema: z.ZodMiniType<FindLinkedInConversationResponse, unknown>;
+export declare function findLinkedInConversationResponseFromJSON(jsonString: string): SafeParseResult<FindLinkedInConversationResponse, SDKValidationError>;
+/** @internal */
+export type GetConversationMessagesRequest$Outbound = {
+    conversationUrn: string;
+    deliveredAt?: number | undefined;
+};
+/** @internal */
+export declare const GetConversationMessagesRequest$outboundSchema: z.ZodMiniType<GetConversationMessagesRequest$Outbound, GetConversationMessagesRequest>;
+export declare function getConversationMessagesRequestToJSON(getConversationMessagesRequest: GetConversationMessagesRequest): string;
+/** @internal */
+export declare const GetConversationMessagesSender$inboundSchema: z.ZodMiniType<GetConversationMessagesSender, unknown>;
+export declare function getConversationMessagesSenderFromJSON(jsonString: string): SafeParseResult<GetConversationMessagesSender, SDKValidationError>;
+/** @internal */
+export declare const GetConversationMessagesType$inboundSchema: z.ZodMiniType<GetConversationMessagesType, unknown>;
+/** @internal */
+export declare const GetConversationMessagesAttachment$inboundSchema: z.ZodMiniType<GetConversationMessagesAttachment, unknown>;
+export declare function getConversationMessagesAttachmentFromJSON(jsonString: string): SafeParseResult<GetConversationMessagesAttachment, SDKValidationError>;
+/** @internal */
+export declare const GetConversationMessagesMessage$inboundSchema: z.ZodMiniType<GetConversationMessagesMessage, unknown>;
+export declare function getConversationMessagesMessageFromJSON(jsonString: string): SafeParseResult<GetConversationMessagesMessage, SDKValidationError>;
+/** @internal */
+export declare const GetConversationMessagesResponse$inboundSchema: z.ZodMiniType<GetConversationMessagesResponse, unknown>;
+export declare function getConversationMessagesResponseFromJSON(jsonString: string): SafeParseResult<GetConversationMessagesResponse, SDKValidationError>;
+/** @internal */
+export type FilterCampaignRequest$Outbound = {
+    campaignSlug: string;
+    actionSlugs: string;
+};
+/** @internal */
+export declare const FilterCampaignRequest$outboundSchema: z.ZodMiniType<FilterCampaignRequest$Outbound, FilterCampaignRequest>;
+export declare function filterCampaignRequestToJSON(filterCampaignRequest: FilterCampaignRequest): string;
+/** @internal */
+export declare const CheckedSlug$inboundSchema: z.ZodMiniType<CheckedSlug, unknown>;
+export declare function checkedSlugFromJSON(jsonString: string): SafeParseResult<CheckedSlug, SDKValidationError>;
+/** @internal */
+export declare const FilterCampaignResponse$inboundSchema: z.ZodMiniType<FilterCampaignResponse, unknown>;
+export declare function filterCampaignResponseFromJSON(jsonString: string): SafeParseResult<FilterCampaignResponse, SDKValidationError>;
+/** @internal */
+export type GetCampaignStatusRequestBody$Outbound = {
+    profiles: Array<string>;
+};
+/** @internal */
+export declare const GetCampaignStatusRequestBody$outboundSchema: z.ZodMiniType<GetCampaignStatusRequestBody$Outbound, GetCampaignStatusRequestBody>;
+export declare function getCampaignStatusRequestBodyToJSON(getCampaignStatusRequestBody: GetCampaignStatusRequestBody): string;
+/** @internal */
+export type GetCampaignStatusRequest$Outbound = {
+    campaignSlug: string;
+    body: GetCampaignStatusRequestBody$Outbound;
+};
+/** @internal */
+export declare const GetCampaignStatusRequest$outboundSchema: z.ZodMiniType<GetCampaignStatusRequest$Outbound, GetCampaignStatusRequest>;
+export declare function getCampaignStatusRequestToJSON(getCampaignStatusRequest: GetCampaignStatusRequest): string;
+/** @internal */
+export declare const GetCampaignStatusProfile$inboundSchema: z.ZodMiniType<GetCampaignStatusProfile, unknown>;
+export declare function getCampaignStatusProfileFromJSON(jsonString: string): SafeParseResult<GetCampaignStatusProfile, SDKValidationError>;
+/** @internal */
+export declare const GetCampaignStatusResponse$inboundSchema: z.ZodMiniType<GetCampaignStatusResponse, unknown>;
+export declare function getCampaignStatusResponseFromJSON(jsonString: string): SafeParseResult<GetCampaignStatusResponse, SDKValidationError>;
+/** @internal */
+export declare const Action$outboundSchema: z.ZodMiniEnum<typeof Action>;
+/** @internal */
+export type SyncCampaignActionsProfile$Outbound = {
+    profile: string;
+    actions: Array<string>;
+};
+/** @internal */
+export declare const SyncCampaignActionsProfile$outboundSchema: z.ZodMiniType<SyncCampaignActionsProfile$Outbound, SyncCampaignActionsProfile>;
+export declare function syncCampaignActionsProfileToJSON(syncCampaignActionsProfile: SyncCampaignActionsProfile): string;
+/** @internal */
+export type SyncCampaignActionsRequestBody$Outbound = {
+    profiles: Array<SyncCampaignActionsProfile$Outbound>;
+};
+/** @internal */
+export declare const SyncCampaignActionsRequestBody$outboundSchema: z.ZodMiniType<SyncCampaignActionsRequestBody$Outbound, SyncCampaignActionsRequestBody>;
+export declare function syncCampaignActionsRequestBodyToJSON(syncCampaignActionsRequestBody: SyncCampaignActionsRequestBody): string;
+/** @internal */
+export type SyncCampaignActionsRequest$Outbound = {
+    campaignSlug: string;
+    body: SyncCampaignActionsRequestBody$Outbound;
+};
+/** @internal */
+export declare const SyncCampaignActionsRequest$outboundSchema: z.ZodMiniType<SyncCampaignActionsRequest$Outbound, SyncCampaignActionsRequest>;
+export declare function syncCampaignActionsRequestToJSON(syncCampaignActionsRequest: SyncCampaignActionsRequest): string;
+/** @internal */
+export declare const Synced$inboundSchema: z.ZodMiniType<Synced, unknown>;
+export declare function syncedFromJSON(jsonString: string): SafeParseResult<Synced, SDKValidationError>;
+/** @internal */
+export declare const SyncCampaignActionsResponse$inboundSchema: z.ZodMiniType<SyncCampaignActionsResponse, unknown>;
+export declare function syncCampaignActionsResponseFromJSON(jsonString: string): SafeParseResult<SyncCampaignActionsResponse, SDKValidationError>;
+/** @internal */
+export type GetCampaignStatsRequestBody$Outbound = {};
+/** @internal */
+export declare const GetCampaignStatsRequestBody$outboundSchema: z.ZodMiniType<GetCampaignStatsRequestBody$Outbound, GetCampaignStatsRequestBody>;
+export declare function getCampaignStatsRequestBodyToJSON(getCampaignStatsRequestBody: GetCampaignStatsRequestBody): string;
+/** @internal */
+export type GetCampaignStatsRequest$Outbound = {
+    campaignSlug: string;
+    body?: GetCampaignStatsRequestBody$Outbound | undefined;
+};
+/** @internal */
+export declare const GetCampaignStatsRequest$outboundSchema: z.ZodMiniType<GetCampaignStatsRequest$Outbound, GetCampaignStatsRequest>;
+export declare function getCampaignStatsRequestToJSON(getCampaignStatsRequest: GetCampaignStatsRequest): string;
+/** @internal */
+export declare const GetCampaignStatsResponse$inboundSchema: z.ZodMiniType<GetCampaignStatsResponse, unknown>;
+export declare function getCampaignStatsResponseFromJSON(jsonString: string): SafeParseResult<GetCampaignStatsResponse, SDKValidationError>;
+//# sourceMappingURL=get-campaign-stats-response.d.ts.map