bereach 0.1.1

package/esm/models/operations/send-linked-in-message-response.d.ts

@@ -0,0 +1,2350 @@
+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 CollectLinkedInLikesRequest = {
+    /**
+     * LinkedIn post URL to inspect for reactions.
+     */
+    postUrl: string;
+    /**
+     * Pagination offset (multiples of 200).
+     */
+    start?: number | undefined;
+    /**
+     * Number of likes to fetch per page (0-200, default 200). Use count=0 for a free total-only check (0 credits, no rate-limit slot consumed).
+     */
+    count?: number | undefined;
+};
+export type CollectLinkedInLikesInternalServerErrorDetails = string | Array<string>;
+export type CollectLinkedInLikesInternalServerErrorError = {
+    code: string;
+    message: string;
+    docs?: string | undefined;
+    details?: string | Array<string> | undefined;
+};
+export declare const CollectLinkedInLikesCode: {
+    readonly RateLimitExceeded: "rate_limit_exceeded";
+};
+export type CollectLinkedInLikesCode = ClosedEnum<typeof CollectLinkedInLikesCode>;
+/**
+ * Current and max daily usage (null if no daily cap).
+ */
+export type CollectLinkedInLikesDaily = {
+    current: number;
+    limit: number;
+};
+/**
+ * Current and max weekly usage (null if no weekly cap).
+ */
+export type CollectLinkedInLikesWeekly = {
+    current: number;
+    limit: number;
+};
+export type CollectLinkedInLikesTooManyRequestsError = {
+    code: CollectLinkedInLikesCode;
+    message: string;
+    docs?: string | undefined;
+    /**
+     * Seconds to wait before retrying.
+     */
+    retryAfter: number;
+    /**
+     * Current and max daily usage (null if no daily cap).
+     */
+    daily: CollectLinkedInLikesDaily | null;
+    /**
+     * Current and max weekly usage (null if no weekly cap).
+     */
+    weekly: CollectLinkedInLikesWeekly | null;
+};
+export type CollectLinkedInLikesUnprocessableEntityDetails = string | Array<string>;
+export type CollectLinkedInLikesUnprocessableEntityError = {
+    code: string;
+    message: string;
+    docs?: string | undefined;
+    details?: string | Array<string> | undefined;
+};
+export type CollectLinkedInLikesGoneDetails = string | Array<string>;
+export type CollectLinkedInLikesGoneError = {
+    code: string;
+    message: string;
+    docs?: string | undefined;
+    details?: string | Array<string> | undefined;
+};
+export type CollectLinkedInLikesConflictDetails = string | Array<string>;
+export type CollectLinkedInLikesConflictError = {
+    code: string;
+    message: string;
+    docs?: string | undefined;
+    details?: string | Array<string> | undefined;
+};
+export type CollectLinkedInLikesNotFoundDetails = string | Array<string>;
+export type CollectLinkedInLikesNotFoundError = {
+    code: string;
+    message: string;
+    docs?: string | undefined;
+    details?: string | Array<string> | undefined;
+};
+export type CollectLinkedInLikesForbiddenDetails = string | Array<string>;
+export type CollectLinkedInLikesForbiddenError = {
+    code: string;
+    message: string;
+    docs?: string | undefined;
+    details?: string | Array<string> | undefined;
+};
+export type CollectLinkedInLikesUnauthorizedDetails = string | Array<string>;
+export type CollectLinkedInLikesUnauthorizedError = {
+    code: string;
+    message: string;
+    docs?: string | undefined;
+    details?: string | Array<string> | undefined;
+};
+export type CollectLinkedInLikesBadRequestDetails = string | Array<string>;
+export type CollectLinkedInLikesBadRequestError = {
+    code: string;
+    message: string;
+    docs?: string | undefined;
+    details?: string | Array<string> | undefined;
+};
+export declare const CollectLinkedInLikesType: {
+    readonly Like: "like";
+};
+export type CollectLinkedInLikesType = ClosedEnum<typeof CollectLinkedInLikesType>;
+export type CollectLinkedInLikesProfile = {
+    name: string;
+    headline?: string | null | undefined;
+    profileUrl?: string | null | undefined;
+    imageUrl?: string | null | undefined;
+    type: CollectLinkedInLikesType;
+};
+/**
+ * List of profiles who liked the post
+ */
+export type CollectLinkedInLikesResponse = {
+    success: boolean;
+    profiles: Array<CollectLinkedInLikesProfile>;
+    count: number;
+    total: number;
+    start: number;
+    hasMore: boolean;
+    /**
+     * The total from your last call to this endpoint for the same post (null on first call). Compare with total to detect new likes without client-side tracking.
+     */
+    previousTotal: 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 CollectLinkedInCommentsRequest = {
+    /**
+     * LinkedIn post URL to inspect for comments.
+     */
+    postUrl: string;
+    /**
+     * Pagination offset (multiples of 100).
+     */
+    start?: number | undefined;
+    /**
+     * Number of comments to fetch per page (0-100, default 100). Use count=0 for a free total-only check (0 credits, no rate-limit slot consumed — can call count=100 immediately after).
+     */
+    count?: number | undefined;
+    /**
+     * When provided, each profile in the response includes actionsCompleted (message/reply/like/visit/connect booleans) and knownDistance (cached memberDistance from recent visits, null if not cached). Enables campaign-aware scraping without manual cross-referencing.
+     */
+    campaignSlug?: string | undefined;
+};
+export declare const CollectLinkedInCommentsType: {
+    readonly Comment: "comment";
+};
+export type CollectLinkedInCommentsType = ClosedEnum<typeof CollectLinkedInCommentsType>;
+/**
+ * Per-profile action completion status within the campaign. Only present when campaignSlug is provided in the request.
+ */
+export type CollectLinkedInCommentsActionsCompleted = {
+    message: boolean;
+    reply: boolean;
+    like: boolean;
+    visit: boolean;
+    connect: boolean;
+};
+export type CollectLinkedInCommentsProfile = {
+    name: string;
+    headline?: string | null | undefined;
+    profileUrl?: string | null | undefined;
+    imageUrl?: string | null | undefined;
+    type: CollectLinkedInCommentsType;
+    commentText?: string | undefined;
+    timestamp?: number | null | undefined;
+    isEdited?: boolean | undefined;
+    /**
+     * Full comment URN — use directly for /reply and /like endpoints. Do NOT reconstruct from hash fields.
+     */
+    commentUrn?: string | undefined;
+    /**
+     * SHA256 hash of commentUrn — use for dedup slugs only, not for building URNs.
+     */
+    commentHash?: string | undefined;
+    /**
+     * True if the commenter is the post author.
+     */
+    isPostAuthor?: boolean | undefined;
+    /**
+     * Number of replies to this comment.
+     */
+    repliesCount?: number | undefined;
+    /**
+     * True if the post author already replied to this comment.
+     */
+    hasReplyFromPostAuthor?: boolean | undefined;
+    postUrn?: string | undefined;
+    /**
+     * SHA256 hash of postUrn — use for dedup slugs only.
+     */
+    postHash?: string | undefined;
+    /**
+     * Per-profile action completion status within the campaign. Only present when campaignSlug is provided in the request.
+     */
+    actionsCompleted?: CollectLinkedInCommentsActionsCompleted | undefined;
+    /**
+     * Cached memberDistance from a recent profile visit (1 = connected, 2 = 2nd degree, etc.). Only present when campaignSlug is provided. null if the profile has not been visited recently.
+     */
+    knownDistance?: number | null | undefined;
+};
+/**
+ * List of profiles who commented on the post
+ */
+export type CollectLinkedInCommentsResponse = {
+    success: boolean;
+    profiles: Array<CollectLinkedInCommentsProfile>;
+    count: number;
+    total: number;
+    start: number;
+    hasMore: boolean;
+    /**
+     * The total from your last call to this endpoint for the same post (null on first call). Compare with total to detect new comments without client-side tracking.
+     */
+    previousTotal: number | null;
+    /**
+     * Number of returned profiles that already have a completed 'message' action in this campaign. Only present when campaignSlug is provided.
+     */
+    processedCount?: number | undefined;
+    /**
+     * Number of returned profiles that have NOT yet been messaged in this campaign. Only present when campaignSlug is provided.
+     */
+    newCount?: number | 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 CollectLinkedInCommentRepliesRequest = {
+    /**
+     * Comment URN returned by the comments endpoint (e.g., 'urn:li:comment:(activity:123456,789)').
+     */
+    commentUrn: string;
+    /**
+     * Pagination offset (default 0).
+     */
+    start?: number | undefined;
+    /**
+     * Number of replies to fetch per page (0-100, default 100). Use count=0 for a free total-only check (0 credits, no rate-limit slot consumed).
+     */
+    count?: number | undefined;
+};
+export declare const CollectLinkedInCommentRepliesType: {
+    readonly Comment: "comment";
+};
+export type CollectLinkedInCommentRepliesType = ClosedEnum<typeof CollectLinkedInCommentRepliesType>;
+/**
+ * Per-profile action completion status within the campaign. Only present when campaignSlug is provided in the request.
+ */
+export type CollectLinkedInCommentRepliesActionsCompleted = {
+    message: boolean;
+    reply: boolean;
+    like: boolean;
+    visit: boolean;
+    connect: boolean;
+};
+export type Reply = {
+    name: string;
+    headline?: string | null | undefined;
+    profileUrl?: string | null | undefined;
+    imageUrl?: string | null | undefined;
+    type: CollectLinkedInCommentRepliesType;
+    commentText?: string | undefined;
+    timestamp?: number | null | undefined;
+    isEdited?: boolean | undefined;
+    /**
+     * Full comment URN — use directly for /reply and /like endpoints. Do NOT reconstruct from hash fields.
+     */
+    commentUrn?: string | undefined;
+    /**
+     * SHA256 hash of commentUrn — use for dedup slugs only, not for building URNs.
+     */
+    commentHash?: string | undefined;
+    /**
+     * True if the commenter is the post author.
+     */
+    isPostAuthor?: boolean | undefined;
+    /**
+     * Number of replies to this comment.
+     */
+    repliesCount?: number | undefined;
+    /**
+     * True if the post author already replied to this comment.
+     */
+    hasReplyFromPostAuthor?: boolean | undefined;
+    postUrn?: string | undefined;
+    /**
+     * SHA256 hash of postUrn — use for dedup slugs only.
+     */
+    postHash?: string | undefined;
+    /**
+     * Per-profile action completion status within the campaign. Only present when campaignSlug is provided in the request.
+     */
+    actionsCompleted?: CollectLinkedInCommentRepliesActionsCompleted | undefined;
+    /**
+     * Cached memberDistance from a recent profile visit (1 = connected, 2 = 2nd degree, etc.). Only present when campaignSlug is provided. null if the profile has not been visited recently.
+     */
+    knownDistance?: number | null | undefined;
+};
+/**
+ * List of replies to the comment
+ */
+export type CollectLinkedInCommentRepliesResponse = {
+    success: boolean;
+    replies: Array<Reply>;
+    count: number;
+    total: number;
+    start: number;
+    hasMore: boolean;
+    parentCommentUrn: string;
+    /**
+     * The total from your last call to this endpoint for the same comment (null on first call). Compare with total to detect new replies without client-side tracking.
+     */
+    previousTotal: 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 CollectLinkedInPostsRequest = {
+    /**
+     * LinkedIn profile URL to fetch posts from.
+     */
+    profileUrl: string;
+    /**
+     * Number of posts to fetch (0-100, default 20). Use count=0 for a free total-only check (0 credits, no rate-limit slot consumed).
+     */
+    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 CollectLinkedInPostsType: {
+    readonly Activity: "activity";
+    readonly UgcPost: "ugcPost";
+    readonly Share: "share";
+};
+export type CollectLinkedInPostsType = OpenEnum<typeof CollectLinkedInPostsType>;
+export type CollectLinkedInPostsPost = {
+    postUrl: string;
+    text: string;
+    date: number;
+    likesCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    postUrn: string;
+    postId: string;
+    type: CollectLinkedInPostsType;
+};
+/**
+ * Paginated list of posts from the profile
+ */
+export type CollectLinkedInPostsResponse = {
+    success: boolean;
+    posts: Array<CollectLinkedInPostsPost>;
+    count: number;
+    total: number;
+    start: number;
+    hasMore: boolean;
+    paginationToken: string | null;
+    /**
+     * The total from your last call to this endpoint for the same profile (null on first call). Compare with total to detect new posts without client-side tracking.
+     */
+    previousTotal: 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 VisitLinkedInProfileRequest = {
+    /**
+     * LinkedIn profile URL (e.g., 'https://www.linkedin.com/in/username') or profile URN (e.g., 'urn:li:fsd_profile:ACoAABZ0Qo4B6pt58d4FVmts1F7TPi4D1-uL1fw')
+     */
+    profile: string;
+    /**
+     * Optional campaign identifier for tracking only. No dedup — visit always executes.
+     */
+    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;
+    /**
+     * When true, fetches the last 5 posts from the profile (adds a random delay between requests). Defaults to false.
+     */
+    includePosts?: boolean | undefined;
+};
+/**
+ * Connection request status: 'pending' if request was sent successfully, 'failed' if request failed today, 'none' if not tracked
+ */
+export declare const PendingConnection: {
+    readonly Pending: "pending";
+    readonly Failed: "failed";
+    readonly None: "none";
+};
+/**
+ * Connection request status: 'pending' if request was sent successfully, 'failed' if request failed today, 'none' if not tracked
+ */
+export type PendingConnection = OpenEnum<typeof PendingConnection>;
+export type VisitLinkedInProfilePositionStartDate = {
+    month: number | null;
+    year: number;
+};
+export type VisitLinkedInProfilePositionEndDate = {
+    month: number | null;
+    year: number;
+};
+export type VisitLinkedInProfilePosition = {
+    companyName: string | null;
+    title: string | null;
+    companyUrl: string | null;
+    companyLogo: string | null;
+    startDate: VisitLinkedInProfilePositionStartDate | null;
+    endDate: VisitLinkedInProfilePositionEndDate | null;
+    isCurrent: boolean;
+};
+export type VisitLinkedInProfileEducationStartDate = {
+    month: number | null;
+    year: number;
+};
+export type VisitLinkedInProfileEducationEndDate = {
+    month: number | null;
+    year: number;
+};
+export type VisitLinkedInProfileEducation = {
+    schoolName: string | null;
+    degreeName: string | null;
+    fieldOfStudy: string | null;
+    schoolUrl: string | null;
+    schoolLogo: string | null;
+    startDate: VisitLinkedInProfileEducationStartDate | null;
+    endDate: VisitLinkedInProfileEducationEndDate | null;
+};
+export declare const VisitLinkedInProfileType: {
+    readonly Activity: "activity";
+    readonly UgcPost: "ugcPost";
+    readonly Share: "share";
+};
+export type VisitLinkedInProfileType = OpenEnum<typeof VisitLinkedInProfileType>;
+export type VisitLinkedInProfileLastPost = {
+    postUrl: string;
+    text: string;
+    date: number;
+    likesCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    postUrn: string;
+    postId: string;
+    type: VisitLinkedInProfileType;
+};
+/**
+ * Profile contact data
+ */
+export type VisitLinkedInProfileResponse = {
+    success: boolean;
+    firstName: string;
+    lastName: string;
+    headline: string | null;
+    publicIdentifier: string;
+    profileUrl: string;
+    /**
+     * LinkedIn profile URN (e.g. 'urn:li:fsd_profile:ACoAAA...'). Use this for matching against inbox participants.
+     */
+    profileUrn?: string | undefined;
+    imageUrl: string | null;
+    email?: string | null | undefined;
+    location?: string | null | undefined;
+    /**
+     * Current company name (from most recent position)
+     */
+    company?: string | null | undefined;
+    /**
+     * Current job title (from most recent position)
+     */
+    position?: string | null | undefined;
+    /**
+     * Connection degree: 0 (self), 1 (direct connection), 2+ (2nd degree, 3rd degree, etc.), or null if unknown
+     */
+    memberDistance?: number | null | undefined;
+    /**
+     * Connection request status: 'pending' if request was sent successfully, 'failed' if request failed today, 'none' if not tracked
+     */
+    pendingConnection: PendingConnection;
+    /**
+     * Work experience positions
+     */
+    positions?: Array<VisitLinkedInProfilePosition> | undefined;
+    /**
+     * Education entries
+     */
+    educations?: Array<VisitLinkedInProfileEducation> | undefined;
+    /**
+     * Last 5 posts from the profile (only present when includePosts is true)
+     */
+    lastPosts?: Array<VisitLinkedInProfileLastPost> | undefined;
+    /**
+     * true if this result was served from cache (0 credits). Distance-1 profiles are cached for 24h.
+     */
+    cached: 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 VisitLinkedInCompanyRequest = {
+    /**
+     * LinkedIn company URL (e.g., 'https://www.linkedin.com/company/openai') or universal name (e.g., 'openai')
+     */
+    companyUrl: string;
+    /**
+     * Include workplace policy data such as hybrid/remote status and benefits. Costs 1 extra credit (extra API call).
+     */
+    includeWorkplacePolicy?: boolean | undefined;
+};
+/**
+ * Employee count range
+ */
+export type EmployeeCountRange = {
+    start: number;
+    end: number | null;
+};
+export type Headquarter = {
+    country: string | null;
+    geographicArea: string | null;
+    city: string | null;
+    postalCode: string | null;
+    line1: string | null;
+    line2: string | null;
+};
+export type FoundedOn = {
+    year: number;
+};
+export type CallToAction = {
+    type: string;
+    url: string;
+};
+export type AffiliatedCompany = {
+    id: string;
+    universalName: string;
+    name: string;
+    url: string | null;
+    logoUrl: string | null;
+    followerCount: number | null;
+    industry: string | null;
+};
+export type SimilarCompany = {
+    id: string;
+    universalName: string;
+    name: string;
+    url: string | null;
+    logoUrl: string | null;
+    followerCount: number | null;
+    industry: string | null;
+};
+/**
+ * Workplace policy (only present when includeWorkplacePolicy=true)
+ */
+export type WorkplacePolicy = {
+    title: string | null;
+    description: string | null;
+    timeAtOnsite: string | null;
+    benefits: Array<string>;
+};
+/**
+ * Company profile data
+ */
+export type VisitLinkedInCompanyResponse = {
+    success: boolean;
+    /**
+     * LinkedIn numeric company ID
+     */
+    id: string;
+    /**
+     * Company URL slug
+     */
+    universalName: string;
+    name: string;
+    description: string | null;
+    /**
+     * LinkedIn company page URL
+     */
+    url: string;
+    /**
+     * External website URL
+     */
+    websiteUrl: string | null;
+    industry: string | null;
+    /**
+     * Exact employee count on LinkedIn
+     */
+    employeeCount: number | null;
+    /**
+     * Employee count range
+     */
+    employeeCountRange: EmployeeCountRange | null;
+    headquarter: Headquarter | null;
+    logoUrl: string | null;
+    coverImageUrl: string | null;
+    followerCount: number | null;
+    specialities: Array<string>;
+    tagline: string | null;
+    isVerified: boolean;
+    foundedOn: FoundedOn | null;
+    phone: string | null;
+    callToAction: CallToAction | null;
+    hashtags: Array<string>;
+    /**
+     * Showcase / affiliated pages
+     */
+    affiliatedCompanies: Array<AffiliatedCompany>;
+    /**
+     * Similar companies suggested by LinkedIn
+     */
+    similarCompanies: Array<SimilarCompany>;
+    /**
+     * Workplace policy (only present when includeWorkplacePolicy=true)
+     */
+    workplacePolicy?: WorkplacePolicy | null | 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;
+};
+/**
+ * Type of search to perform (required unless url is provided)
+ */
+export declare const CategoryRequest: {
+    readonly Posts: "posts";
+    readonly People: "people";
+    readonly Companies: "companies";
+    readonly Jobs: "jobs";
+};
+/**
+ * Type of search to perform (required unless url is provided)
+ */
+export type CategoryRequest = ClosedEnum<typeof CategoryRequest>;
+/**
+ * Sort order (posts & jobs)
+ */
+export declare const SearchLinkedInSortBy: {
+    readonly Relevance: "relevance";
+    readonly Date: "date";
+};
+/**
+ * Sort order (posts & jobs)
+ */
+export type SearchLinkedInSortBy = ClosedEnum<typeof SearchLinkedInSortBy>;
+/**
+ * Time filter (posts & jobs)
+ */
+export declare const SearchLinkedInDatePosted: {
+    readonly Past24h: "past-24h";
+    readonly PastWeek: "past-week";
+    readonly PastMonth: "past-month";
+};
+/**
+ * Time filter (posts & jobs)
+ */
+export type SearchLinkedInDatePosted = ClosedEnum<typeof SearchLinkedInDatePosted>;
+/**
+ * Media type filter (posts only)
+ */
+export declare const SearchLinkedInContentType: {
+    readonly Images: "images";
+    readonly Videos: "videos";
+    readonly Documents: "documents";
+};
+/**
+ * Media type filter (posts only)
+ */
+export type SearchLinkedInContentType = ClosedEnum<typeof SearchLinkedInContentType>;
+export declare const SearchLinkedInConnectionDegree: {
+    readonly F: "F";
+    readonly S: "S";
+    readonly O: "O";
+};
+export type SearchLinkedInConnectionDegree = ClosedEnum<typeof SearchLinkedInConnectionDegree>;
+export declare const SearchLinkedInCompanySize: {
+    readonly A: "A";
+    readonly B: "B";
+    readonly C: "C";
+    readonly D: "D";
+    readonly E: "E";
+    readonly F: "F";
+    readonly G: "G";
+    readonly H: "H";
+    readonly I: "I";
+};
+export type SearchLinkedInCompanySize = ClosedEnum<typeof SearchLinkedInCompanySize>;
+export declare const SearchLinkedInJobType: {
+    readonly F: "F";
+    readonly P: "P";
+    readonly C: "C";
+    readonly T: "T";
+    readonly I: "I";
+    readonly V: "V";
+    readonly O: "O";
+};
+export type SearchLinkedInJobType = ClosedEnum<typeof SearchLinkedInJobType>;
+export declare const SearchLinkedInExperienceLevel: {
+    readonly One: "1";
+    readonly Two: "2";
+    readonly Three: "3";
+    readonly Four: "4";
+    readonly Five: "5";
+    readonly Six: "6";
+};
+export type SearchLinkedInExperienceLevel = ClosedEnum<typeof SearchLinkedInExperienceLevel>;
+export declare const SearchLinkedInWorkplaceType: {
+    readonly One: "1";
+    readonly Two: "2";
+    readonly Three: "3";
+};
+export type SearchLinkedInWorkplaceType = ClosedEnum<typeof SearchLinkedInWorkplaceType>;
+export type SearchLinkedInRequest = {
+    /**
+     * Type of search to perform (required unless url is provided)
+     */
+    category?: CategoryRequest | undefined;
+    /**
+     * LinkedIn search URL — category and filters are extracted automatically. Explicit params override URL-derived ones.
+     */
+    url?: string | undefined;
+    /**
+     * Search keywords. Supports LinkedIn Boolean syntax: use double quotes for exact phrases (e.g. "outreach automation"), AND to require both terms, OR for alternatives (e.g. CEO OR founder), NOT to exclude (e.g. manager NOT assistant), and parentheses to group (e.g. (CEO OR CTO) AND SaaS). Operators must be UPPERCASE. Without quotes, multi-word queries are treated as AND by default which may return overly broad results — use exact phrases with quotes for precise matching.
+     */
+    keywords?: string | undefined;
+    /**
+     * Sort order (posts & jobs)
+     */
+    sortBy?: SearchLinkedInSortBy | undefined;
+    /**
+     * Time filter (posts & jobs)
+     */
+    datePosted?: SearchLinkedInDatePosted | undefined;
+    /**
+     * Media type filter (posts only)
+     */
+    contentType?: SearchLinkedInContentType | undefined;
+    /**
+     * Author industry IDs (posts only, resolve via /search/parameters)
+     */
+    authorIndustry?: Array<string> | undefined;
+    /**
+     * Author company IDs (posts only, resolve via /search/parameters)
+     */
+    authorCompany?: Array<string> | undefined;
+    /**
+     * Connection degree: F=1st, S=2nd, O=3rd+ (people only)
+     */
+    connectionDegree?: Array<SearchLinkedInConnectionDegree> | undefined;
+    /**
+     * First name filter (people only)
+     */
+    firstName?: string | undefined;
+    /**
+     * Last name filter (people only)
+     */
+    lastName?: string | undefined;
+    /**
+     * Job title filter, supports OR syntax (people only)
+     */
+    title?: string | undefined;
+    /**
+     * Profile URN to find connections of (people only)
+     */
+    connectionOf?: string | undefined;
+    /**
+     * Profile language codes e.g. ['en','fr'] (people only)
+     */
+    profileLanguage?: Array<string> | undefined;
+    /**
+     * School IDs (people only, resolve via /search/parameters)
+     */
+    school?: Array<string> | undefined;
+    /**
+     * Geo IDs (people, companies, jobs -- resolve via /search/parameters)
+     */
+    location?: Array<string> | undefined;
+    /**
+     * Industry IDs (people, companies -- resolve via /search/parameters)
+     */
+    industry?: Array<string> | undefined;
+    /**
+     * Current company IDs (people only, resolve via /search/parameters)
+     */
+    currentCompany?: Array<string> | undefined;
+    /**
+     * Past company IDs (people only, resolve via /search/parameters)
+     */
+    pastCompany?: Array<string> | undefined;
+    /**
+     * Company size: A=1-10, B=11-50, C=51-200, D=201-500, E=501-1K, F=1K-5K, G=5K-10K, H=10K+, I=self (companies only)
+     */
+    companySize?: Array<SearchLinkedInCompanySize> | undefined;
+    /**
+     * Job type: F=Full-time, P=Part-time, C=Contract, T=Temporary, I=Internship, V=Volunteer, O=Other (jobs only)
+     */
+    jobType?: Array<SearchLinkedInJobType> | undefined;
+    /**
+     * Experience level: 1=Internship, 2=Entry, 3=Associate, 4=Mid-Senior, 5=Director, 6=Executive (jobs only)
+     */
+    experienceLevel?: Array<SearchLinkedInExperienceLevel> | undefined;
+    /**
+     * Workplace type: 1=On-site, 2=Remote, 3=Hybrid (jobs only)
+     */
+    workplaceType?: Array<SearchLinkedInWorkplaceType> | undefined;
+    /**
+     * Pagination offset (default 0)
+     */
+    start?: number | undefined;
+    /**
+     * Results per page (default 10, max 50)
+     */
+    count?: number | undefined;
+};
+export declare const SearchLinkedInCategoryResponseBody: {
+    readonly Posts: "posts";
+    readonly People: "people";
+    readonly Companies: "companies";
+    readonly Jobs: "jobs";
+};
+export type SearchLinkedInCategoryResponseBody = OpenEnum<typeof SearchLinkedInCategoryResponseBody>;
+export declare const SearchLinkedInTypeJob: {
+    readonly Job: "JOB";
+};
+export type SearchLinkedInTypeJob = ClosedEnum<typeof SearchLinkedInTypeJob>;
+export type SearchLinkedInItemsJob = {
+    type: SearchLinkedInTypeJob;
+    title: string;
+    company: string | null;
+    companyUrl: string | null;
+    companyLogo: string | null;
+    location: string | null;
+    workplaceType: string | null;
+    postedAt: string | null;
+    jobUrl: string;
+    listingId: string;
+};
+export declare const SearchLinkedInTypeCompany: {
+    readonly Company: "COMPANY";
+};
+export type SearchLinkedInTypeCompany = ClosedEnum<typeof SearchLinkedInTypeCompany>;
+export type SearchLinkedInItemsCompany = {
+    type: SearchLinkedInTypeCompany;
+    name: string;
+    profileUrl: string;
+    summary: string | null;
+    industry: string | null;
+    location: string | null;
+    followersCount: number | null;
+};
+export declare const SearchLinkedInTypePeople: {
+    readonly People: "PEOPLE";
+};
+export type SearchLinkedInTypePeople = ClosedEnum<typeof SearchLinkedInTypePeople>;
+export declare const SearchLinkedInNetworkDistance: {
+    readonly Distance1: "DISTANCE_1";
+    readonly Distance2: "DISTANCE_2";
+    readonly Distance3: "DISTANCE_3";
+    readonly OutOfNetwork: "OUT_OF_NETWORK";
+};
+export type SearchLinkedInNetworkDistance = OpenEnum<typeof SearchLinkedInNetworkDistance>;
+export type SearchLinkedInCurrentPosition = {
+    company: string | null;
+    role: string | null;
+};
+export type SearchLinkedInItemsPeople = {
+    type: SearchLinkedInTypePeople;
+    name: string;
+    profileUrl: string;
+    headline: string | null;
+    location: string | null;
+    profilePicture: string | null;
+    networkDistance: SearchLinkedInNetworkDistance | null;
+    currentPositions: Array<SearchLinkedInCurrentPosition>;
+};
+export declare const SearchLinkedInTypePost: {
+    readonly Post: "POST";
+};
+export type SearchLinkedInTypePost = ClosedEnum<typeof SearchLinkedInTypePost>;
+export type SearchLinkedInAuthor = {
+    name: string;
+    profileUrl: string | null;
+    headline: string | null;
+    profilePicture: string | null;
+    isCompany: boolean;
+};
+export type SearchLinkedInItemsPost = {
+    type: SearchLinkedInTypePost;
+    postUrl: string;
+    text: string;
+    date: number;
+    likesCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    postUrn: string;
+    postId: string;
+    author: SearchLinkedInAuthor;
+    isRepost: boolean;
+};
+export type SearchLinkedInItemsUnion = Array<SearchLinkedInItemsPost> | Array<SearchLinkedInItemsPeople> | Array<SearchLinkedInItemsCompany> | Array<SearchLinkedInItemsJob>;
+export type SearchLinkedInPaging = {
+    start: number;
+    count: number;
+    total: number;
+};
+/**
+ * Search results for the specified category
+ */
+export type SearchLinkedInResponse = {
+    success: boolean;
+    category: SearchLinkedInCategoryResponseBody;
+    items: Array<SearchLinkedInItemsPost> | Array<SearchLinkedInItemsPeople> | Array<SearchLinkedInItemsCompany> | Array<SearchLinkedInItemsJob>;
+    paging: SearchLinkedInPaging;
+    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;
+};
+/**
+ * Sort order. 'relevance' (default) returns the most relevant posts. 'date' returns the most recent posts first.
+ */
+export declare const SearchLinkedInPostsSortBy: {
+    readonly Relevance: "relevance";
+    readonly Date: "date";
+};
+/**
+ * Sort order. 'relevance' (default) returns the most relevant posts. 'date' returns the most recent posts first.
+ */
+export type SearchLinkedInPostsSortBy = ClosedEnum<typeof SearchLinkedInPostsSortBy>;
+/**
+ * Filter by publication date. Useful for finding recent discussions or trending topics.
+ */
+export declare const SearchLinkedInPostsDatePosted: {
+    readonly Past24h: "past-24h";
+    readonly PastWeek: "past-week";
+    readonly PastMonth: "past-month";
+};
+/**
+ * Filter by publication date. Useful for finding recent discussions or trending topics.
+ */
+export type SearchLinkedInPostsDatePosted = ClosedEnum<typeof SearchLinkedInPostsDatePosted>;
+/**
+ * Filter by media type. Only return posts that contain the specified media. 'images' = photo posts, 'videos' = video posts, 'documents' = carousel/PDF posts.
+ */
+export declare const SearchLinkedInPostsContentType: {
+    readonly Images: "images";
+    readonly Videos: "videos";
+    readonly Documents: "documents";
+};
+/**
+ * Filter by media type. Only return posts that contain the specified media. 'images' = photo posts, 'videos' = video posts, 'documents' = carousel/PDF posts.
+ */
+export type SearchLinkedInPostsContentType = ClosedEnum<typeof SearchLinkedInPostsContentType>;
+export type SearchLinkedInPostsRequest = {
+    /**
+     * Search keywords (required). Searches across post text content. Supports LinkedIn Boolean syntax: use double quotes for exact phrases (e.g. "AI automation"), AND to require both terms, OR for alternatives (e.g. "growth hacking" OR "growth marketing"), NOT to exclude (e.g. outreach NOT webinar), and parentheses to group (e.g. (AI OR ML) AND "case study"). Operators must be UPPERCASE. Without quotes, multi-word queries are treated as AND by default which may return broad results.
+     */
+    keywords: string;
+    /**
+     * Optional LinkedIn search URL. If provided, keywords and filters are extracted from the URL. Explicit params override URL-derived values.
+     */
+    url?: string | undefined;
+    /**
+     * Sort order. 'relevance' (default) returns the most relevant posts. 'date' returns the most recent posts first.
+     */
+    sortBy?: SearchLinkedInPostsSortBy | undefined;
+    /**
+     * Filter by publication date. Useful for finding recent discussions or trending topics.
+     */
+    datePosted?: SearchLinkedInPostsDatePosted | undefined;
+    /**
+     * Filter by media type. Only return posts that contain the specified media. 'images' = photo posts, 'videos' = video posts, 'documents' = carousel/PDF posts.
+     */
+    contentType?: SearchLinkedInPostsContentType | undefined;
+    /**
+     * Filter by the post author's industry. Array of LinkedIn industry IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='INDUSTRY'. Example: resolve 'Technology' to get industry IDs.
+     */
+    authorIndustry?: Array<string> | undefined;
+    /**
+     * Filter by the post author's company. Array of LinkedIn company IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='COMPANY'. Example: resolve 'Google' to get company ID '1441'.
+     */
+    authorCompany?: Array<string> | undefined;
+    /**
+     * Pagination offset (default 0). Use multiples of `count` to page through results. Example: start=0 for page 1, start=10 for page 2 (with count=10).
+     */
+    start?: number | undefined;
+    /**
+     * Results per page (default 10, max 50). Controls how many posts are returned per request.
+     */
+    count?: number | undefined;
+};
+export declare const SearchLinkedInPostsCategory: {
+    readonly Posts: "posts";
+};
+export type SearchLinkedInPostsCategory = ClosedEnum<typeof SearchLinkedInPostsCategory>;
+export declare const SearchLinkedInPostsType: {
+    readonly Post: "POST";
+};
+export type SearchLinkedInPostsType = ClosedEnum<typeof SearchLinkedInPostsType>;
+export type SearchLinkedInPostsAuthor = {
+    name: string;
+    profileUrl: string | null;
+    headline: string | null;
+    profilePicture: string | null;
+    isCompany: boolean;
+};
+export type SearchLinkedInPostsItem = {
+    type: SearchLinkedInPostsType;
+    postUrl: string;
+    text: string;
+    date: number;
+    likesCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    postUrn: string;
+    postId: string;
+    author: SearchLinkedInPostsAuthor;
+    isRepost: boolean;
+};
+export type SearchLinkedInPostsPaging = {
+    start: number;
+    count: number;
+    total: number;
+};
+/**
+ * List of LinkedIn posts matching the search criteria
+ */
+export type SearchLinkedInPostsResponse = {
+    success: boolean;
+    category: SearchLinkedInPostsCategory;
+    items: Array<SearchLinkedInPostsItem>;
+    paging: SearchLinkedInPostsPaging;
+    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;
+};
+export declare const SearchLinkedInPeopleConnectionDegree: {
+    readonly F: "F";
+    readonly S: "S";
+    readonly O: "O";
+};
+export type SearchLinkedInPeopleConnectionDegree = ClosedEnum<typeof SearchLinkedInPeopleConnectionDegree>;
+export type SearchLinkedInPeopleRequest = {
+    /**
+     * Search keywords. Matches against name, headline, company, skills, and bio. Optional — you can search by filters alone (e.g. all 2nd-degree connections in Paris). Supports LinkedIn Boolean syntax: use double quotes for exact phrases (e.g. "product manager"), AND to require both terms, OR for alternatives (e.g. CEO OR founder OR CTO), NOT to exclude (e.g. manager NOT assistant), and parentheses to group (e.g. (CEO OR CTO) AND SaaS). Operators must be UPPERCASE.
+     */
+    keywords?: string | undefined;
+    /**
+     * Optional LinkedIn search URL. If provided, keywords and filters are extracted from the URL. Explicit params override URL-derived values.
+     */
+    url?: string | undefined;
+    /**
+     * Filter by connection degree. 'F' = 1st degree (your direct connections), 'S' = 2nd degree (connections of connections), 'O' = 3rd+ degree and out of network. Accepts multiple values, e.g. ['F','S'] for 1st and 2nd degree.
+     */
+    connectionDegree?: Array<SearchLinkedInPeopleConnectionDegree> | undefined;
+    /**
+     * Filter by first name. Exact match (case-insensitive).
+     */
+    firstName?: string | undefined;
+    /**
+     * Filter by last name. Exact match (case-insensitive).
+     */
+    lastName?: string | undefined;
+    /**
+     * Filter by current job title. Matches against the person's current position title. Supports boolean OR syntax with '|' separator. Example: 'CEO|CTO|Founder' finds people with any of these titles.
+     */
+    title?: string | undefined;
+    /**
+     * Find connections of a specific person. Pass the person's LinkedIn profile URN (e.g. 'urn:li:fsd_profile:ACoAABZ0Qo4B...'). Returns people who are connected to this person.
+     */
+    connectionOf?: string | undefined;
+    /**
+     * Filter by LinkedIn profile language. Array of ISO 639-1 codes. Example: ['en'] for English profiles, ['en','fr'] for English or French profiles.
+     */
+    profileLanguage?: Array<string> | undefined;
+    /**
+     * Filter by school/university. Array of LinkedIn school IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='SCHOOL'. Example: resolve 'Harvard' to get school IDs.
+     */
+    school?: Array<string> | undefined;
+    /**
+     * Filter by geographic location. Array of LinkedIn geo IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='GEO'. Example: resolve 'San Francisco' → '102277331'.
+     */
+    location?: Array<string> | undefined;
+    /**
+     * Filter by industry. Array of LinkedIn industry IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='INDUSTRY'.
+     */
+    industry?: Array<string> | undefined;
+    /**
+     * Filter by current employer. Array of LinkedIn company IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='COMPANY'. Example: resolve 'Google' → '1441'.
+     */
+    currentCompany?: Array<string> | undefined;
+    /**
+     * Filter by past employer. Array of LinkedIn company IDs. Finds people who previously worked at these companies.
+     */
+    pastCompany?: Array<string> | undefined;
+    /**
+     * Pagination offset (default 0). Use multiples of `count` to page through results.
+     */
+    start?: number | undefined;
+    /**
+     * Results per page (default 10, max 50).
+     */
+    count?: number | undefined;
+};
+export declare const SearchLinkedInPeopleCategory: {
+    readonly People: "people";
+};
+export type SearchLinkedInPeopleCategory = ClosedEnum<typeof SearchLinkedInPeopleCategory>;
+export declare const SearchLinkedInPeopleType: {
+    readonly People: "PEOPLE";
+};
+export type SearchLinkedInPeopleType = ClosedEnum<typeof SearchLinkedInPeopleType>;
+export declare const SearchLinkedInPeopleNetworkDistance: {
+    readonly Distance1: "DISTANCE_1";
+    readonly Distance2: "DISTANCE_2";
+    readonly Distance3: "DISTANCE_3";
+    readonly OutOfNetwork: "OUT_OF_NETWORK";
+};
+export type SearchLinkedInPeopleNetworkDistance = OpenEnum<typeof SearchLinkedInPeopleNetworkDistance>;
+export type SearchLinkedInPeopleCurrentPosition = {
+    company: string | null;
+    role: string | null;
+};
+export type SearchLinkedInPeopleItem = {
+    type: SearchLinkedInPeopleType;
+    name: string;
+    profileUrl: string;
+    headline: string | null;
+    location: string | null;
+    profilePicture: string | null;
+    networkDistance: SearchLinkedInPeopleNetworkDistance | null;
+    currentPositions: Array<SearchLinkedInPeopleCurrentPosition>;
+};
+export type SearchLinkedInPeoplePaging = {
+    start: number;
+    count: number;
+    total: number;
+};
+/**
+ * List of LinkedIn people matching the search criteria
+ */
+export type SearchLinkedInPeopleResponse = {
+    success: boolean;
+    category: SearchLinkedInPeopleCategory;
+    items: Array<SearchLinkedInPeopleItem>;
+    paging: SearchLinkedInPeoplePaging;
+    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;
+};
+export declare const SearchLinkedInCompaniesCompanySize: {
+    readonly A: "A";
+    readonly B: "B";
+    readonly C: "C";
+    readonly D: "D";
+    readonly E: "E";
+    readonly F: "F";
+    readonly G: "G";
+    readonly H: "H";
+    readonly I: "I";
+};
+export type SearchLinkedInCompaniesCompanySize = ClosedEnum<typeof SearchLinkedInCompaniesCompanySize>;
+export type SearchLinkedInCompaniesRequest = {
+    /**
+     * Search keywords. Matches against company name, description, and specialties. Optional — you can search by filters alone. Supports LinkedIn Boolean syntax: use double quotes for exact phrases (e.g. "artificial intelligence"), AND to require both terms, OR for alternatives (e.g. SaaS OR "cloud computing"), NOT to exclude (e.g. consulting NOT staffing), and parentheses to group (e.g. (AI OR ML) AND healthcare). Operators must be UPPERCASE.
+     */
+    keywords?: string | undefined;
+    /**
+     * Optional LinkedIn search URL. If provided, keywords and filters are extracted from the URL. Explicit params override URL-derived values.
+     */
+    url?: string | undefined;
+    /**
+     * Filter by company HQ location. Array of LinkedIn geo IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='GEO'.
+     */
+    location?: Array<string> | undefined;
+    /**
+     * Filter by company industry. Array of LinkedIn industry IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='INDUSTRY'.
+     */
+    industry?: Array<string> | undefined;
+    /**
+     * Filter by employee count. Multiple values accepted (OR logic). Codes: A=1-10 employees, B=11-50, C=51-200, D=201-500, E=501-1,000, F=1,001-5,000, G=5,001-10,000, H=10,001+, I=Self-employed.
+     */
+    companySize?: Array<SearchLinkedInCompaniesCompanySize> | undefined;
+    /**
+     * Pagination offset (default 0). Use multiples of `count` to page through results.
+     */
+    start?: number | undefined;
+    /**
+     * Results per page (default 10, max 50).
+     */
+    count?: number | undefined;
+};
+export declare const SearchLinkedInCompaniesCategory: {
+    readonly Companies: "companies";
+};
+export type SearchLinkedInCompaniesCategory = ClosedEnum<typeof SearchLinkedInCompaniesCategory>;
+export declare const SearchLinkedInCompaniesType: {
+    readonly Company: "COMPANY";
+};
+export type SearchLinkedInCompaniesType = ClosedEnum<typeof SearchLinkedInCompaniesType>;
+export type SearchLinkedInCompaniesItem = {
+    type: SearchLinkedInCompaniesType;
+    name: string;
+    profileUrl: string;
+    summary: string | null;
+    industry: string | null;
+    location: string | null;
+    followersCount: number | null;
+};
+export type SearchLinkedInCompaniesPaging = {
+    start: number;
+    count: number;
+    total: number;
+};
+/**
+ * List of LinkedIn companies matching the search criteria
+ */
+export type SearchLinkedInCompaniesResponse = {
+    success: boolean;
+    category: SearchLinkedInCompaniesCategory;
+    items: Array<SearchLinkedInCompaniesItem>;
+    paging: SearchLinkedInCompaniesPaging;
+    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;
+};
+/**
+ * Filter by posting date. Useful for finding recently posted jobs.
+ */
+export declare const SearchLinkedInJobsDatePosted: {
+    readonly Past24h: "past-24h";
+    readonly PastWeek: "past-week";
+    readonly PastMonth: "past-month";
+};
+/**
+ * Filter by posting date. Useful for finding recently posted jobs.
+ */
+export type SearchLinkedInJobsDatePosted = ClosedEnum<typeof SearchLinkedInJobsDatePosted>;
+/**
+ * Sort order. 'relevance' (default) or 'date' (most recent first).
+ */
+export declare const SearchLinkedInJobsSortBy: {
+    readonly Relevance: "relevance";
+    readonly Date: "date";
+};
+/**
+ * Sort order. 'relevance' (default) or 'date' (most recent first).
+ */
+export type SearchLinkedInJobsSortBy = ClosedEnum<typeof SearchLinkedInJobsSortBy>;
+export declare const SearchLinkedInJobsJobType: {
+    readonly F: "F";
+    readonly P: "P";
+    readonly C: "C";
+    readonly T: "T";
+    readonly I: "I";
+    readonly V: "V";
+    readonly O: "O";
+};
+export type SearchLinkedInJobsJobType = ClosedEnum<typeof SearchLinkedInJobsJobType>;
+export declare const SearchLinkedInJobsExperienceLevel: {
+    readonly One: "1";
+    readonly Two: "2";
+    readonly Three: "3";
+    readonly Four: "4";
+    readonly Five: "5";
+    readonly Six: "6";
+};
+export type SearchLinkedInJobsExperienceLevel = ClosedEnum<typeof SearchLinkedInJobsExperienceLevel>;
+export declare const SearchLinkedInJobsWorkplaceType: {
+    readonly One: "1";
+    readonly Two: "2";
+    readonly Three: "3";
+};
+export type SearchLinkedInJobsWorkplaceType = ClosedEnum<typeof SearchLinkedInJobsWorkplaceType>;
+export type SearchLinkedInJobsRequest = {
+    /**
+     * Search keywords. Matches against job title, company name, and description. Optional — you can search by filters alone. Supports LinkedIn Boolean syntax: use double quotes for exact phrases (e.g. "frontend engineer"), AND to require both terms, OR for alternatives (e.g. React OR Vue OR Angular), NOT to exclude (e.g. engineer NOT intern), and parentheses to group (e.g. (React OR Vue) AND "senior engineer"). Operators must be UPPERCASE.
+     */
+    keywords?: string | undefined;
+    /**
+     * Optional LinkedIn search URL. If provided, keywords and filters are extracted from the URL. Explicit params override URL-derived values.
+     */
+    url?: string | undefined;
+    /**
+     * Filter by job location. Array of LinkedIn geo IDs. Resolve text to IDs via POST /search/linkedin/parameters with type='GEO'.
+     */
+    location?: Array<string> | undefined;
+    /**
+     * Filter by posting date. Useful for finding recently posted jobs.
+     */
+    datePosted?: SearchLinkedInJobsDatePosted | undefined;
+    /**
+     * Sort order. 'relevance' (default) or 'date' (most recent first).
+     */
+    sortBy?: SearchLinkedInJobsSortBy | undefined;
+    /**
+     * Filter by employment type. Multiple values accepted (OR logic). Codes: F=Full-time, P=Part-time, C=Contract, T=Temporary, I=Internship, V=Volunteer, O=Other.
+     */
+    jobType?: Array<SearchLinkedInJobsJobType> | undefined;
+    /**
+     * Filter by seniority. Multiple values accepted (OR logic). Codes: 1=Internship, 2=Entry level, 3=Associate, 4=Mid-Senior level, 5=Director, 6=Executive.
+     */
+    experienceLevel?: Array<SearchLinkedInJobsExperienceLevel> | undefined;
+    /**
+     * Filter by workplace type. Multiple values accepted (OR logic). Codes: 1=On-site, 2=Remote, 3=Hybrid.
+     */
+    workplaceType?: Array<SearchLinkedInJobsWorkplaceType> | undefined;
+    /**
+     * Pagination offset (default 0). Use multiples of `count` to page through results.
+     */
+    start?: number | undefined;
+    /**
+     * Results per page (default 10, max 50).
+     */
+    count?: number | undefined;
+};
+export declare const SearchLinkedInJobsCategory: {
+    readonly Jobs: "jobs";
+};
+export type SearchLinkedInJobsCategory = ClosedEnum<typeof SearchLinkedInJobsCategory>;
+export declare const SearchLinkedInJobsType: {
+    readonly Job: "JOB";
+};
+export type SearchLinkedInJobsType = ClosedEnum<typeof SearchLinkedInJobsType>;
+export type SearchLinkedInJobsItem = {
+    type: SearchLinkedInJobsType;
+    title: string;
+    company: string | null;
+    companyUrl: string | null;
+    companyLogo: string | null;
+    location: string | null;
+    workplaceType: string | null;
+    postedAt: string | null;
+    jobUrl: string;
+    listingId: string;
+};
+export type SearchLinkedInJobsPaging = {
+    start: number;
+    count: number;
+    total: number;
+};
+/**
+ * List of LinkedIn job listings matching the search criteria
+ */
+export type SearchLinkedInJobsResponse = {
+    success: boolean;
+    category: SearchLinkedInJobsCategory;
+    items: Array<SearchLinkedInJobsItem>;
+    paging: SearchLinkedInJobsPaging;
+    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;
+};
+export type SearchLinkedInByUrlRequest = {
+    /**
+     * A LinkedIn search URL. The endpoint automatically extracts the category, keywords, and all filters from the URL. Example: 'https://www.linkedin.com/search/results/people/?keywords=engineer&network=%5B%22S%22%5D'
+     */
+    url: string;
+    /**
+     * Override pagination offset. If not provided, uses the page from the URL (or defaults to 0).
+     */
+    start?: number | undefined;
+    /**
+     * Override results per page (default 10, max 50).
+     */
+    count?: number | undefined;
+};
+export declare const SearchLinkedInByUrlCategory: {
+    readonly Posts: "posts";
+    readonly People: "people";
+    readonly Companies: "companies";
+    readonly Jobs: "jobs";
+};
+export type SearchLinkedInByUrlCategory = OpenEnum<typeof SearchLinkedInByUrlCategory>;
+export declare const SearchLinkedInByUrlTypeJob: {
+    readonly Job: "JOB";
+};
+export type SearchLinkedInByUrlTypeJob = ClosedEnum<typeof SearchLinkedInByUrlTypeJob>;
+export type SearchLinkedInByUrlItemsJob = {
+    type: SearchLinkedInByUrlTypeJob;
+    title: string;
+    company: string | null;
+    companyUrl: string | null;
+    companyLogo: string | null;
+    location: string | null;
+    workplaceType: string | null;
+    postedAt: string | null;
+    jobUrl: string;
+    listingId: string;
+};
+export declare const SearchLinkedInByUrlTypeCompany: {
+    readonly Company: "COMPANY";
+};
+export type SearchLinkedInByUrlTypeCompany = ClosedEnum<typeof SearchLinkedInByUrlTypeCompany>;
+export type SearchLinkedInByUrlItemsCompany = {
+    type: SearchLinkedInByUrlTypeCompany;
+    name: string;
+    profileUrl: string;
+    summary: string | null;
+    industry: string | null;
+    location: string | null;
+    followersCount: number | null;
+};
+export declare const SearchLinkedInByUrlTypePeople: {
+    readonly People: "PEOPLE";
+};
+export type SearchLinkedInByUrlTypePeople = ClosedEnum<typeof SearchLinkedInByUrlTypePeople>;
+export declare const SearchLinkedInByUrlNetworkDistance: {
+    readonly Distance1: "DISTANCE_1";
+    readonly Distance2: "DISTANCE_2";
+    readonly Distance3: "DISTANCE_3";
+    readonly OutOfNetwork: "OUT_OF_NETWORK";
+};
+export type SearchLinkedInByUrlNetworkDistance = OpenEnum<typeof SearchLinkedInByUrlNetworkDistance>;
+export type SearchLinkedInByUrlCurrentPosition = {
+    company: string | null;
+    role: string | null;
+};
+export type SearchLinkedInByUrlItemsPeople = {
+    type: SearchLinkedInByUrlTypePeople;
+    name: string;
+    profileUrl: string;
+    headline: string | null;
+    location: string | null;
+    profilePicture: string | null;
+    networkDistance: SearchLinkedInByUrlNetworkDistance | null;
+    currentPositions: Array<SearchLinkedInByUrlCurrentPosition>;
+};
+export declare const SearchLinkedInByUrlTypePost: {
+    readonly Post: "POST";
+};
+export type SearchLinkedInByUrlTypePost = ClosedEnum<typeof SearchLinkedInByUrlTypePost>;
+export type SearchLinkedInByUrlAuthor = {
+    name: string;
+    profileUrl: string | null;
+    headline: string | null;
+    profilePicture: string | null;
+    isCompany: boolean;
+};
+export type SearchLinkedInByUrlItemsPost = {
+    type: SearchLinkedInByUrlTypePost;
+    postUrl: string;
+    text: string;
+    date: number;
+    likesCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    postUrn: string;
+    postId: string;
+    author: SearchLinkedInByUrlAuthor;
+    isRepost: boolean;
+};
+export type SearchLinkedInByUrlItemsUnion = Array<SearchLinkedInByUrlItemsPost> | Array<SearchLinkedInByUrlItemsPeople> | Array<SearchLinkedInByUrlItemsCompany> | Array<SearchLinkedInByUrlItemsJob>;
+export type SearchLinkedInByUrlPaging = {
+    start: number;
+    count: number;
+    total: number;
+};
+/**
+ * Search results parsed from the LinkedIn URL
+ */
+export type SearchLinkedInByUrlResponse = {
+    success: boolean;
+    category: SearchLinkedInByUrlCategory;
+    items: Array<SearchLinkedInByUrlItemsPost> | Array<SearchLinkedInByUrlItemsPeople> | Array<SearchLinkedInByUrlItemsCompany> | Array<SearchLinkedInByUrlItemsJob>;
+    paging: SearchLinkedInByUrlPaging;
+    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;
+};
+/**
+ * Parameter type to resolve
+ */
+export declare const ResolveLinkedInSearchParametersType: {
+    readonly Geo: "GEO";
+    readonly Company: "COMPANY";
+    readonly Industry: "INDUSTRY";
+    readonly School: "SCHOOL";
+    readonly Connections: "CONNECTIONS";
+    readonly People: "PEOPLE";
+};
+/**
+ * Parameter type to resolve
+ */
+export type ResolveLinkedInSearchParametersType = ClosedEnum<typeof ResolveLinkedInSearchParametersType>;
+export type ResolveLinkedInSearchParametersRequest = {
+    /**
+     * Parameter type to resolve
+     */
+    type: ResolveLinkedInSearchParametersType;
+    /**
+     * Text to resolve into LinkedIn IDs
+     */
+    keywords: string;
+    /**
+     * Max results (default 10, max 50)
+     */
+    limit?: number | undefined;
+};
+export type ResolveLinkedInSearchParametersItem = {
+    id: string;
+    title: string;
+    type: string;
+};
+/**
+ * Resolved search parameter items
+ */
+export type ResolveLinkedInSearchParametersResponse = {
+    success: boolean;
+    items: Array<ResolveLinkedInSearchParametersItem>;
+    count: number;
+    /**
+     * 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 ConnectLinkedInProfileRequest = {
+    /**
+     * LinkedIn profile URL (e.g., 'https://www.linkedin.com/in/username') or profile URN (e.g., 'urn:li:fsd_profile:ACoAABZ0Qo4B6pt58d4FVmts1F7TPi4D1-uL1fw')
+     */
+    profile: string;
+    /**
+     * Campaign identifier for deduplication. Dedup by profile 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;
+};
+/**
+ * Connection request sent successfully
+ */
+export type ConnectLinkedInProfileResponse = {
+    success: boolean;
+    message: string;
+    /**
+     * True if a connection request was already successfully sent to this profile this week
+     */
+    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 ListLinkedInInvitationsRequest = {
+    /**
+     * Pagination offset (0-based)
+     */
+    start?: number | undefined;
+    /**
+     * Number of invitations to return (max 100)
+     */
+    count?: number | undefined;
+};
+/**
+ * Profile info of the person who sent the invitation
+ */
+export type FromMember = {
+    name?: string | null | undefined;
+    headline?: string | null | undefined;
+    profileUrl?: string | null | undefined;
+    profilePicture?: string | null | undefined;
+};
+export type Invitation = {
+    /**
+     * Invitation ID needed for accepting
+     */
+    invitationId: string;
+    /**
+     * Shared secret needed for accepting
+     */
+    sharedSecret: string;
+    /**
+     * Full invitation URN
+     */
+    entityUrn: string;
+    /**
+     * ISO 8601 timestamp when invitation was sent
+     */
+    sentAt?: string | null | undefined;
+    /**
+     * Custom message included with the invitation
+     */
+    message?: string | null | undefined;
+    /**
+     * Sender's profile ID (pass to accept endpoint)
+     */
+    senderProfileId?: string | null | undefined;
+    /**
+     * Sender's first name (pass to accept endpoint)
+     */
+    senderFirstName?: string | null | undefined;
+    /**
+     * Sender's last name (pass to accept endpoint)
+     */
+    senderLastName?: string | null | undefined;
+    /**
+     * Profile info of the person who sent the invitation
+     */
+    fromMember?: FromMember | null | undefined;
+};
+/**
+ * List of pending invitations
+ */
+export type ListLinkedInInvitationsResponse = {
+    success: boolean;
+    invitations: Array<Invitation>;
+    /**
+     * Total number of pending invitations
+     */
+    total: number;
+    start: number;
+    count: number;
+    /**
+     * 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 AcceptLinkedInInvitationRequest = {
+    /**
+     * Invitation ID (from the list invitations endpoint)
+     */
+    invitationId: string;
+    /**
+     * Shared secret / validation token (from the list invitations endpoint)
+     */
+    sharedSecret: string;
+    /**
+     * Sender's profile ID (from the list invitations endpoint, e.g. 'ACoAAB6pI5sB...'). Recommended for reliability.
+     */
+    senderProfileId?: string | undefined;
+    /**
+     * Sender's first name (from the list invitations endpoint). Recommended for reliability.
+     */
+    firstName?: string | undefined;
+    /**
+     * Sender's last name (from the list invitations endpoint). Recommended for reliability.
+     */
+    lastName?: string | undefined;
+};
+/**
+ * Invitation accepted successfully
+ */
+export type AcceptLinkedInInvitationResponse = {
+    success: boolean;
+    message: string;
+    /**
+     * 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 SendLinkedInMessageRequest = {
+    /**
+     * LinkedIn profile URL (e.g., 'https://www.linkedin.com/in/username') or profile URN (e.g., 'urn:li:member:123456')
+     */
+    profile: string;
+    /**
+     * Message content to send
+     */
+    message: string;
+    /**
+     * Campaign identifier for deduplication. Dedup by profile 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;
+};
+/**
+ * Message sent successfully
+ */
+export type SendLinkedInMessageResponse = {
+    success: boolean;
+    messageId: string;
+    /**
+     * 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;
+};
+/** @internal */
+export type CollectLinkedInLikesRequest$Outbound = {
+    postUrl: string;
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const CollectLinkedInLikesRequest$outboundSchema: z.ZodMiniType<CollectLinkedInLikesRequest$Outbound, CollectLinkedInLikesRequest>;
+export declare function collectLinkedInLikesRequestToJSON(collectLinkedInLikesRequest: CollectLinkedInLikesRequest): string;
+/** @internal */
+export declare const CollectLinkedInLikesInternalServerErrorDetails$inboundSchema: z.ZodMiniType<CollectLinkedInLikesInternalServerErrorDetails, unknown>;
+export declare function collectLinkedInLikesInternalServerErrorDetailsFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesInternalServerErrorDetails, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesInternalServerErrorError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesInternalServerErrorError, unknown>;
+export declare function collectLinkedInLikesInternalServerErrorErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesInternalServerErrorError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesCode$inboundSchema: z.ZodMiniEnum<typeof CollectLinkedInLikesCode>;
+/** @internal */
+export declare const CollectLinkedInLikesDaily$inboundSchema: z.ZodMiniType<CollectLinkedInLikesDaily, unknown>;
+export declare function collectLinkedInLikesDailyFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesDaily, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesWeekly$inboundSchema: z.ZodMiniType<CollectLinkedInLikesWeekly, unknown>;
+export declare function collectLinkedInLikesWeeklyFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesWeekly, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesTooManyRequestsError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesTooManyRequestsError, unknown>;
+export declare function collectLinkedInLikesTooManyRequestsErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesTooManyRequestsError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesUnprocessableEntityDetails$inboundSchema: z.ZodMiniType<CollectLinkedInLikesUnprocessableEntityDetails, unknown>;
+export declare function collectLinkedInLikesUnprocessableEntityDetailsFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesUnprocessableEntityDetails, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesUnprocessableEntityError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesUnprocessableEntityError, unknown>;
+export declare function collectLinkedInLikesUnprocessableEntityErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesUnprocessableEntityError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesGoneDetails$inboundSchema: z.ZodMiniType<CollectLinkedInLikesGoneDetails, unknown>;
+export declare function collectLinkedInLikesGoneDetailsFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesGoneDetails, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesGoneError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesGoneError, unknown>;
+export declare function collectLinkedInLikesGoneErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesGoneError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesConflictDetails$inboundSchema: z.ZodMiniType<CollectLinkedInLikesConflictDetails, unknown>;
+export declare function collectLinkedInLikesConflictDetailsFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesConflictDetails, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesConflictError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesConflictError, unknown>;
+export declare function collectLinkedInLikesConflictErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesConflictError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesNotFoundDetails$inboundSchema: z.ZodMiniType<CollectLinkedInLikesNotFoundDetails, unknown>;
+export declare function collectLinkedInLikesNotFoundDetailsFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesNotFoundDetails, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesNotFoundError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesNotFoundError, unknown>;
+export declare function collectLinkedInLikesNotFoundErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesNotFoundError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesForbiddenDetails$inboundSchema: z.ZodMiniType<CollectLinkedInLikesForbiddenDetails, unknown>;
+export declare function collectLinkedInLikesForbiddenDetailsFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesForbiddenDetails, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesForbiddenError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesForbiddenError, unknown>;
+export declare function collectLinkedInLikesForbiddenErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesForbiddenError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesUnauthorizedDetails$inboundSchema: z.ZodMiniType<CollectLinkedInLikesUnauthorizedDetails, unknown>;
+export declare function collectLinkedInLikesUnauthorizedDetailsFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesUnauthorizedDetails, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesUnauthorizedError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesUnauthorizedError, unknown>;
+export declare function collectLinkedInLikesUnauthorizedErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesUnauthorizedError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesBadRequestDetails$inboundSchema: z.ZodMiniType<CollectLinkedInLikesBadRequestDetails, unknown>;
+export declare function collectLinkedInLikesBadRequestDetailsFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesBadRequestDetails, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesBadRequestError$inboundSchema: z.ZodMiniType<CollectLinkedInLikesBadRequestError, unknown>;
+export declare function collectLinkedInLikesBadRequestErrorFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesBadRequestError, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesType$inboundSchema: z.ZodMiniEnum<typeof CollectLinkedInLikesType>;
+/** @internal */
+export declare const CollectLinkedInLikesProfile$inboundSchema: z.ZodMiniType<CollectLinkedInLikesProfile, unknown>;
+export declare function collectLinkedInLikesProfileFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesProfile, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInLikesResponse$inboundSchema: z.ZodMiniType<CollectLinkedInLikesResponse, unknown>;
+export declare function collectLinkedInLikesResponseFromJSON(jsonString: string): SafeParseResult<CollectLinkedInLikesResponse, SDKValidationError>;
+/** @internal */
+export type CollectLinkedInCommentsRequest$Outbound = {
+    postUrl: string;
+    start?: number | undefined;
+    count?: number | undefined;
+    campaignSlug?: string | undefined;
+};
+/** @internal */
+export declare const CollectLinkedInCommentsRequest$outboundSchema: z.ZodMiniType<CollectLinkedInCommentsRequest$Outbound, CollectLinkedInCommentsRequest>;
+export declare function collectLinkedInCommentsRequestToJSON(collectLinkedInCommentsRequest: CollectLinkedInCommentsRequest): string;
+/** @internal */
+export declare const CollectLinkedInCommentsType$inboundSchema: z.ZodMiniEnum<typeof CollectLinkedInCommentsType>;
+/** @internal */
+export declare const CollectLinkedInCommentsActionsCompleted$inboundSchema: z.ZodMiniType<CollectLinkedInCommentsActionsCompleted, unknown>;
+export declare function collectLinkedInCommentsActionsCompletedFromJSON(jsonString: string): SafeParseResult<CollectLinkedInCommentsActionsCompleted, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInCommentsProfile$inboundSchema: z.ZodMiniType<CollectLinkedInCommentsProfile, unknown>;
+export declare function collectLinkedInCommentsProfileFromJSON(jsonString: string): SafeParseResult<CollectLinkedInCommentsProfile, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInCommentsResponse$inboundSchema: z.ZodMiniType<CollectLinkedInCommentsResponse, unknown>;
+export declare function collectLinkedInCommentsResponseFromJSON(jsonString: string): SafeParseResult<CollectLinkedInCommentsResponse, SDKValidationError>;
+/** @internal */
+export type CollectLinkedInCommentRepliesRequest$Outbound = {
+    commentUrn: string;
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const CollectLinkedInCommentRepliesRequest$outboundSchema: z.ZodMiniType<CollectLinkedInCommentRepliesRequest$Outbound, CollectLinkedInCommentRepliesRequest>;
+export declare function collectLinkedInCommentRepliesRequestToJSON(collectLinkedInCommentRepliesRequest: CollectLinkedInCommentRepliesRequest): string;
+/** @internal */
+export declare const CollectLinkedInCommentRepliesType$inboundSchema: z.ZodMiniEnum<typeof CollectLinkedInCommentRepliesType>;
+/** @internal */
+export declare const CollectLinkedInCommentRepliesActionsCompleted$inboundSchema: z.ZodMiniType<CollectLinkedInCommentRepliesActionsCompleted, unknown>;
+export declare function collectLinkedInCommentRepliesActionsCompletedFromJSON(jsonString: string): SafeParseResult<CollectLinkedInCommentRepliesActionsCompleted, SDKValidationError>;
+/** @internal */
+export declare const Reply$inboundSchema: z.ZodMiniType<Reply, unknown>;
+export declare function replyFromJSON(jsonString: string): SafeParseResult<Reply, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInCommentRepliesResponse$inboundSchema: z.ZodMiniType<CollectLinkedInCommentRepliesResponse, unknown>;
+export declare function collectLinkedInCommentRepliesResponseFromJSON(jsonString: string): SafeParseResult<CollectLinkedInCommentRepliesResponse, SDKValidationError>;
+/** @internal */
+export type CollectLinkedInPostsRequest$Outbound = {
+    profileUrl: string;
+    count?: number | undefined;
+    start?: number | undefined;
+    paginationToken?: string | undefined;
+};
+/** @internal */
+export declare const CollectLinkedInPostsRequest$outboundSchema: z.ZodMiniType<CollectLinkedInPostsRequest$Outbound, CollectLinkedInPostsRequest>;
+export declare function collectLinkedInPostsRequestToJSON(collectLinkedInPostsRequest: CollectLinkedInPostsRequest): string;
+/** @internal */
+export declare const CollectLinkedInPostsType$inboundSchema: z.ZodMiniType<CollectLinkedInPostsType, unknown>;
+/** @internal */
+export declare const CollectLinkedInPostsPost$inboundSchema: z.ZodMiniType<CollectLinkedInPostsPost, unknown>;
+export declare function collectLinkedInPostsPostFromJSON(jsonString: string): SafeParseResult<CollectLinkedInPostsPost, SDKValidationError>;
+/** @internal */
+export declare const CollectLinkedInPostsResponse$inboundSchema: z.ZodMiniType<CollectLinkedInPostsResponse, unknown>;
+export declare function collectLinkedInPostsResponseFromJSON(jsonString: string): SafeParseResult<CollectLinkedInPostsResponse, SDKValidationError>;
+/** @internal */
+export type VisitLinkedInProfileRequest$Outbound = {
+    profile: string;
+    campaignSlug?: string | undefined;
+    actionSlug?: string | undefined;
+    includePosts?: boolean | undefined;
+};
+/** @internal */
+export declare const VisitLinkedInProfileRequest$outboundSchema: z.ZodMiniType<VisitLinkedInProfileRequest$Outbound, VisitLinkedInProfileRequest>;
+export declare function visitLinkedInProfileRequestToJSON(visitLinkedInProfileRequest: VisitLinkedInProfileRequest): string;
+/** @internal */
+export declare const PendingConnection$inboundSchema: z.ZodMiniType<PendingConnection, unknown>;
+/** @internal */
+export declare const VisitLinkedInProfilePositionStartDate$inboundSchema: z.ZodMiniType<VisitLinkedInProfilePositionStartDate, unknown>;
+export declare function visitLinkedInProfilePositionStartDateFromJSON(jsonString: string): SafeParseResult<VisitLinkedInProfilePositionStartDate, SDKValidationError>;
+/** @internal */
+export declare const VisitLinkedInProfilePositionEndDate$inboundSchema: z.ZodMiniType<VisitLinkedInProfilePositionEndDate, unknown>;
+export declare function visitLinkedInProfilePositionEndDateFromJSON(jsonString: string): SafeParseResult<VisitLinkedInProfilePositionEndDate, SDKValidationError>;
+/** @internal */
+export declare const VisitLinkedInProfilePosition$inboundSchema: z.ZodMiniType<VisitLinkedInProfilePosition, unknown>;
+export declare function visitLinkedInProfilePositionFromJSON(jsonString: string): SafeParseResult<VisitLinkedInProfilePosition, SDKValidationError>;
+/** @internal */
+export declare const VisitLinkedInProfileEducationStartDate$inboundSchema: z.ZodMiniType<VisitLinkedInProfileEducationStartDate, unknown>;
+export declare function visitLinkedInProfileEducationStartDateFromJSON(jsonString: string): SafeParseResult<VisitLinkedInProfileEducationStartDate, SDKValidationError>;
+/** @internal */
+export declare const VisitLinkedInProfileEducationEndDate$inboundSchema: z.ZodMiniType<VisitLinkedInProfileEducationEndDate, unknown>;
+export declare function visitLinkedInProfileEducationEndDateFromJSON(jsonString: string): SafeParseResult<VisitLinkedInProfileEducationEndDate, SDKValidationError>;
+/** @internal */
+export declare const VisitLinkedInProfileEducation$inboundSchema: z.ZodMiniType<VisitLinkedInProfileEducation, unknown>;
+export declare function visitLinkedInProfileEducationFromJSON(jsonString: string): SafeParseResult<VisitLinkedInProfileEducation, SDKValidationError>;
+/** @internal */
+export declare const VisitLinkedInProfileType$inboundSchema: z.ZodMiniType<VisitLinkedInProfileType, unknown>;
+/** @internal */
+export declare const VisitLinkedInProfileLastPost$inboundSchema: z.ZodMiniType<VisitLinkedInProfileLastPost, unknown>;
+export declare function visitLinkedInProfileLastPostFromJSON(jsonString: string): SafeParseResult<VisitLinkedInProfileLastPost, SDKValidationError>;
+/** @internal */
+export declare const VisitLinkedInProfileResponse$inboundSchema: z.ZodMiniType<VisitLinkedInProfileResponse, unknown>;
+export declare function visitLinkedInProfileResponseFromJSON(jsonString: string): SafeParseResult<VisitLinkedInProfileResponse, SDKValidationError>;
+/** @internal */
+export type VisitLinkedInCompanyRequest$Outbound = {
+    companyUrl: string;
+    includeWorkplacePolicy?: boolean | undefined;
+};
+/** @internal */
+export declare const VisitLinkedInCompanyRequest$outboundSchema: z.ZodMiniType<VisitLinkedInCompanyRequest$Outbound, VisitLinkedInCompanyRequest>;
+export declare function visitLinkedInCompanyRequestToJSON(visitLinkedInCompanyRequest: VisitLinkedInCompanyRequest): string;
+/** @internal */
+export declare const EmployeeCountRange$inboundSchema: z.ZodMiniType<EmployeeCountRange, unknown>;
+export declare function employeeCountRangeFromJSON(jsonString: string): SafeParseResult<EmployeeCountRange, SDKValidationError>;
+/** @internal */
+export declare const Headquarter$inboundSchema: z.ZodMiniType<Headquarter, unknown>;
+export declare function headquarterFromJSON(jsonString: string): SafeParseResult<Headquarter, SDKValidationError>;
+/** @internal */
+export declare const FoundedOn$inboundSchema: z.ZodMiniType<FoundedOn, unknown>;
+export declare function foundedOnFromJSON(jsonString: string): SafeParseResult<FoundedOn, SDKValidationError>;
+/** @internal */
+export declare const CallToAction$inboundSchema: z.ZodMiniType<CallToAction, unknown>;
+export declare function callToActionFromJSON(jsonString: string): SafeParseResult<CallToAction, SDKValidationError>;
+/** @internal */
+export declare const AffiliatedCompany$inboundSchema: z.ZodMiniType<AffiliatedCompany, unknown>;
+export declare function affiliatedCompanyFromJSON(jsonString: string): SafeParseResult<AffiliatedCompany, SDKValidationError>;
+/** @internal */
+export declare const SimilarCompany$inboundSchema: z.ZodMiniType<SimilarCompany, unknown>;
+export declare function similarCompanyFromJSON(jsonString: string): SafeParseResult<SimilarCompany, SDKValidationError>;
+/** @internal */
+export declare const WorkplacePolicy$inboundSchema: z.ZodMiniType<WorkplacePolicy, unknown>;
+export declare function workplacePolicyFromJSON(jsonString: string): SafeParseResult<WorkplacePolicy, SDKValidationError>;
+/** @internal */
+export declare const VisitLinkedInCompanyResponse$inboundSchema: z.ZodMiniType<VisitLinkedInCompanyResponse, unknown>;
+export declare function visitLinkedInCompanyResponseFromJSON(jsonString: string): SafeParseResult<VisitLinkedInCompanyResponse, SDKValidationError>;
+/** @internal */
+export declare const CategoryRequest$outboundSchema: z.ZodMiniEnum<typeof CategoryRequest>;
+/** @internal */
+export declare const SearchLinkedInSortBy$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInSortBy>;
+/** @internal */
+export declare const SearchLinkedInDatePosted$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInDatePosted>;
+/** @internal */
+export declare const SearchLinkedInContentType$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInContentType>;
+/** @internal */
+export declare const SearchLinkedInConnectionDegree$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInConnectionDegree>;
+/** @internal */
+export declare const SearchLinkedInCompanySize$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInCompanySize>;
+/** @internal */
+export declare const SearchLinkedInJobType$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInJobType>;
+/** @internal */
+export declare const SearchLinkedInExperienceLevel$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInExperienceLevel>;
+/** @internal */
+export declare const SearchLinkedInWorkplaceType$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInWorkplaceType>;
+/** @internal */
+export type SearchLinkedInRequest$Outbound = {
+    category?: string | undefined;
+    url?: string | undefined;
+    keywords?: string | undefined;
+    sortBy?: string | undefined;
+    datePosted?: string | undefined;
+    contentType?: string | undefined;
+    authorIndustry?: Array<string> | undefined;
+    authorCompany?: Array<string> | undefined;
+    connectionDegree?: Array<string> | undefined;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    title?: string | undefined;
+    connectionOf?: string | undefined;
+    profileLanguage?: Array<string> | undefined;
+    school?: Array<string> | undefined;
+    location?: Array<string> | undefined;
+    industry?: Array<string> | undefined;
+    currentCompany?: Array<string> | undefined;
+    pastCompany?: Array<string> | undefined;
+    companySize?: Array<string> | undefined;
+    jobType?: Array<string> | undefined;
+    experienceLevel?: Array<string> | undefined;
+    workplaceType?: Array<string> | undefined;
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const SearchLinkedInRequest$outboundSchema: z.ZodMiniType<SearchLinkedInRequest$Outbound, SearchLinkedInRequest>;
+export declare function searchLinkedInRequestToJSON(searchLinkedInRequest: SearchLinkedInRequest): string;
+/** @internal */
+export declare const SearchLinkedInCategoryResponseBody$inboundSchema: z.ZodMiniType<SearchLinkedInCategoryResponseBody, unknown>;
+/** @internal */
+export declare const SearchLinkedInTypeJob$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInTypeJob>;
+/** @internal */
+export declare const SearchLinkedInItemsJob$inboundSchema: z.ZodMiniType<SearchLinkedInItemsJob, unknown>;
+export declare function searchLinkedInItemsJobFromJSON(jsonString: string): SafeParseResult<SearchLinkedInItemsJob, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInTypeCompany$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInTypeCompany>;
+/** @internal */
+export declare const SearchLinkedInItemsCompany$inboundSchema: z.ZodMiniType<SearchLinkedInItemsCompany, unknown>;
+export declare function searchLinkedInItemsCompanyFromJSON(jsonString: string): SafeParseResult<SearchLinkedInItemsCompany, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInTypePeople$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInTypePeople>;
+/** @internal */
+export declare const SearchLinkedInNetworkDistance$inboundSchema: z.ZodMiniType<SearchLinkedInNetworkDistance, unknown>;
+/** @internal */
+export declare const SearchLinkedInCurrentPosition$inboundSchema: z.ZodMiniType<SearchLinkedInCurrentPosition, unknown>;
+export declare function searchLinkedInCurrentPositionFromJSON(jsonString: string): SafeParseResult<SearchLinkedInCurrentPosition, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInItemsPeople$inboundSchema: z.ZodMiniType<SearchLinkedInItemsPeople, unknown>;
+export declare function searchLinkedInItemsPeopleFromJSON(jsonString: string): SafeParseResult<SearchLinkedInItemsPeople, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInTypePost$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInTypePost>;
+/** @internal */
+export declare const SearchLinkedInAuthor$inboundSchema: z.ZodMiniType<SearchLinkedInAuthor, unknown>;
+export declare function searchLinkedInAuthorFromJSON(jsonString: string): SafeParseResult<SearchLinkedInAuthor, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInItemsPost$inboundSchema: z.ZodMiniType<SearchLinkedInItemsPost, unknown>;
+export declare function searchLinkedInItemsPostFromJSON(jsonString: string): SafeParseResult<SearchLinkedInItemsPost, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInItemsUnion$inboundSchema: z.ZodMiniType<SearchLinkedInItemsUnion, unknown>;
+export declare function searchLinkedInItemsUnionFromJSON(jsonString: string): SafeParseResult<SearchLinkedInItemsUnion, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPaging$inboundSchema: z.ZodMiniType<SearchLinkedInPaging, unknown>;
+export declare function searchLinkedInPagingFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPaging, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInResponse$inboundSchema: z.ZodMiniType<SearchLinkedInResponse, unknown>;
+export declare function searchLinkedInResponseFromJSON(jsonString: string): SafeParseResult<SearchLinkedInResponse, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPostsSortBy$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInPostsSortBy>;
+/** @internal */
+export declare const SearchLinkedInPostsDatePosted$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInPostsDatePosted>;
+/** @internal */
+export declare const SearchLinkedInPostsContentType$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInPostsContentType>;
+/** @internal */
+export type SearchLinkedInPostsRequest$Outbound = {
+    keywords: string;
+    url?: string | undefined;
+    sortBy?: string | undefined;
+    datePosted?: string | undefined;
+    contentType?: string | undefined;
+    authorIndustry?: Array<string> | undefined;
+    authorCompany?: Array<string> | undefined;
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const SearchLinkedInPostsRequest$outboundSchema: z.ZodMiniType<SearchLinkedInPostsRequest$Outbound, SearchLinkedInPostsRequest>;
+export declare function searchLinkedInPostsRequestToJSON(searchLinkedInPostsRequest: SearchLinkedInPostsRequest): string;
+/** @internal */
+export declare const SearchLinkedInPostsCategory$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInPostsCategory>;
+/** @internal */
+export declare const SearchLinkedInPostsType$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInPostsType>;
+/** @internal */
+export declare const SearchLinkedInPostsAuthor$inboundSchema: z.ZodMiniType<SearchLinkedInPostsAuthor, unknown>;
+export declare function searchLinkedInPostsAuthorFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPostsAuthor, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPostsItem$inboundSchema: z.ZodMiniType<SearchLinkedInPostsItem, unknown>;
+export declare function searchLinkedInPostsItemFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPostsItem, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPostsPaging$inboundSchema: z.ZodMiniType<SearchLinkedInPostsPaging, unknown>;
+export declare function searchLinkedInPostsPagingFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPostsPaging, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPostsResponse$inboundSchema: z.ZodMiniType<SearchLinkedInPostsResponse, unknown>;
+export declare function searchLinkedInPostsResponseFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPostsResponse, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPeopleConnectionDegree$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInPeopleConnectionDegree>;
+/** @internal */
+export type SearchLinkedInPeopleRequest$Outbound = {
+    keywords?: string | undefined;
+    url?: string | undefined;
+    connectionDegree?: Array<string> | undefined;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    title?: string | undefined;
+    connectionOf?: string | undefined;
+    profileLanguage?: Array<string> | undefined;
+    school?: Array<string> | undefined;
+    location?: Array<string> | undefined;
+    industry?: Array<string> | undefined;
+    currentCompany?: Array<string> | undefined;
+    pastCompany?: Array<string> | undefined;
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const SearchLinkedInPeopleRequest$outboundSchema: z.ZodMiniType<SearchLinkedInPeopleRequest$Outbound, SearchLinkedInPeopleRequest>;
+export declare function searchLinkedInPeopleRequestToJSON(searchLinkedInPeopleRequest: SearchLinkedInPeopleRequest): string;
+/** @internal */
+export declare const SearchLinkedInPeopleCategory$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInPeopleCategory>;
+/** @internal */
+export declare const SearchLinkedInPeopleType$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInPeopleType>;
+/** @internal */
+export declare const SearchLinkedInPeopleNetworkDistance$inboundSchema: z.ZodMiniType<SearchLinkedInPeopleNetworkDistance, unknown>;
+/** @internal */
+export declare const SearchLinkedInPeopleCurrentPosition$inboundSchema: z.ZodMiniType<SearchLinkedInPeopleCurrentPosition, unknown>;
+export declare function searchLinkedInPeopleCurrentPositionFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPeopleCurrentPosition, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPeopleItem$inboundSchema: z.ZodMiniType<SearchLinkedInPeopleItem, unknown>;
+export declare function searchLinkedInPeopleItemFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPeopleItem, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPeoplePaging$inboundSchema: z.ZodMiniType<SearchLinkedInPeoplePaging, unknown>;
+export declare function searchLinkedInPeoplePagingFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPeoplePaging, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInPeopleResponse$inboundSchema: z.ZodMiniType<SearchLinkedInPeopleResponse, unknown>;
+export declare function searchLinkedInPeopleResponseFromJSON(jsonString: string): SafeParseResult<SearchLinkedInPeopleResponse, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInCompaniesCompanySize$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInCompaniesCompanySize>;
+/** @internal */
+export type SearchLinkedInCompaniesRequest$Outbound = {
+    keywords?: string | undefined;
+    url?: string | undefined;
+    location?: Array<string> | undefined;
+    industry?: Array<string> | undefined;
+    companySize?: Array<string> | undefined;
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const SearchLinkedInCompaniesRequest$outboundSchema: z.ZodMiniType<SearchLinkedInCompaniesRequest$Outbound, SearchLinkedInCompaniesRequest>;
+export declare function searchLinkedInCompaniesRequestToJSON(searchLinkedInCompaniesRequest: SearchLinkedInCompaniesRequest): string;
+/** @internal */
+export declare const SearchLinkedInCompaniesCategory$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInCompaniesCategory>;
+/** @internal */
+export declare const SearchLinkedInCompaniesType$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInCompaniesType>;
+/** @internal */
+export declare const SearchLinkedInCompaniesItem$inboundSchema: z.ZodMiniType<SearchLinkedInCompaniesItem, unknown>;
+export declare function searchLinkedInCompaniesItemFromJSON(jsonString: string): SafeParseResult<SearchLinkedInCompaniesItem, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInCompaniesPaging$inboundSchema: z.ZodMiniType<SearchLinkedInCompaniesPaging, unknown>;
+export declare function searchLinkedInCompaniesPagingFromJSON(jsonString: string): SafeParseResult<SearchLinkedInCompaniesPaging, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInCompaniesResponse$inboundSchema: z.ZodMiniType<SearchLinkedInCompaniesResponse, unknown>;
+export declare function searchLinkedInCompaniesResponseFromJSON(jsonString: string): SafeParseResult<SearchLinkedInCompaniesResponse, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInJobsDatePosted$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInJobsDatePosted>;
+/** @internal */
+export declare const SearchLinkedInJobsSortBy$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInJobsSortBy>;
+/** @internal */
+export declare const SearchLinkedInJobsJobType$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInJobsJobType>;
+/** @internal */
+export declare const SearchLinkedInJobsExperienceLevel$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInJobsExperienceLevel>;
+/** @internal */
+export declare const SearchLinkedInJobsWorkplaceType$outboundSchema: z.ZodMiniEnum<typeof SearchLinkedInJobsWorkplaceType>;
+/** @internal */
+export type SearchLinkedInJobsRequest$Outbound = {
+    keywords?: string | undefined;
+    url?: string | undefined;
+    location?: Array<string> | undefined;
+    datePosted?: string | undefined;
+    sortBy?: string | undefined;
+    jobType?: Array<string> | undefined;
+    experienceLevel?: Array<string> | undefined;
+    workplaceType?: Array<string> | undefined;
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const SearchLinkedInJobsRequest$outboundSchema: z.ZodMiniType<SearchLinkedInJobsRequest$Outbound, SearchLinkedInJobsRequest>;
+export declare function searchLinkedInJobsRequestToJSON(searchLinkedInJobsRequest: SearchLinkedInJobsRequest): string;
+/** @internal */
+export declare const SearchLinkedInJobsCategory$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInJobsCategory>;
+/** @internal */
+export declare const SearchLinkedInJobsType$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInJobsType>;
+/** @internal */
+export declare const SearchLinkedInJobsItem$inboundSchema: z.ZodMiniType<SearchLinkedInJobsItem, unknown>;
+export declare function searchLinkedInJobsItemFromJSON(jsonString: string): SafeParseResult<SearchLinkedInJobsItem, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInJobsPaging$inboundSchema: z.ZodMiniType<SearchLinkedInJobsPaging, unknown>;
+export declare function searchLinkedInJobsPagingFromJSON(jsonString: string): SafeParseResult<SearchLinkedInJobsPaging, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInJobsResponse$inboundSchema: z.ZodMiniType<SearchLinkedInJobsResponse, unknown>;
+export declare function searchLinkedInJobsResponseFromJSON(jsonString: string): SafeParseResult<SearchLinkedInJobsResponse, SDKValidationError>;
+/** @internal */
+export type SearchLinkedInByUrlRequest$Outbound = {
+    url: string;
+    start?: number | undefined;
+    count?: number | undefined;
+};
+/** @internal */
+export declare const SearchLinkedInByUrlRequest$outboundSchema: z.ZodMiniType<SearchLinkedInByUrlRequest$Outbound, SearchLinkedInByUrlRequest>;
+export declare function searchLinkedInByUrlRequestToJSON(searchLinkedInByUrlRequest: SearchLinkedInByUrlRequest): string;
+/** @internal */
+export declare const SearchLinkedInByUrlCategory$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlCategory, unknown>;
+/** @internal */
+export declare const SearchLinkedInByUrlTypeJob$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInByUrlTypeJob>;
+/** @internal */
+export declare const SearchLinkedInByUrlItemsJob$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlItemsJob, unknown>;
+export declare function searchLinkedInByUrlItemsJobFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlItemsJob, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInByUrlTypeCompany$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInByUrlTypeCompany>;
+/** @internal */
+export declare const SearchLinkedInByUrlItemsCompany$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlItemsCompany, unknown>;
+export declare function searchLinkedInByUrlItemsCompanyFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlItemsCompany, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInByUrlTypePeople$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInByUrlTypePeople>;
+/** @internal */
+export declare const SearchLinkedInByUrlNetworkDistance$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlNetworkDistance, unknown>;
+/** @internal */
+export declare const SearchLinkedInByUrlCurrentPosition$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlCurrentPosition, unknown>;
+export declare function searchLinkedInByUrlCurrentPositionFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlCurrentPosition, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInByUrlItemsPeople$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlItemsPeople, unknown>;
+export declare function searchLinkedInByUrlItemsPeopleFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlItemsPeople, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInByUrlTypePost$inboundSchema: z.ZodMiniEnum<typeof SearchLinkedInByUrlTypePost>;
+/** @internal */
+export declare const SearchLinkedInByUrlAuthor$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlAuthor, unknown>;
+export declare function searchLinkedInByUrlAuthorFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlAuthor, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInByUrlItemsPost$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlItemsPost, unknown>;
+export declare function searchLinkedInByUrlItemsPostFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlItemsPost, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInByUrlItemsUnion$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlItemsUnion, unknown>;
+export declare function searchLinkedInByUrlItemsUnionFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlItemsUnion, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInByUrlPaging$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlPaging, unknown>;
+export declare function searchLinkedInByUrlPagingFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlPaging, SDKValidationError>;
+/** @internal */
+export declare const SearchLinkedInByUrlResponse$inboundSchema: z.ZodMiniType<SearchLinkedInByUrlResponse, unknown>;
+export declare function searchLinkedInByUrlResponseFromJSON(jsonString: string): SafeParseResult<SearchLinkedInByUrlResponse, SDKValidationError>;
+/** @internal */
+export declare const ResolveLinkedInSearchParametersType$outboundSchema: z.ZodMiniEnum<typeof ResolveLinkedInSearchParametersType>;
+/** @internal */
+export type ResolveLinkedInSearchParametersRequest$Outbound = {
+    type: string;
+    keywords: string;
+    limit?: number | undefined;
+};
+/** @internal */
+export declare const ResolveLinkedInSearchParametersRequest$outboundSchema: z.ZodMiniType<ResolveLinkedInSearchParametersRequest$Outbound, ResolveLinkedInSearchParametersRequest>;
+export declare function resolveLinkedInSearchParametersRequestToJSON(resolveLinkedInSearchParametersRequest: ResolveLinkedInSearchParametersRequest): string;
+/** @internal */
+export declare const ResolveLinkedInSearchParametersItem$inboundSchema: z.ZodMiniType<ResolveLinkedInSearchParametersItem, unknown>;
+export declare function resolveLinkedInSearchParametersItemFromJSON(jsonString: string): SafeParseResult<ResolveLinkedInSearchParametersItem, SDKValidationError>;
+/** @internal */
+export declare const ResolveLinkedInSearchParametersResponse$inboundSchema: z.ZodMiniType<ResolveLinkedInSearchParametersResponse, unknown>;
+export declare function resolveLinkedInSearchParametersResponseFromJSON(jsonString: string): SafeParseResult<ResolveLinkedInSearchParametersResponse, SDKValidationError>;
+/** @internal */
+export type ConnectLinkedInProfileRequest$Outbound = {
+    profile: string;
+    campaignSlug?: string | undefined;
+    actionSlug?: string | undefined;
+};
+/** @internal */
+export declare const ConnectLinkedInProfileRequest$outboundSchema: z.ZodMiniType<ConnectLinkedInProfileRequest$Outbound, ConnectLinkedInProfileRequest>;
+export declare function connectLinkedInProfileRequestToJSON(connectLinkedInProfileRequest: ConnectLinkedInProfileRequest): string;
+/** @internal */
+export declare const ConnectLinkedInProfileResponse$inboundSchema: z.ZodMiniType<ConnectLinkedInProfileResponse, unknown>;
+export declare function connectLinkedInProfileResponseFromJSON(jsonString: string): SafeParseResult<ConnectLinkedInProfileResponse, SDKValidationError>;
+/** @internal */
+export type ListLinkedInInvitationsRequest$Outbound = {
+    start: number;
+    count: number;
+};
+/** @internal */
+export declare const ListLinkedInInvitationsRequest$outboundSchema: z.ZodMiniType<ListLinkedInInvitationsRequest$Outbound, ListLinkedInInvitationsRequest>;
+export declare function listLinkedInInvitationsRequestToJSON(listLinkedInInvitationsRequest: ListLinkedInInvitationsRequest): string;
+/** @internal */
+export declare const FromMember$inboundSchema: z.ZodMiniType<FromMember, unknown>;
+export declare function fromMemberFromJSON(jsonString: string): SafeParseResult<FromMember, SDKValidationError>;
+/** @internal */
+export declare const Invitation$inboundSchema: z.ZodMiniType<Invitation, unknown>;
+export declare function invitationFromJSON(jsonString: string): SafeParseResult<Invitation, SDKValidationError>;
+/** @internal */
+export declare const ListLinkedInInvitationsResponse$inboundSchema: z.ZodMiniType<ListLinkedInInvitationsResponse, unknown>;
+export declare function listLinkedInInvitationsResponseFromJSON(jsonString: string): SafeParseResult<ListLinkedInInvitationsResponse, SDKValidationError>;
+/** @internal */
+export type AcceptLinkedInInvitationRequest$Outbound = {
+    invitationId: string;
+    sharedSecret: string;
+    senderProfileId?: string | undefined;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+};
+/** @internal */
+export declare const AcceptLinkedInInvitationRequest$outboundSchema: z.ZodMiniType<AcceptLinkedInInvitationRequest$Outbound, AcceptLinkedInInvitationRequest>;
+export declare function acceptLinkedInInvitationRequestToJSON(acceptLinkedInInvitationRequest: AcceptLinkedInInvitationRequest): string;
+/** @internal */
+export declare const AcceptLinkedInInvitationResponse$inboundSchema: z.ZodMiniType<AcceptLinkedInInvitationResponse, unknown>;
+export declare function acceptLinkedInInvitationResponseFromJSON(jsonString: string): SafeParseResult<AcceptLinkedInInvitationResponse, SDKValidationError>;
+/** @internal */
+export type SendLinkedInMessageRequest$Outbound = {
+    profile: string;
+    message: string;
+    campaignSlug?: string | undefined;
+    actionSlug?: string | undefined;
+};
+/** @internal */
+export declare const SendLinkedInMessageRequest$outboundSchema: z.ZodMiniType<SendLinkedInMessageRequest$Outbound, SendLinkedInMessageRequest>;
+export declare function sendLinkedInMessageRequestToJSON(sendLinkedInMessageRequest: SendLinkedInMessageRequest): string;
+/** @internal */
+export declare const SendLinkedInMessageResponse$inboundSchema: z.ZodMiniType<SendLinkedInMessageResponse, unknown>;
+export declare function sendLinkedInMessageResponseFromJSON(jsonString: string): SafeParseResult<SendLinkedInMessageResponse, SDKValidationError>;
+//# sourceMappingURL=send-linked-in-message-response.d.ts.map