interface LocationValue {
    city?: string;
    /** community.lexicon.location.address field -- preferred over `city`. */
    locality?: string;
    region?: string;
    country: string;
    countryCode?: string;
    postalCode?: string;
    geonameId?: number;
}
interface SkillRef {
    uri: string;
}
interface ProfilePosition {
    rkey: string;
    /**
     * Optional: omitted for self-employed / freelance / independent positions.
     * The lexicon and the record schema already make company optional.
     */
    company?: string;
    /**
     * Portable org entity identifier (Wikidata/ROR/LEI URI) written when the user
     * picks an organization from the resolver typeahead. Absent for free-text or
     * independent positions (#159).
     */
    entityRef?: string;
    /**
     * Resolved current canonical name of the durably-linked company (#240),
     * computed by the AppView at read time. Render this over `company` for a
     * linked position, so a name correction reaches every linked profile without
     * a PDS write. Absent for free-text or unresolved positions (fall back to
     * `company`).
     */
    entityName?: string;
    /**
     * Company-page slug for a durably-linked position, resolved by the AppView at
     * read time alongside `entityName` (#159). Lets a consumer link the company
     * name to its `/c/{domain}` page without re-resolving `entityRef`. `domain` is
     * the readable form, `publicId` the durable fallback; build the link as
     * `/c/${companyDomain ?? companyPublicId}`. Both absent for free-text /
     * unlinked positions.
     */
    companyDomain?: string;
    companyPublicId?: string;
    title: string;
    description?: string;
    startedAt: string;
    endedAt?: string;
    location?: LocationValue | null;
    employmentType?: string;
    /**
     * Party this role is held on behalf of, when the person represents someone else --
     * most often a fund whose board seat this is. A disclosure rather than a role type,
     * so it is a separate field from `employmentType`. Absent for independent roles.
     */
    onBehalfOf?: string;
    /** DID of the represented party, when known. May be an organization or a person. */
    onBehalfOfDid?: string;
    /** Portable entity identifier for the represented party (Wikidata/ROR/LEI URI). */
    onBehalfOfEntityRef?: string;
    workplaceType?: string;
    skills?: SkillRef[];
    linkedSkills?: ProfileSkill[];
    primary?: boolean;
    hidden?: boolean;
}
interface ProfileEducation {
    rkey: string;
    institution: string;
    /**
     * Portable org entity identifier (Wikidata/ROR/LEI URI) written when the user
     * links the institution to a resolved organization (#159/#241). Absent for
     * free-text entries. Mirrors `ProfilePosition.entityRef`; the AppView sends it
     * for display (the "Linked" badge).
     */
    entityRef?: string;
    /**
     * Resolved current canonical name of the durably-linked institution (#252),
     * computed by the AppView at read time. Render this over `institution` for a
     * linked entry, so a name correction reaches every linked profile without a
     * PDS write. Absent for free-text or unresolved entries (fall back to
     * `institution`).
     */
    entityName?: string;
    degree?: string;
    fieldOfStudy?: string;
    description?: string;
    activities?: string;
    startedAt?: string;
    endedAt?: string;
    hidden?: boolean;
}
interface ProfileSkill {
    rkey: string;
    name: string;
    /**
     * CID of the skill record, needed as a strongRef when endorsing it. Often
     * absent: only the firehose carries a CID, so a skill added moments ago has
     * none indexed yet. Pass it to `createEndorsement` when present and omit it
     * otherwise -- the AppView resolves it from the owner's PDS.
     */
    cid?: string;
    category?: string;
    /**
     * Freeform user-defined grouping label nested under `category` (e.g.
     * "Frontend", "Backend"). No known values; renderers decide the display
     * label. See `groupSkillsBySubCategory`.
     */
    subCategory?: string;
    endorsementCount?: number;
    endorsed?: boolean;
    /**
     * Names this skill was endorsed under, where they differ from what it is
     * called now. Absent when nothing has drifted.
     *
     * A rename keeps the same record, so endorsements follow it and stay
     * counted. Showing the original name is what keeps that honest: a reader can
     * see that a skill now called one thing was vouched for as another, instead
     * of the rename quietly laundering the endorsement.
     */
    endorsedAs?: string[];
    activityBacked?: boolean;
}
interface SkillSuggestion {
    canonicalName: string;
    slug: string;
    category: string;
}
interface Endorsement {
    endorserDid: string;
    endorserHandle: string;
    endorserDisplayName?: string;
    endorserAvatar?: string;
    comment?: string;
    relationshipContext?: string;
    createdAt: string;
}
interface EndorsementData {
    skillRkey: string;
    comment?: string;
    relationshipContext?: string;
}
interface ProfileLocation {
    rkey: string;
    type: string;
    label?: string | null;
    isPrimary: boolean;
    locationCountry?: string | null;
    locationRegion?: string | null;
    /** Legacy alias for `locationLocality`; emitted by sifa-api during the additive response window. */
    locationCity?: string | null;
    /** community.lexicon.location.address field name -- prefer over `locationCity`. */
    locationLocality?: string | null;
    countryCode?: string | null;
    location?: string | null;
}
interface ProfileCertification {
    rkey: string;
    name: string;
    /**
     * Issuing organization. The write contract names this field `authority`
     * everywhere (record schema, DB column, PDS record); the AppView read view
     * emits `authority` as the canonical field (#249). Optional during the
     * deprecation window while consumers migrate off the legacy `issuingOrg`
     * alias below.
     */
    authority?: string;
    /**
     * @deprecated Legacy read-view alias for {@link authority} (#249). Carries the
     * same value; will be dropped once web + SDK consumers read `authority`.
     */
    issuingOrg?: string;
    /**
     * Portable org entity identifier (Wikidata/ROR/LEI URI) linking the issuing
     * organization to a resolved entity (#159/#241). Absent for free-text entries.
     * Mirrors `ProfilePosition.entityRef`; the AppView sends it for display.
     */
    entityRef?: string;
    /**
     * Resolved current canonical name of the durably-linked issuing organization
     * (#252), computed by the AppView at read time. Render this over `authority`
     * for a linked entry. Absent for free-text or unresolved entries (fall back to
     * `authority`).
     */
    entityName?: string;
    issueDate?: string;
    expiryDate?: string;
    credentialUrl?: string;
    hidden?: boolean;
}
interface ProfileProject {
    rkey: string;
    name: string;
    description?: string;
    url?: string;
    startDate?: string;
    endDate?: string;
    /** Other people named on this project, hydrated from the stored DIDs. */
    members?: ProjectMemberCard[];
    /**
     * AT-URI of the same project as recorded elsewhere, when this entry
     * duplicates another person's. Set so consumers can tell the two describe one
     * project; both still render from their own owner's record.
     */
    /** AT-URI of the same record on another person's profile, when they keep one. */
    sameAs?: string;
    hidden?: boolean;
}
interface PublicationContributor {
    name: string;
    orcidId?: string;
    did?: string;
    handle?: string;
}
/**
 * A co-author an importer produced that the profile owner can offer to link to
 * a Sifa account.
 *
 * Matched on verified ORCID iD only, never on name: "A. Example", "Alice
 * Example", and "Example, A." are one person, and "J. Smith" is four hundred.
 *
 * A suggestion, never a claim. Nothing reaches any repository until the owner
 * acts, which is what makes ORCID re-syncing safe: matching writes nothing, so
 * a re-sync cannot generate a confirmation request.
 */
interface AuthorSuggestion {
    /** ORCID iD the match was made on. The join key back to a contributor. */
    orcidId: string;
    did: string;
    handle: string;
    /** Display name on the matched account, for showing what is being proposed. */
    displayName?: string;
}
interface ProfilePublication {
    rkey: string;
    title: string;
    subtitle?: string;
    publisher?: string;
    date?: string;
    url?: string;
    description?: string;
    source?: 'sifa' | 'standard' | 'orcid';
    doi?: string;
    type?: string;
    typeLabel?: string;
    contributors?: PublicationContributor[];
    verified?: boolean;
    verifiedVia?: string;
    orcidPutCode?: number;
    hidden?: boolean;
    orcidCorroborated?: boolean;
    pendingVerification?: boolean;
    appId?: string;
    /**
     * AT-URI of the parent `site.standard.publication` for Standard.site
     * articles — the subscribable unit. Used to group articles by publication
     * on the profile. Undefined for Sifa/ORCID publications.
     */
    publicationUri?: string | null;
    /** Canonical publication origin — the subscribe / link-out target. */
    publicationUrl?: string | null;
    /** Publication display name for the group header (falls back to host). */
    publicationName?: string | null;
    /**
     * Cover image URL for Standard.site articles — the document's `coverImage`
     * blob (CDN-served), falling back to the article page's og:image. Undefined
     * for Sifa/ORCID publications, null when none could be resolved.
     */
    image?: string | null;
}
interface ProfileVolunteering {
    rkey: string;
    organization: string;
    /**
     * Portable org entity identifier (Wikidata/ROR/LEI URI) linking the
     * organization to a resolved entity (#159/#241). Absent for free-text entries.
     * Mirrors `ProfilePosition.entityRef`; the AppView sends it for display.
     */
    entityRef?: string;
    /**
     * Resolved current canonical name of the durably-linked organization (#252),
     * computed by the AppView at read time. Render this over `organization` for a
     * linked entry. Absent for free-text or unresolved entries (fall back to
     * `organization`).
     */
    entityName?: string;
    role?: string;
    cause?: string;
    startDate?: string;
    endDate?: string;
    description?: string;
    hidden?: boolean;
}
interface ProfileHonor {
    rkey: string;
    title: string;
    issuer?: string;
    /**
     * Portable org entity identifier (Wikidata/ROR/LEI URI) linking the issuer to a
     * resolved entity (#159/#241). Absent for free-text entries. Mirrors
     * `ProfilePosition.entityRef`; the AppView sends it for display.
     */
    entityRef?: string;
    /**
     * Resolved current canonical name of the durably-linked issuer (#252),
     * computed by the AppView at read time. Render this over `issuer` for a linked
     * entry. Absent for free-text or unresolved entries (fall back to `issuer`).
     */
    entityName?: string;
    date?: string;
    description?: string;
    hidden?: boolean;
}
/**
 * One proof link on an involvement record, as served by the AppView. Mirrors
 * `id.sifa.defs#artifactLink`, plus the computed rung-2 verification signal.
 */
interface ProfileInvolvementLink {
    url: string;
    kind?: string;
    label?: string;
    /**
     * Rung-2 cross-ref: true when the link host matches one of the owner's
     * *verified* `externalAccount` records (GitHub, GitLab, ORCID, ...).
     * Computed by the AppView; deterministic host match, no new primitive.
     */
    verified?: boolean;
    /**
     * Platform token of the matched verified external account (e.g.
     * `id.sifa.defs#platformGithub`), for the badge label. Absent when
     * `verified` is not true.
     */
    verifiedPlatform?: string;
}
/**
 * An involvement entry as served by the AppView: an `id.sifa.profile.involvement`
 * record, or a mapped legacy `id.sifa.profile.volunteering` record (`legacy`),
 * grouped in the UI by `kind` via the SDK's involvement-kind taxonomy.
 */
/** One artifact link on an investment (round announcement, portfolio page, filing). */
interface ProfileInvestmentLink {
    url: string;
    kind?: string;
    label?: string;
}
/** A capital position: money the person put in. Roles with duties are positions. */
interface ProfileInvestment {
    rkey: string;
    /** For a limited-partner entry this names the fund, not a portfolio company. */
    company: string;
    companyDid?: string;
    entityRef?: string;
    /** Resolved canonical name of the linked company. Render over `company` when present. */
    entityName?: string;
    /** How the capital went in. Angel, syndicate member or LP -- never GP. */
    role?: string;
    /** The company's funding stage at the time of the investment, not its stage today. */
    stage?: string;
    /** active / exited / written off / undisclosed. */
    status?: string;
    /** The vehicle the capital went through. Absent for a cheque in the person's own name. */
    via?: string;
    viaDid?: string;
    viaEntityRef?: string;
    /** Whole major currency units plus an ISO 4217 code. Absent unless the person opted in. */
    amount?: {
        value: number;
        currency: string;
    };
    startedAt?: string;
    endedAt?: string;
    description?: string;
    links?: ProfileInvestmentLink[];
    hidden?: boolean;
}
interface ProfileInvolvement {
    rkey: string;
    /** Involvement-kind token; drives the display heading. Legacy rows map to charity. */
    kind: string;
    upstream?: string;
    upstreamDid?: string;
    upstreamUrl?: string;
    role?: string;
    description?: string;
    startedAt?: string;
    endedAt?: string;
    links?: ProfileInvolvementLink[];
    /**
     * Portable org entity identifier (Wikidata/ROR/LEI URI) written when the user
     * picks the upstream from the resolver typeahead. Absent for free-text or
     * one-off involvement.
     */
    entityRef?: string;
    /**
     * Resolved current canonical name of the durably-linked upstream, computed by
     * the AppView at read time. Render over `upstream` when present. Absent for
     * free-text or unresolved entries.
     */
    entityName?: string;
    location?: LocationValue | null;
    skills?: SkillRef[];
    /** Skill records resolved from `skills`, for display. */
    linkedSkills?: ProfileSkill[];
    /**
     * True when this row is a mapped legacy `id.sifa.profile.volunteering` record
     * (no `kind`), rendered under "Volunteering". Editing it backfills to an
     * `involvement` record and deletes the legacy one.
     */
    legacy?: boolean;
    hidden?: boolean;
    /** Other people named on this involvement, hydrated from the stored DIDs. */
    collaborators?: ProjectMemberCard[];
    /** AT-URI of the same involvement as recorded on another person's profile. */
    sameAs?: string;
}
type LanguageProficiency = 'elementary' | 'limited_working' | 'professional_working' | 'full_professional' | 'native';
interface ProfileLanguage {
    rkey: string;
    language: string;
    proficiency?: LanguageProficiency;
    hidden?: boolean;
}
interface ProfileCourse {
    rkey: string;
    name: string;
    institution?: string;
    /**
     * Portable org entity identifier (Wikidata/ROR/LEI URI) linking the institution
     * to a resolved entity (#159/#241). Absent for free-text entries. Mirrors
     * `ProfilePosition.entityRef`; the AppView sends it for display.
     */
    entityRef?: string;
    /**
     * Resolved current canonical name of the durably-linked institution (#252),
     * computed by the AppView at read time. Render this over `institution` for a
     * linked entry. Absent for free-text or unresolved entries (fall back to
     * `institution`).
     */
    entityName?: string;
    number?: string;
    /** rkey of the associated certification, resolved from the course's
     * `credential` at-uri. Used to join the course to a certification in the
     * same profile payload (for the linked-credential date and link). */
    credentialRkey?: string;
    /** Date the course was completed, as an RFC 3339 datetime. Optional; the
     * editor collects month granularity (YYYY-MM). */
    completedAt?: string;
    hidden?: boolean;
}
/** A related link on a presentation or delivery, as returned by the AppView. */
interface PresentationLinkView {
    uri: string;
    label?: string;
    type?: string;
}
/**
 * A co-speaker on a delivery, hydrated from a stored DID to a profile card.
 * Any atproto account; `hasSifaProfile` is true when they have a claimed Sifa
 * profile (vs an unclaimed atproto account that still renders at /p/<handle>).
 */
/**
 * Another person named on someone's record, as rendered by the AppView.
 *
 * `displayName` and `avatar` are present only when `confirmed` is true. An
 * unconfirmed claim renders as a bare handle with no identity attached and no
 * link to a profile: naming someone is a claim, and until they affirm it the
 * claim must not borrow their face.
 */
interface ActorCard {
    did: string;
    handle: string;
    displayName?: string;
    avatar?: string;
    hasSifaProfile?: boolean;
    /** True once the named person has published a matching `id.sifa.confirmation`. */
    confirmed?: boolean;
    /**
     * True when the record was materially changed after being confirmed -- a
     * rename, or a changed role. The confirmation stands until withdrawn, but the
     * UI should say the claim has moved since it was affirmed.
     */
    confirmedStale?: boolean;
}
/** @deprecated Use {@link ActorCard}. Kept so existing co-speaker call sites keep compiling. */
type CoSpeaker = ActorCard;
/**
 * Roles shipped today. The lexicon declares these as `knownValues`, so the
 * field itself stays a plain string: a consumer meeting a role it does not
 * recognise should show it rather than discard it.
 *
 * Display only. A record living in someone else's repository cannot grant
 * write access to anything, and the UI must not imply that it does.
 */
declare const PROJECT_ROLES: readonly ["id.sifa.defs#projectOwner", "id.sifa.defs#projectCore", "id.sifa.defs#projectContributor"];
type ProjectRole = (typeof PROJECT_ROLES)[number];
/** A person named as a member of a project, with their role alongside the actor card. */
interface ProjectMemberCard extends ActorCard {
    role?: string;
    title?: string;
}
/** An occasion on which a presentation was delivered (the AppView view-model). */
interface ProfilePresentationDelivery {
    rkey: string;
    /** rkey of the parent presentation when this delivery references one. */
    presentationRkey?: string | null;
    /** Co-speakers at this occasion, hydrated from the stored DIDs. */
    coSpeakers?: CoSpeaker[];
    /** AT-URI of the same session as recorded on another person's profile. */
    sameAs?: string;
    title?: string | null;
    role?: string | null;
    eventName?: string | null;
    /** Day-only date, YYYY-MM-DD. */
    date?: string | null;
    location?: string | null;
    locationCountry?: string | null;
    locationRegion?: string | null;
    locationLocality?: string | null;
    countryCode?: string | null;
    /** Full community.lexicon.calendar.event mode token. */
    mode?: string | null;
    /** Full community.lexicon.calendar.event status token. */
    status?: string | null;
    links?: PresentationLinkView[];
    /** at-uri of the linked calendar event, when present. */
    eventUri?: string | null;
    hidden?: boolean;
}
/** A reusable presentation with its deliveries grouped underneath (AppView view-model). */
interface ProfilePresentation {
    rkey: string;
    title: string;
    description?: string | null;
    /** Duration in minutes: a fixed value (min only) or a range. */
    duration?: {
        minMinutes: number;
        maxMinutes?: number;
    } | null;
    intendedAudiences?: string[];
    links?: PresentationLinkView[];
    /** at-uri of a long-form write-up (Leaflet / site.standard document). */
    writeupUri?: string | null;
    /** Resolved URL of the uploaded cover image, when present. */
    coverImageUrl?: string | null;
    hidden?: boolean;
    deliveries?: ProfilePresentationDelivery[];
}
interface TrustStat {
    key: string;
    label: string;
    value: number;
}
interface ActiveApp {
    id: string;
    name: string;
    category: string;
    recentCount: number;
    latestRecordAt?: string | null;
}
interface VerifiedAccount {
    platform: string;
    identifier: string;
    url?: string;
}
interface ExternalAccountKeytraceClaim {
    rkey: string;
    claimedAt: string;
}
interface ExternalAccount {
    rkey: string;
    platform: string;
    url: string;
    label?: string;
    feedUrl?: string;
    primary?: boolean;
    verifiable: boolean;
    verified: boolean;
    verifiedVia?: string | null;
    source?: 'sifa' | 'keytrace' | 'keyoxide' | 'marque';
    hidden?: boolean;
    keytraceVerified?: boolean;
    keytraceClaim?: ExternalAccountKeytraceClaim;
}
interface FeedItem {
    title: string;
    excerpt: string;
    url: string;
    timestamp: string;
    source: string;
}
interface PdsProviderInfo {
    name: string;
    host: string;
}
interface ProfileIndustry {
    industry: string;
    domain?: string;
}
interface ProfileOverrideSource {
    headline?: string;
    about?: string;
    displayName?: string;
    avatarUrl?: string;
}
/**
 * A structured physical address on the org view. Mirrors
 * `community.lexicon.location.address`; every field is optional.
 */
interface OrgAddressView {
    country: string | null;
    postalCode: string | null;
    region: string | null;
    locality: string | null;
    street: string | null;
    name: string | null;
}
/** A featured link on the org view. Both `name` and `url` are present. */
interface OrgLinkView {
    name: string;
    url: string;
}
/**
 * The org-profile fields exposed on the profile resolve when the org rendering
 * floor is met. Narrow on purpose: `contact` is never included (not rendered
 * publicly); record URI/CID are internal. Mirrors sifa-api's `OrgProfileView`.
 */
interface OrgProfileView {
    name: string;
    description: string | null;
    website: string | null;
    /** Blob CID (or resolved URL) of the org logo, when present. */
    logoBlob: string | null;
    entityRefs: string[] | null;
    addresses: OrgAddressView[] | null;
    /** Self-selected headcount range (declared bucket, never calculated). */
    companySize: string | null;
    links: OrgLinkView[] | null;
}
/**
 * A company entity recognized purely from the handle's registrable domain
 * (#160 auto-recognize), independent of any org record. Present on the verdict
 * when `recognized` is true. `domain` is the handle's registrable domain and
 * round-trips through `/c/<domain>`; `publicId` is nullable because entities
 * minted before the public_id backfill have none.
 */
interface RecognizedEntity {
    publicId: string | null;
    domain: string;
    name: string;
}
/**
 * Server-computed org rendering-floor verdict (#160), carried on the profile
 * resolve so clients need no extra round-trip. Read it via the `useOrgProfile`
 * hook.
 *
 * `isOrg` is the CLAIMED floor: true when the account has an
 * `id.sifa.org.profile` record AND its handle is a custom registrable domain
 * (the authoritative, PSL-backed check lives server-side).
 *
 * `recognized` is INDEPENDENT of `isOrg`: true when the handle's registrable
 * domain resolves to a known, non-suppressed, non-natural-person company entity
 * in Sifa's DB, even with no org record yet (auto-recognize known-company
 * domains). A known company that has not yet claimed is
 * `recognized: true, isOrg: false`; a claimed recognized company is both true.
 * Use it to treat a recognized-but-unclaimed company account as a company
 * (company onboarding, `/c/` routing) before it claims.
 */
interface OrgFloorVerdict {
    isOrg: boolean;
    orgProfile?: OrgProfileView;
    recognized: boolean;
    /**
     * Whether the account's handle is a custom registrable apex domain, i.e.
     * eligible to CLAIM an org page (#306). Mirrors the `isBindableHandleDomain`
     * floor the api enforces at write time, surfaced so the `/claim` wizard can
     * gate on eligibility BEFORE the authority consent rather than failing the
     * final PDS write. Independent of `isOrg`/`recognized` -- purely the handle's
     * shape, so a `*.bsky.social` account reads false and a not-yet-claimed
     * custom domain reads true.
     *
     * Optional here (a tolerant reader): the api always emits it, but a profile
     * payload cached before this field shipped may omit it. Gate on the explicit
     * `customDomain === false` for the up-front block; treat absent as unknown and
     * let the api 403 stay the authoritative backstop -- never enforce on this
     * field alone.
     */
    customDomain?: boolean;
    /**
     * Whether the account also keeps a visible personal profile, from
     * `id.sifa.org.profile.personalProfileVisible`. True only for a claimed org
     * (`isOrg`) that opted in -- the sole-trader case, where one DID carries both
     * a person facet at `/p/` and a company facet at `/c/` and neither route
     * redirects to the other. Absent or false is the exclusive default: the
     * account presents solely as an organization and `/p/` redirects to `/c/`.
     */
    personalProfileVisible?: boolean;
    /**
     * Invariant (not encoded in the type, matching the flat wire shape the api
     * sends): present whenever `recognized` is true, absent when false. Callers
     * that read it after narrowing on `recognized === true` should still
     * defensively check, since the type does not enforce the pairing.
     */
    recognizedEntity?: RecognizedEntity;
}
/**
 * The account owner's answer to "are you a person, a company, or both?".
 *
 * `'person'` and `'company'` are Sifa-local overrides stored in
 * `account_render_overrides` (set via `POST /api/account/render-preference`).
 * `'both'` is NOT stored here -- it is the portable
 * `id.sifa.org.profile.personalProfileVisible` declaration in the account's own
 * PDS, so any AppView can evaluate it without asking Sifa. Resolve the combined
 * answer with `resolveAccountFacetMode`.
 */
type AccountFacetMode = 'person' | 'company' | 'both';
interface Profile {
    did: string;
    handle: string;
    /**
     * Sifa-local render override, absent when the account has never set one
     * (auto: today's recognition behaviour). `'person'` is the escape hatch for a
     * personal domain that Sifa catalogued as a company.
     */
    renderPreference?: 'person' | 'company' | null;
    /**
     * Org rendering-floor verdict (#160). Present on the profile resolve; absent
     * on payloads that predate the field. When `org.isOrg` is true the account
     * renders as an organization (`/c/`).
     */
    org?: OrgFloorVerdict;
    displayName?: string;
    /**
     * Given (first) name from `id.sifa.profile.self.givenName`. Schema.org
     * `Person.givenName`. Optional; absent for users who haven't filled in
     * structured name fields. Consumers wanting a rendered name should use
     * `formatStructuredName(givenName, familyName) ?? displayName ?? handle`.
     */
    givenName?: string;
    /**
     * Family (last) name from `id.sifa.profile.self.familyName`. Schema.org
     * `Person.familyName`. See `givenName` for fallback guidance.
     */
    familyName?: string;
    /**
     * Free-form phonetic respelling of the user's name from
     * `id.sifa.profile.self.namePronunciation` (e.g. `Foo-kuh`). Optional; a
     * native field with no `app.bsky.actor.profile` equivalent. Text only.
     */
    namePronunciation?: string;
    /**
     * Resolved URL of the name-pronunciation audio clip from
     * `id.sifa.profile.self.namePronunciationAudio`, served from the user's PDS
     * (`com.atproto.sync.getBlob`). Optional; absent when no clip is set.
     */
    namePronunciationAudioUrl?: string;
    avatar?: string;
    pronouns?: string;
    headline?: string;
    about?: string;
    hasHeadlineOverride?: boolean;
    hasAboutOverride?: boolean;
    hasDisplayNameOverride?: boolean;
    hasAvatarUrlOverride?: boolean;
    source?: ProfileOverrideSource;
    industries?: ProfileIndustry[];
    location?: LocationValue | null;
    locations?: ProfileLocation[];
    /**
     * @deprecated Flat location field emitted at the response root during the
     * additive response window for `community.lexicon.location.address`.
     * Prefer the structured `locations[]` array (use the entry where
     * `isPrimary` is true).
     */
    locationCountry?: string | null;
    /**
     * @deprecated See `locationCountry`. Prefer `locations[].locationRegion`.
     */
    locationRegion?: string | null;
    /**
     * @deprecated Legacy alias for `locationLocality`; emitted alongside it
     * during the additive response window. Prefer `locations[].locationLocality`.
     */
    locationCity?: string | null;
    /**
     * @deprecated community.lexicon.location.address field name. Prefer
     * `locations[].locationLocality`.
     */
    locationLocality?: string | null;
    /**
     * @deprecated See `locationCountry`. Prefer `locations[].countryCode`.
     */
    countryCode?: string | null;
    website?: string;
    openTo?: string[];
    preferredWorkplace?: string[];
    availableFromUtc?: number;
    availableToUtc?: number;
    pdsProvider?: PdsProviderInfo | null;
    claimed: boolean;
    /**
     * User-set opt-out flag from `id.sifa.profile.self.discoverable`. When
     * `false`, the rendering app emits `noindex` and excludes the page from
     * sitemaps. Absent means default-true (current behavior for existing
     * records that predate this field).
     */
    discoverable?: boolean;
    isOwnProfile?: boolean;
    createdAt?: string;
    trustStats?: TrustStat[];
    verifiedAccounts?: VerifiedAccount[];
    activeApps?: ActiveApp[];
    blueskyVerified?: boolean;
    blueskyVerifiedAt?: string | null;
    followersCount: number;
    followingCount: number;
    connectionsCount: number;
    atprotoFollowersCount?: number;
    positions: ProfilePosition[];
    education: ProfileEducation[];
    skills: ProfileSkill[];
    certifications?: ProfileCertification[];
    projects?: ProfileProject[];
    publications?: ProfilePublication[];
    /**
     * Co-authors on imported publications that resolve to a Sifa account.
     *
     * Owner-only, and absent rather than empty for every other viewer, so a
     * consumer cannot tell "no suggestions" from "not yours". Join to a
     * publication contributor by `orcidId`.
     */
    authorSuggestions?: AuthorSuggestion[];
    volunteering?: ProfileVolunteering[];
    involvement?: ProfileInvolvement[];
    investments?: ProfileInvestment[];
    honors?: ProfileHonor[];
    languages?: ProfileLanguage[];
    courses?: ProfileCourse[];
    presentations?: ProfilePresentation[];
    presentationDeliveries?: ProfilePresentationDelivery[];
    externalAccounts?: ExternalAccount[];
}

export { type AccountFacetMode as A, type ProfileInvestmentLink as B, type CoSpeaker as C, type ProfileInvolvementLink as D, type Endorsement as E, type FeedItem as F, type ProfileLocation as G, type ProfileOverrideSource as H, type ProfilePresentation as I, type ProfileVolunteering as J, type ProjectMemberCard as K, type LocationValue as L, type ProjectRole as M, type PublicationContributor as N, type OrgAddressView as O, type ProfileSkill as P, type SkillSuggestion as Q, type RecognizedEntity as R, type SkillRef as S, type TrustStat as T, type VerifiedAccount as V, type ProfilePresentationDelivery as a, type PdsProviderInfo as b, type Profile as c, type ProfilePosition as d, type ProfileCertification as e, type ProfileEducation as f, type ProfileHonor as g, type ProfileLanguage as h, type ProfileProject as i, type ProfilePublication as j, type ProfileInvolvement as k, type ActiveApp as l, type ActorCard as m, type AuthorSuggestion as n, type EndorsementData as o, type ExternalAccount as p, type ExternalAccountKeytraceClaim as q, type LanguageProficiency as r, type OrgFloorVerdict as s, type OrgLinkView as t, type OrgProfileView as u, PROJECT_ROLES as v, type PresentationLinkView as w, type ProfileCourse as x, type ProfileIndustry as y, type ProfileInvestment as z };