@azure/arm-containerservice 24.2.0-beta.1 → 25.0.0

package/dist/esm/api/managedClusters/operations.js

@@ -0,0 +1,1069 @@
+import {
+  errorResponseDeserializer,
+  managedClusterSerializer,
+  managedClusterDeserializer,
+  managedClusterServicePrincipalProfileSerializer,
+  managedClusterAADProfileSerializer,
+  tagsObjectSerializer,
+  _managedClusterListResultDeserializer,
+  managedClusterAccessProfileDeserializer,
+  credentialResultsDeserializer,
+  runCommandRequestSerializer,
+  runCommandResultDeserializer,
+  _outboundEnvironmentEndpointCollectionDeserializer,
+  managedClusterUpgradeProfileDeserializer,
+  meshRevisionProfileDeserializer,
+  _meshRevisionProfileListDeserializer,
+  meshUpgradeProfileDeserializer,
+  _meshUpgradeProfileListDeserializer,
+  kubernetesVersionListResultDeserializer
+} 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 _listKubernetesVersionsSend(context, location, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.ContainerService/locations/{location}/kubernetesVersions{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      location,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listKubernetesVersionsDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return kubernetesVersionListResultDeserializer(result.body);
+}
+async function listKubernetesVersions(context, location, options = { requestOptions: {} }) {
+  const result = await _listKubernetesVersionsSend(context, location, options);
+  return _listKubernetesVersionsDeserialize(result);
+}
+function _listMeshUpgradeProfilesSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/meshUpgradeProfiles{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listMeshUpgradeProfilesDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return _meshUpgradeProfileListDeserializer(result.body);
+}
+function listMeshUpgradeProfiles(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  return buildPagedAsyncIterator(
+    context,
+    () => _listMeshUpgradeProfilesSend(context, resourceGroupName, resourceName, options),
+    _listMeshUpgradeProfilesDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2026-01-01" }
+  );
+}
+function _getMeshUpgradeProfileSend(context, resourceGroupName, resourceName, mode, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/meshUpgradeProfiles/{mode}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      mode,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getMeshUpgradeProfileDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return meshUpgradeProfileDeserializer(result.body);
+}
+async function getMeshUpgradeProfile(context, resourceGroupName, resourceName, mode, options = { requestOptions: {} }) {
+  const result = await _getMeshUpgradeProfileSend(
+    context,
+    resourceGroupName,
+    resourceName,
+    mode,
+    options
+  );
+  return _getMeshUpgradeProfileDeserialize(result);
+}
+function _listMeshRevisionProfilesSend(context, location, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.ContainerService/locations/{location}/meshRevisionProfiles{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      location,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listMeshRevisionProfilesDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return _meshRevisionProfileListDeserializer(result.body);
+}
+function listMeshRevisionProfiles(context, location, options = { requestOptions: {} }) {
+  return buildPagedAsyncIterator(
+    context,
+    () => _listMeshRevisionProfilesSend(context, location, options),
+    _listMeshRevisionProfilesDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2026-01-01" }
+  );
+}
+function _getMeshRevisionProfileSend(context, location, mode, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.ContainerService/locations/{location}/meshRevisionProfiles/{mode}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      location,
+      mode,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getMeshRevisionProfileDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return meshRevisionProfileDeserializer(result.body);
+}
+async function getMeshRevisionProfile(context, location, mode, options = { requestOptions: {} }) {
+  const result = await _getMeshRevisionProfileSend(context, location, mode, options);
+  return _getMeshRevisionProfileDeserialize(result);
+}
+function _getUpgradeProfileSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/upgradeProfiles/default{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getUpgradeProfileDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return managedClusterUpgradeProfileDeserializer(result.body);
+}
+async function getUpgradeProfile(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const result = await _getUpgradeProfileSend(context, resourceGroupName, resourceName, options);
+  return _getUpgradeProfileDeserialize(result);
+}
+function _listOutboundNetworkDependenciesEndpointsSend(context, resourceGroupName, resourceName, options = {
+  requestOptions: {}
+}) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/outboundNetworkDependenciesEndpoints{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listOutboundNetworkDependenciesEndpointsDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return _outboundEnvironmentEndpointCollectionDeserializer(result.body);
+}
+function listOutboundNetworkDependenciesEndpoints(context, resourceGroupName, resourceName, options = {
+  requestOptions: {}
+}) {
+  return buildPagedAsyncIterator(
+    context,
+    () => _listOutboundNetworkDependenciesEndpointsSend(
+      context,
+      resourceGroupName,
+      resourceName,
+      options
+    ),
+    _listOutboundNetworkDependenciesEndpointsDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2026-01-01" }
+  );
+}
+function _getCommandResultSend(context, resourceGroupName, resourceName, commandId, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/commandResults/{commandId}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      commandId,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getCommandResultDeserialize(result) {
+  const expectedStatuses = ["200", "202"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return runCommandResultDeserializer(result.body);
+}
+async function getCommandResult(context, resourceGroupName, resourceName, commandId, options = { requestOptions: {} }) {
+  const result = await _getCommandResultSend(
+    context,
+    resourceGroupName,
+    resourceName,
+    commandId,
+    options
+  );
+  return _getCommandResultDeserialize(result);
+}
+function _runCommandSend(context, resourceGroupName, resourceName, requestPayload, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/runCommand{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: runCommandRequestSerializer(requestPayload)
+  });
+}
+async function _runCommandDeserialize(result) {
+  const expectedStatuses = ["202", "200", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return runCommandResultDeserializer(result.body);
+}
+function runCommand(context, resourceGroupName, resourceName, requestPayload, options = { requestOptions: {} }) {
+  return getLongRunningPoller(context, _runCommandDeserialize, ["202", "200", "201"], {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _runCommandSend(context, resourceGroupName, resourceName, requestPayload, options),
+    resourceLocationConfig: "location",
+    apiVersion: context.apiVersion ?? "2026-01-01"
+  });
+}
+function _startSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/start{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+async function _startDeserialize(result) {
+  const expectedStatuses = ["202", "204", "200", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return;
+}
+function start(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  return getLongRunningPoller(context, _startDeserialize, ["202", "204", "200", "201"], {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _startSend(context, resourceGroupName, resourceName, options),
+    resourceLocationConfig: "location",
+    apiVersion: context.apiVersion ?? "2026-01-01"
+  });
+}
+function _stopSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/stop{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+async function _stopDeserialize(result) {
+  const expectedStatuses = ["202", "204", "200", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return;
+}
+function stop(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  return getLongRunningPoller(context, _stopDeserialize, ["202", "204", "200", "201"], {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _stopSend(context, resourceGroupName, resourceName, options),
+    resourceLocationConfig: "location",
+    apiVersion: context.apiVersion ?? "2026-01-01"
+  });
+}
+function _rotateServiceAccountSigningKeysSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/rotateServiceAccountSigningKeys{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+async function _rotateServiceAccountSigningKeysDeserialize(result) {
+  const expectedStatuses = ["202", "204", "200", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return;
+}
+function rotateServiceAccountSigningKeys(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  return getLongRunningPoller(
+    context,
+    _rotateServiceAccountSigningKeysDeserialize,
+    ["202", "204", "200", "201"],
+    {
+      updateIntervalInMs: options?.updateIntervalInMs,
+      abortSignal: options?.abortSignal,
+      getInitialResponse: () => _rotateServiceAccountSigningKeysSend(context, resourceGroupName, resourceName, options),
+      resourceLocationConfig: "location",
+      apiVersion: context.apiVersion ?? "2026-01-01"
+    }
+  );
+}
+function _abortLatestOperationSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/abort{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+async function _abortLatestOperationDeserialize(result) {
+  const expectedStatuses = ["202", "204", "200", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return;
+}
+function abortLatestOperation(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  return getLongRunningPoller(
+    context,
+    _abortLatestOperationDeserialize,
+    ["202", "204", "200", "201"],
+    {
+      updateIntervalInMs: options?.updateIntervalInMs,
+      abortSignal: options?.abortSignal,
+      getInitialResponse: () => _abortLatestOperationSend(context, resourceGroupName, resourceName, options),
+      resourceLocationConfig: "location",
+      apiVersion: context.apiVersion ?? "2026-01-01"
+    }
+  );
+}
+function _rotateClusterCertificatesSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/rotateClusterCertificates{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+async function _rotateClusterCertificatesDeserialize(result) {
+  const expectedStatuses = ["202", "204", "200", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return;
+}
+function rotateClusterCertificates(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  return getLongRunningPoller(
+    context,
+    _rotateClusterCertificatesDeserialize,
+    ["202", "204", "200", "201"],
+    {
+      updateIntervalInMs: options?.updateIntervalInMs,
+      abortSignal: options?.abortSignal,
+      getInitialResponse: () => _rotateClusterCertificatesSend(context, resourceGroupName, resourceName, options),
+      resourceLocationConfig: "location",
+      apiVersion: context.apiVersion ?? "2026-01-01"
+    }
+  );
+}
+function _resetAADProfileSend(context, resourceGroupName, resourceName, parameters, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/resetAADProfile{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    body: managedClusterAADProfileSerializer(parameters)
+  });
+}
+async function _resetAADProfileDeserialize(result) {
+  const expectedStatuses = ["202", "200", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return;
+}
+function resetAADProfile(context, resourceGroupName, resourceName, parameters, options = { requestOptions: {} }) {
+  return getLongRunningPoller(context, _resetAADProfileDeserialize, ["202", "200", "201"], {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _resetAADProfileSend(context, resourceGroupName, resourceName, parameters, options),
+    resourceLocationConfig: "location",
+    apiVersion: context.apiVersion ?? "2026-01-01"
+  });
+}
+function _resetServicePrincipalProfileSend(context, resourceGroupName, resourceName, parameters, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/resetServicePrincipalProfile{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    body: managedClusterServicePrincipalProfileSerializer(parameters)
+  });
+}
+async function _resetServicePrincipalProfileDeserialize(result) {
+  const expectedStatuses = ["202", "200", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return;
+}
+function resetServicePrincipalProfile(context, resourceGroupName, resourceName, parameters, options = { requestOptions: {} }) {
+  return getLongRunningPoller(
+    context,
+    _resetServicePrincipalProfileDeserialize,
+    ["202", "200", "201"],
+    {
+      updateIntervalInMs: options?.updateIntervalInMs,
+      abortSignal: options?.abortSignal,
+      getInitialResponse: () => _resetServicePrincipalProfileSend(
+        context,
+        resourceGroupName,
+        resourceName,
+        parameters,
+        options
+      ),
+      resourceLocationConfig: "location",
+      apiVersion: context.apiVersion ?? "2026-01-01"
+    }
+  );
+}
+function _listClusterMonitoringUserCredentialsSend(context, resourceGroupName, resourceName, options = {
+  requestOptions: {}
+}) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/listClusterMonitoringUserCredential{?api%2Dversion,server%2Dfqdn}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01",
+      "server%2Dfqdn": options?.serverFqdn
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listClusterMonitoringUserCredentialsDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return credentialResultsDeserializer(result.body);
+}
+async function listClusterMonitoringUserCredentials(context, resourceGroupName, resourceName, options = {
+  requestOptions: {}
+}) {
+  const result = await _listClusterMonitoringUserCredentialsSend(
+    context,
+    resourceGroupName,
+    resourceName,
+    options
+  );
+  return _listClusterMonitoringUserCredentialsDeserialize(result);
+}
+function _listClusterUserCredentialsSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/listClusterUserCredential{?api%2Dversion,server%2Dfqdn,format}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01",
+      "server%2Dfqdn": options?.serverFqdn,
+      format: options?.format
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listClusterUserCredentialsDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return credentialResultsDeserializer(result.body);
+}
+async function listClusterUserCredentials(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const result = await _listClusterUserCredentialsSend(
+    context,
+    resourceGroupName,
+    resourceName,
+    options
+  );
+  return _listClusterUserCredentialsDeserialize(result);
+}
+function _listClusterAdminCredentialsSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/listClusterAdminCredential{?api%2Dversion,server%2Dfqdn}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01",
+      "server%2Dfqdn": options?.serverFqdn
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listClusterAdminCredentialsDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return credentialResultsDeserializer(result.body);
+}
+async function listClusterAdminCredentials(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const result = await _listClusterAdminCredentialsSend(
+    context,
+    resourceGroupName,
+    resourceName,
+    options
+  );
+  return _listClusterAdminCredentialsDeserialize(result);
+}
+function _getAccessProfileSend(context, resourceGroupName, resourceName, roleName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/accessProfiles/{roleName}/listCredential{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      roleName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getAccessProfileDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return managedClusterAccessProfileDeserializer(result.body);
+}
+async function getAccessProfile(context, resourceGroupName, resourceName, roleName, options = { requestOptions: {} }) {
+  const result = await _getAccessProfileSend(
+    context,
+    resourceGroupName,
+    resourceName,
+    roleName,
+    options
+  );
+  return _getAccessProfileDeserialize(result);
+}
+function _listSend(context, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/providers/Microsoft.ContainerService/managedClusters{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return _managedClusterListResultDeserializer(result.body);
+}
+function list(context, options = { requestOptions: {} }) {
+  return buildPagedAsyncIterator(
+    context,
+    () => _listSend(context, options),
+    _listDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2026-01-01" }
+  );
+}
+function _listByResourceGroupSend(context, resourceGroupName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listByResourceGroupDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return _managedClusterListResultDeserializer(result.body);
+}
+function listByResourceGroup(context, resourceGroupName, options = { requestOptions: {} }) {
+  return buildPagedAsyncIterator(
+    context,
+    () => _listByResourceGroupSend(context, resourceGroupName, options),
+    _listByResourceGroupDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2026-01-01" }
+  );
+}
+function _$deleteSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).delete({
+    ...operationOptionsToRequestParameters(options),
+    headers: {
+      ...options?.ifMatch !== void 0 ? { "if-match": options?.ifMatch } : {},
+      ...options.requestOptions?.headers
+    }
+  });
+}
+async function _$deleteDeserialize(result) {
+  const expectedStatuses = ["202", "204", "200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return;
+}
+function $delete(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  return getLongRunningPoller(context, _$deleteDeserialize, ["202", "204", "200"], {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _$deleteSend(context, resourceGroupName, resourceName, options),
+    resourceLocationConfig: "azure-async-operation",
+    apiVersion: context.apiVersion ?? "2026-01-01"
+  });
+}
+function _updateTagsSend(context, resourceGroupName, resourceName, parameters, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).patch({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: {
+      ...options?.ifMatch !== void 0 ? { "if-match": options?.ifMatch } : {},
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    },
+    body: tagsObjectSerializer(parameters)
+  });
+}
+async function _updateTagsDeserialize(result) {
+  const expectedStatuses = ["200", "202", "201"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return managedClusterDeserializer(result.body);
+}
+function updateTags(context, resourceGroupName, resourceName, parameters, options = { requestOptions: {} }) {
+  return getLongRunningPoller(context, _updateTagsDeserialize, ["200", "202", "201"], {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _updateTagsSend(context, resourceGroupName, resourceName, parameters, options),
+    resourceLocationConfig: "azure-async-operation",
+    apiVersion: context.apiVersion ?? "2026-01-01"
+  });
+}
+function _createOrUpdateSend(context, resourceGroupName, resourceName, parameters, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).put({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: {
+      ...options?.ifMatch !== void 0 ? { "if-match": options?.ifMatch } : {},
+      ...options?.ifNoneMatch !== void 0 ? { "if-none-match": options?.ifNoneMatch } : {},
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    },
+    body: managedClusterSerializer(parameters)
+  });
+}
+async function _createOrUpdateDeserialize(result) {
+  const expectedStatuses = ["200", "201", "202"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return managedClusterDeserializer(result.body);
+}
+function createOrUpdate(context, resourceGroupName, resourceName, parameters, options = { requestOptions: {} }) {
+  return getLongRunningPoller(context, _createOrUpdateDeserialize, ["200", "201", "202"], {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _createOrUpdateSend(context, resourceGroupName, resourceName, parameters, options),
+    resourceLocationConfig: "azure-async-operation",
+    apiVersion: context.apiVersion ?? "2026-01-01"
+  });
+}
+function _getSend(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}{?api%2Dversion}",
+    {
+      subscriptionId: context.subscriptionId,
+      resourceGroupName,
+      resourceName,
+      "api%2Dversion": context.apiVersion ?? "2026-01-01"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = errorResponseDeserializer(result.body);
+    throw error;
+  }
+  return managedClusterDeserializer(result.body);
+}
+async function get(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+  const result = await _getSend(context, resourceGroupName, resourceName, options);
+  return _getDeserialize(result);
+}
+export {
+  $delete,
+  _$deleteDeserialize,
+  _$deleteSend,
+  _abortLatestOperationDeserialize,
+  _abortLatestOperationSend,
+  _createOrUpdateDeserialize,
+  _createOrUpdateSend,
+  _getAccessProfileDeserialize,
+  _getAccessProfileSend,
+  _getCommandResultDeserialize,
+  _getCommandResultSend,
+  _getDeserialize,
+  _getMeshRevisionProfileDeserialize,
+  _getMeshRevisionProfileSend,
+  _getMeshUpgradeProfileDeserialize,
+  _getMeshUpgradeProfileSend,
+  _getSend,
+  _getUpgradeProfileDeserialize,
+  _getUpgradeProfileSend,
+  _listByResourceGroupDeserialize,
+  _listByResourceGroupSend,
+  _listClusterAdminCredentialsDeserialize,
+  _listClusterAdminCredentialsSend,
+  _listClusterMonitoringUserCredentialsDeserialize,
+  _listClusterMonitoringUserCredentialsSend,
+  _listClusterUserCredentialsDeserialize,
+  _listClusterUserCredentialsSend,
+  _listDeserialize,
+  _listKubernetesVersionsDeserialize,
+  _listKubernetesVersionsSend,
+  _listMeshRevisionProfilesDeserialize,
+  _listMeshRevisionProfilesSend,
+  _listMeshUpgradeProfilesDeserialize,
+  _listMeshUpgradeProfilesSend,
+  _listOutboundNetworkDependenciesEndpointsDeserialize,
+  _listOutboundNetworkDependenciesEndpointsSend,
+  _listSend,
+  _resetAADProfileDeserialize,
+  _resetAADProfileSend,
+  _resetServicePrincipalProfileDeserialize,
+  _resetServicePrincipalProfileSend,
+  _rotateClusterCertificatesDeserialize,
+  _rotateClusterCertificatesSend,
+  _rotateServiceAccountSigningKeysDeserialize,
+  _rotateServiceAccountSigningKeysSend,
+  _runCommandDeserialize,
+  _runCommandSend,
+  _startDeserialize,
+  _startSend,
+  _stopDeserialize,
+  _stopSend,
+  _updateTagsDeserialize,
+  _updateTagsSend,
+  abortLatestOperation,
+  createOrUpdate,
+  get,
+  getAccessProfile,
+  getCommandResult,
+  getMeshRevisionProfile,
+  getMeshUpgradeProfile,
+  getUpgradeProfile,
+  list,
+  listByResourceGroup,
+  listClusterAdminCredentials,
+  listClusterMonitoringUserCredentials,
+  listClusterUserCredentials,
+  listKubernetesVersions,
+  listMeshRevisionProfiles,
+  listMeshUpgradeProfiles,
+  listOutboundNetworkDependenciesEndpoints,
+  resetAADProfile,
+  resetServicePrincipalProfile,
+  rotateClusterCertificates,
+  rotateServiceAccountSigningKeys,
+  runCommand,
+  start,
+  stop,
+  updateTags
+};