@azure/ai-projects 2.0.1 → 2.0.2

package/dist/esm/api/beta/memoryStores/operations.js

@@ -1,415 +1,346 @@
-import {
-  memorySearchOptionsSerializer,
-  apiErrorResponseDeserializer,
-  memoryStoreDefinitionUnionSerializer,
-  memoryStoreDeserializer,
-  _agentsPagedResultMemoryStoreObjectDeserializer,
-  deleteMemoryStoreResponseDeserializer,
-  memoryStoreSearchResponseDeserializer,
-  memoryStoreUpdateResponseDeserializer,
-  memoryStoreUpdateCompletedResultDeserializer,
-  memoryStoreDeleteScopeResponseDeserializer
-} from "../../../models/models.js";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { memorySearchOptionsSerializer, apiErrorResponseDeserializer, memoryStoreDefinitionUnionSerializer, memoryStoreDeserializer, _agentsPagedResultMemoryStoreObjectDeserializer, deleteMemoryStoreResponseDeserializer, memoryStoreSearchResponseDeserializer, memoryStoreUpdateResponseDeserializer, memoryStoreUpdateCompletedResultDeserializer, memoryStoreDeleteScopeResponseDeserializer, } from "../../../models/models.js";
 import { buildPagedAsyncIterator } from "../../../static-helpers/pagingHelpers.js";
 import { getLongRunningPoller } from "../../../static-helpers/pollingHelpers.js";
 import { expandUrlTemplate } from "../../../static-helpers/urlTemplate.js";
 import { createRestError, operationOptionsToRequestParameters } from "@azure-rest/core-client";
-function _deleteScopeSend(context, name, scope, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores/{name}:delete_scope{?api-version}",
-    {
-      name,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export function _deleteScopeSend(context, name, scope, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores/{name}:delete_scope{?api-version}", {
+        name: name,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: { scope: scope },
+    });
+}
+export async function _deleteScopeDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  );
-  return context.path(path).post({
-    ...operationOptionsToRequestParameters(options),
-    contentType: "application/json",
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    },
-    body: { scope }
-  });
+    return memoryStoreDeleteScopeResponseDeserializer(result.body);
 }
-async function _deleteScopeDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  return memoryStoreDeleteScopeResponseDeserializer(result.body);
+/** Delete all memories associated with a specific scope from a memory store. */
+export async function deleteScope(context, name, scope, options = { requestOptions: {} }) {
+    const result = await _deleteScopeSend(context, name, scope, options);
+    return _deleteScopeDeserialize(result);
 }
-async function deleteScope(context, name, scope, options = { requestOptions: {} }) {
-  const result = await _deleteScopeSend(context, name, scope, options);
-  return _deleteScopeDeserialize(result);
+export function _getUpdateResultSend(context, name, updateId, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores/{name}/updates/{update_id}{?api-version}", {
+        name: name,
+        update_id: updateId,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
 }
-function _getUpdateResultSend(context, name, updateId, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores/{name}/updates/{update_id}{?api-version}",
-    {
-      name,
-      update_id: updateId,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _getUpdateResultDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  );
-  return context.path(path).get({
-    ...operationOptionsToRequestParameters(options),
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    }
-  });
+    return memoryStoreUpdateResponseDeserializer(result.body);
 }
-async function _getUpdateResultDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  return memoryStoreUpdateResponseDeserializer(result.body);
+/** Get memory store update result. */
+export async function getUpdateResult(context, name, updateId, options = { requestOptions: {} }) {
+    const result = await _getUpdateResultSend(context, name, updateId, options);
+    return _getUpdateResultDeserialize(result);
 }
-async function getUpdateResult(context, name, updateId, options = { requestOptions: {} }) {
-  const result = await _getUpdateResultSend(context, name, updateId, options);
-  return _getUpdateResultDeserialize(result);
+export function _updateMemoriesSend(context, name, scope, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores/{name}:update_memories{?api-version}", {
+        name: name,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: {
+            scope: scope,
+            items: options?.items,
+            previous_update_id: options?.previousUpdateId,
+            update_delay: options?.updateDelayInSecs,
+        },
+    });
 }
-function _updateMemoriesSend(context, name, scope, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores/{name}:update_memories{?api-version}",
-    {
-      name,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _updateMemoriesDeserialize(result) {
+    const expectedStatuses = ["202", "200", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  );
-  return context.path(path).post({
-    ...operationOptionsToRequestParameters(options),
-    contentType: "application/json",
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    },
-    body: {
-      scope,
-      items: options?.items,
-      previous_update_id: options?.previousUpdateId,
-      update_delay: options?.updateDelayInSecs
+    if (result?.body?.result === undefined) {
+        throw createRestError(`Expected a result in the response at position "result.body.result"`, result);
     }
-  });
+    return memoryStoreUpdateCompletedResultDeserializer(result.body.result);
 }
-async function _updateMemoriesDeserialize(result) {
-  const expectedStatuses = ["202", "200", "201"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  if (result?.body?.result === void 0) {
-    throw createRestError(
-      `Expected a result in the response at position "result.body.result"`,
-      result
-    );
-  }
-  return memoryStoreUpdateCompletedResultDeserializer(result.body.result);
+/** Update memory store with conversation memories. */
+export function updateMemories(context, name, scope, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _updateMemoriesDeserialize, ["202", "200", "201"], {
+        updateIntervalInMs: options?.updateIntervalInMs,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _updateMemoriesSend(context, name, scope, options),
+        apiVersion: context.apiVersion,
+        pollHeaders: {
+            ...options?.requestOptions?.headers,
+            "foundry-features": "MemoryStores=V1Preview",
+        },
+        statusNormalizations: {
+            queued: "running",
+            in_progress: "running",
+            completed: "succeeded",
+            failed: "failed",
+            superseded: "canceled",
+        },
+    });
 }
-function updateMemories(context, name, scope, options = { requestOptions: {} }) {
-  return getLongRunningPoller(context, _updateMemoriesDeserialize, ["202", "200", "201"], {
-    updateIntervalInMs: options?.updateIntervalInMs,
-    abortSignal: options?.abortSignal,
-    getInitialResponse: () => _updateMemoriesSend(context, name, scope, options),
-    apiVersion: context.apiVersion,
-    pollHeaders: {
-      ...options?.requestOptions?.headers,
-      "foundry-features": "MemoryStores=V1Preview"
-    },
-    statusNormalizations: {
-      queued: "running",
-      in_progress: "running",
-      completed: "succeeded",
-      failed: "failed",
-      superseded: "canceled"
-    }
-  });
+export function _searchMemoriesSend(context, name, scope, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores/{name}:search_memories{?api-version}", {
+        name: name,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: {
+            scope: scope,
+            items: !options?.items
+                ? options?.items
+                : options?.items.map((p) => {
+                    return p;
+                }),
+            previous_search_id: options?.previousSearchId,
+            options: !options?.options
+                ? options?.options
+                : memorySearchOptionsSerializer(options?.options),
+        },
+    });
 }
-function _searchMemoriesSend(context, name, scope, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores/{name}:search_memories{?api-version}",
-    {
-      name,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _searchMemoriesDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  );
-  return context.path(path).post({
-    ...operationOptionsToRequestParameters(options),
-    contentType: "application/json",
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    },
-    body: {
-      scope,
-      items: !options?.items ? options?.items : options?.items.map((p) => {
-        return p;
-      }),
-      previous_search_id: options?.previousSearchId,
-      options: !options?.options ? options?.options : memorySearchOptionsSerializer(options?.options)
-    }
-  });
+    return memoryStoreSearchResponseDeserializer(result.body);
 }
-async function _searchMemoriesDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  return memoryStoreSearchResponseDeserializer(result.body);
+/** Search for relevant memories from a memory store based on conversation context. */
+export async function searchMemories(context, name, scope, options = { requestOptions: {} }) {
+    const result = await _searchMemoriesSend(context, name, scope, options);
+    return _searchMemoriesDeserialize(result);
 }
-async function searchMemories(context, name, scope, options = { requestOptions: {} }) {
-  const result = await _searchMemoriesSend(context, name, scope, options);
-  return _searchMemoriesDeserialize(result);
+export function _deleteSend(context, name, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores/{name}{?api-version}", {
+        name: name,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).delete({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
 }
-function _deleteSend(context, name, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores/{name}{?api-version}",
-    {
-      name,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _deleteDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  );
-  return context.path(path).delete({
-    ...operationOptionsToRequestParameters(options),
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    }
-  });
+    return deleteMemoryStoreResponseDeserializer(result.body);
 }
-async function _deleteDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  return deleteMemoryStoreResponseDeserializer(result.body);
+/** Delete a memory store. */
+export async function $delete(context, name, options = { requestOptions: {} }) {
+    const result = await _deleteSend(context, name, options);
+    return _deleteDeserialize(result);
 }
-async function $delete(context, name, options = { requestOptions: {} }) {
-  const result = await _deleteSend(context, name, options);
-  return _deleteDeserialize(result);
+export function _listSend(context, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores{?limit,order,after,before,api-version}", {
+        limit: options?.limit,
+        order: options?.order,
+        after: options?.after,
+        before: options?.before,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
 }
-function _listSend(context, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores{?limit,order,after,before,api-version}",
-    {
-      limit: options?.limit,
-      order: options?.order,
-      after: options?.after,
-      before: options?.before,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
-    }
-  );
-  return context.path(path).get({
-    ...operationOptionsToRequestParameters(options),
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
+export async function _listDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  });
+    return _agentsPagedResultMemoryStoreObjectDeserializer(result.body);
 }
-async function _listDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  return _agentsPagedResultMemoryStoreObjectDeserializer(result.body);
+/** List all memory stores. */
+export function list(context, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listSend(context, options), _listDeserialize, ["200"], {
+        itemName: "data",
+        apiVersion: context.apiVersion,
+        nextPageRequestOptions: {
+            headers: {
+                "foundry-features": "MemoryStores=V1Preview",
+            },
+        },
+    });
 }
-function list(context, options = { requestOptions: {} }) {
-  return buildPagedAsyncIterator(
-    context,
-    () => _listSend(context, options),
-    _listDeserialize,
-    ["200"],
-    {
-      itemName: "data",
-      apiVersion: context.apiVersion,
-      nextPageRequestOptions: {
+export function _getSend(context, name, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores/{name}{?api-version}", {
+        name: name,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
         headers: {
-          "foundry-features": "MemoryStores=V1Preview"
-        }
-      }
-    }
-  );
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
 }
-function _getSend(context, name, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores/{name}{?api-version}",
-    {
-      name,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
-    }
-  );
-  return context.path(path).get({
-    ...operationOptionsToRequestParameters(options),
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
+export async function _getDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  });
+    return memoryStoreDeserializer(result.body);
 }
-async function _getDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  return memoryStoreDeserializer(result.body);
+/** Retrieve a memory store. */
+export async function get(context, name, options = { requestOptions: {} }) {
+    const result = await _getSend(context, name, options);
+    return _getDeserialize(result);
 }
-async function get(context, name, options = { requestOptions: {} }) {
-  const result = await _getSend(context, name, options);
-  return _getDeserialize(result);
+export function _updateSend(context, name, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores/{name}{?api-version}", {
+        name: name,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: { description: options?.description, metadata: options?.metadata },
+    });
 }
-function _updateSend(context, name, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores/{name}{?api-version}",
-    {
-      name,
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _updateDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  );
-  return context.path(path).post({
-    ...operationOptionsToRequestParameters(options),
-    contentType: "application/json",
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    },
-    body: { description: options?.description, metadata: options?.metadata }
-  });
+    return memoryStoreDeserializer(result.body);
 }
-async function _updateDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  return memoryStoreDeserializer(result.body);
+/** Update a memory store. */
+export async function update(context, name, options = { requestOptions: {} }) {
+    const result = await _updateSend(context, name, options);
+    return _updateDeserialize(result);
 }
-async function update(context, name, options = { requestOptions: {} }) {
-  const result = await _updateSend(context, name, options);
-  return _updateDeserialize(result);
+export function _createSend(context, name, definition, options = { requestOptions: {} }) {
+    const foundryFeatures = "MemoryStores=V1Preview";
+    const path = expandUrlTemplate("/memory_stores{?api-version}", {
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            "foundry-features": foundryFeatures,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: {
+            name: name,
+            description: options?.description,
+            metadata: options?.metadata,
+            definition: memoryStoreDefinitionUnionSerializer(definition),
+        },
+    });
 }
-function _createSend(context, name, definition, options = { requestOptions: {} }) {
-  const foundryFeatures = "MemoryStores=V1Preview";
-  const path = expandUrlTemplate(
-    "/memory_stores{?api-version}",
-    {
-      "api-version": context.apiVersion
-    },
-    {
-      allowReserved: options?.requestOptions?.skipUrlEncoding
+export async function _createDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        error.details = apiErrorResponseDeserializer(result.body);
+        throw error;
     }
-  );
-  return context.path(path).post({
-    ...operationOptionsToRequestParameters(options),
-    contentType: "application/json",
-    headers: {
-      "foundry-features": foundryFeatures,
-      accept: "application/json",
-      ...options.requestOptions?.headers
-    },
-    body: {
-      name,
-      description: options?.description,
-      metadata: options?.metadata,
-      definition: memoryStoreDefinitionUnionSerializer(definition)
-    }
-  });
-}
-async function _createDeserialize(result) {
-  const expectedStatuses = ["200"];
-  if (!expectedStatuses.includes(result.status)) {
-    const error = createRestError(result);
-    error.details = apiErrorResponseDeserializer(result.body);
-    throw error;
-  }
-  return memoryStoreDeserializer(result.body);
+    return memoryStoreDeserializer(result.body);
 }
-async function create(context, name, definition, options = { requestOptions: {} }) {
-  const result = await _createSend(context, name, definition, options);
-  return _createDeserialize(result);
+/** Create a memory store. */
+export async function create(context, name, definition, options = { requestOptions: {} }) {
+    const result = await _createSend(context, name, definition, options);
+    return _createDeserialize(result);
 }
-export {
-  $delete,
-  _createDeserialize,
-  _createSend,
-  _deleteDeserialize,
-  _deleteScopeDeserialize,
-  _deleteScopeSend,
-  _deleteSend,
-  _getDeserialize,
-  _getSend,
-  _getUpdateResultDeserialize,
-  _getUpdateResultSend,
-  _listDeserialize,
-  _listSend,
-  _searchMemoriesDeserialize,
-  _searchMemoriesSend,
-  _updateDeserialize,
-  _updateMemoriesDeserialize,
-  _updateMemoriesSend,
-  _updateSend,
-  create,
-  deleteScope,
-  get,
-  getUpdateResult,
-  list,
-  searchMemories,
-  update,
-  updateMemories
-};
+//# sourceMappingURL=operations.js.map