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

package/dist/react-native/api/managedClusters/operations.js

@@ -0,0 +1,806 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+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";
+export function _listKubernetesVersionsSend(context, location, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/providers/Microsoft.ContainerService/locations/{location}/kubernetesVersions{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        location: 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 },
+    });
+}
+export 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);
+}
+/** Contains extra metadata on the version, including supported patch versions, capabilities, available upgrades, and details on preview status of the version */
+export async function listKubernetesVersions(context, location, options = { requestOptions: {} }) {
+    const result = await _listKubernetesVersionsSend(context, location, options);
+    return _listKubernetesVersionsDeserialize(result);
+}
+export 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: resourceGroupName,
+        resourceName: 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 },
+    });
+}
+export 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);
+}
+/** Lists available upgrades for all service meshes in a specific cluster. */
+export 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" });
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        mode: 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 },
+    });
+}
+export 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);
+}
+/** Gets available upgrades for a service mesh in a cluster. */
+export async function getMeshUpgradeProfile(context, resourceGroupName, resourceName, mode, options = { requestOptions: {} }) {
+    const result = await _getMeshUpgradeProfileSend(context, resourceGroupName, resourceName, mode, options);
+    return _getMeshUpgradeProfileDeserialize(result);
+}
+export function _listMeshRevisionProfilesSend(context, location, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/providers/Microsoft.ContainerService/locations/{location}/meshRevisionProfiles{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        location: 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 },
+    });
+}
+export 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);
+}
+/** Contains extra metadata on each revision, including supported revisions, cluster compatibility and available upgrades */
+export 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" });
+}
+export 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: location,
+        mode: 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 },
+    });
+}
+export 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);
+}
+/** Contains extra metadata on the revision, including supported revisions, cluster compatibility and available upgrades */
+export async function getMeshRevisionProfile(context, location, mode, options = { requestOptions: {} }) {
+    const result = await _getMeshRevisionProfileSend(context, location, mode, options);
+    return _getMeshRevisionProfileDeserialize(result);
+}
+export 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: resourceGroupName,
+        resourceName: 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 },
+    });
+}
+export 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);
+}
+/** Gets the upgrade profile of a managed cluster. */
+export async function getUpgradeProfile(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+    const result = await _getUpgradeProfileSend(context, resourceGroupName, resourceName, options);
+    return _getUpgradeProfileDeserialize(result);
+}
+export 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: resourceGroupName,
+        resourceName: 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 },
+    });
+}
+export 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);
+}
+/** Gets a list of egress endpoints (network endpoints of all outbound dependencies) in the specified managed cluster. The operation returns properties of each egress endpoint. */
+export 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" });
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        commandId: 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 },
+    });
+}
+export 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);
+}
+/** Gets the results of a command which has been run on the Managed Cluster. */
+export async function getCommandResult(context, resourceGroupName, resourceName, commandId, options = { requestOptions: {} }) {
+    const result = await _getCommandResultSend(context, resourceGroupName, resourceName, commandId, options);
+    return _getCommandResultDeserialize(result);
+}
+export 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: resourceGroupName,
+        resourceName: 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),
+    });
+}
+export 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);
+}
+/** AKS will create a pod to run the command. This is primarily useful for private clusters. For more information see [AKS Run Command](https://docs.microsoft.com/azure/aks/private-clusters#aks-run-command-preview). */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        "api%2Dversion": context.apiVersion ?? "2026-01-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export 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;
+}
+/** See [starting a cluster](https://docs.microsoft.com/azure/aks/start-stop-cluster) for more details about starting a cluster. */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        "api%2Dversion": context.apiVersion ?? "2026-01-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export 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;
+}
+/** This can only be performed on Azure Virtual Machine Scale set backed clusters. Stopping a cluster stops the control plane and agent nodes entirely, while maintaining all object and cluster state. A cluster does not accrue charges while it is stopped. See [stopping a cluster](https://docs.microsoft.com/azure/aks/start-stop-cluster) for more details about stopping a cluster. */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        "api%2Dversion": context.apiVersion ?? "2026-01-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export 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;
+}
+/** Rotates the service account signing keys of a managed cluster. */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        "api%2Dversion": context.apiVersion ?? "2026-01-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export 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;
+}
+/** Aborts the currently running operation on the managed cluster. The Managed Cluster will be moved to a Canceling state and eventually to a Canceled state when cancellation finishes. If the operation completes before cancellation can take place, a 409 error code is returned. */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        "api%2Dversion": context.apiVersion ?? "2026-01-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export 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;
+}
+/** See [Certificate rotation](https://docs.microsoft.com/azure/aks/certificate-rotation) for more details about rotating managed cluster certificates. */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: 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),
+    });
+}
+export 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;
+}
+/** **WARNING**: This API will be deprecated. Please see [AKS-managed Azure Active Directory integration](https://aka.ms/aks-managed-aad) to update your cluster with AKS-managed Azure AD. */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: 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),
+    });
+}
+export 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;
+}
+/** This action cannot be performed on a cluster that is not using a service principal */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: 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 },
+    });
+}
+export 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);
+}
+/** Lists the cluster monitoring user credentials of a managed cluster. */
+export async function listClusterMonitoringUserCredentials(context, resourceGroupName, resourceName, options = {
+    requestOptions: {},
+}) {
+    const result = await _listClusterMonitoringUserCredentialsSend(context, resourceGroupName, resourceName, options);
+    return _listClusterMonitoringUserCredentialsDeserialize(result);
+}
+export 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: resourceGroupName,
+        resourceName: 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 },
+    });
+}
+export 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);
+}
+/** Lists the user credentials of a managed cluster. */
+export async function listClusterUserCredentials(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+    const result = await _listClusterUserCredentialsSend(context, resourceGroupName, resourceName, options);
+    return _listClusterUserCredentialsDeserialize(result);
+}
+export 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: resourceGroupName,
+        resourceName: 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 },
+    });
+}
+export 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);
+}
+/** Lists the admin credentials of a managed cluster. */
+export async function listClusterAdminCredentials(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+    const result = await _listClusterAdminCredentialsSend(context, resourceGroupName, resourceName, options);
+    return _listClusterAdminCredentialsDeserialize(result);
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        roleName: 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 },
+    });
+}
+export 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);
+}
+/** **WARNING**: This API will be deprecated. Instead use [ListClusterUserCredentials](https://docs.microsoft.com/rest/api/aks/managedclusters/listclusterusercredentials) or [ListClusterAdminCredentials](https://docs.microsoft.com/rest/api/aks/managedclusters/listclusteradmincredentials) . */
+export async function getAccessProfile(context, resourceGroupName, resourceName, roleName, options = { requestOptions: {} }) {
+    const result = await _getAccessProfileSend(context, resourceGroupName, resourceName, roleName, options);
+    return _getAccessProfileDeserialize(result);
+}
+export 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 },
+    });
+}
+export 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);
+}
+/** Gets a list of managed clusters in the specified subscription. */
+export function list(context, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listSend(context, options), _listDeserialize, ["200"], { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2026-01-01" });
+}
+export function _listByResourceGroupSend(context, resourceGroupName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters{?api%2Dversion}", {
+        subscriptionId: context.subscriptionId,
+        resourceGroupName: 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 },
+    });
+}
+export 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);
+}
+/** Lists managed clusters in the specified subscription and resource group. */
+export 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" });
+}
+export 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: resourceGroupName,
+        resourceName: resourceName,
+        "api%2Dversion": context.apiVersion ?? "2026-01-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).delete({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            ...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export 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;
+}
+/** Deletes a managed cluster. */
+/**
+ *  @fixme delete is a reserved word that cannot be used as an operation name.
+ *         Please add @clientName("clientName") or @clientName("<JS-Specific-Name>", "javascript")
+ *         to the operation to override the generated name.
+ */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: 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 !== undefined ? { "if-match": options?.ifMatch } : {}),
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: tagsObjectSerializer(parameters),
+    });
+}
+export 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);
+}
+/** Updates tags on a managed cluster. */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: 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 !== undefined ? { "if-match": options?.ifMatch } : {}),
+            ...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: managedClusterSerializer(parameters),
+    });
+}
+export 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);
+}
+/** Creates or updates a managed cluster. */
+export 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",
+    });
+}
+export 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: resourceGroupName,
+        resourceName: 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 },
+    });
+}
+export 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);
+}
+/** Gets a managed cluster. */
+export async function get(context, resourceGroupName, resourceName, options = { requestOptions: {} }) {
+    const result = await _getSend(context, resourceGroupName, resourceName, options);
+    return _getDeserialize(result);
+}
+//# sourceMappingURL=operations.js.map