import { S as Schemas, c as components } from './_spec-EgN7VmAI.mjs';
import { F as FetchOptions, S as StorageMode, B as BoardRequest, A as Awaitable, L as Logger, a as BoardClient, b as SearchSuggestQuery } from './search-DKS7OIn2.mjs';
export { c as ACCESS_TOKEN_KEY, d as BOARD_ACCESS_GRANT_KEY, C as CompanySuggestion, e as CustomStorage, M as MarketSuggestion, R as REFRESH_TOKEN_KEY, f as SearchSuggestType, g as SuggestResult, h as SuggestionItem, T as TermSuggestion } from './search-DKS7OIn2.mjs';
import { c as CompaniesListQuery, d as CompanyListEnvelope, e as CompaniesSearchBody, f as CompanyJobsListQuery, g as CompanySimilarQuery, h as CompanyMarketsListQuery, i as SalaryDetailQuery } from './board-q0svBKW3.mjs';
export { a as CompanyCategorySalary, j as CompanyMarket, k as CompanyMarketRef, b as CompanySalary, l as CompanySalarySummary, C as CustomFieldDefinition, m as CustomFieldOption, n as CustomFieldType, L as LocationSalaryDetail, o as LocationSkillsIndex, p as LocationTitlesIndex, P as PublicBoard, q as PublicBoardAds, r as PublicBoardAnalytics, s as PublicBoardFeatures, t as PublicBoardJobForm, u as PublicCompany, v as PublicCompanyDetail, w as PublicCompanyMembership, x as SalaryCompany, y as SalaryLocation, z as SalarySkill, A as SalaryTitle, B as SkillLocationSalary, D as SkillLocationsIndex, S as SkillSalaryDetail, E as TitleLocationSalary, F as TitleLocationsIndex, T as TitleSalaryDetail } from './board-q0svBKW3.mjs';
export { B as BoardSeo } from './seo-CI3wLKUW.mjs';
import { R as RemoteOption, E as EmploymentType, S as Seniority, L as ListEnvelope, a as JobsListQuery, b as JobCardListEnvelope, c as JobsSearchBody, d as JobCardSearchEnvelope, e as JobsSimilarQuery, f as SearchEnvelope } from './jobs-CfrxlDMU.mjs';
export { g as CustomFieldValue, C as CustomFieldValues, h as EducationRequirement, i as JobCatalogPagination, j as JobCompany, J as JobSort, O as OfficeLocation, k as OffsetPagination, P as PublicJob, l as PublicJobCard, m as RelatedSearch, n as RemotePermit, o as RemoteTimezone, p as StorefrontPagination } from './jobs-CfrxlDMU.mjs';
import { a as BlogPostsListQuery, b as BlogSimilarQuery, c as BlogSearchBody } from './blog-T7gQ0ciz.mjs';
export { B as BlogAuthorEmbed, d as BlogTagEmbed, e as PublicBlogAdjacentPosts, f as PublicBlogAuthor, g as PublicBlogPost, P as PublicBlogPostSummary, h as PublicBlogTag } from './blog-T7gQ0ciz.mjs';

/**
 * Well-known `<domain>_<snake_reason>` codes the Board API sends, grouped by
 * surface — the catalog for i18n lookup tables and error tracking. Drift-gated
 * against the v1 API source (`error-codes.test.ts`).
 *
 * Deliberately NOT exhaustive-by-type: new codes MAY ship within v1
 * (additive, per `01-conventions.md` §11.3), so `BoardApiErrorCode` keeps
 * plain strings assignable while still autocompleting the known set.
 * `unknown_error` is SDK-synthesized when a response carries no parseable
 * envelope.
 */
declare const BOARD_API_ERROR_CODES: readonly ["internal_error", "validation_bad_request", "validation_payload_too_large", "rate_limited", "rate_limit_unavailable", "search_unavailable", "too_many_filter_values", "pagination_invalid_cursor", "pagination_offset_too_large", "auth_unauthenticated", "auth_forbidden", "plan_upgrade_required", "unknown_error", "boards_not_found", "board_page_not_found", "board_auth_account_not_found", "board_auth_email_taken", "board_auth_invalid_credentials", "board_auth_invalid_token", "board_auth_registration_disabled", "board_auth_token_expired", "invalid_current_password", "no_password", "same_email", "email_taken", "invalid_token", "board_password_required", "board_password_invalid", "jobs_not_found", "jobs_invalid_filter", "categories_not_found", "skills_not_found", "places_not_found", "companies_not_found", "company_markets_not_found", "company_salary_not_found", "company_category_salary_not_found", "salaries_title_not_found", "salaries_skill_not_found", "salaries_location_not_found", "salaries_title_location_not_found", "salaries_skill_location_not_found", "blog_post_not_found", "blog_author_not_found", "blog_tag_not_found", "talent_not_found", "talent_directory_not_found", "talent_directory_restricted", "job_recommendations_not_found", "recommended_talent_not_found", "job_alert_not_found", "job_alerts_disabled", "candidate_alert_limit_reached", "candidate_alert_not_found", "candidate_entry_not_found", "candidate_handle_taken", "candidate_job_not_found", "candidate_notification_preference_paused", "resume_invalid_file", "resume_upload_forbidden", "applications_external_apply_only", "applications_country_not_allowed", "applications_guest_not_allowed", "applications_job_not_found", "applications_not_found", "applications_resume_invalid_file", "applications_unprocessable", "messaging_application_not_found", "messaging_application_not_linked", "messaging_blocked", "messaging_cannot_block_self", "messaging_cold_rule", "messaging_conversation_not_found", "messaging_disabled", "messaging_edit_window_expired", "messaging_message_deleted", "messaging_message_not_found", "messaging_not_author", "messaging_not_participant", "messaging_not_permitted", "messaging_not_recipient", "messaging_rate_limited", "messaging_recipient_not_found", "messaging_recipient_not_open", "messaging_unsend_window_expired", "employer_applicant_not_found", "employer_ats_unprocessable", "employer_checkout_failed", "employer_company_exists", "employer_free_email_website", "employer_company_name_taken", "employer_company_not_found", "employer_job_not_found", "employer_job_slug_taken", "employer_jobs_quota_exceeded", "membership_required", "employer_not_member", "employer_payment_required", "employer_pipeline_stage_not_found", "employer_member_not_found", "employer_invite_not_found", "not_company_admin", "not_company_member", "company_deletion_disabled", "last_admin", "already_member", "already_invited", "invalid_email", "invite_email_mismatch", "candidate_role", "job_not_published", "talent_list_not_found", "sourced_candidate_not_found", "sourced_convert_unavailable", "candidate_paywall_access_required", "paywall_already_active", "paywall_disabled", "paywall_invalid_checkout_session", "paywall_no_candidate_profile", "paywall_no_recurring_subscription", "paywall_offer_not_found", "talent_access_unavailable", "company_required", "already_on_plan", "talent_access_required", "messaging_talent_access_required", "stripe_not_connected", "membership_plan_not_found", "membership_seat_taken", "job_posting_logo_lookup_unavailable", "job_posting_logo_not_found", "job_posting_rejected"];
/**
 * The known code set plus open string — new codes ship additively within v1,
 * so exhaustive narrowing is intentionally impossible.
 */
type BoardApiErrorCode = (typeof BOARD_API_ERROR_CODES)[number] | (string & {});
/**
 * Error raised for every non-2xx Board API response.
 *
 * Carries the complete v1 error envelope (`01-conventions.md` §5.2):
 * `{ error: { code, message, details?, requestId } }` — nothing is
 * discarded, so callers never need to string-match messages.
 *
 * @example
 * try {
 *   await board.jobs.retrieve('senior-chef');
 * } catch (e) {
 *   if (isNotFound(e)) showEmptyState();
 *   else throw e;
 * }
 */
declare class BoardApiError extends Error {
    readonly status: number;
    /** `<domain>_<snake_reason>` code from the v1 error envelope. */
    readonly code: BoardApiErrorCode;
    /** Structured, per-code details — shape varies by `code`. */
    readonly details?: unknown;
    readonly requestId?: string;
    /** The parsed response body, untouched. */
    readonly raw: unknown;
    constructor(input: {
        status: number;
        code: string;
        message: string;
        details?: unknown;
        requestId?: string;
        raw: unknown;
    });
}
/**
 * Structural, not `instanceof`: the helper subpaths (`/server`, …) and the
 * core entry build as separate bundles, so class identity differs across
 * entries — `instanceof` would silently return false for a real
 * `BoardApiError` thrown by the core client. The constructor pins
 * `name = 'BoardApiError'`, making the name check a stable brand for every
 * guard built on this one.
 */
declare function isBoardApiError(e: unknown): e is BoardApiError;
declare function isNotFound(e: unknown): e is BoardApiError;
declare function isUnauthorized(e: unknown): e is BoardApiError;
/**
 * The board is password-protected and the read carried no valid `X-Board-Access`
 * grant. Distinct from an expired board-USER token (also 401): this code means
 * "call `password.verify()` again to mint a fresh grant", not "re-login".
 */
declare function isBoardPasswordRequired(e: unknown): e is BoardApiError;
declare function isForbidden(e: unknown): e is BoardApiError;
declare function isValidationError(e: unknown): e is BoardApiError;
declare function isRateLimited(e: unknown): e is BoardApiError;
declare function isConflict(e: unknown): e is BoardApiError;
/**
 * Create/update rejected because the company website is a free / consumer
 * email provider domain (`employer_free_email_website`). Distinct from a
 * generic 409 conflict — callers should prompt for a real company website
 * (or omit website), not retry the same domain.
 */
declare function isFreeEmailWebsiteError(e: unknown): e is BoardApiError;

/** The minimal page shape every v1 list/search envelope satisfies. */
interface PageShape {
    hasMore: boolean;
    nextCursor: string | null;
    data: unknown[];
}
type ItemOf<P extends PageShape> = P['data'][number];
interface Paginator<P extends PageShape> extends AsyncIterable<ItemOf<P>> {
    /** Iterate raw page envelopes instead of items. */
    pages(): AsyncGenerator<P, void, undefined>;
    /**
     * Collect items into an array, fetching pages only until `limit` items are
     * gathered. The cap is required — an unbounded collect over a large board
     * (tens of thousands of jobs) is an out-of-memory foot-gun.
     *
     * The cap bounds ITEMS collected, not the per-request page size — that is
     * the `limit` in the list QUERY. Collecting 500 items at the API's default
     * page size means many round trips; pass a page size too:
     * `paginate(board.jobs.list, { limit: 100 }).toArray({ limit: 500 })`.
     */
    toArray(opts: {
        limit: number;
    }): Promise<ItemOf<P>[]>;
}
/**
 * Walk a paginated list method to exhaustion — `for await` over items or
 * pages, echoing the opaque `nextCursor` forward per `01-conventions.md` §7
 * until `hasMore` is `false`.
 *
 * Works with any SDK list/search method (or a closure over one, for methods
 * that take a leading id/slug). Cursor iteration order is stable only under
 * an explicit sort/query — see the jobs skill.
 *
 * `offset` is honored for the FIRST page only and dropped afterwards: on
 * job catalog reads let `offset` take precedence over `cursor`, so carrying it
 * forward would re-serve the same page forever.
 *
 * @example
 * // every published job, one page of 100 at a time
 * for await (const card of paginate(board.jobs.list, { limit: 100 })) {
 *   urls.push(card.links.public);
 * }
 *
 * @example
 * // raw pages (e.g. sitemap bucketing); leading-arg methods via a closure
 * const pager = paginate((q, o) => board.companies.listJobs('acme', q, o));
 * for await (const page of pager.pages()) { … }
 *
 * @example
 * // toArray's limit caps ITEMS; the query limit sets the PAGE size —
 * // pass both, or 500 items arrive at the default page size (many trips).
 * const first500 = await paginate(board.companies.list, { limit: 100 })
 *   .toArray({ limit: 500 });
 */
declare function paginate<Q extends Record<string, unknown>, P extends PageShape>(listFn: (query?: Q, options?: FetchOptions) => Promise<P>, query?: Q, options?: FetchOptions): Paginator<P>;

/**
 * Kept in lockstep with the package.json `version` field — guarded by
 * version.test.ts, which fails the suite on any drift. A hand-written
 * constant because the package is platform-neutral and cannot read
 * package.json at runtime.
 */
declare const SDK_VERSION = "4.26.0";

type SavedJob = Schemas['SavedJob'];
type SavedJobsListQuery = {
    cursor?: string;
    /** 1–100. */
    limit?: number;
};
/** Personalized recommendation wrapper — embeds the slim job card. */
type RecommendedJob = Schemas['RecommendedJob'];
type RecommendedJobsListQuery = {
    /** Opaque position cursor from a previous page's `nextCursor`. */
    cursor?: string;
    /** 1–100. */
    limit?: number;
};
/**
 * Employer→candidate recommendation wrapper — embeds the same
 * `talent_directory_entry` card the public directory emits.
 *
 * The wrapper exists so typed `reasons` and a coarse `strength` band can land
 * later as MINOR additions rather than breaks. It will never carry a rank,
 * score, band, or ranker identity: order is the ranking. This is a sourcing
 * surface, not a screening one.
 */
type RecommendedTalent = Schemas['RecommendedTalent'];
type RecommendedTalentListQuery = {
    /** Required. The job to source candidates for; it must belong to `:slug`. */
    job: string;
    /** Opaque position cursor from a previous page's `nextCursor`. */
    cursor?: string;
    /** 1–100. */
    limit?: number;
};
type TalentListFilters = {
    q?: string;
    skill?: string;
    jobSearchStatus?: 'actively_looking' | 'open_to_offers' | 'not_looking';
    languages?: string[];
    openToRelocate?: boolean;
    place?: string;
    sort?: 'relevance' | 'newest';
    seniority?: string;
    permitCountry?: string;
    interestedRole?: string;
};
type TalentList = {
    id: string;
    object: 'talent_list';
    name: string;
    filters: TalentListFilters;
    jobId: string | null;
    createdBy: string;
    createdAt: number;
    updatedAt: number;
};
type CreateTalentListBody = {
    name: string;
    filters?: TalentListFilters;
    job?: string;
};
type UpdateTalentListBody = {
    name?: string;
    filters?: TalentListFilters;
    job?: string | null;
};
type SourcedCandidate = {
    id: string;
    object: 'sourced_candidate';
    candidate: Schemas['TalentDirectoryEntry'];
    sourcedAt: number;
    sourcedBy: string;
};
type AddSourcedCandidateBody = {
    job: string;
    candidateBoardUserId: string;
};
type ConvertSourcedCandidateBody = {
    stage: string;
};
type SaveJobBody = Schemas['SaveJobBody'];
/** The authenticated user's lean candidate profile singleton. */
type CandidateProfile = Schemas['CandidateProfile'];
/** Optional-field merge-patch body for `board.me.profile.update`. */
type UpdateCandidateProfileBody = Schemas['UpdateCandidateProfileBody'];
/** The result of `board.me.profile.handleAvailable(handle)`. */
type HandleAvailability = Schemas['HandleAvailability'];
type CandidateExperience = Schemas['CandidateExperience'];
type CreateExperienceBody = Schemas['CreateExperienceBody'];
type UpdateExperienceBody = Schemas['UpdateExperienceBody'];
type CandidateEducation = Schemas['CandidateEducation'];
type CreateEducationBody = Schemas['CreateEducationBody'];
type UpdateEducationBody = Schemas['UpdateEducationBody'];
type CandidateSkill = Schemas['CandidateSkill'];
type UpdateSkillsBody = Schemas['UpdateSkillsBody'];
type CandidateLanguage = Schemas['CandidateLanguage'];
type UpdateLanguagesBody = Schemas['UpdateLanguagesBody'];
/** The result of `board.me.profile.uploadAvatar(file)`. */
type CandidateAvatar = Schemas['CandidateAvatar'];
type NotificationPreference = Schemas['NotificationPreference'];
type UpdateNotificationPreferenceBody = Schemas['UpdateNotificationPreferenceBody'];
type UnsubscribeBody = Schemas['UnsubscribeBody'];
/** One inbox row — the counterparty identity is live-resolved. */
type Conversation = Schemas['Conversation'];
/** A conversation header — adds the viewer's role + last-read pointer. */
type ConversationDetail = Schemas['ConversationDetail'];
/** One message in a thread. `body` is `''` when unsent (tombstoned). */
type Message = Schemas['Message'];
/** The distinct-unread-thread count for the inbox badge. */
type UnreadCount = Schemas['UnreadCount'];
/** Query for `board.me.conversations.list`. */
type ConversationsListQuery = {
    /** `true` for the archived view; omit/false for the main inbox. */
    archived?: boolean;
    cursor?: string;
    /** 1–100. */
    limit?: number;
};
/** One of the authenticated board user's job-alert preferences. */
type Alert = Schemas['Alert'];
/** Create/replace body for `board.me.alerts.create` / `board.me.alerts.update`. */
type AlertBody = Schemas['AlertBody'];
/** The candidate's own view of an application they submitted. */
type Application = Schemas['Application'];
/** Body for `board.jobs.apply` (name/email omitted when signed in). */
type ApplyBody = Schemas['ApplyBody'];
/** Merge-patch body for `board.me.applications.updateFacts`. */
type UpdateApplicationFactsBody = Schemas['UpdateApplicationFactsBody'];
/** Query for `board.me.applications.list`. */
type ApplicationsListQuery = {
    cursor?: string;
    /** 1–100. */
    limit?: number;
};
/** Query for `board.me.conversations.listMessages`. */
type ThreadMessagesQuery = {
    cursor?: string;
    /** 1–200. */
    limit?: number;
};
/** Body for `board.me.conversations.start` (cold-initiate a candidate). */
type StartConversationBody = Schemas['StartConversationBody'];
/** Body for `board.me.conversations.startAboutApplication` (message an applicant). */
type StartAboutApplicationBody = Schemas['StartAboutApplicationBody'];
/** Body for `board.me.conversations.reply`. */
type ReplyBody = Schemas['ReplyBody'];
/** The result of `board.me.conversations.markRead`. */
type ReadReceipt = Schemas['ReadReceipt'];
/** The result of `board.me.conversations.{archive,unarchive}`. */
type ConversationArchive = Schemas['ConversationArchive'];
/** Body for `board.me.messages.edit`. */
type EditMessageBody = Schemas['EditMessageBody'];
/** Body for `board.me.messages.report`. */
type ReportBody = Schemas['ReportBody'];
/** The result of `board.me.messages.report` (with the auto-block outcome). */
type ModerationReport = Schemas['ModerationReport'];
/** One blocked user from `board.me.blocks.list`. */
type BlockedUser = Schemas['BlockedUser'];
/** Body for `board.me.blocks.create`. */
type BlockUserBody = Schemas['BlockUserBody'];
/** The result of `board.me.blocks.create`. */
type Block = Schemas['Block'];
/** The result of `board.me.blocks.status`. */
type BlockStatus = Schemas['BlockStatus'];
/** The result of `board.me.conversations.findExisting`. */
type ConversationRef = Schemas['ConversationRef'];
/** Query for `board.me.conversations.findExisting`. */
type FindExistingConversationQuery = {
    candidateBoardUserId: string;
};
/** The candidate's resume state (async parse status + stored file). */
type Resume = Schemas['Resume'];
/** Options for `board.me.resume.upload`. */
type ResumeUploadOptions = {
    keepResumeOnFile?: boolean;
    importMode?: 'append_only' | 'replace_all';
    confirmReplaceAll?: boolean;
};
/** The caller's tie to a company, with a computed claim `status`. */
type CompanyMembership = Schemas['CompanyMembership'];
/** The full editable company (`board.me.companies.update` echoes this). */
type EmployerCompany = Schemas['EmployerCompany'];
/** A search hit from `board.me.companies.search`. */
type ClaimableCompany = Schemas['ClaimableCompany'];
type CreateCompanyBody = Schemas['CreateCompanyBody'];
type UpdateEmployerCompanyBody = Schemas['UpdateEmployerCompanyBody'];
type SendWorkEmailBody = Schemas['SendWorkEmailBody'];
type ConfirmWorkEmailBody = Schemas['ConfirmWorkEmailBody'];
/** Body for `board.me.updatePassword`. */
type UpdatePasswordBody = Schemas['UpdatePasswordBody'];
/** Body for `board.me.requestEmailChange`. */
type RequestEmailChangeBody = Schemas['RequestEmailChangeBody'];
/** Body for `board.me.confirmEmailChange`. */
type ConfirmEmailChangeBody = Schemas['ConfirmEmailChangeBody'];
/** One approved company member from `board.me.companies.listMembers`. */
type CompanyMember = Schemas['CompanyMember'];
/** Body for `board.me.companies.updateMemberRole`. */
type UpdateCompanyMemberRoleBody = Schemas['UpdateCompanyMemberRoleBody'];
/** One pending company member invite from `board.me.companies.listInvites`. */
type CompanyMemberInvite = Schemas['CompanyMemberInvite'];
/** Body for `board.me.companies.createInvite`. */
type CreateCompanyMemberInviteBody = Schemas['CreateCompanyMemberInviteBody'];
/** Result of `board.me.acceptInvite`. */
type CompanyMemberInviteAcceptance = Schemas['CompanyMemberInviteAcceptance'];
/** Body for `board.me.acceptInvite`. */
type AcceptCompanyMemberInviteBody = Schemas['AcceptCompanyMemberInviteBody'];
/**
 * The viewer's per-employer talent entitlement from
 * `board.me.talentAccess.retrieve` — the talent-CTA signal (sourced from the
 * same subscription/credit-pack truth the talent paywall enforces), plus
 * charging model and remaining unlock/message credits.
 */
type TalentAccess = Schemas['TalentAccess'];
/** Per-candidate unlock/credit gate from `board.me.talentAccess.retrieveCandidate`. */
type TalentCandidateAccess = Schemas['TalentCandidateAccess'];
/** Body for `board.me.talentAccess.checkout`. */
type TalentAccessCheckoutBody = Schemas['TalentAccessCheckoutBody'];
/** Body for `board.me.talentAccess.claim`. */
type TalentAccessClaimBody = Schemas['TalentAccessClaimBody'];
/** Idempotent result from `board.me.talentAccess.claim`. */
type TalentAccessClaim = Schemas['TalentAccessClaim'];
/**
 * Connected-account mount kit from `board.me.talentAccess.checkout` — same
 * generated schema as candidate-access checkout (`origin: talent_access`).
 */
type TalentAccessCheckoutSession = Schemas['AccessCheckoutSession'];
/** Polled state of a talent-access checkout session (`board.me.talentAccess.retrieveCheckout`). */
type TalentAccessCheckoutSessionState = Schemas['AccessCheckoutSessionState'];
/** Body for `board.me.companies.startMembershipCheckout`. */
type MembershipCheckoutBody = Schemas['MembershipCheckoutBody'];
/**
 * Connected-account mount kit from `board.me.companies.startMembershipCheckout`
 * — same generated schema as talent-access checkout (`origin: membership`).
 */
type MembershipCheckoutSession = Schemas['AccessCheckoutSession'];
/** Polled state of a membership checkout session (`board.me.companies.retrieveMembershipCheckout`). */
type MembershipCheckoutSessionState = Schemas['AccessCheckoutSessionState'];
/** Result of `board.me.talentAccess.unlock`. */
type TalentUnlock = Schemas['TalentUnlock'];
/** Body for `board.me.talentAccess.unlock`. */
type TalentUnlockBody = Schemas['TalentUnlockBody'];
/** Body for `board.me.talentAccess.upgrade`. */
type TalentAccessUpgradeBody = Schemas['TalentAccessUpgradeBody'];
/**
 * Acknowledgement from `board.me.talentAccess.upgrade` — entitlement (new
 * credit counters) lands via webhook; re-read `me.talentAccess.retrieve`.
 */
type TalentAccessUpgrade = Schemas['TalentUpgrade'];
/** Query for `board.me.companies.search`. */
type EmployerCompanySearchQuery = {
    q: string;
    /** 1–50. */
    limit?: number;
};
/** Flat list-item shape from `board.me.companies.jobs.list`. */
type EmployerJobSummary = Schemas['EmployerJobSummary'];
/** The full job from `board.me.companies.jobs.retrieve` + every mutation echo. */
type EmployerJob = Schemas['EmployerJob'];
type CreateEmployerJobBody = Schemas['EmployerCreateJobBody'];
type UpdateEmployerJobBody = Schemas['EmployerUpdateJobBody'];
/** Query for `board.me.companies.jobs.list`. */
type EmployerJobsListQuery = {
    /** 1–200 (default 200). */
    limit?: number;
};
/**
 * One job's reporting funnel from `board.me.companies.jobStats.retrieve`.
 * `views` / `applyClicks` degrade to `0` when reporting data is temporarily
 * unavailable, so a `0` is "no activity" OR "analytics briefly unavailable".
 * `applications` is `null` for an external-apply job.
 */
type EmployerJobStat = Schemas['EmployerJobStat'];
/**
 * One daily bucket from `board.me.companies.jobStats.timeseries`, aggregated
 * across the company's jobs. Zero-filled over the window, ascending by date.
 */
type EmployerJobStatsPoint = Schemas['EmployerJobStatsPoint'];
/** Query for `board.me.companies.jobStats.timeseries`. */
type EmployerJobStatsTimeseriesQuery = {
    /** Inclusive window start (ISO 8601). Defaults to 30 days before `until`. */
    since?: string;
    /** Exclusive window end (ISO 8601). Defaults to now. */
    until?: string;
};
/**
 * The company-level profile-views summary from
 * `board.me.companies.profileStats.retrieve` — views of the company profile
 * page itself (`/companies/{slug}`, tabs and bots excluded). `profileViews`
 * degrades to `0` on an analytics outage.
 */
type EmployerProfileStats = Schemas['EmployerProfileStats'];
/**
 * One daily bucket from `board.me.companies.profileStats.timeseries`.
 * Zero-filled over the window, ascending by date.
 */
type EmployerProfileViewsPoint = Schemas['EmployerProfileViewsPoint'];
/** Query for `board.me.companies.profileStats.timeseries`. */
type EmployerProfileViewsTimeseriesQuery = {
    /** Inclusive window start (ISO 8601). Defaults to 30 days before `until`. */
    since?: string;
    /** Exclusive window end (ISO 8601). Defaults to now. */
    until?: string;
};
/** A job's full applicant pipeline (job header + stage rail + applicants). */
type EmployerPipeline = Schemas['EmployerPipeline'];
/** One applicant on a job's pipeline, with its activity timeline. */
type EmployerApplicant = Schemas['EmployerApplicant'];
/** One row of a job's stage rail. */
type EmployerPipelineStage = Schemas['EmployerPipelineStage'];
type MoveApplicantStageBody = Schemas['MoveApplicantStageBody'];
type BulkMoveApplicantsBody = Schemas['BulkMoveApplicantsBody'];
type BulkRejectApplicantsBody = Schemas['BulkRejectApplicantsBody'];
type AddApplicantNoteBody = Schemas['AddApplicantNoteBody'];
type CreatePipelineStageBody = Schemas['CreatePipelineStageBody'];
type UpdatePipelineStageBody = Schemas['UpdatePipelineStageBody'];
type ReorderPipelineStagesBody = Schemas['ReorderPipelineStagesBody'];
/** Query for `board.me.companies.applicants.list`. */
type EmployerPipelineQuery = {
    /** The job id whose pipeline to read. */
    job: string;
    /** Filter to a single stage (systemStage key, custom stage id, or `applied`). */
    stage?: string;
};
/** A reusable billing option (active subscription / pre-purchased bundle slot). */
type EmployerBillingOption = Schemas['EmployerBillingOption'];
/** The result of `board.me.companies.jobs.checkout`. */
type EmployerCheckout = Schemas['EmployerCheckout'];
type EmployerCheckoutBody = Schemas['EmployerCheckoutBody'];
/** Optional body for `board.me.companies.billingPortal.create`. */
type CompanyBillingPortalBody = Schemas['CompanyBillingPortalBody'];
/** A minted company Stripe Customer Portal session (job posting + talent access). */
type CompanyBillingPortalSession = Schemas['CompanyBillingPortalSession'];

/**
 * Pure derivations for a message thread — kept out of
 * components so the fiddly bits (own-vs-counterparty, the cold-message rule,
 * the seen target) are unit-testable without a DOM. A message is "own" when
 * its author is not the counterparty (works even before the counterparty has
 * ever replied).
 */

declare function isOwnMessage(message: Message, counterpartyId: string): boolean;
/**
 * The cold-message rule (client-side mirror of the server gate): the viewer
 * has sent at least one message and the counterparty has not replied yet.
 * Once the counterparty sends anything, the cap lifts. The server enforces
 * the rule authoritatively (`messaging_cold_rule` 403); this mirror exists
 * so the composer can disable itself instead of surfacing the error.
 */
declare function isColdRule(messages: Message[], counterpartyId: string): boolean;
/** The id of the viewer's most recent message (the only one that shows "Seen"). */
declare function lastOwnMessageId(messages: Message[], counterpartyId: string): string | null;

/**
 * The apply-decision ladder as a pure function — a core-entry
 * derive export like `messaging-derive`, so security/logic fixes ship via
 * the versioned package instead of re-copied registry files. Unit-testable
 * independent of React. Mirrors the hosted board's rule: past the
 * registration wall an external `applicationUrl`, when present, is the
 * apply path for EVERYONE — it is never gated behind verification, so a
 * signed-in-but-unverified candidate is never worse off than an anonymous
 * visitor. The wall itself gates every path including that external link,
 * matching hosted `job-apply-button.tsx`.
 */
type ApplyAction = {
    kind: 'external';
    url: string;
}
/**
 * `reason` says WHY sign-in is required, because callers gate on it:
 * `'registration-wall'` outranks an external-applications-only board
 * (a board with `nativeApplications: false` must still show the wall's
 * sign-in CTA), whereas `'native-apply'` is collapsed away there.
 * Optional — absent on the deprecated `resolveApplyAction` path.
 */
 | {
    kind: 'sign-in';
    reason?: 'registration-wall' | 'native-apply';
} | {
    kind: 'verify-email';
} | {
    kind: 'native';
    jobSlug: string;
}
/**
 * Anonymous guest apply — the visitor supplies name/email inline instead
 * of registering. Only reachable when the board's registration wall is
 * OFF and the caller set `allowGuestApply`, mirroring the hosted API,
 * which rejects an anonymous apply only on a walled board.
 */
 | {
    kind: 'guest';
    jobSlug: string;
} | {
    kind: 'applied';
} | {
    kind: 'none';
};
/**
 * A job's `applicationUrl` is operator/submitter-controlled and reaches
 * this component through the public API, so it can carry a dangerous
 * scheme (`javascript:`, `data:`, `vbscript:`) that would execute when
 * rendered as an `<a href>`. Only http(s) and mailto are safe apply
 * targets; anything else is treated as no external URL at all.
 */
declare function isSafeApplicationUrl(url: string): boolean;
interface ApplyDecisionState {
    jobSlug: string | null;
    applicationUrl: string | null;
    viewer: {
        emailVerified: boolean;
    } | null;
    applied: boolean;
    /**
     * The board's `features.registrationWall`. When `true` the hosted board
     * requires a signed-in candidate before ANY apply path — the external
     * employer link included. When `false` an anonymous visitor may apply
     * natively as a guest: `POST /jobs/:jobSlug/apply` accepts an
     * unauthenticated caller who supplies name/email, and rejects a guest
     * only when the wall is on.
     *
     * Sign-in — not verification — is the wall's bar, matching hosted: a
     * signed-in-but-unverified candidate clears it.
     */
    registrationWall: boolean;
    /**
     * Does this UI have a guest-apply form to render? Opt-in, because the
     * decision cannot know: a client with no form must keep getting
     * `sign-in`, not a `guest` action it cannot present. Ignored when
     * `registrationWall` is `true` — the wall always wins.
     */
    allowGuestApply?: boolean;
}
/**
 * The full apply ladder including the registration wall. Prefer this over
 * the deprecated `resolveApplyAction`, which cannot see the wall and so
 * hands an anonymous visitor the external employer link on a walled board.
 */
declare function resolveApplyDecision(state: ApplyDecisionState): ApplyAction;
/**
 * @deprecated Wall-blind — use {@link resolveApplyDecision}, which takes
 * the board's `features.registrationWall`. Kept as a one-line forward
 * (`registrationWall: false`) so pinned callers keep their behaviour
 * byte-for-byte; see docs/policy/removals.md.
 */
declare function resolveApplyAction(state: Omit<ApplyDecisionState, 'registrationWall' | 'allowGuestApply'>): ApplyAction;

type BoardUser = Schemas['BoardUser'];
type BoardAuthSession = Schemas['BoardAuthSession'];
type RegisterBody = Schemas['BoardAuthRegisterBody'];
type LoginBody = Schemas['BoardAuthLoginBody'];
type RefreshBody = Schemas['BoardAuthRefreshBody'];
type LogoutBody = Schemas['BoardAuthLogoutBody'];
type VerifyEmailBody = Schemas['BoardAuthVerifyEmailBody'];
type ForgotPasswordBody = Schemas['BoardAuthForgotPasswordBody'];
type ResetPasswordBody = Schemas['BoardAuthResetPasswordBody'];
type RequestMagicLinkBody = Schemas['BoardAuthRequestMagicLinkBody'];
type ConsumeMagicLinkBody = Schemas['BoardAuthConsumeMagicLinkBody'];
type OAuthProvider = 'google' | 'linkedin';
type OAuthAuthorizationQuery = {
    returnTo?: string;
    /**
     * Role profile to create when the handshake signs up a NEW user; defaults
     * to `candidate`. Pass `employer` from an employer sign-up surface — the
     * role is fixed at authorize time and cannot be changed on the callback.
     */
    role?: 'candidate' | 'employer';
};
type OAuthAuthorizationUrl = Schemas['BoardAuthOAuthAuthorizationUrl'];
type OAuthExchangeBody = Schemas['BoardAuthOAuthExchangeBody'];

type EmbedJobsQuery = {
    /** Free-text search query, up to 200 characters. */
    q?: string;
    cursor?: string;
    /** Default 8; values above the embed ceiling of 50 are clamped to 50. */
    limit?: number;
    /** Job catalog page offset; takes precedence over `cursor`. `offset + limit` ≤ 10,000. */
    offset?: number;
    /** Repeated param (up to 10) — OR-matched. Repeat `companyId` per value. */
    companyId?: string[];
    remoteOption?: RemoteOption[];
    employmentType?: EmploymentType[];
    seniority?: Seniority[];
    /** Place slug for a geo radius search; unresolvable slugs are ignored. */
    location?: string;
    /** Radius in km around `location` (10–250; default 50). */
    radius?: number;
};

/**
 * The board-access grant returned by `password.verify()`. Send `token` as
 * the `X-Board-Access` header on content reads to pass a board's password
 * wall (the SDK does this automatically once the grant is stored).
 */
type BoardAccessGrant = Schemas['BoardAccessGrant'];

/**
 * A board user's marketing-email consent, or `null` when no decision exists.
 *
 * Carries no disclosure text or wording version: the checkbox copy is authored
 * by the board's own frontend, so the API records the decision, not the prose.
 */
type MarketingConsent = Schemas['MarketingConsent'];

/**
 * The result of resolving a path against the board's configured redirects
 * (`board.redirects.resolve()`). A headless frontend 308s to `target`, or
 * 404s when it's `null`.
 */
type RedirectResolution = Schemas['RedirectResolution'];

/** A short-lived opaque hand-off to the dedicated Apply gateway. */
type ApplyIntent = Schemas['ApplyIntent'];
/** Duplicate-click session key; it must not contain profile or other PII. */
type CreateApplyIntentBody = Schemas['CreateApplyIntentBody'];

/** Server-side request that prepares a browser-direct country approval. */
type CreateApplyApprovalBody = Schemas['CreateApplyApprovalBody'];
/** Generic plan; `not_required` deliberately does not disclose why. */
type ApplyApprovalPlan = Schemas['ApplyApprovalPlan'];
/** Cookieless `/r/:opaque` response returned only to the bound board origin. */
interface ApplyApprovalReceipt {
    object: 'apply_approval_receipt';
    id: string;
    expiresAt: string;
}

/**
 * A candidate's public profile — header (name, headline, location, bio, avatar,
 * job-search status) plus their experiences, education, skills, and languages.
 * Only `public` profiles are returned; `jobSearchStatus` is `null` when the
 * candidate scoped it to employers only.
 */
type TalentProfile = Schemas['TalentProfile'];
/** A candidate card in the public talent directory. */
type TalentDirectoryEntry = Schemas['TalentDirectoryEntry'];
type TalentDirectoryQuery = {
    cursor?: string;
    /** Free-text search (name / headline / skills). */
    q?: string;
    /** Filter to candidates listing a given skill. */
    skill?: string;
    /** 1–100, default 20. */
    limit?: number;
    /**
     * Directory page offset (candidates to skip); takes precedence over
     * `cursor`. Pair with the response `count` to page in parallel.
     */
    offset?: number;
    jobSearchStatus?: 'actively_looking' | 'open_to_offers' | 'not_looking';
    /** Comma-separated language names. */
    languages?: string;
    openToRelocate?: 'true' | 'false';
    /** English source place slug. No-op until place ids ship. */
    place?: string;
    sort?: 'relevance' | 'newest';
    seniority?: string;
    permitCountry?: string;
    interestedRole?: string;
};
type TalentDirectoryListEnvelope = ListEnvelope<TalentDirectoryEntry>;

/**
 * A board plan (employer or job-seeker pricing). `purpose` says what the plan
 * entitles; `pricingMode` says how it is bought — a `contact` plan is
 * quote-only, so render `priceText` and the CTA fields instead of `price`.
 * Talent-access plans carry a `talent` allowance block.
 */
type Plan = Schemas['Plan'];
/**
 * @deprecated Use `plans.list()` and keep the rows whose `purpose` is
 * `employer_service` and whose `pricingMode` is `contact`.
 *
 * A sales-led ("contact us") plan — a custom CTA tier with no programmatic price.
 */
type SalesLedPlan = Schemas['SalesLedPlan'];
type PlansListQuery = {
    /** Filter to a single purpose. Omit to return all public plans. */
    purpose?: 'job_posting' | 'talent_access' | 'membership' | 'job_seeker' | 'employer_service' | 'job_seeker_service';
};
type PlanListEnvelope = ListEnvelope<Plan>;
type SalesLedPlanListEnvelope = ListEnvelope<SalesLedPlan>;

/** An enabled candidate-access paywall offer tier (public). */
type PaywallOffer = Schemas['PaywallOffer'];
/**
 * The connected-account embedded-checkout mount kit returned by
 * `board.me.access.checkout`. Mount with `loadStripe(publishableKey, {
 * stripeAccount: stripeAccountId })` then `initEmbeddedCheckout({ clientSecret })`.
 */
type AccessCheckoutSession = Schemas['AccessCheckoutSession'];
/** The polled state of a checkout session (`board.me.access.retrieveCheckout`). */
type AccessCheckoutSessionState = Schemas['AccessCheckoutSessionState'];
/** The viewer's candidate-access entitlement (`board.me.access.grant`). */
type AccessGrant = Schemas['AccessGrant'];
/** A minted Stripe billing-portal session (`board.me.access.portal`). */
type AccessPortalSession = Schemas['AccessPortalSession'];
/** Body for `board.me.access.checkout`. */
type AccessCheckoutBody = Schemas['AccessCheckoutBody'];
/** Body for `board.me.access.portal`. */
type AccessPortalBody = Schemas['AccessPortalBody'];
type PaywallOfferListEnvelope = ListEnvelope<PaywallOffer>;

type JobAlertFrequency = 'weekly';
type JobAlertRemoteOption = 'on_site' | 'hybrid' | 'remote';
/**
 * Alert filters a consumer can capture. Only `jobFunctions` (→ job categories),
 * `placeSlugs` (→ place IDs) and `remoteOptions` scope the digest server-side;
 * `seniorityLevels`/`salary*` are stored but do not filter delivery.
 */
type JobAlertFiltersInput = {
    jobFunctions?: string[];
    seniorityLevels?: string[];
    remoteOptions?: JobAlertRemoteOption[];
    placeSlugs?: string[];
    salaryMin?: number;
    salaryMax?: number;
    salaryCurrency?: string;
};
/** Body for `jobAlerts.subscribe`. `consent` must be `true` (server-enforced). */
type JobAlertSubscribeInput = {
    email: string;
    consent: true;
    frequency?: JobAlertFrequency;
    filters?: JobAlertFiltersInput;
    /** Scopes the alert to the originating job/search (for the digest + analytics). */
    context?: {
        source?: string;
        jobId?: string;
        jobSlug?: string;
    };
};
type JobAlertSubscription = Schemas['PublicJobAlertSubscription'];
type JobAlertConfirmation = Schemas['PublicJobAlertConfirmation'];
type JobAlertResendResult = Schemas['PublicJobAlertResend'];
type JobAlertManageResult = Schemas['PublicJobAlertManageResult'];
type JobAlertManageState = Schemas['PublicJobAlertManageState'];
/** One stored alert preference on the manage page. */
type JobAlertPreference = JobAlertManageState['preferences'][number];
/** The stored filter criteria surfaced on a manage-page preference. */
type JobAlertStoredFilters = JobAlertPreference['filters'];
/** Query for `jobAlerts.manage` — the HMAC manage token from the digest email. */
type JobAlertManageQuery = {
    subscription: string;
    token: string;
};
/** Body for `jobAlerts.unsubscribe` / `resubscribe` (HMAC manage token). */
type JobAlertManageTokenInput = {
    subscriptionId: string;
    token: string;
    preferenceId?: string;
};
type JobAlertUpdatePreferenceInput = {
    subscriptionId: string;
    preferenceId: string;
    token: string;
    /** Required — the update is a full replace; restate it to avoid resetting cadence. */
    frequency: JobAlertFrequency;
    filters?: JobAlertFiltersInput;
};
type JobAlertDeletePreferenceInput = {
    subscriptionId: string;
    preferenceId: string;
    token: string;
};

/** A board plan for the job-submission wizard. The `id` is the `selectedPlan`. */
type JobPostingPlan = Schemas['JobPostingPlan'];
/** The body of `board.jobPosting.create(...)`. */
type CreateJobPostingInput = Schemas['CreateJobPostingBody'];
/**
 * The status-discriminated outcome of a submission: `checkout` (a Stripe
 * Checkout URL to redirect to), `published`, `pending_approval`, or
 * `invoice_sent`. A rejected submission throws a `BoardApiError` instead.
 */
type JobPostingResult = Schemas['JobPostingResult'];
/**
 * The result of `uploadLogo()` / `fetchLogoByDomain()`: a stored logo whose
 * `publicUrl` you pass back as the top-level `logoUrl` on `create(...)`.
 */
type JobPostingLogoResult = Schemas['JobPostingLogo'];
type JobPostingBillingVerification = Schemas['JobPostingBillingVerification'];
type JobPostingBillingOptions = Schemas['JobPostingBillingOptions'];

type TaxonomyGeo = Schemas['TaxonomyGeo'];
type TaxonomyResolution = Schemas['PublicTaxonomyResolution'];
type PublicTaxonomyTerm = Schemas['PublicTaxonomyTerm'];
type PublicPlace = Schemas['PublicPlace'];
/**
 * One canonical remote-permit option (`worldwide`, a world region /
 * continent / region / subregion, a `custom` bloc like EU, an ISO 3166-1
 * `country`, or an ISO 3166-2 `subdivision`) — the `{type, value}` pairs
 * the `remotePermits` and job-posting `remoteWorkingPermits` fields accept.
 */
type RemotePermitTaxonomyEntry = Schemas['RemotePermitTaxonomyEntry'];
type TaxonomyListQuery = {
    q?: string;
    cursor?: string;
    limit?: number;
    /** `name` (default) or `jobCount` (highest published-job count first). */
    sort?: 'name' | 'jobCount';
};
/**
 * Query for `taxonomy.places.list()`. Omit it (or `q`) for the full
 * locations directory; pass `q` (≥2 chars) for location autocomplete — the
 * top name matches ranked, what a location search field renders.
 */
type PlacesListQuery = {
    /** Location autocomplete query; ≥2 chars → top name matches, under 2 → empty. */
    q?: string;
    /** Max autocomplete results when `q` is given (1–50; default 10). */
    limit?: number;
};

/** One bucket in the board's sitemap: its name, size, and freshness stamp. */
type BoardSitemapBucketSummary = Schemas['BoardSitemapBucketSummary'];
/**
 * The board's sitemap bucket index (`board.sitemap()`) — the buckets the board
 * publishes, in canonical order, empty ones omitted. Read each bucket's paths
 * with `board.sitemap.entries(bucket)`.
 */
type BoardSitemapIndex = Schemas['BoardSitemap'];
/**
 * One sitemap URL as a BOARD-RELATIVE path (always leading `/`). Prefix it with
 * your own origin — the API never returns an origin, so a custom domain, a
 * preview deploy, and production all build correct URLs from the same page.
 */
type SitemapEntry = Schemas['SitemapEntry'];
type SitemapEntriesQuery = {
    /** Page size, 1–1000 (default 1000). */
    limit?: number;
    /** Opaque forward cursor from a previous response's `nextCursor`. */
    cursor?: string;
};
/** One page of a bucket's entries. Walk it with `paginate`. */
type SitemapEntriesEnvelope = ListEnvelope<SitemapEntry>;

interface CreateBoardClientOptions {
    /** Cavuno API origin. Defaults to the production service. */
    baseUrl?: string;
    /** Board identifier: `pk_…` key (provisioned default) | `boards_…` ID | slug. */
    board: string;
    auth?: {
        /** Default: `'memory'` in the browser, `'nostore'` on the server. */
        storage?: StorageMode;
    };
    globalHeaders?: Record<string, string>;
    onRequest?: (req: BoardRequest) => Awaitable<BoardRequest>;
    onResponse?: (res: Response, req: BoardRequest) => Awaitable<void>;
    logger?: Logger;
}
/**
 * Create a Board API client.
 *
 * Isomorphic (browser, Workers, Node ≥ 20), zero dependencies. One
 * module-scoped instance is safe under SSR as long as per-user state
 * stays per-call (`options.headers`) rather than in `auth.storage`.
 *
 * @example
 * import { createBoardClient } from '@cavuno/board';
 *
 * const board = createBoardClient({
 *   board: 'pk_a8f3…',
 * });
 * const { data } = await board.jobs.list({ limit: 20 });
 */
declare function createBoardClient(options: CreateBoardClientOptions): {
    /**
     * Escape hatch: raw typed request through the full pipeline (board
     * base path, default headers, bearer token, hooks). Custom
     * endpoints work without an SDK release.
     */
    client: BoardClient;
    /**
     * Board context — identity, brand (`logoUrl` + favicon `icons`), language,
     * features, analytics, and AdSense (`ads.enabled`, `ads.clientId`, and `ads.defaultSlotId`).
     * Per-placement slot ids are not on this resource.
     *
     * @example
     * const { name, language, logoUrl, icons, ads } = await board.context();
     */
    context(options?: FetchOptions): Promise<{
        object: "public_board";
        id: string;
        slug: string;
        name: string;
        language: string;
        logoUrl: string | null;
        icons: {
            ico: string | null;
            svg: string | null;
            appleTouch: string | null;
            icon192: string | null;
            icon512: string | null;
            iconMaskable512: string | null;
        };
        primaryDomain: string | null;
        showCavunoBranding: boolean;
        features: {
            jobAlerts: boolean;
            jobRecommendationsEnabled: boolean;
            recommendedTalentEnabled: boolean;
            candidates: boolean;
            employers: boolean;
            blog: boolean;
            talentDirectory: "off" | "public" | "employers_only";
            registrationWall: boolean;
            passwordProtected: boolean;
            publicJobSubmission: boolean;
            candidatePaywall: boolean;
            impressum: boolean;
            nativeApplications: boolean;
            messaging: boolean;
        };
        talentAccessModel: "paid_messaging" | "paid_unlocks_and_messaging" | null;
        posting: {
            requiresMembership: boolean;
        };
        analytics: {
            ga4MeasurementId: string | null;
            gtmId: string | null;
            metaPixelId: string | null;
            linkedInPartnerId: string | null;
            linkedInConversionSignUpId: string | null;
            linkedInConversionLoginId: string | null;
            linkedInConversionApplyClickId: string | null;
            linkedInConversionApplySubmitId: string | null;
            linkedInConversionJobAlertSubscribeId: string | null;
            cookieConsentRequired: boolean;
        };
        ads: {
            enabled: boolean;
            clientId: string | null;
            defaultSlotId: string | null;
        };
        customFields: {
            job: components["schemas"]["CustomFieldDefinition"][];
        };
        jobForm: {
            salary: {
                visible: boolean;
                required: boolean;
                minBound: number | null;
                maxBound: number | null;
                allowedCurrencies: string[] | null;
            };
            seniority: {
                visible: boolean;
                required: boolean;
                allowedOptions: string[];
            };
            location: {
                visible: boolean;
                allowedCountries: string[] | null;
            };
            sponsorship: {
                visible: boolean;
            };
            workArrangement: {
                allowedOptions: string[];
            };
            employmentType: {
                allowedOptions: string[];
            };
        };
        contact: {
            email: string | null;
            legalName: string | null;
            websiteUrl: string | null;
            xUrl: string | null;
            facebookUrl: string | null;
            linkedinUrl: string | null;
        };
    }>;
    /**
     * Board SEO infra tokens — `ads.txt`, IndexNow key, Google site-verification,
     * canonical base URL, and `manifest.name`. Favicon / app-icon URLs are
     * brand identity on `board.context()` (`logoUrl` + `icons`).
     *
     * @example
     * const { adsTxt, canonicalBase } = await board.seo();
     */
    seo(options?: FetchOptions): Promise<{
        object: "board_seo";
        adsTxt: string | null;
        indexNowKey: string | null;
        googleSiteVerification: string | null;
        canonicalBase: string;
        manifest: {
            name: string;
        };
    }>;
    jobs: {
        list(query?: JobsListQuery, options?: FetchOptions): Promise<JobCardListEnvelope>;
        retrieve(jobSlug: string, query?: Record<string, never>, options?: FetchOptions): Promise<{
            id: string;
            object: "public_job";
            title: string;
            slug: string | null;
            status: "draft" | "published" | "expired" | "archived";
            companyId: string | null;
            employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
            remoteOption: "on_site" | "hybrid" | "remote" | null;
            seniority: "entry_level" | "associate" | "mid_level" | "senior" | "lead" | "principal" | "director" | "executive" | null;
            salaryMin: number | null;
            salaryMax: number | null;
            salaryCurrency: string | null;
            salaryTimeframe: "per_year" | "per_month" | "per_week" | "per_day" | "per_hour" | null;
            isFeatured: boolean;
            publishedAt: string | null;
            expiresAt: string | null;
            createdAt: string;
            updatedAt: string;
            links: components["schemas"]["PublicJobLinks"];
            description: string | null;
            applicationUrl: string | null;
            isSponsored: boolean;
            applyAction: "native" | "external_direct" | "gateway_external" | "gateway_native";
            remotePermits: {
                type: string;
                value: string;
            }[];
            remoteWorldwide: boolean | null;
            remoteTimezones: {
                type: string;
                value: string;
                plusMinus?: number;
            }[];
            remoteAllowedTzOffsets: number[];
            remoteWorkPermitCountryCodes: string[];
            remoteWorkPermitSubdivisionCodes: string[];
            remoteSponsorship: "yes" | "no" | "unknown";
            educationRequirements: ("high_school" | "associate_degree" | "bachelor_degree" | "professional_certificate" | "postgraduate_degree" | "no_requirements")[];
            experienceMonths: number | null;
            experienceInPlaceOfEducation: boolean | null;
            inOfficePeriod: "per_week" | "per_month" | "per_year" | null;
            inOfficeFrequency: number | null;
            company: components["schemas"]["JobCompany"];
            officeLocations: components["schemas"]["JobOfficeLocation"][];
            categories: {
                slug: string;
                name: string;
            }[];
            skills: {
                slug: string;
                name: string;
            }[];
            placeHierarchy: {
                slug: string;
                name: string;
            }[];
            customFieldValues: {
                [key: string]: string | string[] | boolean | number;
            };
        }>;
        search(body: JobsSearchBody, query?: Record<string, never>, options?: FetchOptions): Promise<JobCardSearchEnvelope>;
        similar(jobSlug: string, query?: JobsSimilarQuery, options?: FetchOptions): Promise<ListEnvelope<{
            id: string;
            object: "job_card";
            slug: string;
            title: string;
            publishedAt: string | null;
            employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
            remoteOption: "on_site" | "hybrid" | "remote" | null;
            remoteLocationLabel: string | null;
            remoteWorldwide: boolean | null;
            remoteWorkPermitCountryCodes: string[];
            salaryMin: number | null;
            salaryMax: number | null;
            salaryCurrency: string | null;
            salaryTimeframe: string | null;
            isFeatured: boolean;
            isSponsored: boolean;
            summary: string | null;
            locationLabel: string | null;
            company: {
                slug: string;
                name: string;
                logoUrl: string | null;
            } | null;
            categories: {
                slug: string;
                name: string;
            }[];
            skills: {
                slug: string;
                name: string;
            }[];
            links: {
                public: string | null;
            };
            description?: string | null;
        }>>;
        apply(jobSlug: string, body?: ApplyBody, options?: FetchOptions): Promise<{
            id: string;
            object: "application";
            status: "applied" | "interviewing" | "negotiation" | "hired" | "archived";
            appliedAt: string;
            updatedAt: string;
            coverNote: string | null;
            candidateName: string | null;
            candidateEmail: string | null;
            candidateLocation: string | null;
            candidateHeadline: string | null;
            resumeFilename: string | null;
            job: {
                id: string;
                title: string;
                slug: string | null;
                companySlug: string | null;
                companyName: string | null;
            } | null;
        }>;
        createApplyIntent(jobSlug: string, body: CreateApplyIntentBody, options?: FetchOptions): Promise<{
            id: string;
            object: "apply_intent";
            gatewayUrl: string;
            expiresAt: string;
        }>;
        prepareApplyApproval(jobSlug: string, body: CreateApplyApprovalBody, options?: FetchOptions): Promise<{
            object: "apply_approval_plan";
            kind: "not_required";
        } | {
            object: "apply_approval_plan";
            kind: "approval_required";
            approvalUrl: string;
            expiresAt: string;
        }>;
        uploadApplicationResume(jobSlug: string, file: Blob, opts?: {
            applicationId?: string;
        }, options?: FetchOptions): Promise<{
            id: string;
            object: "application";
            status: "applied" | "interviewing" | "negotiation" | "hired" | "archived";
            appliedAt: string;
            updatedAt: string;
            coverNote: string | null;
            candidateName: string | null;
            candidateEmail: string | null;
            candidateLocation: string | null;
            candidateHeadline: string | null;
            resumeFilename: string | null;
            job: {
                id: string;
                title: string;
                slug: string | null;
                companySlug: string | null;
                companyName: string | null;
            } | null;
        }>;
        myApplication(jobSlug: string, options?: FetchOptions): Promise<{
            id: string;
            object: "application";
            status: "applied" | "interviewing" | "negotiation" | "hired" | "archived";
            appliedAt: string;
            updatedAt: string;
            coverNote: string | null;
            candidateName: string | null;
            candidateEmail: string | null;
            candidateLocation: string | null;
            candidateHeadline: string | null;
            resumeFilename: string | null;
            job: {
                id: string;
                title: string;
                slug: string | null;
                companySlug: string | null;
                companyName: string | null;
            } | null;
        }>;
    };
    embed: {
        jobs(query?: EmbedJobsQuery, options?: FetchOptions): Promise<ListEnvelope<{
            id: string;
            object: "job_card";
            slug: string;
            title: string;
            publishedAt: string | null;
            employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
            remoteOption: "on_site" | "hybrid" | "remote" | null;
            remoteLocationLabel: string | null;
            remoteWorldwide: boolean | null;
            remoteWorkPermitCountryCodes: string[];
            salaryMin: number | null;
            salaryMax: number | null;
            salaryCurrency: string | null;
            salaryTimeframe: string | null;
            isFeatured: boolean;
            isSponsored: boolean;
            summary: string | null;
            locationLabel: string | null;
            company: {
                slug: string;
                name: string;
                logoUrl: string | null;
            } | null;
            categories: {
                slug: string;
                name: string;
            }[];
            skills: {
                slug: string;
                name: string;
            }[];
            links: {
                public: string | null;
            };
            description?: string | null;
        }>>;
    };
    companies: {
        list(query?: CompaniesListQuery, options?: FetchOptions): Promise<CompanyListEnvelope>;
        retrieve(companySlug: string, query?: Record<string, never>, options?: FetchOptions): Promise<{
            id: string;
            object: "public_company";
            name: string;
            slug: string;
            website: string | null;
            logoUrl: string | null;
            summary: string | null;
            description: string | null;
            jobCount: number;
            publishedJobCount: number;
            salarySampleCount: number;
            membership: components["schemas"]["PublicCompanyMembership"];
            links: components["schemas"]["PublicCompanyLinks"];
        } & {
            markets: components["schemas"]["CompanyMarketRef"][];
        }>;
        search(body: CompaniesSearchBody, query?: Record<string, never>, options?: FetchOptions): Promise<SearchEnvelope<{
            id: string;
            object: "public_company";
            name: string;
            slug: string;
            website: string | null;
            logoUrl: string | null;
            summary: string | null;
            description: string | null;
            jobCount: number;
            publishedJobCount: number;
            salarySampleCount: number;
            membership: components["schemas"]["PublicCompanyMembership"];
            links: components["schemas"]["PublicCompanyLinks"];
        }>>;
        listJobs(companySlug: string, query?: CompanyJobsListQuery, options?: FetchOptions): Promise<JobCardListEnvelope>;
        similar(companySlug: string, query?: CompanySimilarQuery, options?: FetchOptions): Promise<ListEnvelope<{
            id: string;
            object: "public_company";
            name: string;
            slug: string;
            website: string | null;
            logoUrl: string | null;
            summary: string | null;
            description: string | null;
            jobCount: number;
            publishedJobCount: number;
            salarySampleCount: number;
            membership: components["schemas"]["PublicCompanyMembership"];
            links: components["schemas"]["PublicCompanyLinks"];
        }>>;
        markets: ((query?: CompanyMarketsListQuery, options?: FetchOptions) => Promise<ListEnvelope<{
            object: "company_market";
            slug: string;
            name: string;
            companyCount: number;
        }>>) & {
            resolve(market: string, options?: FetchOptions): Promise<{
                object: "taxonomy_resolution";
                type: "category" | "skill" | "place" | "market";
                sourceSlug: string;
                canonicalSlug: string;
                displayName: string;
                redirectTo: string | null;
                geo: components["schemas"]["TaxonomyGeo"];
            }>;
        };
        salaries: ((companySlug: string, options?: FetchOptions) => Promise<{
            object: "company_salary";
            companyName: string;
            companySlug: string;
            companyLogoPath: string | null;
            companyWebsite: string | null;
            overallSalary: {
                avgMin: number;
                avgMax: number;
                jobCount: number;
            } | null;
            bySeniority: {
                seniority: string;
                avgSalaryMin: number;
                avgSalaryMax: number;
                jobCount: number;
                boardAvgMin: number | null;
                boardAvgMax: number | null;
                boardMedianMin: number | null;
                boardMedianMax: number | null;
                boardP25Min: number | null;
                boardP75Min: number | null;
                boardP25Max: number | null;
                boardP75Max: number | null;
                diffPercent: number | null;
            }[];
            competitors: {
                companySlug: string;
                companyName: string;
                logoPath: string | null;
                avgSalaryMin: number;
                avgSalaryMax: number;
                jobCount: number;
            }[];
            topLocations: {
                locationName: string;
                countryCode: string;
                placeSlug: string;
                avgSalaryMin: number;
                avgSalaryMax: number;
                jobCount: number;
            }[];
            byCategory: {
                categorySlug: string;
                categoryName: string;
                avgSalaryMin: number;
                avgSalaryMax: number;
                jobCount: number;
            }[];
            boardOverallAvgMin: number | null;
            boardOverallAvgMax: number | null;
            boardMedianMin: number | null;
            boardMedianMax: number | null;
            boardP25Min: number | null;
            boardP75Min: number | null;
            boardP25Max: number | null;
            boardP75Max: number | null;
            currency: string;
        }>) & {
            summary(companySlug: string, options?: FetchOptions): Promise<{
                object: "company_salary_summary";
                companyName: string;
                companySlug: string;
                overallSalary: {
                    avgMin: number;
                    avgMax: number;
                    jobCount: number;
                } | null;
                topCategories: {
                    categorySlug: string;
                    categoryName: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
                sampleCount: number;
                currency: string;
            }>;
            category(companySlug: string, categorySlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "company_category_salary";
                categorySourceSlug: string;
                categoryCanonicalSlug: string;
                companyName: string;
                companySlug: string;
                companyLogoPath: string | null;
                companyWebsite: string | null;
                categoryName: string;
                overallSalary: {
                    avgMin: number;
                    avgMax: number;
                    jobCount: number;
                } | null;
                bySeniority: {
                    seniority: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    boardAvgMin: number | null;
                    boardAvgMax: number | null;
                    boardMedianMin: number | null;
                    boardMedianMax: number | null;
                    boardP25Min: number | null;
                    boardP75Min: number | null;
                    boardP25Max: number | null;
                    boardP75Max: number | null;
                    diffPercent: number | null;
                }[];
                competitors: {
                    companySlug: string;
                    companyName: string;
                    logoPath: string | null;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
                boardCategoryAvgMin: number | null;
                boardCategoryAvgMax: number | null;
                boardCategoryP25Min: number | null;
                boardCategoryP75Max: number | null;
                currency: string;
            }>;
        };
    };
    blog: {
        posts: {
            list(query?: BlogPostsListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "public_blog_post";
                title: string;
                slug: string;
                featured: boolean;
                coverUrl: string | null;
                featureImageAlt: string | null;
                customExcerpt: string | null;
                readingTimeMin: number | null;
                publishedAt: string | null;
                canonicalUrl: string | null;
                createdAt: string;
                authors: components["schemas"]["PublicBlogAuthorEmbed"][];
                tags: components["schemas"]["PublicBlogTagEmbed"][];
            }>>;
            retrieve(postSlug: string, query?: Record<string, never>, options?: FetchOptions): Promise<{
                id: string;
                object: "public_blog_post";
                title: string;
                slug: string;
                featured: boolean;
                coverUrl: string | null;
                featureImageAlt: string | null;
                customExcerpt: string | null;
                readingTimeMin: number | null;
                publishedAt: string | null;
                canonicalUrl: string | null;
                createdAt: string;
                authors: components["schemas"]["PublicBlogAuthorEmbed"][];
                tags: components["schemas"]["PublicBlogTagEmbed"][];
            } & {
                html: string | null;
                ogImageUrl: string | null;
                featureImageCaption: string | null;
                seoTitle: string | null;
                seoDescription: string | null;
                redirected: boolean;
                newSlug: string | null;
            }>;
            adjacent(postSlug: string, options?: FetchOptions): Promise<{
                object: "blog_adjacent_posts";
                previous: components["schemas"]["PublicBlogPostSummary"] | null;
                next: components["schemas"]["PublicBlogPostSummary"] | null;
            }>;
            similar(postSlug: string, query?: BlogSimilarQuery, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "public_blog_post";
                title: string;
                slug: string;
                featured: boolean;
                coverUrl: string | null;
                featureImageAlt: string | null;
                customExcerpt: string | null;
                readingTimeMin: number | null;
                publishedAt: string | null;
                canonicalUrl: string | null;
                createdAt: string;
                authors: components["schemas"]["PublicBlogAuthorEmbed"][];
                tags: components["schemas"]["PublicBlogTagEmbed"][];
            }>>;
        };
        tags: {
            list(query?: Record<string, never>, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                name: string;
                slug: string;
                description: string | null;
            } & {
                object: "public_blog_tag";
            }>>;
            retrieve(tagSlug: string, query?: Record<string, never>, options?: FetchOptions): Promise<{
                id: string;
                name: string;
                slug: string;
                description: string | null;
            } & {
                object: "public_blog_tag";
            }>;
        };
        authors: {
            list(query?: Record<string, never>, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                name: string;
                slug: string;
                bio: string | null;
                location: string | null;
                avatarUrl: string | null;
                websiteUrl: string | null;
                facebookUrl: string | null;
                twitterUrl: string | null;
                linkedinUrl: string | null;
                githubUrl: string | null;
            } & {
                object: "public_blog_author";
            }>>;
            retrieve(authorSlug: string, query?: Record<string, never>, options?: FetchOptions): Promise<{
                id: string;
                name: string;
                slug: string;
                bio: string | null;
                location: string | null;
                avatarUrl: string | null;
                websiteUrl: string | null;
                facebookUrl: string | null;
                twitterUrl: string | null;
                linkedinUrl: string | null;
                githubUrl: string | null;
            } & {
                object: "public_blog_author";
            }>;
        };
        search(body: BlogSearchBody, query?: Record<string, never>, options?: FetchOptions): Promise<SearchEnvelope<{
            id: string;
            object: "public_blog_post";
            title: string;
            slug: string;
            featured: boolean;
            coverUrl: string | null;
            featureImageAlt: string | null;
            customExcerpt: string | null;
            readingTimeMin: number | null;
            publishedAt: string | null;
            canonicalUrl: string | null;
            createdAt: string;
            authors: components["schemas"]["PublicBlogAuthorEmbed"][];
            tags: components["schemas"]["PublicBlogTagEmbed"][];
        }>>;
    };
    auth: {
        register(body: RegisterBody, options?: FetchOptions): Promise<{
            object: "board_auth_session";
            accessToken: string;
            refreshToken: string;
            expiresAt: number;
            boardUser: components["schemas"]["BoardUser"];
            isNewUser?: boolean;
        }>;
        login(body: LoginBody, options?: FetchOptions): Promise<{
            object: "board_auth_session";
            accessToken: string;
            refreshToken: string;
            expiresAt: number;
            boardUser: components["schemas"]["BoardUser"];
            isNewUser?: boolean;
        }>;
        refresh(body?: RefreshBody, options?: FetchOptions): Promise<{
            object: "board_auth_session";
            accessToken: string;
            refreshToken: string;
            expiresAt: number;
            boardUser: components["schemas"]["BoardUser"];
            isNewUser?: boolean;
        }>;
        logout(body?: LogoutBody, options?: FetchOptions): Promise<void>;
        verifyEmail(body: VerifyEmailBody, options?: FetchOptions): Promise<void>;
        verifyWorkEmail(body: ConfirmWorkEmailBody, options?: FetchOptions): Promise<{
            id: string;
            object: "company_membership";
            status: "approved" | "pending_work_email" | "awaiting_admin" | "rejected";
            role: string;
            workEmail: string | null;
            workEmailVerifiedAt: string | null;
            company: {
                id: string;
                name: string;
                slug: string | null;
                website: string | null;
                logoUrl: string | null;
            };
        }>;
        verifyEmailWithCode(body: {
            code: string;
        }, options?: FetchOptions): Promise<void>;
        resendVerification(options?: FetchOptions): Promise<void>;
        forgotPassword(body: ForgotPasswordBody, options?: FetchOptions): Promise<void>;
        resetPassword(body: ResetPasswordBody, options?: FetchOptions): Promise<void>;
        requestMagicLink(body: RequestMagicLinkBody, options?: FetchOptions): Promise<void>;
        consumeMagicLink(body: ConsumeMagicLinkBody, options?: FetchOptions): Promise<{
            object: "board_auth_session";
            accessToken: string;
            refreshToken: string;
            expiresAt: number;
            boardUser: components["schemas"]["BoardUser"];
            isNewUser?: boolean;
        }>;
        getOAuthAuthorizationUrl(provider: OAuthProvider, query?: OAuthAuthorizationQuery, options?: FetchOptions): Promise<{
            object: "oauth_authorization_url";
            provider: "google" | "linkedin";
            authorizeUrl: string;
        }>;
        exchangeOAuth(body: OAuthExchangeBody, options?: FetchOptions): Promise<{
            object: "board_auth_session";
            accessToken: string;
            refreshToken: string;
            expiresAt: number;
            boardUser: components["schemas"]["BoardUser"];
            isNewUser?: boolean;
        }>;
    };
    me: {
        retrieve(query?: Record<string, never>, options?: FetchOptions): Promise<{
            id: string;
            object: "board_user";
            role: "candidate" | "employer";
            email: string;
            displayName: string | null;
            emailVerified: boolean;
            hasPassword: boolean;
        }>;
        delete(options?: FetchOptions): Promise<void>;
        updatePassword(body: UpdatePasswordBody, options?: FetchOptions): Promise<{
            object: "board_auth_session";
            accessToken: string;
            refreshToken: string;
            expiresAt: number;
            boardUser: components["schemas"]["BoardUser"];
            isNewUser?: boolean;
        }>;
        requestEmailChange(body: RequestEmailChangeBody, options?: FetchOptions): Promise<void>;
        confirmEmailChange(body: ConfirmEmailChangeBody, options?: FetchOptions): Promise<void>;
        acceptInvite(body: AcceptCompanyMemberInviteBody, options?: FetchOptions): Promise<{
            object: "company_member_invite_acceptance";
            companySlug: string;
        }>;
        profile: {
            retrieve(query?: Record<string, never>, options?: FetchOptions): Promise<{
                id: string;
                object: "candidate_profile";
                displayName: string | null;
                bio: string | null;
                avatarUrl: string | null;
                handle: string | null;
                headline: string | null;
                location: string | null;
                countryCode: string | null;
                profileVisibility: "hidden" | "logged_in_only" | "public";
                jobSearchStatus: "actively_looking" | "open_to_offers" | "not_looking";
                jobSearchStatusVisibleTo: "everyone" | "employers_only";
                openToRelocate: boolean;
            }>;
            update(body: UpdateCandidateProfileBody, query?: Record<string, never>, options?: FetchOptions): Promise<{
                id: string;
                object: "candidate_profile";
                displayName: string | null;
                bio: string | null;
                avatarUrl: string | null;
                handle: string | null;
                headline: string | null;
                location: string | null;
                countryCode: string | null;
                profileVisibility: "hidden" | "logged_in_only" | "public";
                jobSearchStatus: "actively_looking" | "open_to_offers" | "not_looking";
                jobSearchStatusVisibleTo: "everyone" | "employers_only";
                openToRelocate: boolean;
            }>;
            handleAvailable(handle: string, options?: FetchOptions): Promise<{
                object: "handle_availability";
                handle: string;
                available: boolean;
            }>;
            listExperience(options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "candidate_experience";
                title: string;
                companyName: string;
                companyUrl: string | null;
                location: string | null;
                employmentType: string | null;
                locationType: string | null;
                foundVia: string | null;
                startDate: string;
                endDate: string | null;
                description: string | null;
                sortOrder: number;
                experienceSkills: string[];
            }>>;
            createExperience(body: CreateExperienceBody, options?: FetchOptions): Promise<{
                id: string;
                object: "candidate_experience";
                title: string;
                companyName: string;
                companyUrl: string | null;
                location: string | null;
                employmentType: string | null;
                locationType: string | null;
                foundVia: string | null;
                startDate: string;
                endDate: string | null;
                description: string | null;
                sortOrder: number;
                experienceSkills: string[];
            }>;
            updateExperience(id: string, body: UpdateExperienceBody, options?: FetchOptions): Promise<{
                id: string;
                object: "candidate_experience";
                title: string;
                companyName: string;
                companyUrl: string | null;
                location: string | null;
                employmentType: string | null;
                locationType: string | null;
                foundVia: string | null;
                startDate: string;
                endDate: string | null;
                description: string | null;
                sortOrder: number;
                experienceSkills: string[];
            }>;
            deleteExperience(id: string, options?: FetchOptions): Promise<void>;
            listEducation(options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "candidate_education";
                institutionName: string;
                institutionUrl: string | null;
                degree: string | null;
                fieldOfStudy: string | null;
                grade: string | null;
                activitiesAndSocieties: string | null;
                startDate: string | null;
                endDate: string | null;
                description: string | null;
                sortOrder: number;
            }>>;
            createEducation(body: CreateEducationBody, options?: FetchOptions): Promise<{
                id: string;
                object: "candidate_education";
                institutionName: string;
                institutionUrl: string | null;
                degree: string | null;
                fieldOfStudy: string | null;
                grade: string | null;
                activitiesAndSocieties: string | null;
                startDate: string | null;
                endDate: string | null;
                description: string | null;
                sortOrder: number;
            }>;
            updateEducation(id: string, body: UpdateEducationBody, options?: FetchOptions): Promise<{
                id: string;
                object: "candidate_education";
                institutionName: string;
                institutionUrl: string | null;
                degree: string | null;
                fieldOfStudy: string | null;
                grade: string | null;
                activitiesAndSocieties: string | null;
                startDate: string | null;
                endDate: string | null;
                description: string | null;
                sortOrder: number;
            }>;
            deleteEducation(id: string, options?: FetchOptions): Promise<void>;
            listSkills(options?: FetchOptions): Promise<ListEnvelope<{
                object: "candidate_skill";
                name: string;
                jobSkillId: string | null;
            }>>;
            updateSkills(body: UpdateSkillsBody, options?: FetchOptions): Promise<ListEnvelope<{
                object: "candidate_skill";
                name: string;
                jobSkillId: string | null;
            }>>;
            listLanguages(options?: FetchOptions): Promise<ListEnvelope<{
                object: "candidate_language";
                name: string;
                proficiency: string;
            }>>;
            updateLanguages(body: UpdateLanguagesBody, options?: FetchOptions): Promise<ListEnvelope<{
                object: "candidate_language";
                name: string;
                proficiency: string;
            }>>;
            uploadAvatar(file: Blob, options?: FetchOptions): Promise<{
                object: "candidate_avatar";
                avatarUrl: string | null;
            }>;
        };
        notificationPreferences: {
            retrieve(options?: FetchOptions): Promise<ListEnvelope<{
                object: "notification_preference";
                channel: "messageEmails" | "applicationEmails" | "recommendedJobEmails";
                subscribed: boolean;
                waitlisted: boolean;
                updatedAt: number | null;
            }>>;
            update(body: UpdateNotificationPreferenceBody, options?: FetchOptions): Promise<ListEnvelope<{
                object: "notification_preference";
                channel: "messageEmails" | "applicationEmails" | "recommendedJobEmails";
                subscribed: boolean;
                waitlisted: boolean;
                updatedAt: number | null;
            }>>;
            unsubscribeWithToken(body: UnsubscribeBody, options?: FetchOptions): Promise<void>;
        };
        companies: {
            search(query: EmployerCompanySearchQuery, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "claimable_company";
                name: string;
                slug: string;
                website: string | null;
            }>>;
            list(options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "company_membership";
                status: "approved" | "pending_work_email" | "awaiting_admin" | "rejected";
                role: string;
                workEmail: string | null;
                workEmailVerifiedAt: string | null;
                company: {
                    id: string;
                    name: string;
                    slug: string | null;
                    website: string | null;
                    logoUrl: string | null;
                };
            }>>;
            create(body: CreateCompanyBody, options?: FetchOptions): Promise<{
                id: string;
                object: "company_membership";
                status: "approved" | "pending_work_email" | "awaiting_admin" | "rejected";
                role: string;
                workEmail: string | null;
                workEmailVerifiedAt: string | null;
                company: {
                    id: string;
                    name: string;
                    slug: string | null;
                    website: string | null;
                    logoUrl: string | null;
                };
            }>;
            claim(slug: string, options?: FetchOptions): Promise<{
                id: string;
                object: "company_membership";
                status: "approved" | "pending_work_email" | "awaiting_admin" | "rejected";
                role: string;
                workEmail: string | null;
                workEmailVerifiedAt: string | null;
                company: {
                    id: string;
                    name: string;
                    slug: string | null;
                    website: string | null;
                    logoUrl: string | null;
                };
            }>;
            cancelClaim(slug: string, options?: FetchOptions): Promise<void>;
            retrieve(slug: string, options?: FetchOptions): Promise<{
                id: string;
                object: "employer_company";
                name: string;
                slug: string;
                website: string | null;
                description: string | null;
                summary: string | null;
                xUrl: string | null;
                linkedinUrl: string | null;
                facebookUrl: string | null;
                logoUrl: string | null;
                deletionEnabled: boolean;
            }>;
            update(slug: string, body: UpdateEmployerCompanyBody, options?: FetchOptions): Promise<{
                id: string;
                object: "employer_company";
                name: string;
                slug: string;
                website: string | null;
                description: string | null;
                summary: string | null;
                xUrl: string | null;
                linkedinUrl: string | null;
                facebookUrl: string | null;
                logoUrl: string | null;
                deletionEnabled: boolean;
            }>;
            delete(slug: string, options?: FetchOptions): Promise<void>;
            listMembers(slug: string, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "company_member";
                boardUserId: string;
                displayName: string | null;
                email: string;
                role: "admin" | "member";
                approvedBy: string | null;
                createdAt: string;
            }>>;
            updateMemberRole(slug: string, memberId: string, body: UpdateCompanyMemberRoleBody, options?: FetchOptions): Promise<void>;
            removeMember(slug: string, memberId: string, options?: FetchOptions): Promise<void>;
            leave(slug: string, options?: FetchOptions): Promise<void>;
            startMembershipCheckout(slug: string, body: MembershipCheckoutBody, options?: FetchOptions): Promise<{
                object: "checkout_session";
                sessionId: string;
                clientSecret: string;
                stripeAccountId: string;
                publishableKey: string;
                offerType: "recurring" | "lifetime";
            }>;
            retrieveMembershipCheckout(slug: string, sessionId: string, options?: FetchOptions): Promise<{
                object: "checkout_session_state";
                status: "open" | "complete" | "expired";
                clientSecret: string | null;
            }>;
            listInvites(slug: string, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "company_member_invite";
                email: string;
                createdAt: string;
                expiresAt: string;
            }>>;
            createInvite(slug: string, body: CreateCompanyMemberInviteBody, options?: FetchOptions): Promise<{
                id: string;
                object: "company_member_invite";
                email: string;
                createdAt: string;
                expiresAt: string;
            }>;
            revokeInvite(slug: string, inviteId: string, options?: FetchOptions): Promise<void>;
            uploadLogo(slug: string, file: Blob, options?: FetchOptions): Promise<{
                id: string;
                object: "employer_company";
                name: string;
                slug: string;
                website: string | null;
                description: string | null;
                summary: string | null;
                xUrl: string | null;
                linkedinUrl: string | null;
                facebookUrl: string | null;
                logoUrl: string | null;
                deletionEnabled: boolean;
            }>;
            workEmail: {
                verify(slug: string, body: SendWorkEmailBody, options?: FetchOptions): Promise<{
                    id: string;
                    object: "company_membership";
                    status: "approved" | "pending_work_email" | "awaiting_admin" | "rejected";
                    role: string;
                    workEmail: string | null;
                    workEmailVerifiedAt: string | null;
                    company: {
                        id: string;
                        name: string;
                        slug: string | null;
                        website: string | null;
                        logoUrl: string | null;
                    };
                }>;
                confirm(slug: string, body: ConfirmWorkEmailBody, options?: FetchOptions): Promise<{
                    id: string;
                    object: "company_membership";
                    status: "approved" | "pending_work_email" | "awaiting_admin" | "rejected";
                    role: string;
                    workEmail: string | null;
                    workEmailVerifiedAt: string | null;
                    company: {
                        id: string;
                        name: string;
                        slug: string | null;
                        website: string | null;
                        logoUrl: string | null;
                    };
                }>;
            };
            jobs: {
                list(slug: string, query?: EmployerJobsListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                    id: string;
                    object: "employer_job";
                    title: string;
                    slug: string | null;
                    status: "draft" | "published" | "expired" | "archived";
                    companyId: string | null;
                    employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
                    remoteOption: "on_site" | "hybrid" | "remote" | null;
                    seniority: "entry_level" | "associate" | "mid_level" | "senior" | "lead" | "principal" | "director" | "executive" | null;
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                    salaryTimeframe: "per_year" | "per_month" | "per_week" | "per_day" | "per_hour" | null;
                    isFeatured: boolean;
                    publishedAt: string | null;
                    expiresAt: string | null;
                    createdAt: string;
                    updatedAt: string;
                    links: components["schemas"]["EmployerJobLinks"];
                }>>;
                retrieve(slug: string, id: string, options?: FetchOptions): Promise<{
                    id: string;
                    object: "employer_job";
                    title: string;
                    slug: string | null;
                    status: "draft" | "published" | "expired" | "archived";
                    companyId: string | null;
                    employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
                    remoteOption: "on_site" | "hybrid" | "remote" | null;
                    seniority: "entry_level" | "associate" | "mid_level" | "senior" | "lead" | "principal" | "director" | "executive" | null;
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                    salaryTimeframe: "per_year" | "per_month" | "per_week" | "per_day" | "per_hour" | null;
                    isFeatured: boolean;
                    publishedAt: string | null;
                    expiresAt: string | null;
                    createdAt: string;
                    updatedAt: string;
                    links: components["schemas"]["EmployerJobLinks"];
                } & {
                    description: string | null;
                    applicationUrl: string | null;
                    remotePermits: {
                        type: string;
                        value: string;
                    }[];
                    remoteWorldwide: boolean | null;
                    remoteTimezones: {
                        type: string;
                        value: string;
                        plusMinus?: number;
                    }[];
                    remoteAllowedTzOffsets: number[];
                    remoteWorkPermitCountryCodes: string[];
                    remoteWorkPermitSubdivisionCodes: string[];
                    remoteSponsorship: "yes" | "no" | "unknown";
                    educationRequirements: ("high_school" | "associate_degree" | "bachelor_degree" | "professional_certificate" | "postgraduate_degree" | "no_requirements")[];
                    experienceMonths: number | null;
                    experienceInPlaceOfEducation: boolean | null;
                    inOfficePeriod: "per_week" | "per_month" | "per_year" | null;
                    inOfficeFrequency: number | null;
                    company: components["schemas"]["JobCompany"];
                    officeLocations: components["schemas"]["JobOfficeLocation"][];
                }>;
                create(slug: string, body: CreateEmployerJobBody, options?: FetchOptions): Promise<{
                    id: string;
                    object: "employer_job";
                    title: string;
                    slug: string | null;
                    status: "draft" | "published" | "expired" | "archived";
                    companyId: string | null;
                    employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
                    remoteOption: "on_site" | "hybrid" | "remote" | null;
                    seniority: "entry_level" | "associate" | "mid_level" | "senior" | "lead" | "principal" | "director" | "executive" | null;
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                    salaryTimeframe: "per_year" | "per_month" | "per_week" | "per_day" | "per_hour" | null;
                    isFeatured: boolean;
                    publishedAt: string | null;
                    expiresAt: string | null;
                    createdAt: string;
                    updatedAt: string;
                    links: components["schemas"]["EmployerJobLinks"];
                } & {
                    description: string | null;
                    applicationUrl: string | null;
                    remotePermits: {
                        type: string;
                        value: string;
                    }[];
                    remoteWorldwide: boolean | null;
                    remoteTimezones: {
                        type: string;
                        value: string;
                        plusMinus?: number;
                    }[];
                    remoteAllowedTzOffsets: number[];
                    remoteWorkPermitCountryCodes: string[];
                    remoteWorkPermitSubdivisionCodes: string[];
                    remoteSponsorship: "yes" | "no" | "unknown";
                    educationRequirements: ("high_school" | "associate_degree" | "bachelor_degree" | "professional_certificate" | "postgraduate_degree" | "no_requirements")[];
                    experienceMonths: number | null;
                    experienceInPlaceOfEducation: boolean | null;
                    inOfficePeriod: "per_week" | "per_month" | "per_year" | null;
                    inOfficeFrequency: number | null;
                    company: components["schemas"]["JobCompany"];
                    officeLocations: components["schemas"]["JobOfficeLocation"][];
                }>;
                update(slug: string, id: string, body: UpdateEmployerJobBody, options?: FetchOptions): Promise<{
                    id: string;
                    object: "employer_job";
                    title: string;
                    slug: string | null;
                    status: "draft" | "published" | "expired" | "archived";
                    companyId: string | null;
                    employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
                    remoteOption: "on_site" | "hybrid" | "remote" | null;
                    seniority: "entry_level" | "associate" | "mid_level" | "senior" | "lead" | "principal" | "director" | "executive" | null;
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                    salaryTimeframe: "per_year" | "per_month" | "per_week" | "per_day" | "per_hour" | null;
                    isFeatured: boolean;
                    publishedAt: string | null;
                    expiresAt: string | null;
                    createdAt: string;
                    updatedAt: string;
                    links: components["schemas"]["EmployerJobLinks"];
                } & {
                    description: string | null;
                    applicationUrl: string | null;
                    remotePermits: {
                        type: string;
                        value: string;
                    }[];
                    remoteWorldwide: boolean | null;
                    remoteTimezones: {
                        type: string;
                        value: string;
                        plusMinus?: number;
                    }[];
                    remoteAllowedTzOffsets: number[];
                    remoteWorkPermitCountryCodes: string[];
                    remoteWorkPermitSubdivisionCodes: string[];
                    remoteSponsorship: "yes" | "no" | "unknown";
                    educationRequirements: ("high_school" | "associate_degree" | "bachelor_degree" | "professional_certificate" | "postgraduate_degree" | "no_requirements")[];
                    experienceMonths: number | null;
                    experienceInPlaceOfEducation: boolean | null;
                    inOfficePeriod: "per_week" | "per_month" | "per_year" | null;
                    inOfficeFrequency: number | null;
                    company: components["schemas"]["JobCompany"];
                    officeLocations: components["schemas"]["JobOfficeLocation"][];
                }>;
                delete(slug: string, id: string, options?: FetchOptions): Promise<void>;
                publish(slug: string, id: string, options?: FetchOptions): Promise<{
                    id: string;
                    object: "employer_job";
                    title: string;
                    slug: string | null;
                    status: "draft" | "published" | "expired" | "archived";
                    companyId: string | null;
                    employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
                    remoteOption: "on_site" | "hybrid" | "remote" | null;
                    seniority: "entry_level" | "associate" | "mid_level" | "senior" | "lead" | "principal" | "director" | "executive" | null;
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                    salaryTimeframe: "per_year" | "per_month" | "per_week" | "per_day" | "per_hour" | null;
                    isFeatured: boolean;
                    publishedAt: string | null;
                    expiresAt: string | null;
                    createdAt: string;
                    updatedAt: string;
                    links: components["schemas"]["EmployerJobLinks"];
                } & {
                    description: string | null;
                    applicationUrl: string | null;
                    remotePermits: {
                        type: string;
                        value: string;
                    }[];
                    remoteWorldwide: boolean | null;
                    remoteTimezones: {
                        type: string;
                        value: string;
                        plusMinus?: number;
                    }[];
                    remoteAllowedTzOffsets: number[];
                    remoteWorkPermitCountryCodes: string[];
                    remoteWorkPermitSubdivisionCodes: string[];
                    remoteSponsorship: "yes" | "no" | "unknown";
                    educationRequirements: ("high_school" | "associate_degree" | "bachelor_degree" | "professional_certificate" | "postgraduate_degree" | "no_requirements")[];
                    experienceMonths: number | null;
                    experienceInPlaceOfEducation: boolean | null;
                    inOfficePeriod: "per_week" | "per_month" | "per_year" | null;
                    inOfficeFrequency: number | null;
                    company: components["schemas"]["JobCompany"];
                    officeLocations: components["schemas"]["JobOfficeLocation"][];
                }>;
                unpublish(slug: string, id: string, options?: FetchOptions): Promise<{
                    id: string;
                    object: "employer_job";
                    title: string;
                    slug: string | null;
                    status: "draft" | "published" | "expired" | "archived";
                    companyId: string | null;
                    employmentType: "full_time" | "part_time" | "contract" | "internship" | "temporary" | "volunteer" | "other" | null;
                    remoteOption: "on_site" | "hybrid" | "remote" | null;
                    seniority: "entry_level" | "associate" | "mid_level" | "senior" | "lead" | "principal" | "director" | "executive" | null;
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                    salaryTimeframe: "per_year" | "per_month" | "per_week" | "per_day" | "per_hour" | null;
                    isFeatured: boolean;
                    publishedAt: string | null;
                    expiresAt: string | null;
                    createdAt: string;
                    updatedAt: string;
                    links: components["schemas"]["EmployerJobLinks"];
                } & {
                    description: string | null;
                    applicationUrl: string | null;
                    remotePermits: {
                        type: string;
                        value: string;
                    }[];
                    remoteWorldwide: boolean | null;
                    remoteTimezones: {
                        type: string;
                        value: string;
                        plusMinus?: number;
                    }[];
                    remoteAllowedTzOffsets: number[];
                    remoteWorkPermitCountryCodes: string[];
                    remoteWorkPermitSubdivisionCodes: string[];
                    remoteSponsorship: "yes" | "no" | "unknown";
                    educationRequirements: ("high_school" | "associate_degree" | "bachelor_degree" | "professional_certificate" | "postgraduate_degree" | "no_requirements")[];
                    experienceMonths: number | null;
                    experienceInPlaceOfEducation: boolean | null;
                    inOfficePeriod: "per_week" | "per_month" | "per_year" | null;
                    inOfficeFrequency: number | null;
                    company: components["schemas"]["JobCompany"];
                    officeLocations: components["schemas"]["JobOfficeLocation"][];
                }>;
                checkout(slug: string, id: string, body: EmployerCheckoutBody, options?: FetchOptions): Promise<{
                    object: "employer_checkout";
                    status: "checkout" | "published" | "invoice_sent";
                    checkoutUrl: string | null;
                    jobId: string;
                    jobSlug: string | null;
                }>;
            };
            billingOptions: {
                list(slug: string, options?: FetchOptions): Promise<ListEnvelope<{
                    id: string;
                    object: "employer_billing_option";
                    type: "subscription" | "order" | "plan_assignment";
                    kind?: "member_post";
                    planId: string;
                    planName: string;
                    planKind: "subscription" | "one_time" | "bundle";
                    jobsRemaining: number;
                    jobsTotal: number;
                    featuredRemaining: number;
                    featuredTotal: number;
                    jobsUnlimited?: boolean;
                    featuredUnlimited?: boolean;
                    renewsAt: string | null;
                }>>;
            };
            billingPortal: {
                create(slug: string, body?: CompanyBillingPortalBody, options?: FetchOptions): Promise<{
                    object: "portal_session";
                    url: string;
                }>;
            };
            jobStats: {
                retrieve(slug: string, options?: FetchOptions): Promise<ListEnvelope<{
                    object: "employer_job_stat";
                    jobId: string;
                    views: number;
                    applyClicks: number;
                    applications: number | null;
                }>>;
                timeseries(slug: string, query?: EmployerJobStatsTimeseriesQuery, options?: FetchOptions): Promise<ListEnvelope<{
                    object: "employer_job_stats_point";
                    date: string;
                    views: number;
                    applyClicks: number;
                }>>;
            };
            profileStats: {
                retrieve(slug: string, options?: FetchOptions): Promise<{
                    object: "employer_profile_stats";
                    profileViews: number;
                }>;
                timeseries(slug: string, query?: EmployerProfileViewsTimeseriesQuery, options?: FetchOptions): Promise<ListEnvelope<{
                    object: "employer_profile_views_point";
                    date: string;
                    views: number;
                }>>;
            };
            recommendedTalent: {
                list(slug: string, query: RecommendedTalentListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                    object: "recommended_talent";
                    candidate: components["schemas"]["TalentDirectoryEntry"];
                }>>;
            };
            talentLists: {
                list(slug: string, options?: FetchOptions): Promise<ListEnvelope<TalentList>>;
                create(slug: string, body: CreateTalentListBody, options?: FetchOptions): Promise<TalentList>;
                update(slug: string, listId: string, body: UpdateTalentListBody, options?: FetchOptions): Promise<TalentList>;
                remove(slug: string, listId: string, options?: FetchOptions): Promise<void>;
            };
            sourcedCandidates: {
                list(slug: string, query: {
                    job: string;
                }, options?: FetchOptions): Promise<ListEnvelope<SourcedCandidate>>;
                add(slug: string, body: AddSourcedCandidateBody, options?: FetchOptions): Promise<{
                    id: string;
                    object: "sourced_candidate";
                    created: boolean;
                }>;
                remove(slug: string, sourcedId: string, options?: FetchOptions): Promise<void>;
                convert(slug: string, sourcedId: string, body: ConvertSourcedCandidateBody, options?: FetchOptions): Promise<{
                    id: string;
                    object: "application";
                    created: boolean;
                }>;
            };
            applicants: {
                list(slug: string, query: EmployerPipelineQuery, options?: FetchOptions): Promise<{
                    object: "employer_pipeline";
                    job: {
                        id: string;
                        title: string;
                        status: string;
                        expiresAt: string | null;
                    };
                    stages: components["schemas"]["EmployerPipelineStage"][];
                    applicants: components["schemas"]["EmployerApplicant"][];
                }>;
                move(slug: string, applicationId: string, body: MoveApplicantStageBody, options?: FetchOptions): Promise<void>;
                bulkMove(slug: string, body: BulkMoveApplicantsBody, options?: FetchOptions): Promise<void>;
                bulkReject(slug: string, body: BulkRejectApplicantsBody, options?: FetchOptions): Promise<void>;
                addNote(slug: string, applicationId: string, body: AddApplicantNoteBody, options?: FetchOptions): Promise<void>;
            };
            pipelineStages: {
                create(slug: string, body: CreatePipelineStageBody, options?: FetchOptions): Promise<void>;
                update(slug: string, stageId: string, body: UpdatePipelineStageBody, options?: FetchOptions): Promise<void>;
                remove(slug: string, stageId: string, options?: FetchOptions): Promise<void>;
                reorder(slug: string, body: ReorderPipelineStagesBody, options?: FetchOptions): Promise<void>;
            };
        };
        talentAccess: {
            retrieve(options?: FetchOptions): Promise<{
                object: "talent_access";
                isEmployer: boolean;
                paywallActive: boolean;
                hasTalentAccess: boolean;
                hasUnlimitedUnlocks: boolean;
                accessModel: "none" | "paid_messaging" | "paid_unlocks_and_messaging";
                companyId: string | null;
                unlockCreditsRemaining: number;
                messageCreditsRemaining: number;
                hasUnlimitedMessages: boolean;
            }>;
            retrieveCandidate(candidateId: string, options?: FetchOptions): Promise<{
                object: "talent_candidate_access";
                candidateId: string;
                companyId: string | null;
                alreadyUnlocked: boolean;
                unlockCreditsRemaining: number;
                messageCreditsRemaining: number;
                hasUnlimitedUnlocks: boolean;
                hasUnlimitedMessages: boolean;
                hasActiveTalentSubscription: boolean;
            }>;
            checkout(body: TalentAccessCheckoutBody, options?: FetchOptions): Promise<{
                object: "checkout_session";
                sessionId: string;
                clientSecret: string;
                stripeAccountId: string;
                publishableKey: string;
                offerType: "recurring" | "lifetime";
            }>;
            claim(body: TalentAccessClaimBody, options?: FetchOptions): Promise<{
                object: "talent_access_claim";
                assignmentId: string;
                alreadyClaimed: boolean;
            }>;
            retrieveCheckout(sessionId: string, options?: FetchOptions): Promise<{
                object: "checkout_session_state";
                status: "open" | "complete" | "expired";
                clientSecret: string | null;
            }>;
            unlock(body: TalentUnlockBody, options?: FetchOptions): Promise<{
                object: "talent_unlock";
                alreadyUnlocked: boolean;
                unlockCreditsRemaining: number | null;
            }>;
            upgrade(body: TalentAccessUpgradeBody, options?: FetchOptions): Promise<{
                object: "talent_upgrade";
                ok: true;
            }>;
        };
        alerts: {
            list(options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "alert";
                label: string | null;
                frequency: "weekly";
                isActive: boolean;
                filters: {
                    jobFunctions: string[];
                    seniorityLevels: string[];
                    remoteOptions: string[];
                    placeIds: string[];
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                };
                lastSentAt: string | null;
            }>>;
            create(body: AlertBody, options?: FetchOptions): Promise<{
                id: string;
                object: "alert";
                label: string | null;
                frequency: "weekly";
                isActive: boolean;
                filters: {
                    jobFunctions: string[];
                    seniorityLevels: string[];
                    remoteOptions: string[];
                    placeIds: string[];
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                };
                lastSentAt: string | null;
            }>;
            retrieve(alertId: string, options?: FetchOptions): Promise<{
                id: string;
                object: "alert";
                label: string | null;
                frequency: "weekly";
                isActive: boolean;
                filters: {
                    jobFunctions: string[];
                    seniorityLevels: string[];
                    remoteOptions: string[];
                    placeIds: string[];
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                };
                lastSentAt: string | null;
            }>;
            update(alertId: string, body: AlertBody, options?: FetchOptions): Promise<{
                id: string;
                object: "alert";
                label: string | null;
                frequency: "weekly";
                isActive: boolean;
                filters: {
                    jobFunctions: string[];
                    seniorityLevels: string[];
                    remoteOptions: string[];
                    placeIds: string[];
                    salaryMin: number | null;
                    salaryMax: number | null;
                    salaryCurrency: string | null;
                };
                lastSentAt: string | null;
            }>;
            remove(alertId: string, options?: FetchOptions): Promise<void>;
        };
        applications: {
            list(query?: ApplicationsListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "application";
                status: "applied" | "interviewing" | "negotiation" | "hired" | "archived";
                appliedAt: string;
                updatedAt: string;
                coverNote: string | null;
                candidateName: string | null;
                candidateEmail: string | null;
                candidateLocation: string | null;
                candidateHeadline: string | null;
                resumeFilename: string | null;
                job: {
                    id: string;
                    title: string;
                    slug: string | null;
                    companySlug: string | null;
                    companyName: string | null;
                } | null;
            }>>;
            retrieve(applicationId: string, options?: FetchOptions): Promise<{
                id: string;
                object: "application";
                status: "applied" | "interviewing" | "negotiation" | "hired" | "archived";
                appliedAt: string;
                updatedAt: string;
                coverNote: string | null;
                candidateName: string | null;
                candidateEmail: string | null;
                candidateLocation: string | null;
                candidateHeadline: string | null;
                resumeFilename: string | null;
                job: {
                    id: string;
                    title: string;
                    slug: string | null;
                    companySlug: string | null;
                    companyName: string | null;
                } | null;
            }>;
            updateFacts(applicationId: string, body: UpdateApplicationFactsBody, options?: FetchOptions): Promise<{
                id: string;
                object: "application";
                status: "applied" | "interviewing" | "negotiation" | "hired" | "archived";
                appliedAt: string;
                updatedAt: string;
                coverNote: string | null;
                candidateName: string | null;
                candidateEmail: string | null;
                candidateLocation: string | null;
                candidateHeadline: string | null;
                resumeFilename: string | null;
                job: {
                    id: string;
                    title: string;
                    slug: string | null;
                    companySlug: string | null;
                    companyName: string | null;
                } | null;
            }>;
            withdraw(applicationId: string, options?: FetchOptions): Promise<void>;
        };
        resume: {
            upload(file: Blob, opts?: ResumeUploadOptions, options?: FetchOptions): Promise<{
                object: "resume";
                parseStatus: "parsing" | "parsed" | "failed" | null;
                parseFailureReason: string | null;
                parsedAt: string | null;
                keepResumeOnFile: boolean | null;
                hasResumeOnFile: boolean;
                file: {
                    url: string;
                    contentType: string;
                    sizeBytes: number;
                } | null;
            }>;
            retrieve(options?: FetchOptions): Promise<{
                object: "resume";
                parseStatus: "parsing" | "parsed" | "failed" | null;
                parseFailureReason: string | null;
                parsedAt: string | null;
                keepResumeOnFile: boolean | null;
                hasResumeOnFile: boolean;
                file: {
                    url: string;
                    contentType: string;
                    sizeBytes: number;
                } | null;
            }>;
            delete(options?: FetchOptions): Promise<void>;
        };
        recommendedJobs: {
            list(query?: RecommendedJobsListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                object: "recommended_job";
                job: components["schemas"]["PublicJobCard"];
            }>>;
        };
        savedJobs: {
            list(query?: SavedJobsListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "saved_job";
                jobId: string;
                savedAt: string;
                job: components["schemas"]["PublicJobCard"];
            }>>;
            save(body: SaveJobBody, query?: Record<string, never>, options?: FetchOptions): Promise<{
                id: string;
                object: "saved_job";
                jobId: string;
                savedAt: string;
                job: components["schemas"]["PublicJobCard"];
            }>;
            unsave(jobId: string, query?: Record<string, never>, options?: FetchOptions): Promise<void>;
        };
        conversations: {
            list(query?: ConversationsListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "conversation";
                lastMessageAt: string;
                lastMessageSnippet: string;
                lastMessageAuthorBoardUserId: string;
                archivedAt: string | null;
                hasUnread: boolean;
                counterparty: components["schemas"]["ConversationCounterparty"];
            }>>;
            unreadCount(options?: FetchOptions): Promise<{
                object: "unread_count";
                count: number;
            }>;
            retrieve(id: string, options?: FetchOptions): Promise<{
                id: string;
                object: "conversation";
                lastMessageAt: string;
                lastMessageSnippet: string;
                lastMessageAuthorBoardUserId: string;
                archivedAt: string | null;
                hasUnread: boolean;
                counterparty: components["schemas"]["ConversationCounterparty"];
            } & {
                viewerRole: "employer" | "candidate";
                viewerLastReadMessageId: string | null;
            }>;
            listMessages(id: string, query?: ThreadMessagesQuery, options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "message";
                conversationId: string;
                authorBoardUserId: string;
                recipientBoardUserId: string;
                body: string;
                author: components["schemas"]["MessageAuthor"];
                sentAt: string;
                editedAt: string | null;
                deletedAt: string | null;
                readAt: string | null;
            }>>;
            start(body: StartConversationBody, options?: FetchOptions): Promise<{
                id: string;
                object: "message";
                conversationId: string;
                authorBoardUserId: string;
                recipientBoardUserId: string;
                body: string;
                author: components["schemas"]["MessageAuthor"];
                sentAt: string;
                editedAt: string | null;
                deletedAt: string | null;
                readAt: string | null;
            }>;
            startAboutApplication(body: StartAboutApplicationBody, options?: FetchOptions): Promise<{
                id: string;
                object: "message";
                conversationId: string;
                authorBoardUserId: string;
                recipientBoardUserId: string;
                body: string;
                author: components["schemas"]["MessageAuthor"];
                sentAt: string;
                editedAt: string | null;
                deletedAt: string | null;
                readAt: string | null;
            }>;
            reply(id: string, body: ReplyBody, options?: FetchOptions): Promise<{
                id: string;
                object: "message";
                conversationId: string;
                authorBoardUserId: string;
                recipientBoardUserId: string;
                body: string;
                author: components["schemas"]["MessageAuthor"];
                sentAt: string;
                editedAt: string | null;
                deletedAt: string | null;
                readAt: string | null;
            }>;
            markRead(id: string, options?: FetchOptions): Promise<{
                object: "read_receipt";
                markedAt: string;
            }>;
            archive(id: string, options?: FetchOptions): Promise<{
                object: "conversation_archive";
                archivedAt: string | null;
            }>;
            unarchive(id: string, options?: FetchOptions): Promise<{
                object: "conversation_archive";
                archivedAt: string | null;
            }>;
            findExisting(query: FindExistingConversationQuery, options?: FetchOptions): Promise<{
                object: "conversation_ref";
                conversationId: string | null;
            }>;
        };
        blocks: {
            list(options?: FetchOptions): Promise<ListEnvelope<{
                id: string;
                object: "blocked_user";
                boardUserId: string;
                displayName: string;
                avatarUrl: string | null;
                createdAt: string;
            }>>;
            create(body: BlockUserBody, options?: FetchOptions): Promise<{
                object: "block";
                blocked: true;
            }>;
            remove(boardUserId: string, options?: FetchOptions): Promise<void>;
            status(boardUserId: string, options?: FetchOptions): Promise<{
                object: "block_status";
                blocked: boolean;
            }>;
        };
        messages: {
            edit(id: string, body: EditMessageBody, options?: FetchOptions): Promise<{
                id: string;
                object: "message";
                conversationId: string;
                authorBoardUserId: string;
                recipientBoardUserId: string;
                body: string;
                author: components["schemas"]["MessageAuthor"];
                sentAt: string;
                editedAt: string | null;
                deletedAt: string | null;
                readAt: string | null;
            }>;
            unsend(id: string, options?: FetchOptions): Promise<{
                id: string;
                object: "message";
                conversationId: string;
                authorBoardUserId: string;
                recipientBoardUserId: string;
                body: string;
                author: components["schemas"]["MessageAuthor"];
                sentAt: string;
                editedAt: string | null;
                deletedAt: string | null;
                readAt: string | null;
            }>;
            report(id: string, body: ReportBody, options?: FetchOptions): Promise<{
                object: "moderation_report";
                id: string;
                blocked: boolean;
            }>;
        };
        marketingConsent: {
            retrieve(options?: FetchOptions): Promise<{
                id: string;
                object: "marketing_consent";
                status: "granted" | "withdrawn";
                source: string;
                reason: "person_request" | "operator_request" | "account_deleted" | null;
                grantedAt: string | null;
                withdrawnAt: string | null;
                revision: number;
            } | null>;
            grant(options?: FetchOptions): Promise<{
                id: string;
                object: "marketing_consent";
                status: "granted" | "withdrawn";
                source: string;
                reason: "person_request" | "operator_request" | "account_deleted" | null;
                grantedAt: string | null;
                withdrawnAt: string | null;
                revision: number;
            } | null>;
            withdraw(options?: FetchOptions): Promise<{
                id: string;
                object: "marketing_consent";
                status: "granted" | "withdrawn";
                source: string;
                reason: "person_request" | "operator_request" | "account_deleted" | null;
                grantedAt: string | null;
                withdrawnAt: string | null;
                revision: number;
            } | null>;
        };
        access: {
            checkout(body: AccessCheckoutBody, options?: FetchOptions): Promise<{
                object: "checkout_session";
                sessionId: string;
                clientSecret: string;
                stripeAccountId: string;
                publishableKey: string;
                offerType: "recurring" | "lifetime";
            }>;
            retrieveCheckout(sessionId: string, options?: FetchOptions): Promise<{
                object: "checkout_session_state";
                status: "open" | "complete" | "expired";
                clientSecret: string | null;
            }>;
            grant(options?: FetchOptions): Promise<{
                object: "access_grant";
                hasAccess: boolean;
                status: "active" | "past_due" | "unpaid" | "incomplete" | "incomplete_expired" | "canceled" | "pending" | null;
                offerType: "recurring" | "lifetime" | null;
                offerKey: string | null;
                currentPeriodEnd: string | null;
                cancelAtPeriodEnd: boolean;
            }>;
            portal(body?: AccessPortalBody, options?: FetchOptions): Promise<{
                object: "portal_session";
                url: string;
            }>;
        };
    };
    password: {
        verify(password: string, options?: FetchOptions): Promise<BoardAccessGrant>;
    };
    taxonomy: {
        categories: {
            list(query?: TaxonomyListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                object: "taxonomy_term";
                id: string;
                type: "category" | "skill";
                sourceSlug: string;
                canonicalSlug: string;
                displayName: string;
                jobCount: number;
            }>>;
            resolve(slug: string, options?: FetchOptions): Promise<{
                object: "taxonomy_resolution";
                type: "category" | "skill" | "place" | "market";
                sourceSlug: string;
                canonicalSlug: string;
                displayName: string;
                redirectTo: string | null;
                geo: components["schemas"]["TaxonomyGeo"];
            }>;
        };
        skills: {
            list(query?: TaxonomyListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                object: "taxonomy_term";
                id: string;
                type: "category" | "skill";
                sourceSlug: string;
                canonicalSlug: string;
                displayName: string;
                jobCount: number;
            }>>;
            resolve(slug: string, options?: FetchOptions): Promise<{
                object: "taxonomy_resolution";
                type: "category" | "skill" | "place" | "market";
                sourceSlug: string;
                canonicalSlug: string;
                displayName: string;
                redirectTo: string | null;
                geo: components["schemas"]["TaxonomyGeo"];
            }>;
        };
        remotePermits: {
            list(options?: FetchOptions): Promise<ListEnvelope<{
                type: string;
                value: string;
                label: string;
            }>>;
        };
        places: {
            list(query?: PlacesListQuery, options?: FetchOptions): Promise<ListEnvelope<{
                object: "place";
                id: string;
                parentId: string | null;
                slug: string | null;
                name: string;
                placeType: string;
                countryCode: string | null;
                regionCode: string | null;
                jobCount: number;
            }>>;
            resolve(slug: string, options?: FetchOptions): Promise<{
                object: "taxonomy_resolution";
                type: "category" | "skill" | "place" | "market";
                sourceSlug: string;
                canonicalSlug: string;
                displayName: string;
                redirectTo: string | null;
                geo: components["schemas"]["TaxonomyGeo"];
            }>;
        };
    };
    search: {
        suggest(query?: SearchSuggestQuery, options?: FetchOptions): Promise<{
            object: "suggest_result";
            query: string;
            items: components["schemas"]["SuggestionItem"][];
        }>;
    };
    redirects: {
        resolve(path: string, options?: FetchOptions): Promise<{
            object: "redirect_resolution";
            path: string;
            target: string | null;
        }>;
    };
    jobAlerts: {
        subscribe(input: JobAlertSubscribeInput, options?: FetchOptions): Promise<{
            object: "job_alert_subscription";
            status: "submitted";
        }>;
        confirm(input: {
            token: string;
        }, options?: FetchOptions): Promise<{
            object: "job_alert_confirmation";
            status: "confirmed" | "already_confirmed" | "expired" | "not_found";
        }>;
        resendConfirmation(input: {
            email: string;
        }, options?: FetchOptions): Promise<{
            object: "job_alert_confirmation_resend";
            status: "submitted";
        }>;
        manage(query: JobAlertManageQuery, options?: FetchOptions): Promise<{
            object: "job_alert_manage_state";
            email: string;
            confirmed: boolean;
            unsubscribed: boolean;
            preferences: {
                id: string;
                label: string | null;
                frequency: "weekly";
                isActive: boolean;
                filters: {
                    jobFunctions?: string[];
                    seniorityLevels?: string[];
                    remoteOptions?: string[];
                    placeIds?: string[];
                    salaryMin?: number | null;
                    salaryMax?: number | null;
                    salaryCurrency?: string | null;
                };
                manageToken: string;
            }[];
        }>;
        unsubscribe(input: JobAlertManageTokenInput, options?: FetchOptions): Promise<{
            object: "job_alert_manage_result";
            success: boolean;
        }>;
        resubscribe(input: JobAlertManageTokenInput, options?: FetchOptions): Promise<{
            object: "job_alert_manage_result";
            success: boolean;
        }>;
        updatePreference(input: JobAlertUpdatePreferenceInput, options?: FetchOptions): Promise<{
            object: "job_alert_manage_result";
            success: boolean;
        }>;
        deletePreference(input: JobAlertDeletePreferenceInput, options?: FetchOptions): Promise<{
            object: "job_alert_manage_result";
            success: boolean;
        }>;
    };
    jobPosting: {
        plans(query?: {
            purpose?: "job_posting" | "talent_access";
        }, options?: FetchOptions): Promise<ListEnvelope<{
            object: "job_posting_plan";
            id: string;
            name: string;
            description: string | null;
            kind: string;
            billingInterval: "month" | "year" | null;
            purpose: "job_posting" | "talent_access" | null;
            isRecommended: boolean;
            displayOrder: number | null;
            invoiceOnly: boolean;
            publishTiming: "on_issue" | "on_payment" | null;
            netTermsDays: number | null;
            prices: {
                currency: string;
                amountCents: number;
                isActive: boolean;
            }[];
            features: {
                key: string | null;
                value: string | null;
            }[];
        }>>;
        create(input: CreateJobPostingInput, options?: FetchOptions): Promise<{
            object: "job_posting_result";
            status: "checkout";
            checkoutUrl: string;
            jobId: string;
        } | {
            object: "job_posting_result";
            status: "published";
            jobId: string;
            jobSlug: string;
        } | {
            object: "job_posting_result";
            status: "pending_approval";
            jobId: string;
        } | {
            object: "job_posting_result";
            status: "invoice_sent";
            jobId: string;
        }>;
        uploadLogo(file: Blob, options?: FetchOptions): Promise<{
            object: "job_posting_logo";
            publicUrl: string;
        }>;
        fetchLogoByDomain(domain: string, options?: FetchOptions): Promise<{
            object: "job_posting_logo";
            publicUrl: string;
        }>;
        sendBillingVerification(input: {
            email: string;
        }, options?: FetchOptions): Promise<{
            object: "job_posting_billing_verification";
            success: boolean;
        }>;
        getBillingOptions(input: {
            verificationToken: string;
        }, options?: FetchOptions): Promise<{
            object: "job_posting_billing_options";
            options: {
                id: string;
                type: string;
                planId: string;
                planName: string;
                planKind: string;
                capacities: {
                    key: string;
                    total: number;
                    used: number;
                    remaining: number;
                }[];
                jobsRemaining: number;
                jobsTotal: number;
                featuredRemaining: number;
                featuredTotal: number;
                renewsAt: string | null;
            }[];
        }>;
    };
    salaries: {
        companies: {
            list(options?: FetchOptions): Promise<ListEnvelope<{
                object: "salary_company";
                companySlug: string;
                companyName: string;
                logoPath: string | null;
                avgSalaryMin: number;
                avgSalaryMax: number;
                jobCount: number;
                currency: string;
            }>>;
        };
        titles: {
            list(query?: SalaryDetailQuery, options?: FetchOptions): Promise<ListEnvelope<{
                object: "salary_title";
                slug: string;
                name: string;
                avgSalaryMin: number;
                avgSalaryMax: number;
                p25SalaryMin: number;
                p75SalaryMax: number;
                jobCount: number;
                currency: string;
            }>>;
            retrieve(categorySlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "title_salary_detail";
                sourceSlug: string;
                canonicalSlug: string;
                categoryName: string;
                overallSalary: {
                    avgMin: number;
                    avgMax: number;
                    p25Min: number;
                    p75Max: number;
                    jobCount: number;
                } | null;
                bySeniority: {
                    seniority: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    boardAvgMin: number | null;
                    boardAvgMax: number | null;
                    boardMedianMin: number | null;
                    boardMedianMax: number | null;
                    boardP25Min: number | null;
                    boardP75Min: number | null;
                    boardP25Max: number | null;
                    boardP75Max: number | null;
                    diffPercent: number | null;
                }[];
                topCompanies: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    companySlug: string;
                    companyName: string;
                    logoPath: string | null;
                }[];
                topLocations: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    placeName: string;
                    placeSlug: string;
                    countryCode: string;
                }[];
                topSkills: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    skillSlug: string;
                    skillName: string;
                }[];
                relatedTitles: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    categorySlug: string;
                    categoryName: string;
                }[];
                totalLocationCount: number;
                boardOverallAvgMin: number | null;
                boardOverallAvgMax: number | null;
                boardMedianMin: number | null;
                boardMedianMax: number | null;
                boardP25Min: number | null;
                boardP75Max: number | null;
                currency: string;
            }>;
            locations(categorySlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "title_locations_index";
                sourceSlug: string;
                canonicalSlug: string;
                categoryName: string;
                currency: string;
                locations: components["schemas"]["SalaryLocationIndexItem"][];
            }>;
            location(categorySlug: string, locationSlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "title_location_salary";
                categorySourceSlug: string;
                categoryCanonicalSlug: string;
                locationSourceSlug: string;
                locationCanonicalSlug: string;
                categoryName: string;
                placeName: string;
                countryCode: string;
                adminLevel: string;
                overallSalary: {
                    avgMin: number;
                    avgMax: number;
                    p25Min: number | null;
                    p75Max: number | null;
                    jobCount: number;
                } | null;
                bySeniority: {
                    seniority: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
                childLocations: {
                    placeSlug: string;
                    placeName: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
                childLocationsByRegion: {
                    regionName: string;
                    regionSlug: string;
                    cities: {
                        placeSlug: string;
                        placeName: string;
                        avgSalaryMin: number;
                        avgSalaryMax: number;
                        jobCount: number;
                    }[];
                }[];
                otherLocations: {
                    placeSlug: string;
                    placeName: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
                topSkills: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    skillSlug: string;
                    skillName: string;
                }[];
                topTitles: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    categorySlug: string;
                    categoryName: string;
                }[];
                boardCategoryAvgMin: number | null;
                boardCategoryAvgMax: number | null;
                currency: string;
            }>;
        };
        skills: {
            list(query?: SalaryDetailQuery, options?: FetchOptions): Promise<ListEnvelope<{
                object: "salary_skill";
                slug: string;
                name: string;
                avgSalaryMin: number;
                avgSalaryMax: number;
                p25SalaryMin: number;
                p75SalaryMax: number;
                jobCount: number;
                currency: string;
            }>>;
            retrieve(skillSlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "skill_salary_detail";
                sourceSlug: string;
                canonicalSlug: string;
                skillName: string;
                overallSalary: {
                    avgMin: number;
                    avgMax: number;
                    medianMin: number;
                    medianMax: number;
                    p25Min: number;
                    p75Max: number;
                    jobCount: number;
                } | null;
                bySeniority: {
                    seniority: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    boardAvgMin: number | null;
                    boardAvgMax: number | null;
                    diffPercent: number | null;
                }[];
                topCompanies: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    companySlug: string;
                    companyName: string;
                    logoPath: string | null;
                }[];
                topLocations: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    placeName: string;
                    placeSlug: string;
                    countryCode: string;
                }[];
                topTitles: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    categorySlug: string;
                    categoryName: string;
                }[];
                relatedSkills: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    skillSlug: string;
                    skillName: string;
                }[];
                totalLocationCount: number;
                boardOverallAvgMin: number | null;
                boardOverallAvgMax: number | null;
                boardMedianMin: number | null;
                boardMedianMax: number | null;
                currency: string;
            }>;
            locations(skillSlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "skill_locations_index";
                sourceSlug: string;
                canonicalSlug: string;
                skillName: string;
                currency: string;
                locations: components["schemas"]["SalaryLocationIndexItem"][];
            }>;
            location(skillSlug: string, locationSlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "skill_location_salary";
                skillSourceSlug: string;
                skillCanonicalSlug: string;
                locationSourceSlug: string;
                locationCanonicalSlug: string;
                skillName: string;
                placeName: string;
                countryCode: string;
                adminLevel: string;
                overallSalary: {
                    avgMin: number;
                    avgMax: number;
                    p25Min: number | null;
                    p75Max: number | null;
                    jobCount: number;
                } | null;
                bySeniority: {
                    seniority: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
                childLocations: {
                    placeSlug: string;
                    placeName: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
                childLocationsByRegion: {
                    regionName: string;
                    regionSlug: string;
                    cities: {
                        placeSlug: string;
                        placeName: string;
                        avgSalaryMin: number;
                        avgSalaryMax: number;
                        jobCount: number;
                    }[];
                }[];
                otherLocations: {
                    placeSlug: string;
                    placeName: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
                topSkills: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    skillSlug: string;
                    skillName: string;
                }[];
                topTitles: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    categorySlug: string;
                    categoryName: string;
                }[];
                boardSkillAvgMin: number | null;
                boardSkillAvgMax: number | null;
                currency: string;
            }>;
        };
        locations: {
            list(query?: SalaryDetailQuery, options?: FetchOptions): Promise<ListEnvelope<{
                object: "salary_location";
                placeSlug: string;
                placeName: string;
                parentSlug: string | null;
                avgSalaryMin: number;
                avgSalaryMax: number;
                jobCount: number;
            }>>;
            retrieve(locationSlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "location_salary_detail";
                sourceSlug: string;
                canonicalSlug: string;
                placeName: string;
                placeId: string;
                adminLevel: string;
                countryCode: string;
                overallSalary: {
                    avgMin: number;
                    avgMax: number;
                    medianMin: number;
                    medianMax: number;
                    p25Min: number;
                    p75Max: number;
                    jobCount: number;
                } | null;
                childLocations: {
                    placeName: string;
                    placeSlug: string;
                    countryCode: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    medianSalaryMin: number;
                    medianSalaryMax: number;
                    p25SalaryMin: number;
                    p75SalaryMax: number;
                    jobCount: number;
                    currency: string;
                }[];
                childLocationsByRegion: {
                    regionName: string;
                    regionSlug: string;
                    cities: {
                        placeName: string;
                        placeSlug: string;
                        countryCode: string;
                        avgSalaryMin: number;
                        avgSalaryMax: number;
                        medianSalaryMin: number;
                        medianSalaryMax: number;
                        p25SalaryMin: number;
                        p75SalaryMax: number;
                        jobCount: number;
                        currency: string;
                    }[];
                }[];
                topCategories: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    categorySlug: string;
                    categoryName: string;
                }[];
                topSkills: {
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                    skillSlug: string;
                    skillName: string;
                }[];
                siblingLocations: {
                    placeName: string;
                    placeSlug: string;
                    countryCode: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    medianSalaryMin: number;
                    medianSalaryMax: number;
                    p25SalaryMin: number;
                    p75SalaryMax: number;
                    jobCount: number;
                    currency: string;
                }[];
                boardOverallAvgMin: number | null;
                boardOverallAvgMax: number | null;
                currency: string;
            }>;
            titles(locationSlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "location_titles_index";
                sourceSlug: string;
                canonicalSlug: string;
                placeName: string;
                titles: {
                    slug: string;
                    name: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
            }>;
            skills(locationSlug: string, query?: SalaryDetailQuery, options?: FetchOptions): Promise<{
                object: "location_skills_index";
                sourceSlug: string;
                canonicalSlug: string;
                placeName: string;
                skills: {
                    slug: string;
                    name: string;
                    avgSalaryMin: number;
                    avgSalaryMax: number;
                    jobCount: number;
                }[];
            }>;
        };
    };
    talent: {
        list(query?: TalentDirectoryQuery, options?: FetchOptions): Promise<TalentDirectoryListEnvelope>;
        retrieve(handle: string, options?: FetchOptions): Promise<{
            object: "talent_profile";
            id: string;
            handle: string | null;
            displayName: string | null;
            headline: string | null;
            location: string | null;
            bio: string | null;
            avatarUrl: string | null;
            jobSearchStatus: string | null;
            experiences: {
                title: string;
                companyName: string;
                companyUrl: string | null;
                companyLogoUrl: string | null;
                location: string | null;
                employmentType: string | null;
                locationType: string | null;
                foundVia: string | null;
                startDate: string;
                endDate: string | null;
                description: string | null;
                experienceSkills: string[];
            }[];
            education: {
                institutionName: string;
                institutionUrl: string | null;
                institutionLogoUrl: string | null;
                degree: string | null;
                fieldOfStudy: string | null;
                grade: string | null;
                activitiesAndSocieties: string | null;
                startDate: string | null;
                endDate: string | null;
                description: string | null;
            }[];
            skills: {
                name: string;
                jobSkillId: string | null;
            }[];
            languages: {
                name: string;
                proficiency: string;
            }[];
        }>;
    };
    plans: {
        list(query?: PlansListQuery, options?: FetchOptions): Promise<PlanListEnvelope>;
        salesLed(options?: FetchOptions): Promise<SalesLedPlanListEnvelope>;
    };
    paywall: {
        offers(options?: FetchOptions): Promise<PaywallOfferListEnvelope>;
    };
    sitemap: ((options?: FetchOptions) => Promise<{
        object: "board_sitemap";
        buckets: components["schemas"]["BoardSitemapBucketSummary"][];
    }>) & {
        entries(bucket: string, query?: SitemapEntriesQuery, options?: FetchOptions): Promise<SitemapEntriesEnvelope>;
    };
};
type BoardSdk = ReturnType<typeof createBoardClient>;

export { type AcceptCompanyMemberInviteBody, type AccessCheckoutBody, type AccessCheckoutSession, type AccessCheckoutSessionState, type AccessGrant, type AccessPortalBody, type AccessPortalSession, type AddApplicantNoteBody, type AddSourcedCandidateBody, type Alert, type AlertBody, type Application, type ApplicationsListQuery, type ApplyAction, type ApplyApprovalPlan, type ApplyApprovalReceipt, type ApplyBody, type ApplyDecisionState, type ApplyIntent, Awaitable, BOARD_API_ERROR_CODES, type Block, type BlockStatus, type BlockUserBody, type BlockedUser, BlogPostsListQuery, BlogSearchBody, BlogSimilarQuery, type BoardAccessGrant, BoardApiError, type BoardApiErrorCode, type BoardAuthSession, BoardClient, BoardRequest, type BoardSdk, type BoardSitemapBucketSummary, type BoardSitemapIndex, type BoardUser, type BulkMoveApplicantsBody, type BulkRejectApplicantsBody, type CandidateAvatar, type CandidateEducation, type CandidateExperience, type CandidateLanguage, type CandidateProfile, type CandidateSkill, type ClaimableCompany, CompaniesListQuery, CompaniesSearchBody, type CompanyBillingPortalBody, type CompanyBillingPortalSession, CompanyJobsListQuery, CompanyListEnvelope, CompanyMarketsListQuery, type CompanyMember, type CompanyMemberInvite, type CompanyMemberInviteAcceptance, type CompanyMembership, CompanySimilarQuery, type ConfirmEmailChangeBody, type ConfirmWorkEmailBody, type ConsumeMagicLinkBody, type Conversation, type ConversationArchive, type ConversationDetail, type ConversationRef, type ConversationsListQuery, type ConvertSourcedCandidateBody, type CreateApplyApprovalBody, type CreateApplyIntentBody, type CreateBoardClientOptions, type CreateCompanyBody, type CreateCompanyMemberInviteBody, type CreateEducationBody, type CreateEmployerJobBody, type CreateExperienceBody, type CreateJobPostingInput, type CreatePipelineStageBody, type CreateTalentListBody, type EditMessageBody, type EmbedJobsQuery, type EmployerApplicant, type EmployerBillingOption, type EmployerCheckout, type EmployerCheckoutBody, type EmployerCompany, type EmployerCompanySearchQuery, type EmployerJob, type EmployerJobStat, type EmployerJobStatsPoint, type EmployerJobStatsTimeseriesQuery, type EmployerJobSummary, type EmployerJobsListQuery, type EmployerPipeline, type EmployerPipelineQuery, type EmployerPipelineStage, type EmployerProfileStats, type EmployerProfileViewsPoint, type EmployerProfileViewsTimeseriesQuery, EmploymentType, FetchOptions, type FindExistingConversationQuery, type ForgotPasswordBody, type HandleAvailability, type JobAlertConfirmation, type JobAlertDeletePreferenceInput, type JobAlertFiltersInput, type JobAlertFrequency, type JobAlertManageQuery, type JobAlertManageResult, type JobAlertManageState, type JobAlertManageTokenInput, type JobAlertPreference, type JobAlertRemoteOption, type JobAlertResendResult, type JobAlertStoredFilters, type JobAlertSubscribeInput, type JobAlertSubscription, type JobAlertUpdatePreferenceInput, JobCardListEnvelope, JobCardSearchEnvelope, type JobPostingBillingOptions, type JobPostingBillingVerification, type JobPostingLogoResult, type JobPostingPlan, type JobPostingResult, JobsListQuery, JobsSearchBody, JobsSimilarQuery, ListEnvelope, Logger, type LoginBody, type LogoutBody, type MarketingConsent, type MembershipCheckoutBody, type MembershipCheckoutSession, type MembershipCheckoutSessionState, type Message, type ModerationReport, type MoveApplicantStageBody, type NotificationPreference, type OAuthAuthorizationQuery, type OAuthAuthorizationUrl, type OAuthExchangeBody, type OAuthProvider, type Paginator, type PaywallOffer, type PaywallOfferListEnvelope, type PlacesListQuery, type Plan, type PlanListEnvelope, type PlansListQuery, type PublicPlace, type PublicTaxonomyTerm, type ReadReceipt, type RecommendedJob, type RecommendedJobsListQuery, type RecommendedTalent, type RecommendedTalentListQuery, type RedirectResolution, type RefreshBody, type RegisterBody, RemoteOption, type RemotePermitTaxonomyEntry, type ReorderPipelineStagesBody, type ReplyBody, type ReportBody, type RequestEmailChangeBody, type RequestMagicLinkBody, type ResetPasswordBody, type Resume, type ResumeUploadOptions, SDK_VERSION, SalaryDetailQuery, type SalesLedPlan, type SalesLedPlanListEnvelope, type SaveJobBody, type SavedJob, type SavedJobsListQuery, SearchEnvelope, SearchSuggestQuery, type SendWorkEmailBody, Seniority, type SitemapEntriesEnvelope, type SitemapEntriesQuery, type SitemapEntry, type SourcedCandidate, type StartAboutApplicationBody, type StartConversationBody, StorageMode, type TalentAccess, type TalentAccessCheckoutBody, type TalentAccessCheckoutSession, type TalentAccessCheckoutSessionState, type TalentAccessClaim, type TalentAccessClaimBody, type TalentAccessUpgrade, type TalentAccessUpgradeBody, type TalentCandidateAccess, type TalentDirectoryEntry, type TalentDirectoryListEnvelope, type TalentDirectoryQuery, type TalentList, type TalentListFilters, type TalentProfile, type TalentUnlock, type TalentUnlockBody, type TaxonomyGeo, type TaxonomyListQuery, type TaxonomyResolution, type ThreadMessagesQuery, type UnreadCount, type UnsubscribeBody, type UpdateApplicationFactsBody, type UpdateCandidateProfileBody, type UpdateCompanyMemberRoleBody, type UpdateEducationBody, type UpdateEmployerCompanyBody, type UpdateEmployerJobBody, type UpdateExperienceBody, type UpdateLanguagesBody, type UpdateNotificationPreferenceBody, type UpdatePasswordBody, type UpdatePipelineStageBody, type UpdateSkillsBody, type UpdateTalentListBody, type VerifyEmailBody, createBoardClient, isBoardApiError, isBoardPasswordRequired, isColdRule, isConflict, isForbidden, isFreeEmailWebsiteError, isNotFound, isOwnMessage, isRateLimited, isSafeApplicationUrl, isUnauthorized, isValidationError, lastOwnMessageId, paginate, resolveApplyAction, resolveApplyDecision };