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

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

@@ -0,0 +1,699 @@
+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, {
+  KnownQueryAnswerType: () => KnownQueryAnswerType,
+  KnownQueryCaptionType: () => KnownQueryCaptionType,
+  KnownQueryDebugMode: () => KnownQueryDebugMode,
+  KnownQueryType: () => KnownQueryType,
+  KnownSemanticErrorMode: () => KnownSemanticErrorMode,
+  KnownSemanticErrorReason: () => KnownSemanticErrorReason,
+  KnownSemanticSearchResultsType: () => KnownSemanticSearchResultsType,
+  KnownVectorFilterMode: () => KnownVectorFilterMode,
+  KnownVectorQueryKind: () => KnownVectorQueryKind,
+  autocompleteItemArrayDeserializer: () => autocompleteItemArrayDeserializer,
+  autocompleteItemArraySerializer: () => autocompleteItemArraySerializer,
+  autocompleteItemDeserializer: () => autocompleteItemDeserializer,
+  autocompleteItemSerializer: () => autocompleteItemSerializer,
+  autocompleteResultDeserializer: () => autocompleteResultDeserializer,
+  documentDebugInfoDeserializer: () => documentDebugInfoDeserializer,
+  errorAdditionalInfoArrayDeserializer: () => errorAdditionalInfoArrayDeserializer,
+  errorAdditionalInfoDeserializer: () => errorAdditionalInfoDeserializer,
+  errorDetailArrayDeserializer: () => errorDetailArrayDeserializer,
+  errorDetailDeserializer: () => errorDetailDeserializer,
+  errorResponseDeserializer: () => errorResponseDeserializer,
+  facetResultArrayDeserializer: () => facetResultArrayDeserializer,
+  facetResultArrayRecordDeserializer: () => facetResultArrayRecordDeserializer,
+  facetResultArrayRecordSerializer: () => facetResultArrayRecordSerializer,
+  facetResultArraySerializer: () => facetResultArraySerializer,
+  facetResultDeserializer: () => facetResultDeserializer,
+  facetResultSerializer: () => facetResultSerializer,
+  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,
+  queryResultDocumentSubscoresDeserializer: () => queryResultDocumentSubscoresDeserializer,
+  searchDocumentsResultDeserializer: () => searchDocumentsResultDeserializer,
+  searchDocumentsResultSerializer: () => searchDocumentsResultSerializer,
+  searchRequestDeserializer: () => searchRequestDeserializer,
+  searchResultArrayDeserializer: () => searchResultArrayDeserializer,
+  searchResultArraySerializer: () => searchResultArraySerializer,
+  searchResultDeserializer: () => searchResultDeserializer,
+  searchResultSerializer: () => searchResultSerializer,
+  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,
+  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 item;
+}
+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"]),
+    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"]
+  };
+}
+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"]),
+    count: item["count"]
+  };
+}
+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 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"],
+    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"],
+    vectorQueries: !item["vectorQueries"] ? item["vectorQueries"] : vectorQueryUnionArrayDeserializer(item["vectorQueries"]),
+    vectorFilterMode: item["vectorFilterMode"]
+  };
+}
+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 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 || {});
+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"],
+    kind: item["kind"]
+  };
+}
+function vectorQueryDeserializer(item) {
+  return {
+    kNearestNeighborsCount: item["k"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    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);
+  }
+}
+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"],
+    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"],
+    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"],
+    kind: item["kind"],
+    text: item["text"]
+  };
+}
+function vectorizableTextQueryDeserializer(item) {
+  return {
+    kNearestNeighborsCount: item["k"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    kind: item["kind"],
+    text: item["text"]
+  };
+}
+function vectorizableImageUrlQuerySerializer(item) {
+  return {
+    k: item["kNearestNeighborsCount"],
+    fields: item["fields"],
+    exhaustive: item["exhaustive"],
+    oversampling: item["oversampling"],
+    weight: item["weight"],
+    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"],
+    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"],
+    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"],
+    kind: item["kind"],
+    base64Image: item["base64Image"]
+  };
+}
+var KnownVectorFilterMode = /* @__PURE__ */ ((KnownVectorFilterMode2) => {
+  KnownVectorFilterMode2["PostFilter"] = "postFilter";
+  KnownVectorFilterMode2["PreFilter"] = "preFilter";
+  KnownVectorFilterMode2["StrictPostFilter"] = "strictPostFilter";
+  return KnownVectorFilterMode2;
+})(KnownVectorFilterMode || {});
+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 {
+    vectors: !item["vectors"] ? item["vectors"] : vectorsDebugInfoDeserializer(item["vectors"])
+  };
+}
+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"]
+  };
+}
+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 || {});
+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 item;
+}
+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 item;
+}
+function autocompleteItemDeserializer(item) {
+  return {
+    text: item["text"],
+    queryPlusText: item["queryPlusText"]
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KnownQueryAnswerType,
+  KnownQueryCaptionType,
+  KnownQueryDebugMode,
+  KnownQueryType,
+  KnownSemanticErrorMode,
+  KnownSemanticErrorReason,
+  KnownSemanticSearchResultsType,
+  KnownVectorFilterMode,
+  KnownVectorQueryKind,
+  autocompleteItemArrayDeserializer,
+  autocompleteItemArraySerializer,
+  autocompleteItemDeserializer,
+  autocompleteItemSerializer,
+  autocompleteResultDeserializer,
+  documentDebugInfoDeserializer,
+  errorAdditionalInfoArrayDeserializer,
+  errorAdditionalInfoDeserializer,
+  errorDetailArrayDeserializer,
+  errorDetailDeserializer,
+  errorResponseDeserializer,
+  facetResultArrayDeserializer,
+  facetResultArrayRecordDeserializer,
+  facetResultArrayRecordSerializer,
+  facetResultArraySerializer,
+  facetResultDeserializer,
+  facetResultSerializer,
+  indexActionArraySerializer,
+  indexActionSerializer,
+  indexDocumentsBatchSerializer,
+  indexDocumentsResultDeserializer,
+  indexingResultArrayDeserializer,
+  indexingResultArraySerializer,
+  indexingResultDeserializer,
+  indexingResultSerializer,
+  lookupDocumentDeserializer,
+  queryAnswerResultArrayDeserializer,
+  queryAnswerResultArraySerializer,
+  queryAnswerResultDeserializer,
+  queryAnswerResultSerializer,
+  queryCaptionResultArrayDeserializer,
+  queryCaptionResultDeserializer,
+  queryResultDocumentSubscoresDeserializer,
+  searchDocumentsResultDeserializer,
+  searchDocumentsResultSerializer,
+  searchRequestDeserializer,
+  searchResultArrayDeserializer,
+  searchResultArraySerializer,
+  searchResultDeserializer,
+  searchResultSerializer,
+  singleVectorFieldResultDeserializer,
+  singleVectorFieldResultRecordArrayDeserializer,
+  singleVectorFieldResultRecordDeserializer,
+  suggestDocumentsResultDeserializer,
+  suggestResultArrayDeserializer,
+  suggestResultArraySerializer,
+  suggestResultDeserializer,
+  suggestResultSerializer,
+  textResultDeserializer,
+  vectorQueryDeserializer,
+  vectorQuerySerializer,
+  vectorQueryUnionArrayDeserializer,
+  vectorQueryUnionArraySerializer,
+  vectorQueryUnionDeserializer,
+  vectorQueryUnionSerializer,
+  vectorizableImageBinaryQueryDeserializer,
+  vectorizableImageBinaryQuerySerializer,
+  vectorizableImageUrlQueryDeserializer,
+  vectorizableImageUrlQuerySerializer,
+  vectorizableTextQueryDeserializer,
+  vectorizableTextQuerySerializer,
+  vectorizedQueryDeserializer,
+  vectorizedQuerySerializer,
+  vectorsDebugInfoDeserializer
+});
+//# sourceMappingURL=models.js.map