@azure/search-documents 12.3.0-beta.1 → 13.1.0-beta.1

package/dist/commonjs/models/azure/search/documents/models.js

@@ -0,0 +1,1046 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var models_exports = {};
+__export(models_exports, {
+  KnownHybridCountAndFacetMode: () => KnownHybridCountAndFacetMode,
+  KnownQueryAnswerType: () => KnownQueryAnswerType,
+  KnownQueryCaptionType: () => KnownQueryCaptionType,
+  KnownQueryDebugMode: () => KnownQueryDebugMode,
+  KnownQueryLanguage: () => KnownQueryLanguage,
+  KnownQueryRewritesType: () => KnownQueryRewritesType,
+  KnownQuerySpellerType: () => KnownQuerySpellerType,
+  KnownQueryType: () => KnownQueryType,
+  KnownSemanticErrorMode: () => KnownSemanticErrorMode,
+  KnownSemanticErrorReason: () => KnownSemanticErrorReason,
+  KnownSemanticFieldState: () => KnownSemanticFieldState,
+  KnownSemanticQueryRewritesResultType: () => KnownSemanticQueryRewritesResultType,
+  KnownSemanticSearchResultsType: () => KnownSemanticSearchResultsType,
+  KnownVectorFilterMode: () => KnownVectorFilterMode,
+  KnownVectorQueryKind: () => KnownVectorQueryKind,
+  KnownVectorThresholdKind: () => KnownVectorThresholdKind,
+  autocompleteItemArrayDeserializer: () => autocompleteItemArrayDeserializer,
+  autocompleteItemArraySerializer: () => autocompleteItemArraySerializer,
+  autocompleteItemDeserializer: () => autocompleteItemDeserializer,
+  autocompleteItemSerializer: () => autocompleteItemSerializer,
+  autocompleteResultDeserializer: () => autocompleteResultDeserializer,
+  debugInfoDeserializer: () => debugInfoDeserializer,
+  debugInfoSerializer: () => debugInfoSerializer,
+  documentDebugInfoDeserializer: () => documentDebugInfoDeserializer,
+  errorAdditionalInfoArrayDeserializer: () => errorAdditionalInfoArrayDeserializer,
+  errorAdditionalInfoDeserializer: () => errorAdditionalInfoDeserializer,
+  errorDetailArrayDeserializer: () => errorDetailArrayDeserializer,
+  errorDetailDeserializer: () => errorDetailDeserializer,
+  errorResponseDeserializer: () => errorResponseDeserializer,
+  facetResultArrayDeserializer: () => facetResultArrayDeserializer,
+  facetResultArrayRecordDeserializer: () => facetResultArrayRecordDeserializer,
+  facetResultArrayRecordSerializer: () => facetResultArrayRecordSerializer,
+  facetResultArraySerializer: () => facetResultArraySerializer,
+  facetResultDeserializer: () => facetResultDeserializer,
+  facetResultSerializer: () => facetResultSerializer,
+  hybridSearchDeserializer: () => hybridSearchDeserializer,
+  hybridSearchSerializer: () => hybridSearchSerializer,
+  indexActionArraySerializer: () => indexActionArraySerializer,
+  indexActionSerializer: () => indexActionSerializer,
+  indexDocumentsBatchSerializer: () => indexDocumentsBatchSerializer,
+  indexDocumentsResultDeserializer: () => indexDocumentsResultDeserializer,
+  indexingResultArrayDeserializer: () => indexingResultArrayDeserializer,
+  indexingResultArraySerializer: () => indexingResultArraySerializer,
+  indexingResultDeserializer: () => indexingResultDeserializer,
+  indexingResultSerializer: () => indexingResultSerializer,
+  lookupDocumentDeserializer: () => lookupDocumentDeserializer,
+  queryAnswerResultArrayDeserializer: () => queryAnswerResultArrayDeserializer,
+  queryAnswerResultArraySerializer: () => queryAnswerResultArraySerializer,
+  queryAnswerResultDeserializer: () => queryAnswerResultDeserializer,
+  queryAnswerResultSerializer: () => queryAnswerResultSerializer,
+  queryCaptionResultArrayDeserializer: () => queryCaptionResultArrayDeserializer,
+  queryCaptionResultDeserializer: () => queryCaptionResultDeserializer,
+  queryResultDocumentInnerHitArrayDeserializer: () => queryResultDocumentInnerHitArrayDeserializer,
+  queryResultDocumentInnerHitArrayRecordDeserializer: () => queryResultDocumentInnerHitArrayRecordDeserializer,
+  queryResultDocumentInnerHitDeserializer: () => queryResultDocumentInnerHitDeserializer,
+  queryResultDocumentRerankerInputDeserializer: () => queryResultDocumentRerankerInputDeserializer,
+  queryResultDocumentSemanticFieldArrayDeserializer: () => queryResultDocumentSemanticFieldArrayDeserializer,
+  queryResultDocumentSemanticFieldDeserializer: () => queryResultDocumentSemanticFieldDeserializer,
+  queryResultDocumentSubscoresDeserializer: () => queryResultDocumentSubscoresDeserializer,
+  queryRewritesDebugInfoDeserializer: () => queryRewritesDebugInfoDeserializer,
+  queryRewritesValuesDebugInfoArrayDeserializer: () => queryRewritesValuesDebugInfoArrayDeserializer,
+  queryRewritesValuesDebugInfoDeserializer: () => queryRewritesValuesDebugInfoDeserializer,
+  searchDocumentsResultDeserializer: () => searchDocumentsResultDeserializer,
+  searchDocumentsResultSerializer: () => searchDocumentsResultSerializer,
+  searchRequestDeserializer: () => searchRequestDeserializer,
+  searchResultArrayDeserializer: () => searchResultArrayDeserializer,
+  searchResultArraySerializer: () => searchResultArraySerializer,
+  searchResultDeserializer: () => searchResultDeserializer,
+  searchResultSerializer: () => searchResultSerializer,
+  searchScoreThresholdDeserializer: () => searchScoreThresholdDeserializer,
+  searchScoreThresholdSerializer: () => searchScoreThresholdSerializer,
+  semanticDebugInfoDeserializer: () => semanticDebugInfoDeserializer,
+  singleVectorFieldResultDeserializer: () => singleVectorFieldResultDeserializer,
+  singleVectorFieldResultRecordArrayDeserializer: () => singleVectorFieldResultRecordArrayDeserializer,
+  singleVectorFieldResultRecordDeserializer: () => singleVectorFieldResultRecordDeserializer,
+  suggestDocumentsResultDeserializer: () => suggestDocumentsResultDeserializer,
+  suggestResultArrayDeserializer: () => suggestResultArrayDeserializer,
+  suggestResultArraySerializer: () => suggestResultArraySerializer,
+  suggestResultDeserializer: () => suggestResultDeserializer,
+  suggestResultSerializer: () => suggestResultSerializer,
+  textResultDeserializer: () => textResultDeserializer,
+  vectorQueryDeserializer: () => vectorQueryDeserializer,
+  vectorQuerySerializer: () => vectorQuerySerializer,
+  vectorQueryUnionArrayDeserializer: () => vectorQueryUnionArrayDeserializer,
+  vectorQueryUnionArraySerializer: () => vectorQueryUnionArraySerializer,
+  vectorQueryUnionDeserializer: () => vectorQueryUnionDeserializer,
+  vectorQueryUnionSerializer: () => vectorQueryUnionSerializer,
+  vectorSimilarityThresholdDeserializer: () => vectorSimilarityThresholdDeserializer,
+  vectorSimilarityThresholdSerializer: () => vectorSimilarityThresholdSerializer,
+  vectorThresholdDeserializer: () => vectorThresholdDeserializer,
+  vectorThresholdSerializer: () => vectorThresholdSerializer,
+  vectorThresholdUnionDeserializer: () => vectorThresholdUnionDeserializer,
+  vectorThresholdUnionSerializer: () => vectorThresholdUnionSerializer,
+  vectorizableImageBinaryQueryDeserializer: () => vectorizableImageBinaryQueryDeserializer,
+  vectorizableImageBinaryQuerySerializer: () => vectorizableImageBinaryQuerySerializer,
+  vectorizableImageUrlQueryDeserializer: () => vectorizableImageUrlQueryDeserializer,
+  vectorizableImageUrlQuerySerializer: () => vectorizableImageUrlQuerySerializer,
+  vectorizableTextQueryDeserializer: () => vectorizableTextQueryDeserializer,
+  vectorizableTextQuerySerializer: () => vectorizableTextQuerySerializer,
+  vectorizedQueryDeserializer: () => vectorizedQueryDeserializer,
+  vectorizedQuerySerializer: () => vectorizedQuerySerializer,
+  vectorsDebugInfoDeserializer: () => vectorsDebugInfoDeserializer
+});
+module.exports = __toCommonJS(models_exports);
+var import_parse_csv_collection = require("../../../../static-helpers/serialization/parse-csv-collection.js");
+var import_serialize_record = require("../../../../static-helpers/serialization/serialize-record.js");
+function errorResponseDeserializer(item) {
+  return {
+    error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"])
+  };
+}
+function errorDetailDeserializer(item) {
+  return {
+    code: item["code"],
+    message: item["message"],
+    target: item["target"],
+    details: !item["details"] ? item["details"] : errorDetailArrayDeserializer(item["details"]),
+    additionalInfo: !item["additionalInfo"] ? item["additionalInfo"] : errorAdditionalInfoArrayDeserializer(item["additionalInfo"])
+  };
+}
+function errorDetailArrayDeserializer(result) {
+  return result.map((item) => {
+    return errorDetailDeserializer(item);
+  });
+}
+function errorAdditionalInfoArrayDeserializer(result) {
+  return result.map((item) => {
+    return errorAdditionalInfoDeserializer(item);
+  });
+}
+function errorAdditionalInfoDeserializer(item) {
+  return {
+    type: item["type"],
+    info: !item["info"] ? item["info"] : Object.fromEntries(Object.entries(item["info"]).map(([k, p]) => [k, p]))
+  };
+}
+function searchDocumentsResultSerializer(_item) {
+  return {};
+}
+function searchDocumentsResultDeserializer(item) {
+  return {
+    count: item["@odata.count"],
+    coverage: item["@search.coverage"],
+    facets: !item["@search.facets"] ? item["@search.facets"] : facetResultArrayRecordDeserializer(item["@search.facets"]),
+    answers: !item["@search.answers"] ? item["@search.answers"] : queryAnswerResultArrayDeserializer(item["@search.answers"]),
+    debugInfo: !item["@search.debug"] ? item["@search.debug"] : debugInfoDeserializer(item["@search.debug"]),
+    nextPageParameters: !item["@search.nextPageParameters"] ? item["@search.nextPageParameters"] : searchRequestDeserializer(item["@search.nextPageParameters"]),
+    results: searchResultArrayDeserializer(item["value"]),
+    nextLink: item["@odata.nextLink"],
+    semanticPartialResponseReason: item["@search.semanticPartialResponseReason"],
+    semanticPartialResponseType: item["@search.semanticPartialResponseType"],
+    semanticQueryRewritesResultType: item["@search.semanticQueryRewritesResultType"]
+  };
+}
+function facetResultArrayRecordSerializer(item) {
+  const result = {};
+  Object.keys(item).map((key) => {
+    result[key] = !item[key] ? item[key] : facetResultArraySerializer(item[key]);
+  });
+  return result;
+}
+function facetResultArrayRecordDeserializer(item) {
+  const result = {};
+  Object.keys(item).map((key) => {
+    result[key] = !item[key] ? item[key] : facetResultArrayDeserializer(item[key]);
+  });
+  return result;
+}
+function facetResultArraySerializer(result) {
+  return result.map((item) => {
+    return facetResultSerializer(item);
+  });
+}
+function facetResultArrayDeserializer(result) {
+  return result.map((item) => {
+    return facetResultDeserializer(item);
+  });
+}
+function facetResultSerializer(item) {
+  return { ...(0, import_serialize_record.serializeRecord)(item.additionalProperties ?? {}) };
+}
+function facetResultDeserializer(item) {
+  return {
+    additionalProperties: (0, import_serialize_record.serializeRecord)(item, [
+      "count",
+      "avg",
+      "min",
+      "max",
+      "sum",
+      "cardinality",
+      "facets"
+    ]),
+    count: item["count"],
+    avg: item["avg"],
+    min: item["min"],
+    max: item["max"],
+    sum: item["sum"],
+    cardinality: item["cardinality"],
+    facets: !item["@search.facets"] ? item["@search.facets"] : facetResultArrayRecordDeserializer(item["@search.facets"])
+  };
+}
+function queryAnswerResultArraySerializer(result) {
+  return result.map((item) => {
+    return queryAnswerResultSerializer(item);
+  });
+}
+function queryAnswerResultArrayDeserializer(result) {
+  return result.map((item) => {
+    return queryAnswerResultDeserializer(item);
+  });
+}
+function queryAnswerResultSerializer(item) {
+  return { ...(0, import_serialize_record.serializeRecord)(item.additionalProperties ?? {}) };
+}
+function queryAnswerResultDeserializer(item) {
+  return {
+    additionalProperties: (0, import_serialize_record.serializeRecord)(item, ["score", "key", "text", "highlights"]),
+    score: item["score"],
+    key: item["key"],
+    text: item["text"],
+    highlights: item["highlights"]
+  };
+}
+function debugInfoSerializer(_item) {
+  return {};
+}
+function debugInfoDeserializer(item) {
+  return {
+    queryRewrites: !item["queryRewrites"] ? item["queryRewrites"] : queryRewritesDebugInfoDeserializer(item["queryRewrites"])
+  };
+}
+function queryRewritesDebugInfoDeserializer(item) {
+  return {
+    text: !item["text"] ? item["text"] : queryRewritesValuesDebugInfoDeserializer(item["text"]),
+    vectors: !item["vectors"] ? item["vectors"] : queryRewritesValuesDebugInfoArrayDeserializer(item["vectors"])
+  };
+}
+function queryRewritesValuesDebugInfoDeserializer(item) {
+  return {
+    inputQuery: item["inputQuery"],
+    rewrites: !item["rewrites"] ? item["rewrites"] : item["rewrites"].map((p) => {
+      return p;
+    })
+  };
+}
+function queryRewritesValuesDebugInfoArrayDeserializer(result) {
+  return result.map((item) => {
+    return queryRewritesValuesDebugInfoDeserializer(item);
+  });
+}
+function searchRequestDeserializer(item) {
+  return {
+    includeTotalCount: item["count"],
+    facets: !item["facets"] ? item["facets"] : item["facets"].map((p) => {
+      return p;
+    }),
+    filter: item["filter"],
+    highlightFields: item["highlight"] === null || item["highlight"] === void 0 ? item["highlight"] : (0, import_parse_csv_collection.parseCsvCollection)(item["highlight"]),
+    highlightPostTag: item["highlightPostTag"],
+    highlightPreTag: item["highlightPreTag"],
+    minimumCoverage: item["minimumCoverage"],
+    orderBy: item["orderby"],
+    queryType: item["queryType"],
+    scoringStatistics: item["scoringStatistics"],
+    sessionId: item["sessionId"],
+    scoringParameters: !item["scoringParameters"] ? item["scoringParameters"] : item["scoringParameters"].map((p) => {
+      return p;
+    }),
+    scoringProfile: item["scoringProfile"],
+    debug: item["debug"],
+    searchText: item["search"],
+    searchFields: item["searchFields"],
+    searchMode: item["searchMode"],
+    queryLanguage: item["queryLanguage"],
+    querySpeller: item["speller"],
+    select: item["select"],
+    skip: item["skip"],
+    top: item["top"],
+    semanticConfigurationName: item["semanticConfiguration"],
+    semanticErrorHandling: item["semanticErrorHandling"],
+    semanticMaxWaitInMilliseconds: item["semanticMaxWaitInMilliseconds"],
+    semanticQuery: item["semanticQuery"],
+    answers: item["answers"],
+    captions: item["captions"],
+    queryRewrites: item["queryRewrites"],
+    semanticFields: item["semanticFields"] === null || item["semanticFields"] === void 0 ? item["semanticFields"] : (0, import_parse_csv_collection.parseCsvCollection)(item["semanticFields"]),
+    vectorQueries: !item["vectorQueries"] ? item["vectorQueries"] : vectorQueryUnionArrayDeserializer(item["vectorQueries"]),
+    vectorFilterMode: item["vectorFilterMode"],
+    hybridSearch: !item["hybridSearch"] ? item["hybridSearch"] : hybridSearchDeserializer(item["hybridSearch"])
+  };
+}
+var KnownQueryType = /* @__PURE__ */ ((KnownQueryType2) => {
+  KnownQueryType2["Simple"] = "simple";
+  KnownQueryType2["Full"] = "full";
+  KnownQueryType2["Semantic"] = "semantic";
+  return KnownQueryType2;
+})(KnownQueryType || {});
+var KnownQueryDebugMode = /* @__PURE__ */ ((KnownQueryDebugMode2) => {
+  KnownQueryDebugMode2["Disabled"] = "disabled";
+  KnownQueryDebugMode2["Semantic"] = "semantic";
+  KnownQueryDebugMode2["Vector"] = "vector";
+  KnownQueryDebugMode2["QueryRewrites"] = "queryRewrites";
+  KnownQueryDebugMode2["InnerHits"] = "innerHits";
+  KnownQueryDebugMode2["All"] = "all";
+  return KnownQueryDebugMode2;
+})(KnownQueryDebugMode || {});
+var KnownQueryLanguage = /* @__PURE__ */ ((KnownQueryLanguage2) => {
+  KnownQueryLanguage2["None"] = "none";
+  KnownQueryLanguage2["EnUs"] = "en-us";
+  KnownQueryLanguage2["EnGb"] = "en-gb";
+  KnownQueryLanguage2["EnIn"] = "en-in";
+  KnownQueryLanguage2["EnCa"] = "en-ca";
+  KnownQueryLanguage2["EnAu"] = "en-au";
+  KnownQueryLanguage2["FrFr"] = "fr-fr";
+  KnownQueryLanguage2["FrCa"] = "fr-ca";
+  KnownQueryLanguage2["DeDe"] = "de-de";
+  KnownQueryLanguage2["EsEs"] = "es-es";
+  KnownQueryLanguage2["EsMx"] = "es-mx";
+  KnownQueryLanguage2["ZhCn"] = "zh-cn";
+  KnownQueryLanguage2["ZhTw"] = "zh-tw";
+  KnownQueryLanguage2["PtBr"] = "pt-br";
+  KnownQueryLanguage2["PtPt"] = "pt-pt";
+  KnownQueryLanguage2["ItIt"] = "it-it";
+  KnownQueryLanguage2["JaJp"] = "ja-jp";
+  KnownQueryLanguage2["KoKr"] = "ko-kr";
+  KnownQueryLanguage2["RuRu"] = "ru-ru";
+  KnownQueryLanguage2["CsCz"] = "cs-cz";
+  KnownQueryLanguage2["NlBe"] = "nl-be";
+  KnownQueryLanguage2["NlNl"] = "nl-nl";
+  KnownQueryLanguage2["HuHu"] = "hu-hu";
+  KnownQueryLanguage2["PlPl"] = "pl-pl";
+  KnownQueryLanguage2["SvSe"] = "sv-se";
+  KnownQueryLanguage2["TrTr"] = "tr-tr";
+  KnownQueryLanguage2["HiIn"] = "hi-in";
+  KnownQueryLanguage2["ArSa"] = "ar-sa";
+  KnownQueryLanguage2["ArEg"] = "ar-eg";
+  KnownQueryLanguage2["ArMa"] = "ar-ma";
+  KnownQueryLanguage2["ArKw"] = "ar-kw";
+  KnownQueryLanguage2["ArJo"] = "ar-jo";
+  KnownQueryLanguage2["DaDk"] = "da-dk";
+  KnownQueryLanguage2["NoNo"] = "no-no";
+  KnownQueryLanguage2["BgBg"] = "bg-bg";
+  KnownQueryLanguage2["HrHr"] = "hr-hr";
+  KnownQueryLanguage2["HrBa"] = "hr-ba";
+  KnownQueryLanguage2["MsMy"] = "ms-my";
+  KnownQueryLanguage2["MsBn"] = "ms-bn";
+  KnownQueryLanguage2["SlSl"] = "sl-sl";
+  KnownQueryLanguage2["TaIn"] = "ta-in";
+  KnownQueryLanguage2["ViVn"] = "vi-vn";
+  KnownQueryLanguage2["ElGr"] = "el-gr";
+  KnownQueryLanguage2["RoRo"] = "ro-ro";
+  KnownQueryLanguage2["IsIs"] = "is-is";
+  KnownQueryLanguage2["IdId"] = "id-id";
+  KnownQueryLanguage2["ThTh"] = "th-th";
+  KnownQueryLanguage2["LtLt"] = "lt-lt";
+  KnownQueryLanguage2["UkUa"] = "uk-ua";
+  KnownQueryLanguage2["LvLv"] = "lv-lv";
+  KnownQueryLanguage2["EtEe"] = "et-ee";
+  KnownQueryLanguage2["CaEs"] = "ca-es";
+  KnownQueryLanguage2["FiFi"] = "fi-fi";
+  KnownQueryLanguage2["SrBa"] = "sr-ba";
+  KnownQueryLanguage2["SrMe"] = "sr-me";
+  KnownQueryLanguage2["SrRs"] = "sr-rs";
+  KnownQueryLanguage2["SkSk"] = "sk-sk";
+  KnownQueryLanguage2["NbNo"] = "nb-no";
+  KnownQueryLanguage2["HyAm"] = "hy-am";
+  KnownQueryLanguage2["BnIn"] = "bn-in";
+  KnownQueryLanguage2["EuEs"] = "eu-es";
+  KnownQueryLanguage2["GlEs"] = "gl-es";
+  KnownQueryLanguage2["GuIn"] = "gu-in";
+  KnownQueryLanguage2["HeIl"] = "he-il";
+  KnownQueryLanguage2["GaIe"] = "ga-ie";
+  KnownQueryLanguage2["KnIn"] = "kn-in";
+  KnownQueryLanguage2["MlIn"] = "ml-in";
+  KnownQueryLanguage2["MrIn"] = "mr-in";
+  KnownQueryLanguage2["FaAe"] = "fa-ae";
+  KnownQueryLanguage2["PaIn"] = "pa-in";
+  KnownQueryLanguage2["TeIn"] = "te-in";
+  KnownQueryLanguage2["UrPk"] = "ur-pk";
+  return KnownQueryLanguage2;
+})(KnownQueryLanguage || {});
+var KnownQuerySpellerType = /* @__PURE__ */ ((KnownQuerySpellerType2) => {
+  KnownQuerySpellerType2["None"] = "none";
+  KnownQuerySpellerType2["Lexicon"] = "lexicon";
+  return KnownQuerySpellerType2;
+})(KnownQuerySpellerType || {});
+var KnownSemanticErrorMode = /* @__PURE__ */ ((KnownSemanticErrorMode2) => {
+  KnownSemanticErrorMode2["Partial"] = "partial";
+  KnownSemanticErrorMode2["Fail"] = "fail";
+  return KnownSemanticErrorMode2;
+})(KnownSemanticErrorMode || {});
+var KnownQueryAnswerType = /* @__PURE__ */ ((KnownQueryAnswerType2) => {
+  KnownQueryAnswerType2["None"] = "none";
+  KnownQueryAnswerType2["Extractive"] = "extractive";
+  return KnownQueryAnswerType2;
+})(KnownQueryAnswerType || {});
+var KnownQueryCaptionType = /* @__PURE__ */ ((KnownQueryCaptionType2) => {
+  KnownQueryCaptionType2["None"] = "none";
+  KnownQueryCaptionType2["Extractive"] = "extractive";
+  return KnownQueryCaptionType2;
+})(KnownQueryCaptionType || {});
+var KnownQueryRewritesType = /* @__PURE__ */ ((KnownQueryRewritesType2) => {
+  KnownQueryRewritesType2["None"] = "none";
+  KnownQueryRewritesType2["Generative"] = "generative";
+  return KnownQueryRewritesType2;
+})(KnownQueryRewritesType || {});
+function vectorQueryUnionArraySerializer(result) {
+  return result.map((item) => {
+    return vectorQueryUnionSerializer(item);
+  });
+}
+function vectorQueryUnionArrayDeserializer(result) {
+  return result.map((item) => {
+    return vectorQueryUnionDeserializer(item);
+  });
+}
+function vectorQuerySerializer(item) {
+  return {
+    k: item["kNearestNeighborsCount"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionSerializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"]
+  };
+}
+function vectorQueryDeserializer(item) {
+  return {
+    kNearestNeighborsCount: item["k"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionDeserializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"]
+  };
+}
+function vectorQueryUnionSerializer(item) {
+  switch (item.kind) {
+    case "vector":
+      return vectorizedQuerySerializer(item);
+    case "text":
+      return vectorizableTextQuerySerializer(item);
+    case "imageUrl":
+      return vectorizableImageUrlQuerySerializer(item);
+    case "imageBinary":
+      return vectorizableImageBinaryQuerySerializer(item);
+    default:
+      return vectorQuerySerializer(item);
+  }
+}
+function vectorQueryUnionDeserializer(item) {
+  switch (item["kind"]) {
+    case "vector":
+      return vectorizedQueryDeserializer(item);
+    case "text":
+      return vectorizableTextQueryDeserializer(item);
+    case "imageUrl":
+      return vectorizableImageUrlQueryDeserializer(item);
+    case "imageBinary":
+      return vectorizableImageBinaryQueryDeserializer(item);
+    default:
+      return vectorQueryDeserializer(item);
+  }
+}
+function vectorThresholdSerializer(item) {
+  return { kind: item["kind"] };
+}
+function vectorThresholdDeserializer(item) {
+  return {
+    kind: item["kind"]
+  };
+}
+function vectorThresholdUnionSerializer(item) {
+  switch (item.kind) {
+    case "vectorSimilarity":
+      return vectorSimilarityThresholdSerializer(item);
+    case "searchScore":
+      return searchScoreThresholdSerializer(item);
+    default:
+      return vectorThresholdSerializer(item);
+  }
+}
+function vectorThresholdUnionDeserializer(item) {
+  switch (item["kind"]) {
+    case "vectorSimilarity":
+      return vectorSimilarityThresholdDeserializer(item);
+    case "searchScore":
+      return searchScoreThresholdDeserializer(item);
+    default:
+      return vectorThresholdDeserializer(item);
+  }
+}
+var KnownVectorThresholdKind = /* @__PURE__ */ ((KnownVectorThresholdKind2) => {
+  KnownVectorThresholdKind2["VectorSimilarity"] = "vectorSimilarity";
+  KnownVectorThresholdKind2["SearchScore"] = "searchScore";
+  return KnownVectorThresholdKind2;
+})(KnownVectorThresholdKind || {});
+function vectorSimilarityThresholdSerializer(item) {
+  return { kind: item["kind"], value: item["value"] };
+}
+function vectorSimilarityThresholdDeserializer(item) {
+  return {
+    kind: item["kind"],
+    value: item["value"]
+  };
+}
+function searchScoreThresholdSerializer(item) {
+  return { kind: item["kind"], value: item["value"] };
+}
+function searchScoreThresholdDeserializer(item) {
+  return {
+    kind: item["kind"],
+    value: item["value"]
+  };
+}
+var KnownVectorQueryKind = /* @__PURE__ */ ((KnownVectorQueryKind2) => {
+  KnownVectorQueryKind2["Vector"] = "vector";
+  KnownVectorQueryKind2["Text"] = "text";
+  KnownVectorQueryKind2["ImageUrl"] = "imageUrl";
+  KnownVectorQueryKind2["ImageBinary"] = "imageBinary";
+  return KnownVectorQueryKind2;
+})(KnownVectorQueryKind || {});
+function vectorizedQuerySerializer(item) {
+  return {
+    k: item["kNearestNeighborsCount"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionSerializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"],
+    vector: item["vector"].map((p) => {
+      return p;
+    })
+  };
+}
+function vectorizedQueryDeserializer(item) {
+  return {
+    kNearestNeighborsCount: item["k"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionDeserializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"],
+    vector: item["vector"].map((p) => {
+      return p;
+    })
+  };
+}
+function vectorizableTextQuerySerializer(item) {
+  return {
+    k: item["kNearestNeighborsCount"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionSerializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"],
+    text: item["text"],
+    queryRewrites: item["queryRewrites"]
+  };
+}
+function vectorizableTextQueryDeserializer(item) {
+  return {
+    kNearestNeighborsCount: item["k"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionDeserializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"],
+    text: item["text"],
+    queryRewrites: item["queryRewrites"]
+  };
+}
+function vectorizableImageUrlQuerySerializer(item) {
+  return {
+    k: item["kNearestNeighborsCount"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionSerializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"],
+    url: item["url"]
+  };
+}
+function vectorizableImageUrlQueryDeserializer(item) {
+  return {
+    kNearestNeighborsCount: item["k"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionDeserializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"],
+    url: item["url"]
+  };
+}
+function vectorizableImageBinaryQuerySerializer(item) {
+  return {
+    k: item["kNearestNeighborsCount"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionSerializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"],
+    base64Image: item["base64Image"]
+  };
+}
+function vectorizableImageBinaryQueryDeserializer(item) {
+  return {
+    kNearestNeighborsCount: item["k"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    threshold: !item["threshold"] ? item["threshold"] : vectorThresholdUnionDeserializer(item["threshold"]),
+    filterOverride: item["filterOverride"],
+    perDocumentVectorLimit: item["perDocumentVectorLimit"],
+    kind: item["kind"],
+    base64Image: item["base64Image"]
+  };
+}
+var KnownVectorFilterMode = /* @__PURE__ */ ((KnownVectorFilterMode2) => {
+  KnownVectorFilterMode2["PostFilter"] = "postFilter";
+  KnownVectorFilterMode2["PreFilter"] = "preFilter";
+  KnownVectorFilterMode2["StrictPostFilter"] = "strictPostFilter";
+  return KnownVectorFilterMode2;
+})(KnownVectorFilterMode || {});
+function hybridSearchSerializer(item) {
+  return {
+    maxTextRecallSize: item["maxTextRecallSize"],
+    countAndFacetMode: item["countAndFacetMode"]
+  };
+}
+function hybridSearchDeserializer(item) {
+  return {
+    maxTextRecallSize: item["maxTextRecallSize"],
+    countAndFacetMode: item["countAndFacetMode"]
+  };
+}
+var KnownHybridCountAndFacetMode = /* @__PURE__ */ ((KnownHybridCountAndFacetMode2) => {
+  KnownHybridCountAndFacetMode2["CountRetrievableResults"] = "countRetrievableResults";
+  KnownHybridCountAndFacetMode2["CountAllResults"] = "countAllResults";
+  return KnownHybridCountAndFacetMode2;
+})(KnownHybridCountAndFacetMode || {});
+function searchResultArraySerializer(result) {
+  return result.map((item) => {
+    return searchResultSerializer(item);
+  });
+}
+function searchResultArrayDeserializer(result) {
+  return result.map((item) => {
+    return searchResultDeserializer(item);
+  });
+}
+function searchResultSerializer(item) {
+  return { ...(0, import_serialize_record.serializeRecord)(item.additionalProperties ?? {}) };
+}
+function searchResultDeserializer(item) {
+  return {
+    additionalProperties: (0, import_serialize_record.serializeRecord)(item, [
+      "score",
+      "rerankerScore",
+      "rerankerBoostedScore",
+      "highlights",
+      "captions",
+      "documentDebugInfo"
+    ]),
+    score: item["@search.score"],
+    rerankerScore: item["@search.rerankerScore"],
+    rerankerBoostedScore: item["@search.rerankerBoostedScore"],
+    highlights: !item["@search.highlights"] ? item["@search.highlights"] : Object.fromEntries(
+      Object.entries(item["@search.highlights"]).map(([k, p]) => [
+        k,
+        p.map((p1) => {
+          return p1;
+        })
+      ])
+    ),
+    captions: !item["@search.captions"] ? item["@search.captions"] : queryCaptionResultArrayDeserializer(item["@search.captions"]),
+    documentDebugInfo: !item["@search.documentDebugInfo"] ? item["@search.documentDebugInfo"] : documentDebugInfoDeserializer(item["@search.documentDebugInfo"])
+  };
+}
+function queryCaptionResultArrayDeserializer(result) {
+  return result.map((item) => {
+    return queryCaptionResultDeserializer(item);
+  });
+}
+function queryCaptionResultDeserializer(item) {
+  return {
+    additionalProperties: (0, import_serialize_record.serializeRecord)(item, ["text", "highlights"]),
+    text: item["text"],
+    highlights: item["highlights"]
+  };
+}
+function documentDebugInfoDeserializer(item) {
+  return {
+    semantic: !item["semantic"] ? item["semantic"] : semanticDebugInfoDeserializer(item["semantic"]),
+    vectors: !item["vectors"] ? item["vectors"] : vectorsDebugInfoDeserializer(item["vectors"]),
+    innerHits: !item["innerHits"] ? item["innerHits"] : queryResultDocumentInnerHitArrayRecordDeserializer(item["innerHits"])
+  };
+}
+function semanticDebugInfoDeserializer(item) {
+  return {
+    titleField: !item["titleField"] ? item["titleField"] : queryResultDocumentSemanticFieldDeserializer(item["titleField"]),
+    contentFields: !item["contentFields"] ? item["contentFields"] : queryResultDocumentSemanticFieldArrayDeserializer(item["contentFields"]),
+    keywordFields: !item["keywordFields"] ? item["keywordFields"] : queryResultDocumentSemanticFieldArrayDeserializer(item["keywordFields"]),
+    rerankerInput: !item["rerankerInput"] ? item["rerankerInput"] : queryResultDocumentRerankerInputDeserializer(item["rerankerInput"])
+  };
+}
+function queryResultDocumentSemanticFieldDeserializer(item) {
+  return {
+    name: item["name"],
+    state: item["state"]
+  };
+}
+var KnownSemanticFieldState = /* @__PURE__ */ ((KnownSemanticFieldState2) => {
+  KnownSemanticFieldState2["Used"] = "used";
+  KnownSemanticFieldState2["Unused"] = "unused";
+  KnownSemanticFieldState2["Partial"] = "partial";
+  return KnownSemanticFieldState2;
+})(KnownSemanticFieldState || {});
+function queryResultDocumentSemanticFieldArrayDeserializer(result) {
+  return result.map((item) => {
+    return queryResultDocumentSemanticFieldDeserializer(item);
+  });
+}
+function queryResultDocumentRerankerInputDeserializer(item) {
+  return {
+    title: item["title"],
+    content: item["content"],
+    keywords: item["keywords"]
+  };
+}
+function vectorsDebugInfoDeserializer(item) {
+  return {
+    subscores: !item["subscores"] ? item["subscores"] : queryResultDocumentSubscoresDeserializer(item["subscores"])
+  };
+}
+function queryResultDocumentSubscoresDeserializer(item) {
+  return {
+    text: !item["text"] ? item["text"] : textResultDeserializer(item["text"]),
+    vectors: !item["vectors"] ? item["vectors"] : singleVectorFieldResultRecordArrayDeserializer(item["vectors"]),
+    documentBoost: item["documentBoost"]
+  };
+}
+function textResultDeserializer(item) {
+  return {
+    searchScore: item["searchScore"]
+  };
+}
+function singleVectorFieldResultRecordArrayDeserializer(result) {
+  return result.map((item) => {
+    return singleVectorFieldResultRecordDeserializer(item);
+  });
+}
+function singleVectorFieldResultRecordDeserializer(item) {
+  const result = {};
+  Object.keys(item).map((key) => {
+    result[key] = !item[key] ? item[key] : singleVectorFieldResultDeserializer(item[key]);
+  });
+  return result;
+}
+function singleVectorFieldResultDeserializer(item) {
+  return {
+    searchScore: item["searchScore"],
+    vectorSimilarity: item["vectorSimilarity"]
+  };
+}
+function queryResultDocumentInnerHitArrayRecordDeserializer(item) {
+  const result = {};
+  Object.keys(item).map((key) => {
+    result[key] = !item[key] ? item[key] : queryResultDocumentInnerHitArrayDeserializer(item[key]);
+  });
+  return result;
+}
+function queryResultDocumentInnerHitArrayDeserializer(result) {
+  return result.map((item) => {
+    return queryResultDocumentInnerHitDeserializer(item);
+  });
+}
+function queryResultDocumentInnerHitDeserializer(item) {
+  return {
+    ordinal: item["ordinal"],
+    vectors: !item["vectors"] ? item["vectors"] : singleVectorFieldResultRecordArrayDeserializer(item["vectors"])
+  };
+}
+var KnownSemanticErrorReason = /* @__PURE__ */ ((KnownSemanticErrorReason2) => {
+  KnownSemanticErrorReason2["MaxWaitExceeded"] = "maxWaitExceeded";
+  KnownSemanticErrorReason2["CapacityOverloaded"] = "capacityOverloaded";
+  KnownSemanticErrorReason2["Transient"] = "transient";
+  return KnownSemanticErrorReason2;
+})(KnownSemanticErrorReason || {});
+var KnownSemanticSearchResultsType = /* @__PURE__ */ ((KnownSemanticSearchResultsType2) => {
+  KnownSemanticSearchResultsType2["BaseResults"] = "baseResults";
+  KnownSemanticSearchResultsType2["RerankedResults"] = "rerankedResults";
+  return KnownSemanticSearchResultsType2;
+})(KnownSemanticSearchResultsType || {});
+var KnownSemanticQueryRewritesResultType = /* @__PURE__ */ ((KnownSemanticQueryRewritesResultType2) => {
+  KnownSemanticQueryRewritesResultType2["OriginalQueryOnly"] = "originalQueryOnly";
+  return KnownSemanticQueryRewritesResultType2;
+})(KnownSemanticQueryRewritesResultType || {});
+function lookupDocumentDeserializer(item) {
+  return {
+    additionalProperties: (0, import_serialize_record.serializeRecord)(item, [])
+  };
+}
+function suggestDocumentsResultDeserializer(item) {
+  return {
+    results: suggestResultArrayDeserializer(item["value"]),
+    coverage: item["@search.coverage"]
+  };
+}
+function suggestResultArraySerializer(result) {
+  return result.map((item) => {
+    return suggestResultSerializer(item);
+  });
+}
+function suggestResultArrayDeserializer(result) {
+  return result.map((item) => {
+    return suggestResultDeserializer(item);
+  });
+}
+function suggestResultSerializer(item) {
+  return { ...(0, import_serialize_record.serializeRecord)(item.additionalProperties ?? {}) };
+}
+function suggestResultDeserializer(item) {
+  return {
+    additionalProperties: (0, import_serialize_record.serializeRecord)(item, ["text"]),
+    text: item["@search.text"]
+  };
+}
+function indexDocumentsBatchSerializer(item) {
+  return { value: indexActionArraySerializer(item["actions"]) };
+}
+function indexActionArraySerializer(result) {
+  return result.map((item) => {
+    return indexActionSerializer(item);
+  });
+}
+function indexActionSerializer(item) {
+  return {
+    ...(0, import_serialize_record.serializeRecord)(item.additionalProperties ?? {}),
+    "@search.action": item["actionType"]
+  };
+}
+function indexDocumentsResultDeserializer(item) {
+  return {
+    results: indexingResultArrayDeserializer(item["value"])
+  };
+}
+function indexingResultArraySerializer(result) {
+  return result.map((item) => {
+    return indexingResultSerializer(item);
+  });
+}
+function indexingResultArrayDeserializer(result) {
+  return result.map((item) => {
+    return indexingResultDeserializer(item);
+  });
+}
+function indexingResultSerializer(_item) {
+  return {};
+}
+function indexingResultDeserializer(item) {
+  return {
+    key: item["key"],
+    errorMessage: item["errorMessage"],
+    succeeded: item["status"],
+    statusCode: item["statusCode"]
+  };
+}
+function autocompleteResultDeserializer(item) {
+  return {
+    coverage: item["@search.coverage"],
+    results: autocompleteItemArrayDeserializer(item["value"])
+  };
+}
+function autocompleteItemArraySerializer(result) {
+  return result.map((item) => {
+    return autocompleteItemSerializer(item);
+  });
+}
+function autocompleteItemArrayDeserializer(result) {
+  return result.map((item) => {
+    return autocompleteItemDeserializer(item);
+  });
+}
+function autocompleteItemSerializer(_item) {
+  return {};
+}
+function autocompleteItemDeserializer(item) {
+  return {
+    text: item["text"],
+    queryPlusText: item["queryPlusText"]
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KnownHybridCountAndFacetMode,
+  KnownQueryAnswerType,
+  KnownQueryCaptionType,
+  KnownQueryDebugMode,
+  KnownQueryLanguage,
+  KnownQueryRewritesType,
+  KnownQuerySpellerType,
+  KnownQueryType,
+  KnownSemanticErrorMode,
+  KnownSemanticErrorReason,
+  KnownSemanticFieldState,
+  KnownSemanticQueryRewritesResultType,
+  KnownSemanticSearchResultsType,
+  KnownVectorFilterMode,
+  KnownVectorQueryKind,
+  KnownVectorThresholdKind,
+  autocompleteItemArrayDeserializer,
+  autocompleteItemArraySerializer,
+  autocompleteItemDeserializer,
+  autocompleteItemSerializer,
+  autocompleteResultDeserializer,
+  debugInfoDeserializer,
+  debugInfoSerializer,
+  documentDebugInfoDeserializer,
+  errorAdditionalInfoArrayDeserializer,
+  errorAdditionalInfoDeserializer,
+  errorDetailArrayDeserializer,
+  errorDetailDeserializer,
+  errorResponseDeserializer,
+  facetResultArrayDeserializer,
+  facetResultArrayRecordDeserializer,
+  facetResultArrayRecordSerializer,
+  facetResultArraySerializer,
+  facetResultDeserializer,
+  facetResultSerializer,
+  hybridSearchDeserializer,
+  hybridSearchSerializer,
+  indexActionArraySerializer,
+  indexActionSerializer,
+  indexDocumentsBatchSerializer,
+  indexDocumentsResultDeserializer,
+  indexingResultArrayDeserializer,
+  indexingResultArraySerializer,
+  indexingResultDeserializer,
+  indexingResultSerializer,
+  lookupDocumentDeserializer,
+  queryAnswerResultArrayDeserializer,
+  queryAnswerResultArraySerializer,
+  queryAnswerResultDeserializer,
+  queryAnswerResultSerializer,
+  queryCaptionResultArrayDeserializer,
+  queryCaptionResultDeserializer,
+  queryResultDocumentInnerHitArrayDeserializer,
+  queryResultDocumentInnerHitArrayRecordDeserializer,
+  queryResultDocumentInnerHitDeserializer,
+  queryResultDocumentRerankerInputDeserializer,
+  queryResultDocumentSemanticFieldArrayDeserializer,
+  queryResultDocumentSemanticFieldDeserializer,
+  queryResultDocumentSubscoresDeserializer,
+  queryRewritesDebugInfoDeserializer,
+  queryRewritesValuesDebugInfoArrayDeserializer,
+  queryRewritesValuesDebugInfoDeserializer,
+  searchDocumentsResultDeserializer,
+  searchDocumentsResultSerializer,
+  searchRequestDeserializer,
+  searchResultArrayDeserializer,
+  searchResultArraySerializer,
+  searchResultDeserializer,
+  searchResultSerializer,
+  searchScoreThresholdDeserializer,
+  searchScoreThresholdSerializer,
+  semanticDebugInfoDeserializer,
+  singleVectorFieldResultDeserializer,
+  singleVectorFieldResultRecordArrayDeserializer,
+  singleVectorFieldResultRecordDeserializer,
+  suggestDocumentsResultDeserializer,
+  suggestResultArrayDeserializer,
+  suggestResultArraySerializer,
+  suggestResultDeserializer,
+  suggestResultSerializer,
+  textResultDeserializer,
+  vectorQueryDeserializer,
+  vectorQuerySerializer,
+  vectorQueryUnionArrayDeserializer,
+  vectorQueryUnionArraySerializer,
+  vectorQueryUnionDeserializer,
+  vectorQueryUnionSerializer,
+  vectorSimilarityThresholdDeserializer,
+  vectorSimilarityThresholdSerializer,
+  vectorThresholdDeserializer,
+  vectorThresholdSerializer,
+  vectorThresholdUnionDeserializer,
+  vectorThresholdUnionSerializer,
+  vectorizableImageBinaryQueryDeserializer,
+  vectorizableImageBinaryQuerySerializer,
+  vectorizableImageUrlQueryDeserializer,
+  vectorizableImageUrlQuerySerializer,
+  vectorizableTextQueryDeserializer,
+  vectorizableTextQuerySerializer,
+  vectorizedQueryDeserializer,
+  vectorizedQuerySerializer,
+  vectorsDebugInfoDeserializer
+});
+//# sourceMappingURL=models.js.map