Schemas

Reference for all request and response shapes used by the HTTP API.


QueryProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/search

json
{
  "text": "wireless headphones",
  "maxNumberOfRecordsToReturn": 20,
  "mode": "EditDistance",
  "match": {
    "tolerance": "TwoEdits",
    "rungs": "Fewest",
    "oneEditFrom": 3,
    "twoEditsFrom": 6,
    "threeEditsFrom": 9,
    "cursorAt": null,
    "typingPrefixFrom": 2,
    "typingPrefixOneEditFrom": 6,
    "joinedWords": true
  },
  "candidates": {
    "candidatesPerRow": 4,
    "maxCandidates": null,
    "minCandidates": 100,
    "noFallbackForNumbersFrom": 0,
    "indexTerms": "Both",
    "fallback": true,
    "fillWithMostWords": false,
    "fillReach": 0,
    "rest": false
  },
  "ranking": {
    "rerank": true,
    "share": 0.2,
    "typingShift": 0.5,
    "longFieldFrom": 200,
    "longFieldWeightFloor": 0,
    "wholeQueryFloor": true,
    "fieldWeights": null,
    "fieldBoosts": { "title": 2.0 },
    "boosts": null,
    "buries": null
  },
  "enableMatchReport": false,
  "enableFacets": false,
  "facetFields": null,
  "facetValueLimit": 0,
  "offset": 0,
  "includeDocuments": false,
  "collapseBy": null,
  "facetSelections": null,
  "facetRanges": null,
  "counts": null,
  "sortBy": null,
  "sortAscending": false,
  "timeOutLimitMilliseconds": 1000,
  "filter": null,
  "filterExpression": null,
  "filterParameters": null
}

Every part may be left out, or null: its defaults apply. Enums are written by name, in requests and responses alike (a number in a request is still accepted): mode is EditDistance (the default) or Bm25f, and whether the records are reranked is ranking.rerank (default true); match.tolerance Exact, OneEdit, TwoEdits (the default) or ThreeEdits; match.rungs Fewest or All; candidates.indexTerms Both, Words or Patterns. Until 6.0 the query said enableCoverage, coverageDepth, coverageSetup, enableBoost, enableBury, and fieldBoosts, boosts and buries at the top level; none of them is read any more.

filterExpression — a filter expression (see Filters), ANDed with filter when both are given; filterParameters — the tokens its $name placeholders stand for, by name. One that makes no filter is 400 invalidFilterExpression.

match — what counts as a hit: the most edits a word may differ by (tolerance, which caps each field's own tolerance), the shortest word given one edit and two, the word being typed (cursorAt, else the last word when no space follows it) and from how many letters it is also met as the start of a longer word, and whether words written together or apart count as the word.

candidates — who comes in. The records holding every query word (exactly, else within one edit, else two) are counted and taken when they fit under the bound, the rows asked for times candidatesPerRow, at least minCandidates (100) and at most 5 000, or maxCandidates when set, outright; when they are more, the best of them: count is then above ranked, and toleranceCounts has the count by rung. The list is the counted records, cut only to the rows asked for. When no record holds every word, the result says isFallback: the records holding the most of the words first, the pattern matches after them; fallback: false returns an empty list instead. With isFallback, count is how many records hold the most of the words, not how many hold them all, and it can be large with few or no records listed (a garbled word can count thousands): a page that shows a hit count shows none then. With fallback: false, count is 0. rest: true (in EditDistance) puts pattern recognition's best records that were not counted below the counted ones, up to the bound; they are counted in toleranceCounts.rest and in the facets, and none is taken on overflow.

ranking — the order: rerank (whether the reranker orders the candidates, in either mode; off, Bm25f is pattern recognition alone), the reranker's share of the score, the boosts and buries (the tokens the boost and bury endpoints give; a list that is not empty is on), fieldWeights (per field, its weight in the reranker in this search, its rerankWeight otherwise) and fieldBoosts. The dataset's stored boost and bury rules apply to every search, beside the query's own (until 6.0 only with enableBoost and enableBury).

enableFacets — required for an empty text. Empty text with enableFacets: false is refused, not treated as match-everything: 200, no records, and reason set to Search called with empty string and EnableFacets=false. The dataset also needs at least one facetable field; without one the result is empty and reason says so. See Empty search.

facetFields — with enableFacets, the facetable fields to count, by name (["brand", "color"]); null or empty counts every facetable field. Naming the ones a page shows saves counting the rest. A name that is not a facetable field refuses the search, with reason naming it.

facetValueLimit — the most values returned per facet field, the commonest first; 0 returns them all. Only what is returned is cut: facetStats is of every value counted.

counts — named counts, a filter expression each ({ "allEvents": "contentType = \"event\"" }, its $name placeholders from filterParameters): the result's counts says for each name how many of the records count counts the filter lets through. Over the same set as count and the facets, so it costs no search of its own: a page's sections counted beside one search's list. An expression that makes no filter answers 400 invalidFilterExpression.

offset — how many ranked records to pass over before the first returned, for paging: offset: 20 with maxNumberOfRecordsToReturn: 10 returns the 21st to the 30th. Only ranked records can be returned, so page while offset is below ranked, not count (see Result). count and the facets are of the whole search on every page.

includeDocuments — the records' JSON comes with the result, in documents, one a record in the order of records (null for a record deleted since), so a search is one call rather than a search and a documents/lookup. includeFields keeps only the top-level fields named in each record; with collapseBy it must hold its fields, or the search answers 400 invalidArgument.

facetSelections — the values ticked on facets, by facetable field ({ "formats": ["Lydbok", "Pocket"], "languages": ["Bokmål"] }): the records listed hold one of each field's values (OR within a field, AND between fields, and AND with the filter), and each field's facet is counted without its own selection, so its other values keep their counts and can be ticked too; the facets of fields without a selection are counted with them all. Values are folded as the facets fold them. The field need only be facetable; one that is not refuses the search with a reason. facetRanges — a range on a facet, by field, a filter expression on that field alone ({ "publishedYear": "publishedYear >= 2010" }), the field facetable and filterable (a facetable number field is filterable by itself): it narrows the list as a selection does, and the field's facet and facetStats are counted without it, so a slider keeps its whole span. A range expression that makes no filter answers 400 invalidFilterExpression; one on another field is refused with a reason. Each selected field's facet is a search of its own inside the call, with no rows.

collapseBy — one record per value of these fields (["bookTitle"], or several, whose values together decide): a record whose values are a record's higher in the ranking is left out, and the next with values not seen takes its place. Nothing moves; offset counts the records kept, so no page repeats a value. With sortBy the records kept are sorted, and an empty search keeps the first of each value in its sort order. count and the facets count the records, as without. A record holding none of the fields, or null in them, stands alone. A field must have a role (searched, filterable, facetable, sortable) and not be an array; otherwise the search is refused with a reason.

ranking.fieldBoosts — per-query multipliers on each field's configured weight (a field with weight: 2.0 and a boost of 2.0 counts 4×). Keys must be searchable fields: a key that is not empties the whole search, returned today as 200 with no records. null, or a field left out, uses the configured weight unchanged. See Search for details.


Result

Response from POST /api/teams/{teamName}/datasets/{dataSetName}/search

json
{
  "records": [
    { "documentKey": 42, "score": 220 },
    { "documentKey": 17, "score": 185 }
  ],
  "facets": {
    "category": [
      { "key": "electronics", "value": 12 },
      { "key": "accessories", "value": 5 }
    ]
  },
  "toleranceCounts": { "exact": 2, "oneEdit": null, "twoEdits": null, "threeEdits": null },
  "countedTolerance": "Exact",
  "facetStats": {
    "price": { "min": 49, "max": 12990, "count": 812 }
  },
  "count": 2,
  "ranked": 2,
  "isFallback": false,
  "didTimeOut": false
}

score is a 16-bit unsigned integer (0–65535). toleranceCounts says how many records hold every query word exactly, within one edit, two and three, each with those before it (a rung not worked out is null); countedTolerance is the rung the list was taken from (Exact, OneEdit, TwoEdits, ThreeEdits), null when nothing was counted. With candidates.rest, toleranceCounts.rest is the counted rung's records and the related ones taken below them. Both are absent in Bm25f mode. count is how many records answer the search, in every mode (in Bm25f every record with a score, in an empty search every record the filter lets through), and ranked how many were ranked, at most the bound: count above ranked means the bound was too small, ranked above the records returned that a next page has more. When nothing is counted and candidates.fallback is false, count is 0: there are no records, and the fallback's set it would otherwise count is not shown. Until 6.0 the result carried truncationIndex and truncationScore instead.

counts — with the query's counts, how many of the records count counts each named filter lets through. Absent when the query named none.

facetStats — for each number field among the facets counted, the lowest and highest value in the set the facets are counted over, and count, how many of its records hold one (null for an array field, whose records can hold several values). What a range slider reads. Absent without facets.

reason is present when the engine refused the query rather than finding nothing — an empty text without enableFacets, text over the 300-character limit, a dataset that is not ready. The records are empty either way, so check reason alongside didTimeOut and report a refusal as a failure rather than as an empty result.


VectorQueryProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/search/vector

json
{
  "fieldName": "embedding",
  "vector": [0.12, -0.45, 0.33],
  "maxResults": 10,
  "filter": null,
  "filterExpression": null
}

The vector must match the dimension of the indexed embedding field. Its length does not matter: Indx brings it to unit length.


HybridQueryProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/search/hybrid

json
{
  "text": "comfortable wireless headphones",
  "embeddingField": "embedding",
  "vector": [0.12, -0.45, 0.33],
  "alpha": 0.6,
  "maxNumberOfRecordsToReturn": 20,
  "filter": null,
  "filterExpression": null,
  "timeOutLimitMilliseconds": 1000
}

alpha — blend weight in [0, 1]. 0 = pure text, 1 = pure embedding.


EmbeddingResultEntry

Response from search/vector and search/hybrid

json
[
  { "documentKey": 42, "score": 0.94 },
  { "documentKey": 17, "score": 0.81 }
]

score is in [0, 1]. For vector search it is cosine similarity; for hybrid search it is the blended value.


FieldProxy

Used by PUT fields/configuration (request) and GET fields/configuration (response). null on a PUT means "leave unchanged".

json
[
  {
    "fieldName": "name",
    "fieldType": "String",
    "isArray": false,
    "wordMatching": true,
    "patternMatching": true,
    "filterable": false,
    "facetable": false,
    "sortable": false,
    "indexSizes": [3],
    "numberOfStartCharacters": 2,
    "numberOfStopCharacters": 0,
    "embeddable": false,
    "preloadFilters": false,
    "weight": 2.0,
    "bM25b": 0.75,
    "bM25k1": 1.2,
    "tolerance": "OneEdit",
    "rerankWeight": 1.0,
    "typingPrefixFrom": null,
    "caseSensitive": false,
    "textRules": []
  }
]

fieldType and isArray are read-only — they are populated by the server on GET and ignored on PUT.

  • wordMatching: the field is matched by its whole words, exactly and within its tolerance; its words are in the word lookup, so it counts.
  • patternMatching: the field is also matched inside its words, with indexSizes (default [3]), numberOfStartCharacters (2) and numberOfStopCharacters (0). Alone it orders records but cannot narrow them.
  • tolerance (Exact, OneEdit, TwoEdits, ThreeEdits): the most edits a query word may be from the field's; capped by the search's match.tolerance. rerankWeight: the field's weight in the reranker, 0 leaves it out. typingPrefixFrom: from how many letters the word being typed matches the start of a longer word here. caseSensitive: match with case.
  • textRules: the field's own string rules, run in their order before the engine's, in the index and in the query met against the field. [{"from": "-", "to": ""}, {"from": " ", "to": ""}] makes a code field (an ISBN, a part number) one word however it is written in the data, so 9780306406157 finds 978-0-306-40615-7. A query is best sent without the separators: with them, the other fields still read several words. [] gives the field the engine's rules again; left out, the rules stay as they are. caseSensitive and textRules take effect at the next load: a change on a loaded dataset rebuilds it, as a change of k1 does.
  • A freshly analyzed dataset has neither role on any field and searches nothing until one is set. Both roles is how a searchable field was matched on servers before 2.0 beta 4.
  • Never send searchable: it is read as wordMatching alone, so the field loses pattern matching. wordIndexing and highResolution bind to nothing.

SystemStatus

Response from GET /api/teams/{teamName}/datasets/{dataSetName}/status

json
{
  "systemState": "Ready",
  "documentCount": 5000,
  "recordsOnDisk": 5000,
  "fieldsDiscovered": 12,
  "searchCounter": 142,
  "secondsToIndex": 3,
  "shadowBuildInProgress": false,
  "shadowBuildStartedUtc": null,
  "version": "6.0.0",
  "licenseInfo": { ... },
  "errorMessage": "",
  "timeOfInstanceCreation": "2025-01-01T00:00:00Z",
  "timeOfLastIndexBuild": "2025-01-01T00:05:00Z"
}

systemState values, written by name: Created · Loading · Loaded · Indexing · Ready · Error

A hibernated dataset reports Created together with recordsOnDisk > 0; fieldsDiscovered says how many fields its stored configuration holds. (-1 Hibernated existed until Sep 2026 and was removed.)


DataSetListDto

Response from GET /api/me/datasets

json
[
  { "name": "products", "teamName": "acme", "role": "Admin" },
  { "name": "catalogue", "teamName": "research", "role": "Editor" }
]

role is "Admin", "Editor", or "Viewer" — your role on the owning team.


TransferToTeamRequest

POST /api/teams/{teamName}/datasets/{dataSetName}/transfer

json
{ "targetTeamName": "research" }

Moves the dataset to another team. The caller must be an Admin of both teams.


FilterProxy

A filter reference returned by filters/value, filters/range, filters/in, filters/position, filters/expression, filters/combine or filters/not. Pass it back in search or bulk-operation requests.

json
{ "hashString": "abc123..." }

ValueFilterProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/filters/value

json
{
  "fieldName": "category",
  "value": "electronics",
  "isCaseSensitive": false
}

value may be a string, a number or a boolean. isCaseSensitive is optional and off by default; a facet count equals a filter count only for a case-sensitive filter. Both kinds read the field's index.

The field must not hold numbers. A value filter compares text, so on a numeric field the request is answered 400 naming the filter to use instead — see RangeFilterProxy.


RangeFilterProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/filters/range

json
{
  "fieldName": "price",
  "lowerLimit": 10,
  "upperLimit": 100
}

Both limits are inclusive, and equal limits are numeric equality — that is how to match one value on a numeric field. The field must hold numbers; a number stored as a JSON string is text, and the request is answered 400 saying to store the values as numbers and load again.


CombinedFilterProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/filters/combine

json
{
  "filters": [
    { "hashString": "abc123..." },
    { "hashString": "def456..." }
  ],
  "useAndOperation": true
}

Two or more filters combined into one, with AND when useAndOperation is true and OR when it is false. One filter returns its own token; an empty list is 400 invalidArgument. Duplicates and order do not matter.


InFilterProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/filters/in

json
{
  "fieldName": "brand",
  "values": ["nike", "puma"],
  "isCaseSensitive": false
}

values are text, numbers or booleans, at least one; on a numeric field they must be numbers. isCaseSensitive as for a value filter; refused on a numeric field.


PositionFilterProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/filters/position

json
{
  "fieldName": "location",
  "latitude": 59.9133,
  "longitude": 10.7389,
  "withinMeter": 1000
}

fieldName names an object holding the numbers latitude and longitude in decimal degrees; both of its fields (location.latitude, location.longitude) must be Filterable. Matches the documents whose position lies within withinMeter metres, both ends inclusive. Latitude within ±90, longitude within ±180, withinMeter 0 or more.


FilterExpressionProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/filters/expression

json
{
  "expression": "$region AND price BETWEEN 100 AND 2000",
  "parameters": { "region": { "hashString": "def456..." } }
}

parameters is optional: the token for each $name placeholder, keyed by the name without $. Answered with { "hashString": "...", "canonical": "..." } - the token, and the expression as the engine reads it.


BoostProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/boosts/from-filter

json
{
  "filterProxy": { "hashString": "abc123..." },
  "boostStrength": "Med"
}

boostStrength: Low, Med or High, written by name (1, 2, 3 are still accepted); any other value is 400 invalidArgument, here and in a search's ranking.boosts. Each strength point lifts a boosted document by 1/255 of the score range, and every hit the boost does not lift loses the same, down to 0: many boosts flatten the order of the hits they leave out. A search whose boosts' strengths sum past 255 (85 at High) is refused - 200, no records, and a reason - since the score could not hold it.


BuryProxy

POST /api/teams/{teamName}/datasets/{dataSetName}/buries/from-filter

json
{
  "filterProxy": { "hashString": "abc123..." },
  "buryStrength": "Med"
}

The counterpart of a boost: the documents the filter holds are taken down by buryStrength points of 1/255 of the score range each, and nothing else moves. Low, Med or High (1, 2, 3 are still accepted); any other value is 400 invalidArgument, here and in a search's ranking.buries. A document taken below the bottom lands on the floor of the range and stays in the list. A search whose buries' strengths sum past 255 is refused as one with too many boosts is. A search's ranking.buries that is not empty is on; the dataset's saved bury rules (PUT buries) apply to every search.

Schemas

AskRequest

A question, and for a follow-up the conversation so far (the last three turns are used). `Proactive`: the page started this answer on its own, in the proactive mode, rather than the visitor asking; it counts against the day's proactive answers.

PropertyTypeDefault
question
string
—
history
object[]
—
proactive
boolean
—

AskShown

On a catalogue, the list a turn put on the page: its filters, words and order, or the agent's picks. A follow-up ("which is the largest?") is about that list.

PropertyTypeDefault
filters
object[]
—
text
string
—
sort
object
—
picks
object[]
—

AskShownPick

A pick an earlier turn put on the page.

PropertyTypeDefault
documentKey
int64
—
title
string
—

AskTurn

An earlier question and its answer in the same conversation, for a follow-up.

PropertyTypeDefault
question
string
—
answer
string
—
shown
object
—

BoostCondition

One condition of a boost rule: a filterable field matched either by an exact IndxServer.Models.BoostCondition.Value (string/keyword fields) or by a numeric IndxServer.Models.BoostCondition.Min/IndxServer.Models.BoostCondition.Max range. Exactly one of the two forms is used: if IndxServer.Models.BoostCondition.Min or IndxServer.Models.BoostCondition.Max is set it's a range, otherwise IndxServer.Models.BoostCondition.Value is an exact match.

PropertyTypeDefault
field
string
—
value
string
—
min
double
—
max
double
—
isRange
boolean
—

BoostProxy

PropertyTypeDefault
boostStrength
string
—
filterProxy
object
—

BoostRule

A persisted, per-dataset ranking rule: when a search has `enableBoost` on, documents matching this rule's combined condition get their score lifted by IndxServer.Models.BoostRule.Strength. Rules are managed in the UI and applied server-side; see `BoostRuleStore`.

PropertyTypeDefault
name
string
—
enabled
boolean
—
conditions
object[]
—
join
string
—
strength
string
—
activeFrom
date
—
activeUntil
date
—

BuryProxy

PropertyTypeDefault
buryStrength
string
—
filterProxy
object
—

BuryRule

A saved bury rule, a boost rule's twin (25 Oct 2026): a name, conditions on filterable fields joined by And or Or, a strength, an optional active period. Applied to a search that runs with `enableBury`: the documents the conditions match are scored lower.

PropertyTypeDefault
name
string
—
enabled
boolean
—
conditions
object[]
—
join
string
—
strength
string
—
activeFrom
date
—
activeUntil
date
—

CandidateProxy

PropertyTypeDefault
candidatesPerRow
int32
—
maxCandidates
int32
—
minCandidates
int32
—
noFallbackForNumbersFrom
int32
—
indexTerms
string
—
fallback
boolean
—
rest
boolean
—
fillWithMostWords
boolean
—
fillReach
int32
—

ChangePasswordRequest

Body of POST /api/changePassword. Used to rotate the seeded admin's initial password (set at deployment time) before any other API calls can be made.

PropertyTypeDefault
currentPassword
string
—
newPassword
string
—

ColdBatchItem

One item of a sync's batch: IndxServer.Controllers.ColdWrite with the record it is of, by its Indx key (IndxServer.Controllers.ColdBatchItem.RecordKey) or by the sender's own id (IndxServer.Controllers.ColdBatchItem.Id): the id a webhook gave the record, or the record's key as text.

PropertyTypeDefault
name
string
—
content
string
—
recordKey
int64
—
id
string
—
language
string
—
contentType
string
—
description
string
—
visibility
string
—
sourceRef
string
—
sourceUpdatedUtc
date-time
—

ColdWrite

An item as written: the content and what is said about it. The record, name and language are the route's and the query's; who wrote it is the server's to say.

PropertyTypeDefault
content
string
—
contentType
string
—
description
string
—
visibility
string
—
sourceRef
string
—
sourceUpdatedUtc
date-time
—

CombinedFilterProxy

PropertyTypeDefault
filters
object[]
—
useAndOperation
boolean
—

ConvertEventRequest

The convert event: whatever the customer considers valuable (order, add-to-cart, …). Type is the customer's own name for it. Value/Currency/Quantity are optional commerce magnitudes. QueryId is optional — a conversion may happen long after the search or from another channel, and still counts on the document. Count as for IndxServer.Models.SelectEventRequest.

PropertyTypeDefault
queryId
string
—
documentKey
int64
—
type
string
—
value
double
—
currency
string
—
quantity
int64
—
subject
string
—
count
boolean
—

CreateWebhookRequest

PropertyTypeDefault
name
string
—
idField
string
—
versionField
string
—
brakeShare
double
—
source
string
—
settings
object
—

DatasetQueryParameters

A dataset's query parameters: the values a search takes when its request leaves them out. The same shape, names and meaning as those parts of a search body (6.0: `mode`, `match`, `candidates`, `ranking`), so a value can be copied between the two. Null means "not set here", and the engine default applies. Resolution, member by member: the request, then this, then the engine default (IndxServer.Services.QueryParameterResolution). A search's own values are not kept here: the cursor, the index terms, the field weights and boosts, the boosts and buries (M:IndxServer.Services.QueryParameterResolution.Validate(IndxServer.Models.DatasetQueryParameters)).

PropertyTypeDefault
mode
string
—
match
object
—
candidates
object
—
ranking
object
—

DemoCreated

The dataset made, and its name.

PropertyTypeDefault
dataSet
string
—

FacetValueSearchRequest

The body of `facets/{field}/search`: what a visitor typed into a facet's own search field ("Search actors…"), how many values to answer, and the search the facet belongs to, so the counts are of its records.

PropertyTypeDefault
text
string
—
rows
int32
—
search
object
—
values
string[]
—

FieldProfile

A searched field's search settings under a name many fields share (Nov 2026): its Indx.Api.Field.Tolerance, Indx.Api.Field.RerankWeight, the and the Indx.Api.PatternMatchingSetup it takes when Indx.Api.Field.PatternMatching is on. A console convenience over the engine's own values: choosing a profile for a field writes them onto it, editing a profile writes them onto every field that has it, and the engine stays where the values live. A profile also has the fields' own text rules (Indx.Api.FieldProxy.TextRules, 17 Nov 2026): strings replaced before the dataset's, built into the index, so a change rebuilds it. Indx.Api.Field.CaseSensitive is not here yet.

PropertyTypeDefault
id
string
—
name
string
—
about
string
—
builtIn
boolean
—
tolerance
string
—
rerankWeight
float
—
indexSizes
int32[]
—
numberOfStartCharacters
int32
—
numberOfStopCharacters
int32
—
typingPrefixFrom
int32
—
textRules
object[]
—

FieldProfilesRequest

PUT fields/profiles. Each part left out (null) is left as it is. `Profiles` is the dataset's own list, whole: a profile with a built-in's id is that built-in as this dataset changes it, one left out of the list is deleted (a built-in back to its shipped values). `Assignments` gives fields their profile by id, or null for none (the field keeps its values, as its own); fields not named keep theirs. `DefaultProfileId` is the profile a field gets when it becomes searched.

PropertyTypeDefault
profiles
object[]
—
assignments
object
—
defaultProfileId
string
—

FieldProxy

PropertyTypeDefault
fieldName
string
—
fieldType
string
—
isArray
boolean
—
optional
boolean
—
sampleValue
string
—
wordMatching
boolean
—
filterable
boolean
—
facetable
boolean
—
sortable
boolean
—
patternMatching
boolean
—
embeddable
boolean
—
preloadFilters
boolean
—
weight
float
—
bM25b
float
—
bM25k1
float
—
tolerance
string
—
typingPrefixFrom
int32
—
rerankWeight
float
—
indexSizes
int32[]
—
numberOfStartCharacters
int32
—
numberOfStopCharacters
int32
—
caseSensitive
boolean
—
textRules
object[]
—

FilterExpressionProxy

PropertyTypeDefault
expression
string
—
parameters
object
—

FilterFieldUpdateProxy

PropertyTypeDefault
filter
object
—
fieldName
string
—
value
any
—

FilterProxy

PropertyTypeDefault
hashString
string
—

FilterSuggestion

One filter the description asked for: a value (text, or true/false) or a number range, either end open. Field and value are the dataset's own, checked against what it holds.

PropertyTypeDefault
field
string
—
value
string
—
min
double
—
max
double
—

FiltersRequest

PropertyTypeDefault
text
string
—

GroupedSearchRequest

The body of `search/groups`: one text and its settings, split into named sections, each with its own filter, rows and count: a search box's books, authors and events in one call. The members of the search itself are every group's; a group's own filter is ANDed with the search's, and its own candidates, ranking and match replace the search's.

PropertyTypeDefault
mode
string
—
match
object
—
candidates
object
—
ranking
object
—
enableMatchReport
boolean
—
enableFacets
boolean
false
facetFields
string[]
—
facetValueLimit
int32
0
offset
int32
0
includeDocuments
boolean
false
filter
object
—
filterExpression
string
—
filterParameters
object
—
facetSelections
object
—
facetRanges
object
—
collapseBy
string[]
—
counts
object
—
logPrefix
string
—
maxNumberOfRecordsToReturn
int32
30
measureFit
boolean
false
sortAscending
boolean
false
sortBy
string
—
text
string
—
timeOutLimitMilliseconds
int32
1000
includeFields
string[]
—
groups
object[]
—

HybridQueryProxy

PropertyTypeDefault
text
string
—
maxNumberOfRecordsToReturn
int32
10
filter
object
—
filterExpression
string
—
filterParameters
object
—
timeOutLimitMilliseconds
int32
1000
embeddingField
string
—
vector
float[]
—
alpha
float
0.5

InFilterProxy

PropertyTypeDefault
fieldName
string
—
values
any[]
—
isCaseSensitive
boolean
—

IntentRequest

The text to judge. `Prefetch`: asked while the visitor still types, ahead of the pause; it warms the judge's cache and is not counted as a judgement.

PropertyTypeDefault
text
string
—
prefetch
boolean
—

JsonNode

PropertyTypeDefault
options
object
—
parent
object
—
root
object
—

JsonNodeOptions

PropertyTypeDefault
propertyNameCaseInsensitive
boolean
—

LicenseInfo

PropertyTypeDefault
description
string
—
documentLimit
int32
—
documentLimitExceeded
boolean
—
expirationDate
date-time
—
licenseFileFound
boolean
—
licensed
boolean
—
licensedTo
string
—
licenseFileName
string
—
type
string
—
validLicense
boolean
—

MatchProxy

PropertyTypeDefault
tolerance
string
—
rungs
string
—
oneEditFrom
int32
—
twoEditsFrom
int32
—
threeEditsFrom
int32
—
cursorAt
int32
—
typingPrefixFrom
int32
—
typingPrefixOneEditFrom
int32
—
joinedWords
boolean
—

MultiSearchItem

One search of `search/multi`: a search with its own say in the statistics, over the query string's, so a page can send its visitor's search beside its helper searches in one call and count only the first.

PropertyTypeDefault
mode
string
—
match
object
—
candidates
object
—
ranking
object
—
enableMatchReport
boolean
—
enableFacets
boolean
false
facetFields
string[]
—
facetValueLimit
int32
0
offset
int32
0
includeDocuments
boolean
false
filter
object
—
filterExpression
string
—
filterParameters
object
—
facetSelections
object
—
facetRanges
object
—
collapseBy
string[]
—
counts
object
—
logPrefix
string
—
maxNumberOfRecordsToReturn
int32
30
measureFit
boolean
false
sortAscending
boolean
false
sortBy
string
—
text
string
—
timeOutLimitMilliseconds
int32
1000
includeFields
string[]
—
count
boolean
—
source
string
—
session
string
—

ParseResult

PropertyTypeDefault
token
string
—
progressPercent
int32
—
recordIndex
int32
—
isEndOfStream
boolean
—
errorType
string
—
errorMessage
string
—
lineNumber
int64
—
bytePositionInLine
int64
—
jsonPath
string
—
wasSanitized
boolean
—
originalToken
string
—

PositionFilterProxy

PropertyTypeDefault
fieldName
string
—
latitude
float
—
longitude
float
—
withinMeter
float
—

ProblemDetails

PropertyTypeDefault
type
string
—
title
string
—
status
int32
—
detail
string
—
instance
string
—

ProcessError

PropertyTypeDefault
source
string
—
message
string
—
parseError
object
—
timeStampUtc
date-time
—

ProcessErrorCount

PropertyTypeDefault
error
object
—
count
int32
—

RangeFilterProxy

PropertyTypeDefault
fieldName
string
—
lowerLimit
double
—
upperLimit
double
—

RankingProxy

PropertyTypeDefault
rerank
boolean
—
share
float
—
typingShift
float
—
longFieldFrom
int32
—
longFieldWeightFloor
float
—
wholeQueryFloor
boolean
—
fieldWeights
object
—
fieldBoosts
object
—
boosts
object[]
—
buries
object[]
—

SearchGroup

One section of a IndxServer.Models.GroupedSearchRequest.

PropertyTypeDefault
name
string
—
filter
string
—
rows
int32
—
countFilter
string
—
candidates
object
—
ranking
object
—
match
object
—
primary
boolean
—

SearchOrAskSettings

A dataset's Search or ask settings (IndxServer.Services.SearchOrAsk.SearchOrAskStore). Text and numbers only: the request the judge receives has a fixed shape, so an owner, or Observr after a yes, can make the judge better or worse but cannot break the endpoint.

PropertyTypeDefault
enabled
boolean
—
shown
boolean
—
kind
string
—
siteDescription
string
—
titleField
string
—
sectionFields
string[]
—
snippetFields
string[]
—
thresholds
object
—
mode
string
—
dailyProactiveAnswers
int32
—
strictCoverageWhileAsking
boolean
—
filtersWhileTyping
string
—
filterNotes
string
—
answerInstructions
string
—
knowledge
string
—
answerLanguage
string
—
answers
string
—
answerModel
string
—
searches
string
—
dailyCallBudget
int32
—

SearchOrAskThresholds

Where the judge's probability becomes an offer. Entered at one value and left only below a lower one, so the offer does not blink while a visitor types; the client applies that, since it depends on what this visitor has been shown. A value left null is the judge's own (M:IndxServer.Services.SearchOrAsk.SearchOrAskThresholds.For(System.String)), measured for it: switching the judge brings its numbers along, and only what an owner set by hand stays. What a client is sent is always M:IndxServer.Services.SearchOrAsk.SearchOrAskThresholds.Resolved(System.String,System.String), every value a number, since a published intrface spreads these over its defaults and would read a null as 0.

PropertyTypeDefault
strong
double
—
strongHide
double
—
invite
double
—
inviteHide
double
—
hint
double
—
finished
double
—
found
double
—
refocus
double
—

SelectEventRequest

The select event: the user chose a result. QueryId is the value the search response returned in its `Indx-Query-Id` header; it is optional and opaque — an unknown or expired id still counts on the document, it just finds no search to join. Position is 1-based in the result list. Subject is the optional general identity: a user, a session or a customer-defined segment. Count is false for a select that is not a visitor's (a probe, a test); a select on a search that was not counted is not counted either, whatever it says.

PropertyTypeDefault
queryId
string
—
documentKey
int64
—
position
int32
—
subject
string
—
count
boolean
—

ServerQueryProxy

A search as the server's search routes take it: the library's Indx.Http.QueryProxy, with what only the server does (12 Nov 2026). A subclass, not new members on QueryProxy, because QueryProxy ships in IndxSearchLib and these mean nothing to the library.

PropertyTypeDefault
mode
string
—
match
object
—
candidates
object
—
ranking
object
—
enableMatchReport
boolean
—
enableFacets
boolean
false
facetFields
string[]
—
facetValueLimit
int32
0
offset
int32
0
includeDocuments
boolean
false
filter
object
—
filterExpression
string
—
filterParameters
object
—
facetSelections
object
—
facetRanges
object
—
collapseBy
string[]
—
counts
object
—
logPrefix
string
—
maxNumberOfRecordsToReturn
int32
30
measureFit
boolean
false
sortAscending
boolean
false
sortBy
string
—
text
string
—
timeOutLimitMilliseconds
int32
1000
includeFields
string[]
—

ServerSystemStatus

SystemStatus extended with server-layer fields that the core library has no knowledge of.

PropertyTypeDefault
documentCount
int32
—
errorMessage
string
—
invalidArgument
boolean
—
invalidDataSetName
boolean
—
invalidState
boolean
—
licenseInfo
object
—
recoverableErrors
object[]
—
searchCounter
int32
—
secondsToIndex
double
—
systemState
string
—
timeOfInstanceCreation
date-time
—
timeOfLastIndexBuild
date-time
—
tooLongSearchText
boolean
—
indexedTextTruncated
boolean
—
fieldK1Ignored
boolean
—
wordTokenSizeCapped
boolean
—
unrecoverableErrors
object[]
—
version
string
—
recordsOnDisk
int32
—
fieldsDiscovered
int32
—
shadowBuildInProgress
boolean
—
shadowBuildStartedUtc
date-time
—
shadowBuildFinishedUtc
date-time
—
shadowBuildError
string
—

ShownRequest

PropertyTypeDefault
shown
boolean
—

SortSuggestion

An order the description asked for ("størst", "flest elever"): a Sortable field.

PropertyTypeDefault
field
string
—
descending
boolean
—

StatisticsSettingsUpdate

A change to the statistics settings (PUT …/statistics/settings). A property left out stays as it is; labelField "" goes back to the first searchable field, timeZone "" to the instance's default.

PropertyTypeDefault
recordFilters
boolean
—
labelField
string
—
timeZone
string
—

SynonymEntry

PropertyTypeDefault
direction
string
—
source
string
—
terms
string[]
—

SynonymList

PropertyTypeDefault
name
string
—
description
string
—
updatedUtc
date-time
—
entries
object[]
—

TextRule

PropertyTypeDefault
from
string
—
to
string
—
keepOriginal
boolean
—

UpdateFieldProxy

PropertyTypeDefault
fieldName
string
—
value
any
—

UpdateWebhookRequest

The settings an admin may change once a webhook is made.

PropertyTypeDefault
name
string
—
versionField
string
—
brakeShare
double
—
settings
object
—

ValueFilterProxy

PropertyTypeDefault
fieldName
string
—
value
any
—
isCaseSensitive
boolean
—

VectorQueryProxy

PropertyTypeDefault
fieldName
string
—
vector
float[]
—
maxResults
int32
10
filter
object
—
filterExpression
string
—
filterParameters
object
—