@thejob/schema 2.1.8 → 2.2.0

package/dist/index.d.ts

@@ -42,6 +42,170 @@ declare const UserIdAndCreatedAtSchema: yup.ObjectSchema<{
 }, "">;
 type TUserIdAndCreatedAtSchema = InferType<typeof UserIdAndCreatedAtSchema>;
 
+/**
+ * An open vocabulary: skills, companies, institutes. Any token matches (OR
+ * within a facet); facets AND together.
+ */
+declare const tokens: (label: string) => yup.ArraySchema<string[] | undefined, yup.AnyObject, never[], "d">;
+/**
+ * An open vocabulary of CODES, normalised to uppercase.
+ *
+ * For short closed-ish codes stored uppercase (ISO country, state). The
+ * service matches these case-insensitively anyway, so this is belt-and-braces
+ * — but a filter that reads back `["in"]` after saving looks broken to an
+ * admin, and any consumer comparing the saved value to a stored one would be
+ * comparing "in" against "IN".
+ */
+declare const codeTokens: (label: string) => yup.ArraySchema<string[] | undefined, yup.AnyObject, never[], "d">;
+/** A closed vocabulary, rendered as a chip picker. */
+declare const enumFacet: (values: readonly string[], label: string) => yup.ArraySchema<string[] | undefined, yup.AnyObject, never[], "d">;
+/**
+ * A relative window in whole days, resolved to an absolute bound at query time.
+ *
+ * Relative rather than absolute because a saved filter is re-resolved on every
+ * run: "within 30 days" keeps meaning what its author intended, while a stored
+ * timestamp rots. Bounded so a typo cannot become an unbounded scan.
+ */
+declare const days: (label: string) => yup.NumberSchema<number | undefined, yup.AnyObject, undefined, "">;
+/** A relative window in whole months. See `days`. */
+declare const months: (label: string) => yup.NumberSchema<number | undefined, yup.AnyObject, undefined, "">;
+/** A 0-100 percentage bound. */
+declare const percent: (label: string) => yup.NumberSchema<number | undefined, yup.AnyObject, undefined, "">;
+/**
+ * Absolute epoch milliseconds.
+ *
+ * `widget: "date"` because the STORED form and the ENTERED form are not the
+ * same thing. Epoch ms is right for storage and comparison — `createdAt` is an
+ * integer, and a coerced date string would not compare — but it is not
+ * something anyone types. Rendered as a plain number box, "8" is accepted and
+ * silently means 8ms after 1 Jan 1970, so a filter meant to say "this week"
+ * matches every record ever created and looks correctly configured doing it.
+ *
+ * The form converts; the wire format does not change.
+ */
+declare const epoch: (label: string) => yup.NumberSchema<number | undefined, yup.AnyObject, undefined, "">;
+/**
+ * A money bound that is only meaningful once the filter pins ONE currency.
+ *
+ * Salary is stored as a bare integer with the currency in a separate field, so
+ * "at least 50000" across USD/EUR/GBP/SEK/INR is not a comparison at all — it
+ * silently ranks a Swedish krona salary against a US dollar one. Rather than
+ * return a wrong set, the bound is rejected unless exactly one currency is
+ * selected.
+ *
+ * `currencyField` is a PARAMETER because the sibling facet is named differently
+ * per resource: a user filter pins `salaryCurrencies` against the salary a
+ * candidate wants, while a job filter pins its own currency facet against the
+ * band a job advertises. Hardcoding one name would make this builder silently
+ * inert everywhere else — the `.when` would watch a field that does not exist,
+ * the test would never run, and cross-currency bounds would sail through.
+ */
+declare const currencyBound: (label: string, currencyField: string) => yup.NumberSchema<number | undefined, yup.AnyObject, undefined, "">;
+/**
+ * A facet over an array of OBJECTS, where the parts must describe the SAME entry.
+ *
+ * The problem this solves, measured on production users:
+ *
+ *   skills[]=python & skillProficiencyLevels[]=expert   ->   301 users
+ *   one skill entry that is BOTH python AND expert      ->   103 users
+ *
+ * Those 198 extra people are expert at something else and happen to also list
+ * Python. As two independent facets the query is `{'skills.name': python,
+ * 'skills.proficiencyLevel': expert}`, and Mongo satisfies each from a
+ * DIFFERENT array entry. English + expert over-counted by 1,755 the same way.
+ *
+ * It is silent: the count is plausible, the filter reads correctly, and the
+ * only symptom is mail reaching people who do not match what the admin chose.
+ *
+ * So the pair is ONE facet with the qualifier nested inside it, not two facets
+ * that a caller is trusted to combine. A single value cannot express the wrong
+ * query, which is the same reason `currencyBound` refuses a bound without
+ * exactly one currency: if a combination is only meaningful together, the
+ * schema should make the meaningless form unsayable rather than answer it
+ * wrongly.
+ *
+ * Each entry is `{ name, <qualifier> }`, where `name` is required (a qualifier
+ * alone means "expert at anything", which is not a segment anyone wants) and
+ * the qualifier is optional (naming the skill without a level is a perfectly
+ * good filter). Entries OR together, matching every other list facet.
+ */
+declare const qualified: (qualifierValues: readonly string[] | "open", qualifierKey: string, label: string) => yup.ArraySchema<{
+    [x: string]: string | undefined;
+    [x: number]: string | undefined;
+}[] | undefined, yup.AnyObject, never[], "d">;
+/**
+ * A facet over an array of objects where SEVERAL fields describe one entry and
+ * none of them is "the name" the others qualify.
+ *
+ * `qualified` above covers `{ name, <qualifier> }`, where the qualifier is
+ * meaningless alone ("expert" at nothing). This covers the other shape: one
+ * work-history entry is a company AND a job title, one education entry is an
+ * institute AND a course AND a field of study, and each part is a perfectly
+ * good filter on its own.
+ *
+ * That is why the flat `companies` / `designations` facets REMAIN beside this
+ * one rather than being replaced. "Worked at Google" and "was an engineer,
+ * somewhere" are real questions, and an admin asking for both usually does mean
+ * "has each of these somewhere in their history". What was missing is the
+ * narrower question — "was an engineer AT Google" — which as two flat facets
+ * silently also matched someone who was an engineer at Acme and a designer at
+ * Google. Measured on production: VIT + B.Tech returned 71 users where 64 had
+ * one education entry that was both.
+ *
+ * So this ADDS a way to say the precise thing; it does not take away the loose
+ * one. Every field is optional, but an entry must carry at least one — an
+ * all-empty entry would match every row and silently widen the audience, which
+ * is the failure this whole family of facets exists to prevent. Entries OR
+ * together, like every other list facet.
+ *
+ * ── Field types ─────────────────────────────────────────────────────────────
+ * A field is text by default. Pass an object to type it instead:
+ *
+ *   conjunction(["company", "designation", { name: "isCurrent", type: "boolean" }], …)
+ *
+ * The typed forms exist because not every part of an entry is free text. A work
+ * entry is also "is this their CURRENT job" (`duration.isActive`) and "was it
+ * remote" (`isRemote`), and an education entry has a `studyType` from a closed
+ * vocabulary. Those are the parts that make a same-entry filter worth asking:
+ * "engineer at Google" is a different question from "engineer at Google NOW".
+ *
+ * A boolean field is only a constraint when present. `false` is a real value
+ * here ("not their current job"), so it is NOT dropped as empty the way a blank
+ * string is — which is also why a boolean alone satisfies "at least one field".
+ */
+type ConjunctionField = string | {
+    name: string;
+    type: "string" | "boolean";
+    oneOf?: readonly string[];
+};
+declare const conjunction: (fields: readonly ConjunctionField[], label: string) => yup.ArraySchema<{
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+}[] | undefined, yup.AnyObject, never[], "d">;
+/**
+ * Reject keys a schema does not declare, WITHOUT turning on strict mode.
+ *
+ * A silently dropped key is the dangerous failure: a filter whose "Has Resume"
+ * checkbox arrives under a misspelled name is not a narrower query, it is the
+ * unfiltered one, and it mails everyone while looking correctly configured. The
+ * caller sees a plausible result and no error, so the mistake survives review.
+ *
+ * Yup's own `.noUnknown()` only ERRORS under `.strict()`, and strict mode also
+ * disables coercion — which would reject the `"80"` and `"true"` strings that
+ * HTML form payloads legitimately send. This is written as a `.test()` instead
+ * so both hold at once: unknown keys fail, coercion stays on.
+ *
+ * `allowed` is a FUNCTION, not an array, for two reasons: it is evaluated at
+ * validation time rather than module-load time (so a schema may reference keys
+ * declared later in the file), and it lets two schemas built from the same shape
+ * permit different key sets — which is how a filter's `or` branch forbids a
+ * nested `or` while the top-level filter allows one.
+ */
+declare const rejectUnknownKeys: <T extends {
+    test: (...a: never[]) => T;
+}>(schema: T, allowed: () => readonly string[]) => T;
+
 /**
  * Common option keys shared across schemas. `Yes`/`No` are used by acknowledge
  * questions; `Skill`/`EducationLevel`/`ExperienceLevel`/etc. tag where a choice
@@ -144,6 +308,18 @@ declare enum GroupStatus {
     Active = "active",
     Archived = "archived"
 }
+/**
+ * The enum values as arrays, for schemas that need `.oneOf(...)`.
+ *
+ * The same `Object.values(...)` form `page.constant.ts` already exports
+ * (`SupportedPageTypes`, `SupportedPageStatuses`). Derived rather than written
+ * out, so a new enum member cannot be added to one list and forgotten in the
+ * other.
+ */
+declare const SupportedGroupStatuses: GroupStatus[];
+declare const SupportedGroupVisibilities: GroupVisibility[];
+declare const SupportedGroupManagedBy: GroupManagedBy[];
+declare const SupportedGroupMembershipStatuses: GroupMembershipStatus[];
 
 declare const GroupTranslationSchema: yup.ObjectSchema<{
     language: string;
@@ -197,8 +373,8 @@ declare const GroupSchema: yup.ObjectSchema<{
             description?: string | undefined;
             keywords?: string[] | undefined;
         } | undefined;
-        language: string;
         name: string;
+        language: string;
     }[] | undefined;
     managedBy: GroupManagedBy;
     status: GroupStatus;
@@ -247,6 +423,33 @@ declare const GroupMembershipSchema: yup.ObjectSchema<{
     updatedAt: undefined;
 }, "">;
 
+/**
+ * THE group filter.
+ *
+ * Wrapped in `rejectUnknownKeys` following `UserFilterSchema` rather than
+ * `JobFilterSchema`: an unknown key here is silently dropped by yup and then
+ * matches nothing downstream, so it must fail loudly at the point it is written.
+ */
+declare const GroupFilterSchema: yup.ObjectSchema<{
+    status: string[];
+    visibility: string[];
+    managedBy: string[];
+    isFeatured: boolean | undefined;
+    isDiscoverable: boolean | undefined;
+    countries: string[];
+    featuredMarkets: string[];
+    slugs: string[];
+}, yup.AnyObject, {
+    status: never[];
+    visibility: never[];
+    managedBy: never[];
+    isFeatured: undefined;
+    isDiscoverable: undefined;
+    countries: never[];
+    featuredMarkets: never[];
+    slugs: never[];
+}, "">;
+
 declare enum JobStatus {
     Published = "published",
     Draft = "draft",
@@ -430,8 +633,8 @@ declare const JobSchema: ObjectSchema<{
             dark?: string | null | undefined;
             light?: string | undefined;
         } | null | undefined;
-        type: PageType;
         name: string;
+        type: PageType;
     };
     designation: string | null | undefined;
     employmentType: string;
@@ -702,6 +905,80 @@ declare const JobSchema: ObjectSchema<{
 }, "">;
 type TJobSchema = InferType<typeof JobSchema>;
 
+/**
+ * THE job filter, with unknown keys REJECTED.
+ *
+ * The guard its three sibling filter schemas (user, group, page) already carry,
+ * and this one was written without. Yup's own `.noUnknown()` is not an
+ * alternative: it only errors under `.strict()`, and strict mode also disables
+ * coercion — which would reject the `"7"` and `"true"` strings every query
+ * string is made of. `rejectUnknownKeys` is a `.test()` so both hold at once.
+ *
+ * Why it matters more here than anywhere else: a job filter arrives from a
+ * caller-controlled URL. Without this, a typo'd facet (`workplaceType`) and the
+ * retired `filter[workMode]=remote` form both VALIDATE, then reach the service
+ * as a facet no job document has — a 200 with a plausible full page, which is
+ * indistinguishable from a working search. Three consumers each hand-rolled an
+ * `assertKnownFacets` over `Object.keys` of this schema to compensate; this is
+ * the declaration those existed to substitute for.
+ */
+declare const JobFilterSchema: yup.ObjectSchema<{
+    employmentType: string[];
+    workMode: string[];
+    experienceLevel: string[];
+    educationLevel: string[];
+    status: string[];
+    category: string[];
+    industry: string[];
+    subCategories: string[];
+    tags: string[];
+    jobIds: string[];
+    skills: string[];
+    companies: string[];
+    companyNames: string[];
+    countryCodes: string[];
+    stateCodes: string[];
+    states: string[];
+    cities: string[];
+    isFeatured: boolean | undefined;
+    isPromoted: boolean | undefined;
+    featuredMarkets: string[];
+    salary: {
+        min?: number | undefined;
+        max?: number | undefined;
+        currency?: "USD" | "EUR" | "GBP" | "SEK" | "INR" | undefined;
+    } | undefined;
+    postedWithinDays: number | undefined;
+    createdAt: {
+        min?: number | undefined;
+        max?: number | undefined;
+    } | undefined;
+}, yup.AnyObject, {
+    employmentType: never[];
+    workMode: never[];
+    experienceLevel: never[];
+    educationLevel: never[];
+    status: never[];
+    category: never[];
+    industry: never[];
+    subCategories: never[];
+    tags: never[];
+    jobIds: never[];
+    skills: never[];
+    companies: never[];
+    companyNames: never[];
+    countryCodes: never[];
+    stateCodes: never[];
+    states: never[];
+    cities: never[];
+    isFeatured: undefined;
+    isPromoted: undefined;
+    featuredMarkets: never[];
+    salary: undefined;
+    postedWithinDays: undefined;
+    createdAt: undefined;
+}, "">;
+
 /**
  * Job classification taxonomy: category -> industry -> subCategory.
  *
@@ -1145,6 +1422,464 @@ declare const LocationSchema: yup.ObjectSchema<{
     };
 }, "">;
 
+/**
+ * Constants for the geo reference data (countries / states / cities).
+ *
+ * The data is a MIRROR of the dr5hn/countries-states-cities-database, refreshed
+ * wholesale by common-service rather than authored here. That is why these are
+ * sync/administrative vocabularies: the records themselves have no lifecycle of
+ * their own, only the job that replaces them does.
+ */
+/** Which level of the hierarchy a combined `/geo/search` hit came from. */
+declare enum GeoKind {
+    Country = "country",
+    State = "state",
+    City = "city"
+}
+declare const SupportedGeoKinds: GeoKind[];
+/**
+ * The state machine of one geo refresh run.
+ *
+ * `Skipped` is a SUCCESS, not a failure: the upstream release tag had not
+ * changed, so there was nothing to fetch. Keeping it distinct from `Succeeded`
+ * is what lets the admin dashboard say "already up to date" instead of showing
+ * a progress bar that completes instantly and implies work happened.
+ */
+declare enum GeoSyncStatus {
+    Pending = "pending",
+    Running = "running",
+    Succeeded = "succeeded",
+    Failed = "failed",
+    Skipped = "skipped"
+}
+declare const SupportedGeoSyncStatuses: GeoSyncStatus[];
+/** Terminal states. A run in any other state is still in flight. */
+declare const TerminalGeoSyncStatuses: readonly [GeoSyncStatus.Succeeded, GeoSyncStatus.Failed, GeoSyncStatus.Skipped];
+/** Which phase a running job is in, for the progress display. */
+declare enum GeoSyncPhase {
+    Checking = "checking",
+    Countries = "countries",
+    States = "states",
+    Cities = "cities",
+    Indexing = "indexing",
+    Done = "done"
+}
+declare const SupportedGeoSyncPhases: GeoSyncPhase[];
+/** What triggered a run. `Boot` is reserved; today every run is `Manual`. */
+declare enum GeoSyncTrigger {
+    Manual = "manual",
+    Boot = "boot"
+}
+declare const SupportedGeoSyncTriggers: GeoSyncTrigger[];
+/** Mongo collection names, so service and consumers cannot disagree on them. */
+declare const GEO_COLLECTIONS: {
+    readonly countries: "geo_countries";
+    readonly states: "geo_states";
+    readonly cities: "geo_cities";
+    readonly syncRuns: "geo_sync_runs";
+};
+/**
+ * Max length of a `?search=` term on any `/geo` endpoint.
+ *
+ * Bounded because the term reaches an Atlas `$search` autocomplete clause, and
+ * an unbounded one is a needlessly expensive query for input no human types.
+ */
+declare const GEO_SEARCH_MAX = 64;
+
+/**
+ * A country in the geo reference mirror, backing `GET /geo/countries`.
+ *
+ * Sourced from dr5hn/countries-states-cities-database and refreshed wholesale by
+ * common-service. The upstream record is kept WHOLE — `translations`, `timezones`,
+ * `gdp`, `emoji` and all — and callers narrow with `?fields=` instead. Storing a
+ * projection would mean a re-ingest of 150k+ records every time someone wanted a
+ * field we had decided in advance nobody needed.
+ *
+ * Two deliberate departures from the house style for record schemas:
+ *
+ *   • NOT `.noUnknown().strict()`. `SkillSchema` is strict because it validates
+ *     user INPUT; this types a STORED shape whose upstream fields we keep
+ *     wholesale, so strict mode would reject documents the ingest legitimately
+ *     writes the moment dr5hn adds a column.
+ *   • NOT `.concat(DbDefaultSchema)`. These records have no `shortId` or
+ *     `createdBy` — nobody authors them. They carry the upstream `id` (which is
+ *     also the upsert key) plus our own `syncedAt`.
+ *
+ * Almost everything is nullable because the dataset genuinely has holes:
+ * `capital`, `gdp` and `postalCodeRegex` are absent on many rows. Only the
+ * identity fields are required.
+ */
+declare const CountrySchema: yup.ObjectSchema<{
+    id: number;
+    name: string;
+    countryCode: string;
+    iso3: string | null | undefined;
+    numericCode: string | null | undefined;
+    phonecode: string | null | undefined;
+    capital: string | null | undefined;
+    currency: string | null | undefined;
+    currencyName: string | null | undefined;
+    currencySymbol: string | null | undefined;
+    tld: string | null | undefined;
+    native: string | null | undefined;
+    population: number | null | undefined;
+    gdp: number | null | undefined;
+    region: string | null | undefined;
+    regionId: number | null | undefined;
+    subregion: string | null | undefined;
+    subregionId: number | null | undefined;
+    nationality: string | null | undefined;
+    areaSqKm: number | null | undefined;
+    postalCodeFormat: string | null | undefined;
+    postalCodeRegex: string | null | undefined;
+    timezones: {
+        zoneName?: string | null | undefined;
+        gmtOffset?: number | null | undefined;
+        gmtOffsetName?: string | null | undefined;
+        abbreviation?: string | null | undefined;
+        tzName?: string | null | undefined;
+    }[] | null | undefined;
+    translations: {} | null | undefined;
+    latitude: number | null | undefined;
+    longitude: number | null | undefined;
+    emoji: string | null | undefined;
+    emojiU: string | null | undefined;
+    searchDefault: string[];
+    searchByLocale: {} | null | undefined;
+    syncedAt: number | null | undefined;
+}, yup.AnyObject, {
+    id: undefined;
+    name: undefined;
+    countryCode: undefined;
+    iso3: undefined;
+    numericCode: undefined;
+    phonecode: undefined;
+    capital: undefined;
+    currency: undefined;
+    currencyName: undefined;
+    currencySymbol: undefined;
+    tld: undefined;
+    native: undefined;
+    population: undefined;
+    gdp: undefined;
+    region: undefined;
+    regionId: undefined;
+    subregion: undefined;
+    subregionId: undefined;
+    nationality: undefined;
+    areaSqKm: undefined;
+    postalCodeFormat: undefined;
+    postalCodeRegex: undefined;
+    timezones: "";
+    translations: {};
+    latitude: undefined;
+    longitude: undefined;
+    emoji: undefined;
+    emojiU: undefined;
+    searchDefault: never[];
+    searchByLocale: {};
+    syncedAt: undefined;
+}, "">;
+type Country = InferType<typeof CountrySchema>;
+/** A single entry of `CountrySchema.timezones`. */
+type CountryTimezone = NonNullable<Country["timezones"]>[number];
+/**
+ * The localized-name map, keyed by locale.
+ *
+ * Declared as a type rather than a yup shape for the reason given on
+ * `translations` above: the key set belongs to upstream. Shared by all three
+ * geo record types.
+ */
+type GeoTranslations = Record<string, string>;
+
+/**
+ * A state / province / subdivision in the geo reference mirror, backing
+ * `GET /geo/countries/:countryCode/states` and `GET /geo/states`.
+ *
+ * Sourced from dr5hn and refreshed wholesale; the upstream record is kept whole.
+ * See `CountrySchema` for why this is neither `.strict()` nor concatenated with
+ * `DbDefaultSchema`.
+ *
+ * The parent country's `countryCode` and `countryName` are stored DENORMALIZED,
+ * as upstream ships them. That is deliberate: a flat search hit ("Karnataka")
+ * has to be enough for a UI to back-fill the country dropdown to India without a
+ * second round trip, which is the whole point of searching states without first
+ * picking a country.
+ */
+declare const StateSchema: yup.ObjectSchema<{
+    id: number;
+    name: string;
+    countryId: number | null | undefined;
+    countryCode: string;
+    countryName: string | null | undefined;
+    stateCode: string | null | undefined;
+    stateCodeIso: string | null | undefined;
+    fipsCode: string | null | undefined;
+    type: string | null | undefined;
+    level: number | null | undefined;
+    parentId: number | null | undefined;
+    native: string | null | undefined;
+    latitude: number | null | undefined;
+    longitude: number | null | undefined;
+    timezone: string | null | undefined;
+    translations: {} | null | undefined;
+    searchDefault: string[];
+    searchByLocale: {} | null | undefined;
+    syncedAt: number | null | undefined;
+}, yup.AnyObject, {
+    id: undefined;
+    name: undefined;
+    countryId: undefined;
+    countryCode: undefined;
+    countryName: undefined;
+    stateCode: undefined;
+    stateCodeIso: undefined;
+    fipsCode: undefined;
+    type: undefined;
+    level: undefined;
+    parentId: undefined;
+    native: undefined;
+    latitude: undefined;
+    longitude: undefined;
+    timezone: undefined;
+    translations: {};
+    searchDefault: never[];
+    searchByLocale: {};
+    syncedAt: undefined;
+}, "">;
+type State = InferType<typeof StateSchema>;
+
+/**
+ * A city in the geo reference mirror, backing
+ * `GET /geo/countries/:countryCode/states/:stateCode/cities` and `GET /geo/cities`.
+ *
+ * The big one: ~153,000 rows, ingested by STREAMING the 182 MB upstream JSON
+ * rather than parsing it. See `CountrySchema` for why this is neither `.strict()`
+ * nor concatenated with `DbDefaultSchema`.
+ *
+ * Both parent levels are stored denormalized (`stateCode`/`stateName` and
+ * `countryCode`/`countryName`), as upstream ships them, so a flat search hit
+ * carries everything a UI needs to back-fill the whole cascade.
+ */
+declare const CitySchema: yup.ObjectSchema<{
+    id: number;
+    name: string;
+    stateId: number | null | undefined;
+    stateCode: string | null | undefined;
+    stateCodeIso: string | null | undefined;
+    stateName: string | null | undefined;
+    countryId: number | null | undefined;
+    countryCode: string;
+    countryName: string | null | undefined;
+    latitude: number | null | undefined;
+    longitude: number | null | undefined;
+    native: string | null | undefined;
+    type: string | null | undefined;
+    level: number | null | undefined;
+    parentId: number | null | undefined;
+    population: number | null | undefined;
+    timezone: string | null | undefined;
+    translations: {} | null | undefined;
+    searchDefault: string[];
+    searchByLocale: {} | null | undefined;
+    syncedAt: number | null | undefined;
+}, yup.AnyObject, {
+    id: undefined;
+    name: undefined;
+    stateId: undefined;
+    stateCode: undefined;
+    stateCodeIso: undefined;
+    stateName: undefined;
+    countryId: undefined;
+    countryCode: undefined;
+    countryName: undefined;
+    latitude: undefined;
+    longitude: undefined;
+    native: undefined;
+    type: undefined;
+    level: undefined;
+    parentId: undefined;
+    population: undefined;
+    timezone: undefined;
+    translations: {};
+    searchDefault: never[];
+    searchByLocale: {};
+    syncedAt: undefined;
+}, "">;
+type City = InferType<typeof CitySchema>;
+
+/**
+ * Wrapped so an unknown key is REJECTED rather than silently ignored. See
+ * `SkillFilterSchema` for why this is a `.test()` and not `.noUnknown()`.
+ */
+declare const CountryFilterSchema: yup.ObjectSchema<{
+    countryCodes: string[];
+    iso3s: string[];
+    regions: string[];
+    subregions: string[];
+    names: string[];
+}, yup.AnyObject, {
+    countryCodes: never[];
+    iso3s: never[];
+    regions: never[];
+    subregions: never[];
+    names: never[];
+}, "">;
+
+/**
+ * Wrapped so an unknown key is REJECTED rather than silently ignored. See
+ * `SkillFilterSchema` for why this is a `.test()` and not `.noUnknown()`.
+ */
+declare const StateFilterSchema: yup.ObjectSchema<{
+    countryCodes: string[];
+    stateCodes: string[];
+    names: string[];
+    types: string[];
+}, yup.AnyObject, {
+    countryCodes: never[];
+    stateCodes: never[];
+    names: never[];
+    types: never[];
+}, "">;
+
+/**
+ * Wrapped so an unknown key is REJECTED rather than silently ignored. See
+ * `SkillFilterSchema` for why this is a `.test()` and not `.noUnknown()`.
+ */
+declare const CityFilterSchema: yup.ObjectSchema<{
+    countryCodes: string[];
+    stateCodes: string[];
+    names: string[];
+}, yup.AnyObject, {
+    countryCodes: never[];
+    stateCodes: never[];
+    names: never[];
+}, "">;
+
+/**
+ * Per-collection tally of one ingest pass.
+ *
+ * `upserted` vs `modified` is the assertion worth reading: a re-run over
+ * unchanged upstream data must be ALL `modified` and ZERO `upserted`. Any
+ * `upserted` on a second run means the `id`-keyed upsert is not matching, and
+ * the collection is quietly accumulating duplicates.
+ */
+declare const GeoSyncCountsSchema: yup.ObjectSchema<{
+    read: number;
+    upserted: number;
+    modified: number;
+    matched: number;
+    pruned: number;
+    prunedSkipped: boolean;
+}, yup.AnyObject, {
+    read: 0;
+    upserted: 0;
+    modified: 0;
+    matched: 0;
+    pruned: 0;
+    prunedSkipped: false;
+}, "">;
+/**
+ * One run of the geo refresh job, as stored in `geo_sync_runs` and returned by
+ * `GET /geo/refresh/status`.
+ *
+ * The run document is the ONLY shared state between the job and the status
+ * endpoint: the job writes phase and progress onto it, the dashboard polls it.
+ * Nothing reaches into the job's memory, which is what lets the job be a plain
+ * in-process async function rather than a queue.
+ */
+declare const GeoSyncRunSchema: yup.ObjectSchema<{
+    jobId: string;
+    status: NonNullable<GeoSyncStatus | undefined>;
+    trigger: GeoSyncTrigger | undefined;
+    force: boolean;
+    releaseTag: string | null | undefined;
+    previousReleaseTag: string | null | undefined;
+    startedAt: number;
+    finishedAt: number | null | undefined;
+    durationMs: number | null | undefined;
+    phase: GeoSyncPhase | null | undefined;
+    progress: {
+        collection?: string | null | undefined;
+        total?: number | null | undefined;
+        processed: number;
+    } | null | undefined;
+    counts: {
+        countries?: {
+            read: number;
+            upserted: number;
+            modified: number;
+            matched: number;
+            pruned: number;
+            prunedSkipped: boolean;
+        } | null | undefined;
+        states?: {
+            read: number;
+            upserted: number;
+            modified: number;
+            matched: number;
+            pruned: number;
+            prunedSkipped: boolean;
+        } | null | undefined;
+        cities?: {
+            read: number;
+            upserted: number;
+            modified: number;
+            matched: number;
+            pruned: number;
+            prunedSkipped: boolean;
+        } | null | undefined;
+    } | null | undefined;
+    reason: string | null | undefined;
+    error: string | null | undefined;
+}, yup.AnyObject, {
+    jobId: undefined;
+    status: undefined;
+    trigger: undefined;
+    force: false;
+    releaseTag: undefined;
+    previousReleaseTag: undefined;
+    startedAt: undefined;
+    finishedAt: undefined;
+    durationMs: undefined;
+    phase: undefined;
+    progress: {
+        collection: undefined;
+        processed: 0;
+        total: undefined;
+    };
+    counts: {
+        countries: {
+            read: 0;
+            upserted: 0;
+            modified: 0;
+            matched: 0;
+            pruned: 0;
+            prunedSkipped: false;
+        };
+        states: {
+            read: 0;
+            upserted: 0;
+            modified: 0;
+            matched: 0;
+            pruned: 0;
+            prunedSkipped: false;
+        };
+        cities: {
+            read: 0;
+            upserted: 0;
+            modified: 0;
+            matched: 0;
+            pruned: 0;
+            prunedSkipped: false;
+        };
+    };
+    reason: undefined;
+    error: undefined;
+}, "">;
+type GeoSyncRun = InferType<typeof GeoSyncRunSchema>;
+type GeoSyncCounts = InferType<typeof GeoSyncCountsSchema>;
+
 declare enum PageType {
     Institute = "institute",
     Company = "company"
@@ -1257,25 +1992,107 @@ declare const PageSchema: yup.ObjectSchema<NonNullable<{
     updatedAt: undefined;
 }, "">;
 
+/**
+ * Wrapped so an unknown key is REJECTED rather than silently ignored. See
+ * `SkillFilterSchema` for why this is a `.test()` and not `.noUnknown()`.
+ */
+declare const LanguageFilterSchema: yup.ObjectSchema<{
+    names: string[];
+}, yup.AnyObject, {
+    names: never[];
+}, "">;
+
+/** THE page filter. See `GroupFilterSchema` for why unknown keys must fail loudly. */
+declare const PageFilterSchema: yup.ObjectSchema<{
+    type: string[];
+    status: string[];
+    isFeatured: boolean | undefined;
+    featuredMarkets: string[];
+    slugs: string[];
+}, yup.AnyObject, {
+    type: never[];
+    status: never[];
+    isFeatured: undefined;
+    featuredMarkets: never[];
+    slugs: never[];
+}, "">;
+
+/**
+ * Where a campaign is in its life, as an OPERATOR would describe it.
+ *
+ * The states answer "what is this campaign doing?", not "what is the engine
+ * doing this second". That distinction is the whole design: a repeating
+ * campaign spends almost all its time between occurrences, and a status that
+ * tracked the send itself left it reading `sent` while it had years of mail
+ * still to go, indistinguishable from a one-shot that was finished forever.
+ *
+ * Per-occurrence detail (which run sent, how many, what failed) lives on the
+ * occurrence rows. This field is about the CAMPAIGN.
+ *
+ *   draft ──activate──> running ──pause──> paused ──resume──> running
+ *                          │                  │
+ *                          ├──────stop────────┤
+ *                          │                  │
+ *                          v                  v
+ *                       stopped            stopped        (terminal)
+ *                          │
+ *                   end condition met
+ *                          v
+ *                      completed                          (terminal)
+ *
+ * `failed` is reachable from `running` when a send throws, and is terminal.
+ */
 declare enum CampaignStatus {
+    /** Being written. Has never sent and is not considered by the scheduler. */
     Draft = "draft",
-    Sending = "sending",
-    Sent = "sent",
+    /**
+     * Live: the scheduler will fire it whenever its schedule says so.
+     *
+     * A campaign is `running` from activation until something ends it, INCLUDING
+     * the gaps between occurrences. An "every day, forever" campaign is therefore
+     * `running` permanently, which is the honest answer — it is never finished.
+     */
+    Running = "running",
+    /**
+     * Halted by a person, and resumable.
+     *
+     * Moments that pass while paused are MISSED, and missed moments are skipped
+     * rather than replayed, so resuming does not produce a burst of backdated
+     * mail. An `afterOccurrences` campaign keeps its remaining budget, because
+     * that budget counts sends that happened.
+     */
+    Paused = "paused",
+    /** Halted by a person, permanently. Cannot be resumed; clone it instead. */
+    Stopped = "stopped",
+    /** Its end condition is satisfied: afterOccurrences spent, or onDate passed. */
+    Completed = "completed",
+    /** A send threw and the run could not be completed. */
     Failed = "failed"
 }
 declare const SupportedCampaignStatuses: CampaignStatus[];
+/** No transition leaves these. */
+declare const TerminalCampaignStatuses: readonly [CampaignStatus.Stopped, CampaignStatus.Completed, CampaignStatus.Failed];
+/**
+ * The only status changes allowed, keyed by where the campaign is now.
+ *
+ * Declared as data rather than written as `if` chains in each route, so an
+ * illegal move (resuming a stopped campaign, pausing a draft) is refused in one
+ * place and the diagram above cannot quietly drift from the code.
+ */
+declare const CampaignStatusTransitions: Record<CampaignStatus, readonly CampaignStatus[]>;
+/** Whether a campaign may move from `from` to `to`. */
+declare function canTransitionCampaign(from: CampaignStatus, to: CampaignStatus): boolean;
 /**
  * How a campaign decides when to send.
  *
- * The two scheduled kinds dedupe differently, and that difference is the reason
- * they are separate kinds rather than one kind with a flag:
+ * Every kind here fires on a wall clock, so an occurrence is a shared moment:
+ * its identity is the occurrence itself, and a recipient may legitimately be
+ * mailed again on the next one.
  *
- *  • `Schedule` fires on a wall clock. Every occurrence is a shared moment, so
- *    its identity is the occurrence itself and a recipient may legitimately be
- *    mailed again next occurrence.
- *  • `Lifecycle` fires relative to each user's own anchor date (signup, …), so
- *    there is no shared moment. Identity is the user, permanently: a lifecycle
- *    campaign mails a given person at most once, ever.
+ * A `Lifecycle` kind (per-user, N days after that user's own anchor date) was
+ * removed; it was never used by any campaign. It did not belong beside these:
+ * having no shared moment, it deduped on the USER permanently rather than on
+ * the occurrence, which is a different engine wearing the same word.
  */
 declare enum CampaignTriggerKind {
     /** Admin presses send. Also the dry-run test path. */
@@ -1283,9 +2100,7 @@ declare enum CampaignTriggerKind {
     /** One send, at one future instant. */
     Once = "once",
     /** Repeats on a wall-clock schedule until its end condition. */
-    Schedule = "schedule",
-    /** Fires per user, N days after that user's anchor date. Once per user ever. */
-    Lifecycle = "lifecycle"
+    Schedule = "schedule"
 }
 declare const SupportedCampaignTriggerKinds: CampaignTriggerKind[];
 /** Repeat unit for a `schedule` trigger. */
@@ -1302,18 +2117,6 @@ declare enum CampaignEndKind {
     OnDate = "onDate"
 }
 declare const SupportedCampaignEndKinds: CampaignEndKind[];
-/**
- * The user-document date a `lifecycle` trigger counts its offset from. A closed
- * list because each value must be a real, indexed, immutable-enough date on the
- * user: an anchor that moves would re-fire the campaign for someone already
- * mailed, which the permanent idempotency key would then silently suppress.
- */
-declare enum CampaignAnchorField {
-    CreatedAt = "createdAt",
-    OnboardingCompletedAt = "onboardingCompletedAt",
-    MarketingConsentUpdatedAt = "marketingConsent.updatedAt"
-}
-declare const SupportedCampaignAnchorFields: CampaignAnchorField[];
 /**
  * Where a single template variable's value comes from. The admin picks one per
  * variable the chosen template declares.
@@ -1322,7 +2125,18 @@ declare const SupportedCampaignAnchorFields: CampaignAnchorField[];
  * personalised iff any binding is `Recipient` or `Source`. A stored flag could
  * disagree with the bindings it describes.
  */
-declare enum BindingKind {
+/**
+ * Where ONE template variable's value comes from.
+ *
+ * A campaign names a template, the template declares its variables, and each
+ * variable needs a source: a fixed string, something about the recipient, a
+ * link, or a field of whatever the campaign's data source returned. That
+ * mapping is a "binding".
+ *
+ * The string VALUES are stored in campaign documents — renaming one is a data
+ * migration, not a refactor.
+ */
+declare enum TemplateVariableBindingKind {
     /** A literal typed by the admin. Same for everyone. */
     Static = "static",
     /** A field of the resolved recipient, e.g. `name`. */
@@ -1332,7 +2146,7 @@ declare enum BindingKind {
     /** A field of the campaign's data source output, e.g. `matchedJobs`. */
     Source = "source"
 }
-declare const SupportedBindingKinds: BindingKind[];
+declare const SupportedTemplateVariableBindingKinds: TemplateVariableBindingKind[];
 /** Lifecycle of one materialised occurrence of a scheduled campaign. */
 declare enum OccurrenceStatus {
     Pending = "pending",
@@ -1343,19 +2157,32 @@ declare enum OccurrenceStatus {
 }
 declare const SupportedOccurrenceStatuses: OccurrenceStatus[];
 /**
- * Hard ceiling on recipients per scheduled/lifecycle send, enforced in code and
- * not overridable by config. Distinct from the one-shot audience cap: a campaign
+ * Hard ceiling on recipients per scheduled send, enforced in code and not
+ * overridable by config. Distinct from the one-shot audience cap: a campaign
  * that repeats forever gets the tighter bound, because a misconfigured filter
  * that mails too many people does it again every occurrence.
  */
 declare const CAMPAIGN_MAX_RECIPIENTS_CEILING = 5000;
 
 /**
- * Every clause except `or`. Declared separately so `ListFilterSchema` can embed
- * it as its branch type without referring to itself: the union is deliberately
- * one level deep, and a non-recursive definition is what enforces that.
+ * A mailing list's saved audience query.
+ *
+ * The SAME filter user-service validates, re-exported under the name it carries
+ * where it is stored. Not a separate vocabulary: a list resolves against
+ * user-service, so anything it can save must be something that service accepts.
+ * Defined in `user/user-filter.schema.ts` because it describes users.
+ *
+ * @todo SVELTE-UI-SCHEMA-RENAME — this was `ListFilterSchema`, and
+ * `thejob-svelte-ui` still imports THAT name in
+ * `src/lib/services/admin.service.ts` (3 lines: the import, a doc reference and
+ * the `InferType` argument). It will not typecheck against this build until
+ * those are updated. Deliberately left unmigrated rather than fixed in passing:
+ * renaming an export here is a change to every consumer, and each one is its
+ * own decision. No back-compat alias, so the break is loud rather than silent.
  */
-declare const ListFilterBranchSchema: yup.ObjectSchema<{
+declare const MailingListFilterSchema: yup.ObjectSchema<{
+    emails: string[];
+    authAccountIds: string[];
     countries: string[];
     roles: string[];
     experienceLevels: string[];
@@ -1364,21 +2191,37 @@ declare const ListFilterBranchSchema: yup.ObjectSchema<{
     referralSources: string[];
     statuses: string[];
     profileVisibilities: string[];
-    skillProficiencyLevels: string[];
-    languageProficiencyLevels: string[];
     studyTypes: string[];
     socialAccountTypes: string[];
     salaryCurrencies: string[];
-    skills: string[];
-    languages: string[];
+    skills: {
+        [x: string]: string | undefined;
+        [x: number]: string | undefined;
+    }[];
+    languages: {
+        [x: string]: string | undefined;
+        [x: number]: string | undefined;
+    }[];
     interests: string[];
     companies: string[];
     designations: string[];
     institutes: string[];
     courses: string[];
     fieldsOfStudy: string[];
-    certifications: string[];
-    certificationAuthorities: string[];
+    workHistory: {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    }[];
+    educationHistory: {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    }[];
+    certifications: {
+        [x: string]: string | undefined;
+        [x: number]: string | undefined;
+    }[];
     projects: string[];
     jobRoles: string[];
     jobLocations: string[];
@@ -1415,13 +2258,17 @@ declare const ListFilterBranchSchema: yup.ObjectSchema<{
     signupLocales: string[];
     signupSources: string[];
     educationLevels: string[];
+    marketingSubscribed: boolean | undefined;
     jobAlertFrequencies: string[];
     consentSources: string[];
     consentUpdatedWithinDays: number | undefined;
+    consentUpdatedAfter: number | undefined;
     notificationChannelsEnabled: string[];
     currentlyEmployed: boolean;
     graduatedWithinMonths: number | undefined;
     skillUsedWithinMonths: number | undefined;
+    graduatedAfter: string | undefined;
+    skillUsedAfter: string | undefined;
     hasImage: boolean;
     hasHeadline: boolean;
     hasAboutMe: boolean;
@@ -1432,316 +2279,7 @@ declare const ListFilterBranchSchema: yup.ObjectSchema<{
     hasJobAlert: boolean | undefined;
     hasApplied: boolean | undefined;
     appliedWithinDays: number | undefined;
-    search: string | undefined;
-}, yup.AnyObject, {
-    countries: never[];
-    roles: never[];
-    experienceLevels: never[];
-    targetExperienceLevels: never[];
-    jobSearchUrgencies: never[];
-    referralSources: never[];
-    statuses: never[];
-    profileVisibilities: never[];
-    skillProficiencyLevels: never[];
-    languageProficiencyLevels: never[];
-    studyTypes: never[];
-    socialAccountTypes: never[];
-    salaryCurrencies: never[];
-    skills: never[];
-    languages: never[];
-    interests: never[];
-    companies: never[];
-    designations: never[];
-    institutes: never[];
-    courses: never[];
-    fieldsOfStudy: never[];
-    certifications: never[];
-    certificationAuthorities: never[];
-    projects: never[];
-    jobRoles: never[];
-    jobLocations: never[];
-    hiringForCompanies: never[];
-    coordinatesAtInstitutes: never[];
-    keywords: never[];
-    minSalaryFloor: undefined;
-    minSalaryCeil: undefined;
-    openToWorkOnly: false;
-    remoteExperienceOnly: false;
-    hasResumeOnly: false;
-    onboardingCompletedOnly: false;
-    emailVerifiedOnly: false;
-    mobileVerifiedOnly: false;
-    lastSeenBeforeDays: undefined;
-    lastSeenAfterDays: undefined;
-    createdAtWithinDays: undefined;
-    createdAtOlderThanDays: undefined;
-    completenessMin: undefined;
-    completenessMax: undefined;
-    lastSeenBefore: undefined;
-    lastSeenAfter: undefined;
-    createdAtFrom: undefined;
-    createdAtBefore: undefined;
-    states: never[];
-    stateCodes: never[];
-    cities: never[];
-    withinRadius: undefined;
-    signupCountries: never[];
-    signupLocales: never[];
-    signupSources: never[];
-    educationLevels: never[];
-    jobAlertFrequencies: never[];
-    consentSources: never[];
-    consentUpdatedWithinDays: undefined;
-    notificationChannelsEnabled: never[];
-    currentlyEmployed: false;
-    graduatedWithinMonths: undefined;
-    skillUsedWithinMonths: undefined;
-    hasImage: false;
-    hasHeadline: false;
-    hasAboutMe: false;
-    hasMobile: false;
-    missingSections: never[];
-    companyTypes: never[];
-    instituteTypes: never[];
-    hasJobAlert: undefined;
-    hasApplied: undefined;
-    appliedWithinDays: undefined;
-    search: undefined;
-}, "">;
-/** A branch of `or`: every clause except `or` itself, so unions cannot nest. */
-declare const ListFilterBranch: yup.ObjectSchema<{
-    countries: string[];
-    roles: string[];
-    experienceLevels: string[];
-    targetExperienceLevels: string[];
-    jobSearchUrgencies: string[];
-    referralSources: string[];
-    statuses: string[];
-    profileVisibilities: string[];
-    skillProficiencyLevels: string[];
-    languageProficiencyLevels: string[];
-    studyTypes: string[];
-    socialAccountTypes: string[];
-    salaryCurrencies: string[];
-    skills: string[];
-    languages: string[];
-    interests: string[];
-    companies: string[];
-    designations: string[];
-    institutes: string[];
-    courses: string[];
-    fieldsOfStudy: string[];
-    certifications: string[];
-    certificationAuthorities: string[];
-    projects: string[];
-    jobRoles: string[];
-    jobLocations: string[];
-    hiringForCompanies: string[];
-    coordinatesAtInstitutes: string[];
-    keywords: string[];
-    minSalaryFloor: number | undefined;
-    minSalaryCeil: number | undefined;
-    openToWorkOnly: boolean;
-    remoteExperienceOnly: boolean;
-    hasResumeOnly: boolean;
-    onboardingCompletedOnly: boolean;
-    emailVerifiedOnly: boolean;
-    mobileVerifiedOnly: boolean;
-    lastSeenBeforeDays: number | undefined;
-    lastSeenAfterDays: number | undefined;
-    createdAtWithinDays: number | undefined;
-    createdAtOlderThanDays: number | undefined;
-    completenessMin: number | undefined;
-    completenessMax: number | undefined;
-    lastSeenBefore: number | undefined;
-    lastSeenAfter: number | undefined;
-    createdAtFrom: number | undefined;
-    createdAtBefore: number | undefined;
-    states: string[];
-    stateCodes: string[];
-    cities: string[];
-    withinRadius: {
-        lat: number;
-        lng: number;
-        km: number;
-    } | undefined;
-    signupCountries: string[];
-    signupLocales: string[];
-    signupSources: string[];
-    educationLevels: string[];
-    jobAlertFrequencies: string[];
-    consentSources: string[];
-    consentUpdatedWithinDays: number | undefined;
-    notificationChannelsEnabled: string[];
-    currentlyEmployed: boolean;
-    graduatedWithinMonths: number | undefined;
-    skillUsedWithinMonths: number | undefined;
-    hasImage: boolean;
-    hasHeadline: boolean;
-    hasAboutMe: boolean;
-    hasMobile: boolean;
-    missingSections: string[];
-    companyTypes: string[];
-    instituteTypes: string[];
-    hasJobAlert: boolean | undefined;
-    hasApplied: boolean | undefined;
-    appliedWithinDays: number | undefined;
-    search: string | undefined;
-}, yup.AnyObject, {
-    countries: never[];
-    roles: never[];
-    experienceLevels: never[];
-    targetExperienceLevels: never[];
-    jobSearchUrgencies: never[];
-    referralSources: never[];
-    statuses: never[];
-    profileVisibilities: never[];
-    skillProficiencyLevels: never[];
-    languageProficiencyLevels: never[];
-    studyTypes: never[];
-    socialAccountTypes: never[];
-    salaryCurrencies: never[];
-    skills: never[];
-    languages: never[];
-    interests: never[];
-    companies: never[];
-    designations: never[];
-    institutes: never[];
-    courses: never[];
-    fieldsOfStudy: never[];
-    certifications: never[];
-    certificationAuthorities: never[];
-    projects: never[];
-    jobRoles: never[];
-    jobLocations: never[];
-    hiringForCompanies: never[];
-    coordinatesAtInstitutes: never[];
-    keywords: never[];
-    minSalaryFloor: undefined;
-    minSalaryCeil: undefined;
-    openToWorkOnly: false;
-    remoteExperienceOnly: false;
-    hasResumeOnly: false;
-    onboardingCompletedOnly: false;
-    emailVerifiedOnly: false;
-    mobileVerifiedOnly: false;
-    lastSeenBeforeDays: undefined;
-    lastSeenAfterDays: undefined;
-    createdAtWithinDays: undefined;
-    createdAtOlderThanDays: undefined;
-    completenessMin: undefined;
-    completenessMax: undefined;
-    lastSeenBefore: undefined;
-    lastSeenAfter: undefined;
-    createdAtFrom: undefined;
-    createdAtBefore: undefined;
-    states: never[];
-    stateCodes: never[];
-    cities: never[];
-    withinRadius: undefined;
-    signupCountries: never[];
-    signupLocales: never[];
-    signupSources: never[];
-    educationLevels: never[];
-    jobAlertFrequencies: never[];
-    consentSources: never[];
-    consentUpdatedWithinDays: undefined;
-    notificationChannelsEnabled: never[];
-    currentlyEmployed: false;
-    graduatedWithinMonths: undefined;
-    skillUsedWithinMonths: undefined;
-    hasImage: false;
-    hasHeadline: false;
-    hasAboutMe: false;
-    hasMobile: false;
-    missingSections: never[];
-    companyTypes: never[];
-    instituteTypes: never[];
-    hasJobAlert: undefined;
-    hasApplied: undefined;
-    appliedWithinDays: undefined;
-    search: undefined;
-}, "">;
-declare const ListFilterSchema: yup.ObjectSchema<{
-    countries: string[];
-    roles: string[];
-    experienceLevels: string[];
-    targetExperienceLevels: string[];
-    jobSearchUrgencies: string[];
-    referralSources: string[];
-    statuses: string[];
-    profileVisibilities: string[];
-    skillProficiencyLevels: string[];
-    languageProficiencyLevels: string[];
-    studyTypes: string[];
-    socialAccountTypes: string[];
-    salaryCurrencies: string[];
-    skills: string[];
-    languages: string[];
-    interests: string[];
-    companies: string[];
-    designations: string[];
-    institutes: string[];
-    courses: string[];
-    fieldsOfStudy: string[];
-    certifications: string[];
-    certificationAuthorities: string[];
-    projects: string[];
-    jobRoles: string[];
-    jobLocations: string[];
-    hiringForCompanies: string[];
-    coordinatesAtInstitutes: string[];
-    keywords: string[];
-    minSalaryFloor: number | undefined;
-    minSalaryCeil: number | undefined;
-    openToWorkOnly: boolean;
-    remoteExperienceOnly: boolean;
-    hasResumeOnly: boolean;
-    onboardingCompletedOnly: boolean;
-    emailVerifiedOnly: boolean;
-    mobileVerifiedOnly: boolean;
-    lastSeenBeforeDays: number | undefined;
-    lastSeenAfterDays: number | undefined;
-    createdAtWithinDays: number | undefined;
-    createdAtOlderThanDays: number | undefined;
-    completenessMin: number | undefined;
-    completenessMax: number | undefined;
-    lastSeenBefore: number | undefined;
-    lastSeenAfter: number | undefined;
-    createdAtFrom: number | undefined;
-    createdAtBefore: number | undefined;
-    states: string[];
-    stateCodes: string[];
-    cities: string[];
-    withinRadius: {
-        lat: number;
-        lng: number;
-        km: number;
-    } | undefined;
-    signupCountries: string[];
-    signupLocales: string[];
-    signupSources: string[];
-    educationLevels: string[];
-    jobAlertFrequencies: string[];
-    consentSources: string[];
-    consentUpdatedWithinDays: number | undefined;
-    notificationChannelsEnabled: string[];
-    currentlyEmployed: boolean;
-    graduatedWithinMonths: number | undefined;
-    skillUsedWithinMonths: number | undefined;
-    hasImage: boolean;
-    hasHeadline: boolean;
-    hasAboutMe: boolean;
-    hasMobile: boolean;
-    missingSections: string[];
-    companyTypes: string[];
-    instituteTypes: string[];
-    hasJobAlert: boolean | undefined;
-    hasApplied: boolean | undefined;
-    appliedWithinDays: number | undefined;
-    search: string | undefined;
     or: {
-        search?: string | undefined;
         hasApplied?: boolean | undefined;
         minSalaryFloor?: number | undefined;
         minSalaryCeil?: number | undefined;
@@ -1760,19 +2298,38 @@ declare const ListFilterSchema: yup.ObjectSchema<{
             lng: number;
             km: number;
         } | undefined;
+        marketingSubscribed?: boolean | undefined;
         consentUpdatedWithinDays?: number | undefined;
+        consentUpdatedAfter?: number | undefined;
         graduatedWithinMonths?: number | undefined;
         skillUsedWithinMonths?: number | undefined;
+        graduatedAfter?: string | undefined;
+        skillUsedAfter?: string | undefined;
         hasJobAlert?: boolean | undefined;
         appliedWithinDays?: number | undefined;
         keywords: string[];
         countries: string[];
         courses: string[];
-        skills: string[];
-        languages: string[];
-        certifications: string[];
+        skills: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
+        }[];
+        languages: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
+        }[];
+        certifications: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
+        }[];
         interests: string[];
         projects: string[];
+        companies: string[];
+        stateCodes: string[];
+        states: string[];
+        cities: string[];
+        emails: string[];
+        authAccountIds: string[];
         roles: string[];
         experienceLevels: string[];
         targetExperienceLevels: string[];
@@ -1780,16 +2337,22 @@ declare const ListFilterSchema: yup.ObjectSchema<{
         referralSources: string[];
         statuses: string[];
         profileVisibilities: string[];
-        skillProficiencyLevels: string[];
-        languageProficiencyLevels: string[];
         studyTypes: string[];
         socialAccountTypes: string[];
         salaryCurrencies: string[];
-        companies: string[];
         designations: string[];
         institutes: string[];
         fieldsOfStudy: string[];
-        certificationAuthorities: string[];
+        workHistory: {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[];
+        educationHistory: {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[];
         jobRoles: string[];
         jobLocations: string[];
         hiringForCompanies: string[];
@@ -1800,9 +2363,6 @@ declare const ListFilterSchema: yup.ObjectSchema<{
         onboardingCompletedOnly: boolean;
         emailVerifiedOnly: boolean;
         mobileVerifiedOnly: boolean;
-        states: string[];
-        stateCodes: string[];
-        cities: string[];
         signupCountries: string[];
         signupLocales: string[];
         signupSources: string[];
@@ -1820,6 +2380,8 @@ declare const ListFilterSchema: yup.ObjectSchema<{
         instituteTypes: string[];
     }[];
 }, yup.AnyObject, {
+    emails: never[];
+    authAccountIds: never[];
     countries: never[];
     roles: never[];
     experienceLevels: never[];
@@ -1828,8 +2390,6 @@ declare const ListFilterSchema: yup.ObjectSchema<{
     referralSources: never[];
     statuses: never[];
     profileVisibilities: never[];
-    skillProficiencyLevels: never[];
-    languageProficiencyLevels: never[];
     studyTypes: never[];
     socialAccountTypes: never[];
     salaryCurrencies: never[];
@@ -1841,8 +2401,9 @@ declare const ListFilterSchema: yup.ObjectSchema<{
     institutes: never[];
     courses: never[];
     fieldsOfStudy: never[];
+    workHistory: never[];
+    educationHistory: never[];
     certifications: never[];
-    certificationAuthorities: never[];
     projects: never[];
     jobRoles: never[];
     jobLocations: never[];
@@ -1875,13 +2436,17 @@ declare const ListFilterSchema: yup.ObjectSchema<{
     signupLocales: never[];
     signupSources: never[];
     educationLevels: never[];
+    marketingSubscribed: undefined;
     jobAlertFrequencies: never[];
     consentSources: never[];
     consentUpdatedWithinDays: undefined;
+    consentUpdatedAfter: undefined;
     notificationChannelsEnabled: never[];
     currentlyEmployed: false;
     graduatedWithinMonths: undefined;
     skillUsedWithinMonths: undefined;
+    graduatedAfter: undefined;
+    skillUsedAfter: undefined;
     hasImage: false;
     hasHeadline: false;
     hasAboutMe: false;
@@ -1892,14 +2457,12 @@ declare const ListFilterSchema: yup.ObjectSchema<{
     hasJobAlert: undefined;
     hasApplied: undefined;
     appliedWithinDays: undefined;
-    search: undefined;
     or: never[];
 }, "">;
 declare const MailingListSchema: yup.ObjectSchema<{
     name: string;
     description: string | undefined;
     filter: {
-        search?: string | undefined;
         hasApplied?: boolean | undefined;
         minSalaryFloor?: number | undefined;
         minSalaryCeil?: number | undefined;
@@ -1918,19 +2481,38 @@ declare const MailingListSchema: yup.ObjectSchema<{
             lng: number;
             km: number;
         } | undefined;
+        marketingSubscribed?: boolean | undefined;
         consentUpdatedWithinDays?: number | undefined;
+        consentUpdatedAfter?: number | undefined;
         graduatedWithinMonths?: number | undefined;
         skillUsedWithinMonths?: number | undefined;
+        graduatedAfter?: string | undefined;
+        skillUsedAfter?: string | undefined;
         hasJobAlert?: boolean | undefined;
         appliedWithinDays?: number | undefined;
         keywords: string[];
         countries: string[];
         courses: string[];
-        skills: string[];
-        languages: string[];
-        certifications: string[];
+        skills: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
+        }[];
+        languages: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
+        }[];
+        certifications: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
+        }[];
         interests: string[];
         projects: string[];
+        companies: string[];
+        stateCodes: string[];
+        states: string[];
+        cities: string[];
+        emails: string[];
+        authAccountIds: string[];
         roles: string[];
         experienceLevels: string[];
         targetExperienceLevels: string[];
@@ -1938,16 +2520,22 @@ declare const MailingListSchema: yup.ObjectSchema<{
         referralSources: string[];
         statuses: string[];
         profileVisibilities: string[];
-        skillProficiencyLevels: string[];
-        languageProficiencyLevels: string[];
         studyTypes: string[];
         socialAccountTypes: string[];
         salaryCurrencies: string[];
-        companies: string[];
         designations: string[];
         institutes: string[];
         fieldsOfStudy: string[];
-        certificationAuthorities: string[];
+        workHistory: {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[];
+        educationHistory: {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[];
         jobRoles: string[];
         jobLocations: string[];
         hiringForCompanies: string[];
@@ -1958,9 +2546,6 @@ declare const MailingListSchema: yup.ObjectSchema<{
         onboardingCompletedOnly: boolean;
         emailVerifiedOnly: boolean;
         mobileVerifiedOnly: boolean;
-        states: string[];
-        stateCodes: string[];
-        cities: string[];
         signupCountries: string[];
         signupLocales: string[];
         signupSources: string[];
@@ -1977,7 +2562,6 @@ declare const MailingListSchema: yup.ObjectSchema<{
         companyTypes: string[];
         instituteTypes: string[];
         or: {
-            search?: string | undefined;
             hasApplied?: boolean | undefined;
             minSalaryFloor?: number | undefined;
             minSalaryCeil?: number | undefined;
@@ -1996,19 +2580,38 @@ declare const MailingListSchema: yup.ObjectSchema<{
                 lng: number;
                 km: number;
             } | undefined;
+            marketingSubscribed?: boolean | undefined;
             consentUpdatedWithinDays?: number | undefined;
+            consentUpdatedAfter?: number | undefined;
             graduatedWithinMonths?: number | undefined;
             skillUsedWithinMonths?: number | undefined;
+            graduatedAfter?: string | undefined;
+            skillUsedAfter?: string | undefined;
             hasJobAlert?: boolean | undefined;
             appliedWithinDays?: number | undefined;
             keywords: string[];
             countries: string[];
             courses: string[];
-            skills: string[];
-            languages: string[];
-            certifications: string[];
+            skills: {
+                [x: string]: string | undefined;
+                [x: number]: string | undefined;
+            }[];
+            languages: {
+                [x: string]: string | undefined;
+                [x: number]: string | undefined;
+            }[];
+            certifications: {
+                [x: string]: string | undefined;
+                [x: number]: string | undefined;
+            }[];
             interests: string[];
             projects: string[];
+            companies: string[];
+            stateCodes: string[];
+            states: string[];
+            cities: string[];
+            emails: string[];
+            authAccountIds: string[];
             roles: string[];
             experienceLevels: string[];
             targetExperienceLevels: string[];
@@ -2016,16 +2619,22 @@ declare const MailingListSchema: yup.ObjectSchema<{
             referralSources: string[];
             statuses: string[];
             profileVisibilities: string[];
-            skillProficiencyLevels: string[];
-            languageProficiencyLevels: string[];
             studyTypes: string[];
             socialAccountTypes: string[];
             salaryCurrencies: string[];
-            companies: string[];
             designations: string[];
             institutes: string[];
             fieldsOfStudy: string[];
-            certificationAuthorities: string[];
+            workHistory: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[];
+            educationHistory: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[];
             jobRoles: string[];
             jobLocations: string[];
             hiringForCompanies: string[];
@@ -2036,9 +2645,6 @@ declare const MailingListSchema: yup.ObjectSchema<{
             onboardingCompletedOnly: boolean;
             emailVerifiedOnly: boolean;
             mobileVerifiedOnly: boolean;
-            states: string[];
-            stateCodes: string[];
-            cities: string[];
             signupCountries: string[];
             signupLocales: string[];
             signupSources: string[];
@@ -2060,6 +2666,8 @@ declare const MailingListSchema: yup.ObjectSchema<{
     name: undefined;
     description: undefined;
     filter: {
+        emails: never[];
+        authAccountIds: never[];
         countries: never[];
         roles: never[];
         experienceLevels: never[];
@@ -2068,8 +2676,6 @@ declare const MailingListSchema: yup.ObjectSchema<{
         referralSources: never[];
         statuses: never[];
         profileVisibilities: never[];
-        skillProficiencyLevels: never[];
-        languageProficiencyLevels: never[];
         studyTypes: never[];
         socialAccountTypes: never[];
         salaryCurrencies: never[];
@@ -2081,8 +2687,9 @@ declare const MailingListSchema: yup.ObjectSchema<{
         institutes: never[];
         courses: never[];
         fieldsOfStudy: never[];
+        workHistory: never[];
+        educationHistory: never[];
         certifications: never[];
-        certificationAuthorities: never[];
         projects: never[];
         jobRoles: never[];
         jobLocations: never[];
@@ -2115,13 +2722,17 @@ declare const MailingListSchema: yup.ObjectSchema<{
         signupLocales: never[];
         signupSources: never[];
         educationLevels: never[];
+        marketingSubscribed: undefined;
         jobAlertFrequencies: never[];
         consentSources: never[];
         consentUpdatedWithinDays: undefined;
+        consentUpdatedAfter: undefined;
         notificationChannelsEnabled: never[];
         currentlyEmployed: false;
         graduatedWithinMonths: undefined;
         skillUsedWithinMonths: undefined;
+        graduatedAfter: undefined;
+        skillUsedAfter: undefined;
         hasImage: false;
         hasHeadline: false;
         hasAboutMe: false;
@@ -2132,13 +2743,12 @@ declare const MailingListSchema: yup.ObjectSchema<{
         hasJobAlert: undefined;
         hasApplied: undefined;
         appliedWithinDays: undefined;
-        search: undefined;
         or: never[];
     };
 }, "">;
 /**
  * When a campaign sends. Discriminated by `kind`; the fields each kind needs are
- * required only for that kind, so one stored shape covers all four.
+ * required only for that kind, so one stored shape covers them all.
  */
 declare const CampaignTriggerSchema: yup.ObjectSchema<{
     kind: NonNullable<CampaignTriggerKind | undefined>;
@@ -2153,13 +2763,10 @@ declare const CampaignTriggerSchema: yup.ObjectSchema<{
     byWeekday: number[];
     byMonthday: number | undefined;
     end: {
-        occurrences?: number | undefined;
         date?: number | undefined;
+        occurrences?: number | undefined;
         kind: NonNullable<CampaignEndKind | undefined>;
     };
-    anchorField: CampaignAnchorField | undefined;
-    offsetDays: number | undefined;
-    windowDays: number;
 }, yup.AnyObject, {
     kind: CampaignTriggerKind.Manual;
     timezone: "UTC";
@@ -2172,16 +2779,36 @@ declare const CampaignTriggerSchema: yup.ObjectSchema<{
     end: {
         kind: CampaignEndKind;
     };
-    anchorField: undefined;
-    offsetDays: undefined;
-    windowDays: 2;
 }, "">;
 /**
- * Where one template variable's value comes from. `value` carries the literal for
- * `static`/`url`, and the field path for `recipient`/`source`.
+ * ONE data source a campaign draws content from: which source, how it is
+ * configured, and whether it personalises.
+ *
+ * Extracted so `CampaignSchema.dataSources` can hold several. A campaign used
+ * to store exactly one, which meant a template could never combine (say) jobs
+ * and groups in one mail.
  */
-declare const BindingSchema: yup.ObjectSchema<{
-    kind: NonNullable<BindingKind | undefined>;
+declare const CampaignDataSourceSchema: yup.ObjectSchema<{
+    id: string;
+    personalised: boolean | undefined;
+    params: {
+        [x: string]: {} | undefined;
+        [x: number]: {} | undefined;
+    };
+}, yup.AnyObject, {
+    id: undefined;
+    personalised: undefined;
+    params: undefined;
+}, "">;
+/**
+ * Where ONE template variable's value comes from.
+ *
+ * `value` carries the literal for `static`/`url`, and the field path for
+ * `recipient`/`source`. Named for what it binds: "binding" alone says nothing
+ * about what is being bound to what.
+ */
+declare const TemplateVariableBindingSchema: yup.ObjectSchema<{
+    kind: NonNullable<TemplateVariableBindingKind | undefined>;
     value: string;
 }, yup.AnyObject, {
     kind: undefined;
@@ -2193,24 +2820,26 @@ declare const CampaignSchema: yup.ObjectSchema<{
     html: string | undefined;
     text: string | undefined;
     listId: string;
+    status: CampaignStatus;
     templateKey: string | undefined;
     bindings: {
         [x: string]: {
             value: string;
-            kind: NonNullable<BindingKind | undefined>;
+            kind: NonNullable<TemplateVariableBindingKind | undefined>;
         };
         [x: number]: {
             value: string;
-            kind: NonNullable<BindingKind | undefined>;
+            kind: NonNullable<TemplateVariableBindingKind | undefined>;
         };
     };
-    dataSource: {
+    dataSources: {
+        personalised?: boolean | undefined;
         id: string;
         params: {
             [x: string]: {} | undefined;
             [x: number]: {} | undefined;
         };
-    } | undefined;
+    }[] | undefined;
     trigger: {
         runAt?: number | undefined;
         startAt?: number | undefined;
@@ -2219,20 +2848,16 @@ declare const CampaignSchema: yup.ObjectSchema<{
             unit: NonNullable<CampaignIntervalUnit | undefined>;
         } | undefined;
         byMonthday?: number | undefined;
-        anchorField?: CampaignAnchorField | undefined;
-        offsetDays?: number | undefined;
-        kind: NonNullable<CampaignTriggerKind | undefined>;
         timezone: string;
+        kind: NonNullable<CampaignTriggerKind | undefined>;
         timeOfDay: string;
         byWeekday: number[];
         end: {
-            occurrences?: number | undefined;
             date?: number | undefined;
+            occurrences?: number | undefined;
             kind: NonNullable<CampaignEndKind | undefined>;
         };
-        windowDays: number;
     };
-    enabled: boolean;
     dryRun: boolean;
     maxRecipients: number | undefined;
     utm: {
@@ -2245,9 +2870,10 @@ declare const CampaignSchema: yup.ObjectSchema<{
     html: undefined;
     text: undefined;
     listId: undefined;
+    status: CampaignStatus.Draft;
     templateKey: undefined;
     bindings: undefined;
-    dataSource: undefined;
+    dataSources: undefined;
     trigger: {
         kind: CampaignTriggerKind.Manual;
         timezone: "UTC";
@@ -2260,11 +2886,7 @@ declare const CampaignSchema: yup.ObjectSchema<{
         end: {
             kind: CampaignEndKind;
         };
-        anchorField: undefined;
-        offsetDays: undefined;
-        windowDays: 2;
     };
-    enabled: false;
     dryRun: true;
     maxRecipients: undefined;
     utm: undefined;
@@ -2404,16 +3026,28 @@ declare enum JobAlertFrequency {
 }
 declare const SupportedJobAlertFrequencies: JobAlertFrequency[];
 /**
- * Channels of NOTIFICATION email — mail about activity on the user's own
- * account (a group invite, a job of theirs expiring). Distinct from marketing:
- * notifications are opt-OUT (default on, see `notificationPrefs`), marketing is
- * opt-IN (`marketingConsent.subscribed`). Transactional mail (magic-link,
- * verification) is governed by neither and always sends.
+ * KINDS of notification, by subject matter — what a message is ABOUT, not how
+ * it reaches the user. A notification of a given kind may be delivered over any
+ * transport (email, web push, and later whatsapp or in-app); this enum is the
+ * user's per-subject mute switch and applies across all of them.
+ *
+ * Named `NotificationType` rather than `...Channel` precisely because "channel"
+ * reads as a delivery route. Muting `groupActivity` mutes group activity
+ * everywhere, not merely in the mail.
+ *
+ * Distinct from marketing: notifications are opt-OUT (default on, see
+ * `notificationPrefs`), marketing is opt-IN (`marketingConsent.subscribed`).
+ * Transactional mail (magic-link, verification) is governed by neither and
+ * always sends.
  *
- * Deliberately coarse: four channels a user will actually reason about, rather
+ * Deliberately coarse: four kinds a user will actually reason about, rather
  * than one toggle per email template.
+ *
+ * The VALUES are stored in Mongo as the keys of `notificationPrefs`, so they
+ * are data, not style. Renaming the enum is a type-level change; renaming a
+ * value would be a data migration.
  */
-declare enum NotificationChannel {
+declare enum NotificationType {
     /** Group invites, join requests, membership approved/rejected. */
     GroupActivity = "groupActivity",
     /** Activity on jobs the user posted, e.g. a listing expiring. */
@@ -2423,7 +3057,7 @@ declare enum NotificationChannel {
     /** Product announcements and feature news. */
     ProductUpdates = "productUpdates"
 }
-declare const SupportedNotificationChannels: NotificationChannel[];
+declare const SupportedNotificationTypes: NotificationType[];
 /** ISO-4217 currency codes accepted for the salary preference (extend as needed). */
 declare const SupportedSalaryCurrencies: readonly ["USD", "EUR", "GBP", "SEK", "INR"];
 type SupportedSalaryCurrency = (typeof SupportedSalaryCurrencies)[number];
@@ -2527,6 +3161,19 @@ declare const ReportSchema: yup.ObjectSchema<{
     comment: undefined;
 }, "">;
 
+/**
+ * Wrapped so an unknown key is REJECTED rather than silently ignored, which is
+ * the whole point here: the hand-rolled reader this replaces ignored not just
+ * unknown KEYS but unknown VALUES too.
+ */
+declare const FeedbackFilterSchema: yup.ObjectSchema<{
+    type: string[];
+    status: string[];
+}, yup.AnyObject, {
+    type: never[];
+    status: never[];
+}, "">;
+
 declare enum FeedbackType {
     Bug = "bug",
     Feature = "feature",
@@ -2565,6 +3212,23 @@ declare const FeedbackSchema: yup.ObjectSchema<{
     status: undefined;
 }, "">;
 
+/**
+ * Wrapped so an unknown key is REJECTED rather than silently ignored.
+ *
+ * Yup gives you unknown-key rejection or coercion, never both: `.noUnknown()`
+ * alone accepts `{bogus:1}`, and with `strict: true` it rejects but then throws
+ * on the string values every query param arrives as. Hence a `.test()`.
+ */
+declare const SkillFilterSchema: yup.ObjectSchema<{
+    names: string[];
+    conceptIds: string[];
+    tags: string[];
+}, yup.AnyObject, {
+    names: never[];
+    conceptIds: never[];
+    tags: never[];
+}, "">;
+
 declare const SkillSchema: yup.ObjectSchema<{
     name: string;
     conceptId: string | null | undefined;
@@ -2589,9 +3253,379 @@ declare const SkillSchema: yup.ObjectSchema<{
     shortId: undefined;
     createdBy: undefined;
     createdAt: undefined;
-    updatedBy: undefined;
+    updatedBy: undefined;
+    updatedAt: undefined;
+}, "">;
+
+/**
+ * Billing vocabulary (Paddle).
+ *
+ * Two conventions in this module differ from the rest of the package, both
+ * deliberately and both load-bearing. Read them before editing:
+ *
+ * 1. **Paddle's wire values win.** `SubscriptionStatus` and `TransactionStatus`
+ *    mirror Paddle verbatim, underscores included (`past_due`). The house style
+ *    is lowercase-hyphen, but these values arrive in webhooks and are compared
+ *    as literals; normalising them would silently stop matching live events.
+ *    Never invent a member Paddle does not send.
+ *
+ * 2. **Money is in MINOR units.** Every other amount in this package (salary) is
+ *    a bare integer in the currency's MAJOR unit. Paddle is the opposite. See
+ *    `MoneySchema` in `billing.schema.ts`.
+ */
+/** Whether buying this plan starts a recurring subscription or is a one-time purchase. */
+declare enum PlanKind {
+    Subscription = "subscription",
+    OneOff = "one-off"
+}
+declare const SupportedPlanKinds: PlanKind[];
+/** Whether a plan can currently be bought. Archived plans still grant to existing owners. */
+declare enum PlanStatus {
+    Draft = "draft",
+    Active = "active",
+    Archived = "archived"
+}
+declare const SupportedPlanStatuses: PlanStatus[];
+/**
+ * How a grant gives access to a feature.
+ *
+ * - `boolean` — plain on/off for as long as the plan is held.
+ * - `quota` — N uses per period, refreshed each period.
+ * - `credit` — N uses that do not expire, from a one-off purchase.
+ *
+ * Quota is spent before credit, so an included monthly allowance is used up
+ * before a purchased pack is touched.
+ */
+declare enum GrantType {
+    Boolean = "boolean",
+    Quota = "quota",
+    Credit = "credit"
+}
+declare const SupportedGrantTypes: GrantType[];
+/** The window a quota refreshes on, anchored to the subscription's billing date. */
+declare enum QuotaPeriod {
+    Month = "month",
+    Year = "year",
+    /** Never refreshes: N uses for the lifetime of the subscription. */
+    Lifetime = "lifetime"
+}
+declare const SupportedQuotaPeriods: QuotaPeriod[];
+/**
+ * How often a subscription plan BILLS.
+ *
+ * Deliberately NOT `QuotaPeriod`, though the two share `month` and `year`. They
+ * answer different questions: `QuotaPeriod` is how often a grant refreshes,
+ * this is how often the customer is charged, and a plan may bill yearly while
+ * refreshing its quota monthly (`employer-annual` does exactly that). Reusing
+ * `QuotaPeriod` here would also admit `lifetime`, which is not a billing
+ * interval for a subscription.
+ *
+ * Absent on one-off plans, which are not billed on an interval at all.
+ */
+declare enum BillingPeriod {
+    Month = "month",
+    Year = "year"
+}
+declare const SupportedBillingPeriods: BillingPeriod[];
+/**
+ * Paddle subscription status, verbatim.
+ *
+ * `active`, `trialing` and `past_due` all currently GRANT access: dunning is a
+ * payment problem, and cutting a paying customer off mid-retry is worse than
+ * carrying them for a few days. `paused` and `canceled` do not grant.
+ */
+declare enum SubscriptionStatus {
+    Active = "active",
+    Trialing = "trialing",
+    PastDue = "past_due",
+    Paused = "paused",
+    Canceled = "canceled"
+}
+declare const SupportedSubscriptionStatuses: SubscriptionStatus[];
+/** Subscription statuses that currently entitle the holder to their plan's grants. */
+declare const EntitlingSubscriptionStatuses: SubscriptionStatus[];
+/** Paddle transaction status, verbatim. `completed` is where a one-off is fulfilled. */
+declare enum TransactionStatus {
+    Draft = "draft",
+    Ready = "ready",
+    Billed = "billed",
+    Paid = "paid",
+    Completed = "completed",
+    Canceled = "canceled",
+    PastDue = "past_due"
+}
+declare const SupportedTransactionStatuses: TransactionStatus[];
+/** Which Paddle environment an identifier belongs to. Sandbox and live IDs never match. */
+declare enum PaddleEnvironment {
+    Sandbox = "sandbox",
+    Production = "production"
+}
+declare const SupportedPaddleEnvironments: PaddleEnvironment[];
+/**
+ * Feature keys currently known to the platform.
+ *
+ * INFORMATIONAL ONLY — for autocomplete and for grepping who gates what.
+ *
+ * Do NOT constrain a stored field with `.oneOf(SupportedFeatureKeys)`. Feature
+ * keys are data owned by billing-service, and the entire point of the design is
+ * that putting a feature behind a paywall is a database change. Validating
+ * against this enum would make every new paywall a release of this package plus
+ * a redeploy of every service that holds it — exactly what the design avoids.
+ *
+ * Keys are dot-namespaced `<domain>.<capability>` and are permanent once sold:
+ * renaming one orphans the grants already stored against it.
+ */
+declare enum FeatureKey {
+    JobPost = "job.post",
+    JobAlerts = "job.alerts",
+    PageCreate = "page.create",
+    GroupCreate = "group.create",
+    CandidateFinder = "candidate.finder",
+    SearchAdvanced = "search.advanced",
+    GetDiscovered = "get-discovered"
+}
+declare const SupportedFeatureKeys: FeatureKey[];
+/** Why a gate refused, so the UI can tell "buy this" apart from "wait". */
+declare enum EntitlementDenialReason {
+    /** No plan grants this feature at all. */
+    NotEntitled = "not-entitled",
+    /** Entitled, but the period's quota is spent. */
+    QuotaExhausted = "quota-exhausted",
+    /** Entitled, but the credit balance is zero. */
+    NoCredits = "no-credits"
+}
+declare const SupportedEntitlementDenialReasons: EntitlementDenialReason[];
+/** A single grant cannot hand out more than this per period. Guards a typo'd plan. */
+declare const GRANT_MAX_LIMIT = 100000;
+/** Ceiling on units consumed in one call. A gate spends one unit in the normal case. */
+declare const CONSUME_MAX_UNITS = 1000;
+
+/**
+ * An amount of money as Paddle expresses it.
+ *
+ * ⚠️ MINOR UNITS. `999` here is $9.99, not $999. This is the OPPOSITE of every
+ * other amount in this package: `salaryRange.min`, `minSalary` and friends are
+ * bare integers in the currency's MAJOR unit. Mixing the two is a 100x error in
+ * either direction, which is why the field is named `amountMinor` rather than
+ * `amount` — a bare `amount` next to a bare `currency` would read exactly like
+ * the salary fields and be wrong.
+ *
+ * Paddle transmits this as a STRING of minor units; billing-service parses it to
+ * a number on ingest and keeps the unit. Never render it without dividing by the
+ * currency's exponent.
+ */
+declare const MoneySchema: yup.ObjectSchema<{
+    amountMinor: number;
+    currencyCode: string;
+}, yup.AnyObject, {
+    amountMinor: undefined;
+    currencyCode: undefined;
+}, "">;
+/**
+ * One thing a plan gives you.
+ *
+ * `limit` applies to quota grants, `amount` to credit grants, and neither to
+ * boolean. They are optional at the schema level and enforced by `.when`, so a
+ * malformed plan is caught when an operator saves it rather than when a user's
+ * entitlements silently resolve to nothing.
+ */
+declare const PlanGrantSchema: yup.ObjectSchema<{
+    feature: string;
+    type: NonNullable<GrantType | undefined>;
+    limit: number | undefined;
+    period: QuotaPeriod;
+    amount: number | undefined;
+}, yup.AnyObject, {
+    feature: undefined;
+    type: GrantType.Boolean;
+    limit: undefined;
+    period: QuotaPeriod.Month;
+    amount: undefined;
+}, "">;
+/**
+ * Paddle price identifiers, split by environment.
+ *
+ * Keyed rather than flat because sandbox and live price IDs are different
+ * strings for the same product. Shipping sandbox IDs to production does not fail
+ * at checkout — it fails later, when a webhook arrives carrying a price nothing
+ * maps to, and reads as "plan not found" rather than "wrong environment".
+ */
+declare const PaddlePriceIdsSchema: yup.ObjectSchema<{
+    sandbox: string[];
+    live: string[];
+}, yup.AnyObject, {
+    sandbox: never[];
+    live: never[];
+}, "">;
+/**
+ * What can be bought, and what it grants.
+ *
+ * This document is the paywall. Putting a feature behind it, taking one out, or
+ * changing a quota is an edit here plus a cache bust — no service redeploys.
+ */
+declare const PlanSchema: yup.ObjectSchema<{
+    key: string;
+    name: string;
+    description: string | undefined;
+    kind: NonNullable<PlanKind | undefined>;
+    status: NonNullable<PlanStatus | undefined>;
+    paddlePriceIds: {
+        sandbox: string[];
+        live: string[];
+    };
+    grants: {
+        limit?: number | undefined;
+        amount?: number | undefined;
+        type: NonNullable<GrantType | undefined>;
+        feature: string;
+        period: QuotaPeriod;
+    }[];
+    price: {
+        amountMinor: number;
+        currencyCode: string;
+    } | undefined;
+    billingPeriod: BillingPeriod | undefined;
+    sortOrder: number;
+    createdAt: number | undefined;
+    updatedAt: number | undefined;
+}, yup.AnyObject, {
+    key: undefined;
+    name: undefined;
+    description: undefined;
+    kind: PlanKind.Subscription;
+    status: PlanStatus.Draft;
+    paddlePriceIds: {
+        sandbox: never[];
+        live: never[];
+    };
+    grants: "";
+    price: undefined;
+    billingPeriod: undefined;
+    sortOrder: 0;
+    createdAt: undefined;
+    updatedAt: undefined;
+}, "">;
+/**
+ * A user's Paddle subscription, mirrored locally.
+ *
+ * Paddle is the source of truth; this is a cache kept current by webhooks and
+ * repaired by the reconciler. `lastEventAt` is what makes that safe: Paddle
+ * guarantees no ordering, so every write is conditional on this advancing, and a
+ * late `subscription.updated` cannot resurrect a canceled subscription.
+ */
+declare const BillingSubscriptionSchema: yup.ObjectSchema<{
+    userId: string;
+    paddleSubscriptionId: string;
+    paddleCustomerId: string;
+    planKey: string;
+    priceIds: string[];
+    status: NonNullable<SubscriptionStatus | undefined>;
+    currentPeriodStart: number | undefined;
+    currentPeriodEnd: number | undefined;
+    canceledAt: number | undefined;
+    lastEventAt: number;
+    createdAt: number | undefined;
+    updatedAt: number | undefined;
+}, yup.AnyObject, {
+    userId: undefined;
+    paddleSubscriptionId: undefined;
+    paddleCustomerId: undefined;
+    planKey: undefined;
+    priceIds: "";
+    status: undefined;
+    currentPeriodStart: undefined;
+    currentPeriodEnd: undefined;
+    canceledAt: undefined;
+    lastEventAt: 0;
+    createdAt: undefined;
+    updatedAt: undefined;
+}, "">;
+/** A completed Paddle payment. One-off purchases are fulfilled from these. */
+declare const BillingTransactionSchema: yup.ObjectSchema<{
+    userId: string;
+    paddleTransactionId: string;
+    paddleCustomerId: string | undefined;
+    paddleSubscriptionId: string | undefined;
+    planKey: string | undefined;
+    priceIds: string[];
+    status: NonNullable<TransactionStatus | undefined>;
+    total: {
+        amountMinor: number;
+        currencyCode: string;
+    } | undefined;
+    billedAt: number | undefined;
+    lastEventAt: number;
+    createdAt: number | undefined;
+    updatedAt: number | undefined;
+}, yup.AnyObject, {
+    userId: undefined;
+    paddleTransactionId: undefined;
+    paddleCustomerId: undefined;
+    paddleSubscriptionId: undefined;
+    planKey: undefined;
+    priceIds: "";
+    status: undefined;
+    total: undefined;
+    billedAt: undefined;
+    lastEventAt: 0;
+    createdAt: undefined;
     updatedAt: undefined;
 }, "">;
+/**
+ * The resolved state of one feature for one user.
+ *
+ * Both halves of the answer travel together: `allowed` is what a gate checks,
+ * and the counts are what the UI and the 402 body need. Only `allowed` becomes a
+ * CASL rule — see `defineEntitlementRules` in `@thejob/permission` for why counts
+ * cannot.
+ */
+declare const FeatureEntitlementSchema: yup.ObjectSchema<{
+    feature: string;
+    type: NonNullable<GrantType | undefined>;
+    allowed: NonNullable<boolean | undefined>;
+    limit: number | undefined;
+    used: number | undefined;
+    remaining: number | undefined;
+    credits: number | undefined;
+    resetsAt: number | undefined;
+}, yup.AnyObject, {
+    feature: undefined;
+    type: undefined;
+    allowed: false;
+    limit: undefined;
+    used: undefined;
+    remaining: undefined;
+    credits: undefined;
+    resetsAt: undefined;
+}, "">;
+/** Why a gate refused, with the numbers behind it. The body of a 402. */
+declare const EntitlementDenialSchema: yup.ObjectSchema<{
+    feature: string;
+    reason: NonNullable<EntitlementDenialReason | undefined>;
+    limit: number | undefined;
+    used: number | undefined;
+    resetsAt: number | undefined;
+    upgradeUrl: string | undefined;
+}, yup.AnyObject, {
+    feature: undefined;
+    reason: undefined;
+    limit: undefined;
+    used: undefined;
+    resetsAt: undefined;
+    upgradeUrl: undefined;
+}, "">;
+/** What a service asks for when spending a unit of a metered feature. */
+declare const EntitlementConsumeSchema: yup.ObjectSchema<{
+    userId: string;
+    feature: string;
+    units: number;
+    idempotencyKey: string;
+}, yup.AnyObject, {
+    userId: undefined;
+    feature: undefined;
+    units: 1;
+    idempotencyKey: undefined;
+}, "">;
 
 declare enum SocialAccount {
     Facebook = "facebook",
@@ -2651,8 +3685,8 @@ declare const UserSchema: yup.ObjectSchema<{
                 dark?: string | null | undefined;
                 light?: string | undefined;
             } | null | undefined;
-            type: PageType;
             name: string;
+            type: PageType;
         };
         location: {
             placeId?: string | null | undefined;
@@ -2668,11 +3702,11 @@ declare const UserSchema: yup.ObjectSchema<{
             };
         };
         designation: string;
+        isRemote: boolean;
         duration: {
             [x: string]: string | boolean;
             [x: number]: string | boolean;
         };
-        isRemote: boolean;
     }[];
     educations: {
         description?: string | undefined;
@@ -2695,18 +3729,18 @@ declare const UserSchema: yup.ObjectSchema<{
                 dark?: string | null | undefined;
                 light?: string | undefined;
             } | null | undefined;
-            type: PageType;
             name: string;
+            type: PageType;
         };
+        course: string;
+        fieldOfStudy: string;
+        studyType: NonNullable<StudyType | undefined>;
+        isDistanceLearning: boolean;
         duration: {
             startDate: string;
             endDate: string | null;
             isActive: boolean;
         };
-        course: string;
-        fieldOfStudy: string;
-        isDistanceLearning: boolean;
-        studyType: NonNullable<StudyType | undefined>;
     }[];
     skills: {
         lastUsed?: string | null | undefined;
@@ -2732,7 +3766,11 @@ declare const UserSchema: yup.ObjectSchema<{
         name: string;
         authority: string;
     }[];
-    interests: string[];
+    interests: {
+        name: string;
+        logo: string;
+        id: string;
+    }[];
     languages: {
         name: string;
         proficiencyLevel: NonNullable<ProficiencyLevel | undefined>;
@@ -2755,10 +3793,16 @@ declare const UserSchema: yup.ObjectSchema<{
         applicationUpdates: boolean;
         productUpdates: boolean;
     };
+    pushConsent: {
+        updatedAt?: number | undefined;
+        source?: string | undefined;
+        subscribed: boolean;
+    };
     embedding: {
         vector?: number[] | undefined;
         model?: string | undefined;
     } | null | undefined;
+    createdAt: number | undefined;
     id: string | undefined;
     name: {
         last?: string | undefined;
@@ -2766,6 +3810,7 @@ declare const UserSchema: yup.ObjectSchema<{
     };
     headline: string | undefined;
     image: string | undefined;
+    imageOriginal: string | undefined;
     aboutMe: string | undefined;
     email: string;
     mobile: string | null | undefined;
@@ -2852,8 +3897,8 @@ declare const UserSchema: yup.ObjectSchema<{
                     dark?: string | null | undefined;
                     light?: string | undefined;
                 } | null | undefined;
-                type: PageType;
                 name: string;
+                type: PageType;
             };
             location: {
                 placeId?: string | null | undefined;
@@ -2869,11 +3914,11 @@ declare const UserSchema: yup.ObjectSchema<{
                 };
             };
             designation: string;
+            isRemote: boolean;
             duration: {
                 [x: string]: string | boolean;
                 [x: number]: string | boolean;
             };
-            isRemote: boolean;
         }[] | undefined;
         educations?: {
             description?: string | undefined;
@@ -2896,18 +3941,18 @@ declare const UserSchema: yup.ObjectSchema<{
                     dark?: string | null | undefined;
                     light?: string | undefined;
                 } | null | undefined;
-                type: PageType;
                 name: string;
+                type: PageType;
             };
+            course: string;
+            fieldOfStudy: string;
+            studyType: NonNullable<StudyType | undefined>;
+            isDistanceLearning: boolean;
             duration: {
                 startDate: string;
                 endDate: string | null;
                 isActive: boolean;
             };
-            course: string;
-            fieldOfStudy: string;
-            isDistanceLearning: boolean;
-            studyType: NonNullable<StudyType | undefined>;
         }[] | undefined;
         aboutMe?: string | undefined;
         mobile?: string | undefined;
@@ -2921,94 +3966,443 @@ declare const UserSchema: yup.ObjectSchema<{
                     dark?: string | null | undefined;
                     light?: string | undefined;
                 } | null | undefined;
+                name: string;
                 type: PageType;
+            };
+        }[];
+    } | undefined;
+} & {
+    coordinatorProfile: {
+        coordinatesAt: {
+            jobTitle?: string | undefined;
+            page: {
+                slug?: string | undefined;
+                logo?: {
+                    dark?: string | null | undefined;
+                    light?: string | undefined;
+                } | null | undefined;
                 name: string;
+                type: PageType;
             };
         }[];
-    } | undefined;
-} & {
-    coordinatorProfile: {
-        coordinatesAt: {
-            jobTitle?: string | undefined;
-            page: {
-                slug?: string | undefined;
-                logo?: {
-                    dark?: string | null | undefined;
-                    light?: string | undefined;
-                } | null | undefined;
-                type: PageType;
-                name: string;
-            };
+    } | undefined;
+}, yup.AnyObject, {
+    authAccountId: undefined;
+    socialAccounts: never[];
+    workExperiences: never[];
+    educations: never[];
+    skills: never[];
+    projects: never[];
+    certifications: never[];
+    interests: never[];
+    languages: never[];
+    additionalInfo: never[];
+    status: undefined;
+    roles: UserRole[];
+    marketingConsent: {
+        subscribed: boolean;
+    };
+    notificationPrefs: {
+        groupActivity: boolean;
+        jobActivity: boolean;
+        applicationUpdates: boolean;
+        productUpdates: boolean;
+    };
+    pushConsent: {
+        subscribed: boolean;
+    };
+    embedding: {
+        vector: undefined;
+        model: undefined;
+    };
+    createdAt: undefined;
+    id: undefined;
+    name: {
+        first: undefined;
+        last: undefined;
+    };
+    headline: undefined;
+    image: undefined;
+    imageOriginal: undefined;
+    aboutMe: undefined;
+    email: undefined;
+    mobile: undefined;
+    emailVerified: undefined;
+    mobileVerified: undefined;
+    experienceLevel: undefined;
+    educationLevel: undefined;
+    location: {
+        placeId: undefined;
+        country: undefined;
+        countryCode: undefined;
+        state: undefined;
+        stateCode: undefined;
+        city: undefined;
+        address: undefined;
+        geo: {
+            type: "Point";
+            coordinates: "";
+        };
+    };
+    signupContext: undefined;
+    profileVisibility: UserProfileVisibility.Public;
+    openToWork: false;
+    jobSearchUrgency: undefined;
+    jobLocations: "";
+    targetExperienceLevels: "";
+    jobRoles: "";
+    minSalary: 0;
+    minSalaryCurrency: "USD";
+    referralSource: undefined;
+    resumes: never[];
+    onboardingCompletedAt: undefined;
+    pendingPrefill: undefined;
+    recruiterProfile: undefined;
+    coordinatorProfile: undefined;
+}, "">;
+
+/**
+ * THE user filter. One declaration, three derived uses:
+ *
+ * - `@thejob/users-client` derives its `UserFilter` type with `InferType`.
+ * - `thejob-user-service` derives `USER_FILTER_FACETS` with
+ *   `Object.keys(UserFilterSchema.fields)` — the closed vocabulary it 400s
+ *   against.
+ * - `MailingListSchema.filter` stores one, as does the audience preview.
+ *
+ * It was previously written out three times: a yup schema here, a hand-written
+ * TS interface in the client, and a hand-listed `Set` of ~74 strings in the
+ * service. Three lists of the same names drift, and the drift is invisible — a
+ * facet the schema accepts but the service does not is a 400 on a send that
+ * validated cleanly when it was saved.
+ *
+ * A FILTER, not an audience: it says which users match and nothing about what a
+ * caller intends to do with them. Marketing narrows it one way, an admin list
+ * another, and neither meaning belongs here.
+ *
+ * Every clause AND-s together; `or` unions the whole filter with each branch,
+ * deduplicating by user, for audiences that are genuinely a union rather than an
+ * intersection ("signed up recently OR active recently"). One level only:
+ * branches do not nest, which the non-recursive definition above enforces.
+ */
+declare const UserFilterSchema: yup.ObjectSchema<{
+    emails: string[];
+    authAccountIds: string[];
+    countries: string[];
+    roles: string[];
+    experienceLevels: string[];
+    targetExperienceLevels: string[];
+    jobSearchUrgencies: string[];
+    referralSources: string[];
+    statuses: string[];
+    profileVisibilities: string[];
+    studyTypes: string[];
+    socialAccountTypes: string[];
+    salaryCurrencies: string[];
+    skills: {
+        [x: string]: string | undefined;
+        [x: number]: string | undefined;
+    }[];
+    languages: {
+        [x: string]: string | undefined;
+        [x: number]: string | undefined;
+    }[];
+    interests: string[];
+    companies: string[];
+    designations: string[];
+    institutes: string[];
+    courses: string[];
+    fieldsOfStudy: string[];
+    workHistory: {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    }[];
+    educationHistory: {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    }[];
+    certifications: {
+        [x: string]: string | undefined;
+        [x: number]: string | undefined;
+    }[];
+    projects: string[];
+    jobRoles: string[];
+    jobLocations: string[];
+    hiringForCompanies: string[];
+    coordinatesAtInstitutes: string[];
+    keywords: string[];
+    minSalaryFloor: number | undefined;
+    minSalaryCeil: number | undefined;
+    openToWorkOnly: boolean;
+    remoteExperienceOnly: boolean;
+    hasResumeOnly: boolean;
+    onboardingCompletedOnly: boolean;
+    emailVerifiedOnly: boolean;
+    mobileVerifiedOnly: boolean;
+    lastSeenBeforeDays: number | undefined;
+    lastSeenAfterDays: number | undefined;
+    createdAtWithinDays: number | undefined;
+    createdAtOlderThanDays: number | undefined;
+    completenessMin: number | undefined;
+    completenessMax: number | undefined;
+    lastSeenBefore: number | undefined;
+    lastSeenAfter: number | undefined;
+    createdAtFrom: number | undefined;
+    createdAtBefore: number | undefined;
+    states: string[];
+    stateCodes: string[];
+    cities: string[];
+    withinRadius: {
+        lat: number;
+        lng: number;
+        km: number;
+    } | undefined;
+    signupCountries: string[];
+    signupLocales: string[];
+    signupSources: string[];
+    educationLevels: string[];
+    marketingSubscribed: boolean | undefined;
+    jobAlertFrequencies: string[];
+    consentSources: string[];
+    consentUpdatedWithinDays: number | undefined;
+    consentUpdatedAfter: number | undefined;
+    notificationChannelsEnabled: string[];
+    currentlyEmployed: boolean;
+    graduatedWithinMonths: number | undefined;
+    skillUsedWithinMonths: number | undefined;
+    graduatedAfter: string | undefined;
+    skillUsedAfter: string | undefined;
+    hasImage: boolean;
+    hasHeadline: boolean;
+    hasAboutMe: boolean;
+    hasMobile: boolean;
+    missingSections: string[];
+    companyTypes: string[];
+    instituteTypes: string[];
+    hasJobAlert: boolean | undefined;
+    hasApplied: boolean | undefined;
+    appliedWithinDays: number | undefined;
+    or: {
+        hasApplied?: boolean | undefined;
+        minSalaryFloor?: number | undefined;
+        minSalaryCeil?: number | undefined;
+        lastSeenBeforeDays?: number | undefined;
+        lastSeenAfterDays?: number | undefined;
+        createdAtWithinDays?: number | undefined;
+        createdAtOlderThanDays?: number | undefined;
+        completenessMin?: number | undefined;
+        completenessMax?: number | undefined;
+        lastSeenBefore?: number | undefined;
+        lastSeenAfter?: number | undefined;
+        createdAtFrom?: number | undefined;
+        createdAtBefore?: number | undefined;
+        withinRadius?: {
+            lat: number;
+            lng: number;
+            km: number;
+        } | undefined;
+        marketingSubscribed?: boolean | undefined;
+        consentUpdatedWithinDays?: number | undefined;
+        consentUpdatedAfter?: number | undefined;
+        graduatedWithinMonths?: number | undefined;
+        skillUsedWithinMonths?: number | undefined;
+        graduatedAfter?: string | undefined;
+        skillUsedAfter?: string | undefined;
+        hasJobAlert?: boolean | undefined;
+        appliedWithinDays?: number | undefined;
+        keywords: string[];
+        countries: string[];
+        courses: string[];
+        skills: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
+        }[];
+        languages: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
         }[];
-    } | undefined;
+        certifications: {
+            [x: string]: string | undefined;
+            [x: number]: string | undefined;
+        }[];
+        interests: string[];
+        projects: string[];
+        companies: string[];
+        stateCodes: string[];
+        states: string[];
+        cities: string[];
+        emails: string[];
+        authAccountIds: string[];
+        roles: string[];
+        experienceLevels: string[];
+        targetExperienceLevels: string[];
+        jobSearchUrgencies: string[];
+        referralSources: string[];
+        statuses: string[];
+        profileVisibilities: string[];
+        studyTypes: string[];
+        socialAccountTypes: string[];
+        salaryCurrencies: string[];
+        designations: string[];
+        institutes: string[];
+        fieldsOfStudy: string[];
+        workHistory: {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[];
+        educationHistory: {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[];
+        jobRoles: string[];
+        jobLocations: string[];
+        hiringForCompanies: string[];
+        coordinatesAtInstitutes: string[];
+        openToWorkOnly: boolean;
+        remoteExperienceOnly: boolean;
+        hasResumeOnly: boolean;
+        onboardingCompletedOnly: boolean;
+        emailVerifiedOnly: boolean;
+        mobileVerifiedOnly: boolean;
+        signupCountries: string[];
+        signupLocales: string[];
+        signupSources: string[];
+        educationLevels: string[];
+        jobAlertFrequencies: string[];
+        consentSources: string[];
+        notificationChannelsEnabled: string[];
+        currentlyEmployed: boolean;
+        hasImage: boolean;
+        hasHeadline: boolean;
+        hasAboutMe: boolean;
+        hasMobile: boolean;
+        missingSections: string[];
+        companyTypes: string[];
+        instituteTypes: string[];
+    }[];
 }, yup.AnyObject, {
-    authAccountId: undefined;
-    socialAccounts: never[];
-    workExperiences: never[];
-    educations: never[];
+    emails: never[];
+    authAccountIds: never[];
+    countries: never[];
+    roles: never[];
+    experienceLevels: never[];
+    targetExperienceLevels: never[];
+    jobSearchUrgencies: never[];
+    referralSources: never[];
+    statuses: never[];
+    profileVisibilities: never[];
+    studyTypes: never[];
+    socialAccountTypes: never[];
+    salaryCurrencies: never[];
     skills: never[];
-    projects: never[];
-    certifications: never[];
-    interests: never[];
     languages: never[];
-    additionalInfo: never[];
-    status: undefined;
-    roles: UserRole[];
-    marketingConsent: {
-        subscribed: boolean;
-    };
-    notificationPrefs: {
-        groupActivity: boolean;
-        jobActivity: boolean;
-        applicationUpdates: boolean;
-        productUpdates: boolean;
-    };
-    embedding: {
-        vector: undefined;
-        model: undefined;
-    };
-    id: undefined;
-    name: {
-        first: undefined;
-        last: undefined;
+    interests: never[];
+    companies: never[];
+    designations: never[];
+    institutes: never[];
+    courses: never[];
+    fieldsOfStudy: never[];
+    workHistory: never[];
+    educationHistory: never[];
+    certifications: never[];
+    projects: never[];
+    jobRoles: never[];
+    jobLocations: never[];
+    hiringForCompanies: never[];
+    coordinatesAtInstitutes: never[];
+    keywords: never[];
+    minSalaryFloor: undefined;
+    minSalaryCeil: undefined;
+    openToWorkOnly: false;
+    remoteExperienceOnly: false;
+    hasResumeOnly: false;
+    onboardingCompletedOnly: false;
+    emailVerifiedOnly: false;
+    mobileVerifiedOnly: false;
+    lastSeenBeforeDays: undefined;
+    lastSeenAfterDays: undefined;
+    createdAtWithinDays: undefined;
+    createdAtOlderThanDays: undefined;
+    completenessMin: undefined;
+    completenessMax: undefined;
+    lastSeenBefore: undefined;
+    lastSeenAfter: undefined;
+    createdAtFrom: undefined;
+    createdAtBefore: undefined;
+    states: never[];
+    stateCodes: never[];
+    cities: never[];
+    withinRadius: undefined;
+    signupCountries: never[];
+    signupLocales: never[];
+    signupSources: never[];
+    educationLevels: never[];
+    marketingSubscribed: undefined;
+    jobAlertFrequencies: never[];
+    consentSources: never[];
+    consentUpdatedWithinDays: undefined;
+    consentUpdatedAfter: undefined;
+    notificationChannelsEnabled: never[];
+    currentlyEmployed: false;
+    graduatedWithinMonths: undefined;
+    skillUsedWithinMonths: undefined;
+    graduatedAfter: undefined;
+    skillUsedAfter: undefined;
+    hasImage: false;
+    hasHeadline: false;
+    hasAboutMe: false;
+    hasMobile: false;
+    missingSections: never[];
+    companyTypes: never[];
+    instituteTypes: never[];
+    hasJobAlert: undefined;
+    hasApplied: undefined;
+    appliedWithinDays: undefined;
+    or: never[];
+}, "">;
+
+/**
+ * A single browser's Web Push subscription.
+ *
+ * This is the DEVICE grant, distinct from `user.pushConsent`, which is the
+ * user's intent. Both are required to deliver: consent without a subscription
+ * has nowhere to send, and a subscription without consent must not be used.
+ *
+ * Shape dictated by the Push API, not by us. `endpoint` and `keys` come back
+ * verbatim from `PushSubscription.toJSON()` in the browser and are passed
+ * verbatim to the sender, so nothing here may be normalised or reformatted —
+ * `p256dh` and `auth` are base64url and case-sensitive.
+ *
+ * MANY per user, one per browser profile per device, which is why this is its
+ * own collection rather than a field on the user. The same person on a phone
+ * and a laptop is two rows, and both should receive.
+ */
+declare const PushSubscriptionSchema: yup.ObjectSchema<{
+    userShortId: string;
+    endpoint: string;
+    keys: {
+        p256dh: string;
+        auth: string;
     };
-    headline: undefined;
-    image: undefined;
-    aboutMe: undefined;
-    email: undefined;
-    mobile: undefined;
-    emailVerified: undefined;
-    mobileVerified: undefined;
-    experienceLevel: undefined;
-    educationLevel: undefined;
-    location: {
-        placeId: undefined;
-        country: undefined;
-        countryCode: undefined;
-        state: undefined;
-        stateCode: undefined;
-        city: undefined;
-        address: undefined;
-        geo: {
-            type: "Point";
-            coordinates: "";
-        };
+    expirationTime: number | null | undefined;
+    userAgent: string | undefined;
+    createdAt: number | undefined;
+    lastSeenAt: number | undefined;
+}, yup.AnyObject, {
+    userShortId: undefined;
+    endpoint: undefined;
+    keys: {
+        p256dh: undefined;
+        auth: undefined;
     };
-    signupContext: undefined;
-    profileVisibility: UserProfileVisibility.Public;
-    openToWork: false;
-    jobSearchUrgency: undefined;
-    jobLocations: "";
-    targetExperienceLevels: "";
-    jobRoles: "";
-    minSalary: 0;
-    minSalaryCurrency: "USD";
-    referralSource: undefined;
-    resumes: never[];
-    onboardingCompletedAt: undefined;
-    pendingPrefill: undefined;
-    recruiterProfile: undefined;
-    coordinatorProfile: undefined;
+    expirationTime: undefined;
+    userAgent: undefined;
+    createdAt: undefined;
+    lastSeenAt: undefined;
 }, "">;
 
 declare const UserLanguageSchema: yup.ObjectSchema<{
@@ -3027,6 +4421,7 @@ declare const UserGeneralDetailSchema: yup.ObjectSchema<{
     };
     headline: string | undefined;
     image: string | undefined;
+    imageOriginal: string | undefined;
     aboutMe: string | undefined;
     email: string;
     mobile: string | null | undefined;
@@ -3062,6 +4457,7 @@ declare const UserGeneralDetailSchema: yup.ObjectSchema<{
     };
     headline: undefined;
     image: undefined;
+    imageOriginal: undefined;
     aboutMe: undefined;
     email: undefined;
     mobile: undefined;
@@ -3103,8 +4499,8 @@ declare const WorkExperienceSchema: ObjectSchema<{
             dark?: string | null | undefined;
             light?: string | undefined;
         } | null | undefined;
-        type: PageType;
         name: string;
+        type: PageType;
     };
     designation: string;
     duration: {
@@ -3187,8 +4583,8 @@ declare const EducationSchema: ObjectSchema<{
             dark?: string | null | undefined;
             light?: string | undefined;
         } | null | undefined;
-        type: PageType;
         name: string;
+        type: PageType;
     };
     course: string;
     fieldOfStudy: string;
@@ -3266,7 +4662,38 @@ declare const EducationSchema: ObjectSchema<{
     studyType: undefined;
 }, "">;
 
-declare const UserInterestSchema: yup.StringSchema<string, yup.AnyObject, undefined, "">;
+/**
+ * One interest on a user profile, as a REFERENCE to a taxonomy entry.
+ *
+ * This was declared as a bare `string()` and that was simply wrong about the
+ * data: a full census of the live users collection found 41,822 interest
+ * entries, 100% of them objects, with `id`, `name` and `logo` present on every
+ * single one. Not one string.
+ *
+ * The damage was silent and reached the UI. Because the schema said `string`,
+ * every type derived from it said `string[]`, so an admin panel rendering
+ * `{interest}` type-checked cleanly and printed `[object Object]` to the
+ * operator. The public profile page had already worked around it by declaring
+ * its own local `Interest` interface with the real shape, which is how a wrong
+ * declaration survives: each consumer patches around it privately instead of
+ * one fix at the source.
+ *
+ * `logo` is a material-symbols icon NAME (`cloud`, `code`, `psychology`), not a
+ * URL or a storage key, so it is rendered as an icon rather than fetched.
+ *
+ * Every field is required because the data says so: there is no partial entry
+ * among the 41,822, and these are written by picking an existing taxonomy
+ * entry rather than typed free-hand.
+ */
+declare const UserInterestSchema: yup.ObjectSchema<{
+    id: string;
+    name: string;
+    logo: string;
+}, yup.AnyObject, {
+    id: undefined;
+    name: undefined;
+    logo: undefined;
+}, "">;
 
 declare const UserProjectSchema: yup.ObjectSchema<{
     name: string;
@@ -3384,8 +4811,8 @@ declare const UserJobPreferencesSchema: yup.ObjectSchema<{
                     dark?: string | null | undefined;
                     light?: string | undefined;
                 } | null | undefined;
-                type: PageType;
                 name: string;
+                type: PageType;
             };
             location: {
                 placeId?: string | null | undefined;
@@ -3401,11 +4828,11 @@ declare const UserJobPreferencesSchema: yup.ObjectSchema<{
                 };
             };
             designation: string;
+            isRemote: boolean;
             duration: {
                 [x: string]: string | boolean;
                 [x: number]: string | boolean;
             };
-            isRemote: boolean;
         }[] | undefined;
         educations?: {
             description?: string | undefined;
@@ -3428,18 +4855,18 @@ declare const UserJobPreferencesSchema: yup.ObjectSchema<{
                     dark?: string | null | undefined;
                     light?: string | undefined;
                 } | null | undefined;
-                type: PageType;
                 name: string;
+                type: PageType;
             };
+            course: string;
+            fieldOfStudy: string;
+            studyType: NonNullable<StudyType | undefined>;
+            isDistanceLearning: boolean;
             duration: {
                 startDate: string;
                 endDate: string | null;
                 isActive: boolean;
             };
-            course: string;
-            fieldOfStudy: string;
-            isDistanceLearning: boolean;
-            studyType: NonNullable<StudyType | undefined>;
         }[] | undefined;
         aboutMe?: string | undefined;
         mobile?: string | undefined;
@@ -3476,8 +4903,8 @@ declare const RecruiterPageLinkSchema: yup.ObjectSchema<{
             dark?: string | null | undefined;
             light?: string | undefined;
         } | null | undefined;
-        type: PageType;
         name: string;
+        type: PageType;
     };
     jobTitle: string | undefined;
 }, yup.AnyObject, {
@@ -3529,8 +4956,8 @@ declare const UserRecruiterProfileSchema: yup.ObjectSchema<{
                     dark?: string | null | undefined;
                     light?: string | undefined;
                 } | null | undefined;
-                type: PageType;
                 name: string;
+                type: PageType;
             };
         }[];
     } | undefined;
@@ -3556,8 +4983,8 @@ declare const CoordinatorPageLinkSchema: yup.ObjectSchema<{
             dark?: string | null | undefined;
             light?: string | undefined;
         } | null | undefined;
-        type: PageType;
         name: string;
+        type: PageType;
     };
     jobTitle: string | undefined;
 }, yup.AnyObject, {
@@ -3609,8 +5036,8 @@ declare const UserCoordinatorProfileSchema: yup.ObjectSchema<{
                     dark?: string | null | undefined;
                     light?: string | undefined;
                 } | null | undefined;
-                type: PageType;
                 name: string;
+                type: PageType;
             };
         }[];
     } | undefined;
@@ -3618,6 +5045,37 @@ declare const UserCoordinatorProfileSchema: yup.ObjectSchema<{
     coordinatorProfile: undefined;
 }, "">;
 
+/**
+ * A user, as this package defines one.
+ *
+ * DERIVED from `UserSchema`, never hand-written, so it cannot drift from the
+ * shape the schema validates. Consumers project subsets of it (a listing
+ * returns a handful of fields, a profile read returns more), which is why
+ * every field a projection may omit is optional at the schema level.
+ *
+ * `shortId` and `slug` are assigned by the STORING service and are not part of
+ * the validated input shape, so they are added here rather than in the schema.
+ * `shortId` is the identifier to use everywhere; `authAccountId` is Better
+ * Auth's id and belongs only in auth-related paths.
+ */
+type User = InferType<typeof UserSchema> & {
+    /** Public identifier, server-assigned. The id to key on. */
+    shortId?: string;
+    /** Public profile handle, server-assigned. */
+    slug?: string;
+};
+/**
+ * A stored push subscription, with the identifier the storing service assigns.
+ *
+ * Same split as `User`: `shortId` is server-assigned and so is not part of the
+ * validated input shape. Note that the identifier consumers actually key on
+ * here is `endpoint`, not `shortId` — it is what the browser re-sends on
+ * re-subscribe and what a dead-subscription response names.
+ */
+type PushSubscriptionRecord = InferType<typeof PushSubscriptionSchema> & {
+    /** Public identifier, server-assigned. */
+    shortId?: string;
+};
 type UserProfileOverview = {
     name: InferType<typeof UserGeneralDetailSchema>["name"];
     email: string;
@@ -3856,4 +5314,4 @@ declare const StudentCompletenessSchema: yup.ObjectSchema<{
     };
 }, "">;
 
-export { AnswerChoiceType, ApplicationReceivePreference, BindingKind, BindingSchema, CAMPAIGN_MAX_RECIPIENTS_CEILING, CampaignAnchorField, CampaignEndKind, CampaignIntervalUnit, CampaignSchema, CampaignStatus, CampaignTriggerKind, CampaignTriggerSchema, ChoiceQuestionSchema, Common, CompensationType, CompletenessScoreSchema, ContactTypes, CoordinatorPageLinkSchema, DISPLAY_DATE_FORMAT, DISPLAY_DATE_FORMAT_SHORT, DateStringSchema, DbDefaultSchema, DefaultPaginatedResponse, DefaultPaginationOptions, DefaultUserRoles, DurationSchema, EMPTY_STRING, EducationLevel, EducationSchema, EmployeeCount, EmploymentType, ExperienceLevel, FEEDBACK_MESSAGE_MAX, FeedbackSchema, FeedbackStatus, FeedbackType, GeneraDetailFields, GroupManagedBy, GroupMembershipSchema, GroupMembershipStatus, GroupSchema, GroupStatus, GroupTranslationSchema, GroupVisibility, InputQuestionSchema, JOB_TAXONOMY, JobAlertFrequency, JobCategory, JobIndustry, JobSchema, JobSearchUrgency, JobStatus, JobSubCategory, ListFilterBranch, ListFilterBranchSchema, ListFilterSchema, LocationSchema, MIN_SALARY_LOWER_BOUND, MIN_SALARY_UPPER_BOUND, MailingListSchema, NotificationChannel, OccurrenceStatus, PREFILL_MIRRORED_KEYS, PRIVATE_PROFILE_FIELDS, PageSchema, PageStatus, PageType, type PaginatedResponse, PaginationSchema, PostSchema, PostStatus, type PrefillMirroredKey, type PrivateProfileField, ProficiencyLevel, QuestionSchema, QuestionType, ReadAndAcknowledgeQuestionSchema, RecruiterPageLinkSchema, ReferralSource, ReportReason, ReportSchema, ResourceType, SITEMAP_FORMAT, SYSTEM_DATE_FORMAT, SavedSearchSchema, SavedSearchStatus, SignupContextSource, SkillSchema, SocialAccount, SocialAccountSchema, StudentCompletenessSchema, StudyType, SupportedAnswerChoiceTypes, SupportedApplicationReceivePreferences, SupportedBindingKinds, SupportedCampaignAnchorFields, SupportedCampaignEndKinds, SupportedCampaignIntervalUnits, SupportedCampaignStatuses, SupportedCampaignTriggerKinds, SupportedCompensationTypes, SupportedContactTypes, SupportedEducationLevels, SupportedEmployeeCounts, SupportedEmploymentTypes, SupportedExperienceLevels, SupportedFeedbackStatuses, SupportedFeedbackTypes, SupportedJobAlertFrequencies, SupportedJobCategories, SupportedJobIndustries, SupportedJobSearchUrgencies, SupportedJobStatuses, SupportedJobSubCategories, SupportedNotificationChannels, SupportedOccurrenceStatuses, SupportedPageStatuses, SupportedPageTypes, SupportedPostStatuses, SupportedProficiencyLevels, SupportedQuestionTypes, SupportedReferralSources, SupportedReportReasons, SupportedResourceTypes, SupportedSalaryCurrencies, type SupportedSalaryCurrency, SupportedSavedSearchStatuses, SupportedSignupContextSources, SupportedSocialAccounts, SupportedStudyTypes, SupportedUserProfileVisibilities, SupportedUserRoles, SupportedUserStatuses, SupportedWorkModes, TAXONOMY_LABELS, type TChoiceQuestionSchema, type TDurationSchema, type TInputQuestionSchema, type TJobSchema, type TPostSchema, type TQuestionSchema, type TReadAndAcknowledgeQuestionSchema, type TUserIdAndCreatedAtSchema, TermsAcceptedSchema, UserAdditionalInfoSchema, UserCertificationSchema, UserCompletenessSchema, UserCoordinatorProfileSchema, UserDetailType, UserGeneralDetailSchema, UserIdAndCreatedAtSchema, UserInterestSchema, UserJobPreferencesSchema, UserLanguageSchema, type UserProfileOverview, UserProfileVisibility, UserProjectSchema, UserRecruiterProfileSchema, UserRole, UserSchema, UserSkillSchema, UserStatus, WorkExperienceSchema, WorkMode, categoryOfIndustry, categoryOfSubCategory, dateString, deriveIndustry, getSchemaByQuestion, industriesOfCategory, industryOfSubCategory, subCategoriesOfIndustry };
+export { AnswerChoiceType, ApplicationReceivePreference, BillingPeriod, BillingSubscriptionSchema, BillingTransactionSchema, CAMPAIGN_MAX_RECIPIENTS_CEILING, CONSUME_MAX_UNITS, CampaignDataSourceSchema, CampaignEndKind, CampaignIntervalUnit, CampaignSchema, CampaignStatus, CampaignStatusTransitions, CampaignTriggerKind, CampaignTriggerSchema, ChoiceQuestionSchema, type City, CityFilterSchema, CitySchema, Common, CompensationType, CompletenessScoreSchema, ContactTypes, CoordinatorPageLinkSchema, type Country, CountryFilterSchema, CountrySchema, type CountryTimezone, DISPLAY_DATE_FORMAT, DISPLAY_DATE_FORMAT_SHORT, DateStringSchema, DbDefaultSchema, DefaultPaginatedResponse, DefaultPaginationOptions, DefaultUserRoles, DurationSchema, EMPTY_STRING, EducationLevel, EducationSchema, EmployeeCount, EmploymentType, EntitlementConsumeSchema, EntitlementDenialReason, EntitlementDenialSchema, EntitlingSubscriptionStatuses, ExperienceLevel, FEEDBACK_MESSAGE_MAX, FeatureEntitlementSchema, FeatureKey, FeedbackFilterSchema, FeedbackSchema, FeedbackStatus, FeedbackType, GEO_COLLECTIONS, GEO_SEARCH_MAX, GRANT_MAX_LIMIT, GeneraDetailFields, GeoKind, type GeoSyncCounts, GeoSyncPhase, type GeoSyncRun, GeoSyncRunSchema, GeoSyncStatus, GeoSyncTrigger, type GeoTranslations, GrantType, GroupFilterSchema, GroupManagedBy, GroupMembershipSchema, GroupMembershipStatus, GroupSchema, GroupStatus, GroupTranslationSchema, GroupVisibility, InputQuestionSchema, JOB_TAXONOMY, JobAlertFrequency, JobCategory, JobFilterSchema, JobIndustry, JobSchema, JobSearchUrgency, JobStatus, JobSubCategory, LanguageFilterSchema, LocationSchema, MIN_SALARY_LOWER_BOUND, MIN_SALARY_UPPER_BOUND, MailingListFilterSchema, MailingListSchema, MoneySchema, NotificationType, OccurrenceStatus, PREFILL_MIRRORED_KEYS, PRIVATE_PROFILE_FIELDS, PaddleEnvironment, PaddlePriceIdsSchema, PageFilterSchema, PageSchema, PageStatus, PageType, type PaginatedResponse, PaginationSchema, PlanGrantSchema, PlanKind, PlanSchema, PlanStatus, PostSchema, PostStatus, type PrefillMirroredKey, type PrivateProfileField, ProficiencyLevel, type PushSubscriptionRecord, PushSubscriptionSchema, QuestionSchema, QuestionType, QuotaPeriod, ReadAndAcknowledgeQuestionSchema, RecruiterPageLinkSchema, ReferralSource, ReportReason, ReportSchema, ResourceType, SITEMAP_FORMAT, SYSTEM_DATE_FORMAT, SavedSearchSchema, SavedSearchStatus, SignupContextSource, SkillFilterSchema, SkillSchema, SocialAccount, SocialAccountSchema, type State, StateFilterSchema, StateSchema, StudentCompletenessSchema, StudyType, SubscriptionStatus, SupportedAnswerChoiceTypes, SupportedApplicationReceivePreferences, SupportedBillingPeriods, SupportedCampaignEndKinds, SupportedCampaignIntervalUnits, SupportedCampaignStatuses, SupportedCampaignTriggerKinds, SupportedCompensationTypes, SupportedContactTypes, SupportedEducationLevels, SupportedEmployeeCounts, SupportedEmploymentTypes, SupportedEntitlementDenialReasons, SupportedExperienceLevels, SupportedFeatureKeys, SupportedFeedbackStatuses, SupportedFeedbackTypes, SupportedGeoKinds, SupportedGeoSyncPhases, SupportedGeoSyncStatuses, SupportedGeoSyncTriggers, SupportedGrantTypes, SupportedGroupManagedBy, SupportedGroupMembershipStatuses, SupportedGroupStatuses, SupportedGroupVisibilities, SupportedJobAlertFrequencies, SupportedJobCategories, SupportedJobIndustries, SupportedJobSearchUrgencies, SupportedJobStatuses, SupportedJobSubCategories, SupportedNotificationTypes, SupportedOccurrenceStatuses, SupportedPaddleEnvironments, SupportedPageStatuses, SupportedPageTypes, SupportedPlanKinds, SupportedPlanStatuses, SupportedPostStatuses, SupportedProficiencyLevels, SupportedQuestionTypes, SupportedQuotaPeriods, SupportedReferralSources, SupportedReportReasons, SupportedResourceTypes, SupportedSalaryCurrencies, type SupportedSalaryCurrency, SupportedSavedSearchStatuses, SupportedSignupContextSources, SupportedSocialAccounts, SupportedStudyTypes, SupportedSubscriptionStatuses, SupportedTemplateVariableBindingKinds, SupportedTransactionStatuses, SupportedUserProfileVisibilities, SupportedUserRoles, SupportedUserStatuses, SupportedWorkModes, TAXONOMY_LABELS, type TChoiceQuestionSchema, type TDurationSchema, type TInputQuestionSchema, type TJobSchema, type TPostSchema, type TQuestionSchema, type TReadAndAcknowledgeQuestionSchema, type TUserIdAndCreatedAtSchema, TemplateVariableBindingKind, TemplateVariableBindingSchema, TerminalCampaignStatuses, TerminalGeoSyncStatuses, TermsAcceptedSchema, TransactionStatus, type User, UserAdditionalInfoSchema, UserCertificationSchema, UserCompletenessSchema, UserCoordinatorProfileSchema, UserDetailType, UserFilterSchema, UserGeneralDetailSchema, UserIdAndCreatedAtSchema, UserInterestSchema, UserJobPreferencesSchema, UserLanguageSchema, type UserProfileOverview, UserProfileVisibility, UserProjectSchema, UserRecruiterProfileSchema, UserRole, UserSchema, UserSkillSchema, UserStatus, WorkExperienceSchema, WorkMode, canTransitionCampaign, categoryOfIndustry, categoryOfSubCategory, codeTokens, conjunction, currencyBound, dateString, days, deriveIndustry, enumFacet, epoch, getSchemaByQuestion, industriesOfCategory, industryOfSubCategory, months, percent, qualified, rejectUnknownKeys, subCategoriesOfIndustry, tokens };