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

package/dist/browser/models/models.js

@@ -0,0 +1,4784 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { areAllPropsUndefined } from "../static-helpers/serialization/check-prop-undefined.js";
+import { uint8ArrayToString, stringToUint8Array } from "@azure/core-util";
+export function agentPoolSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, [
+            "count",
+            "vmSize",
+            "osDiskSizeGB",
+            "osDiskType",
+            "kubeletDiskType",
+            "workloadRuntime",
+            "messageOfTheDay",
+            "vnetSubnetID",
+            "podSubnetID",
+            "podIPAllocationMode",
+            "maxPods",
+            "osType",
+            "osSKU",
+            "maxCount",
+            "minCount",
+            "enableAutoScaling",
+            "scaleDownMode",
+            "type",
+            "mode",
+            "orchestratorVersion",
+            "upgradeSettings",
+            "powerState",
+            "availabilityZones",
+            "enableNodePublicIP",
+            "nodePublicIPPrefixID",
+            "scaleSetPriority",
+            "scaleSetEvictionPolicy",
+            "spotMaxPrice",
+            "tags",
+            "nodeLabels",
+            "nodeTaints",
+            "proximityPlacementGroupID",
+            "kubeletConfig",
+            "linuxOSConfig",
+            "enableEncryptionAtHost",
+            "enableUltraSSD",
+            "enableFIPS",
+            "gpuInstanceProfile",
+            "creationData",
+            "capacityReservationGroupID",
+            "hostGroupID",
+            "networkProfile",
+            "windowsProfile",
+            "securityProfile",
+            "gpuProfile",
+            "gatewayProfile",
+            "virtualMachinesProfile",
+            "virtualMachineNodesStatus",
+            "status",
+            "localDNSProfile",
+        ])
+            ? undefined
+            : _agentPoolPropertiesSerializer(item),
+    };
+}
+export function agentPoolDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _agentPoolPropertiesDeserializer(item["properties"])),
+    };
+}
+export function managedClusterAgentPoolProfilePropertiesSerializer(item) {
+    return {
+        count: item["count"],
+        vmSize: item["vmSize"],
+        osDiskSizeGB: item["osDiskSizeGB"],
+        osDiskType: item["osDiskType"],
+        kubeletDiskType: item["kubeletDiskType"],
+        workloadRuntime: item["workloadRuntime"],
+        messageOfTheDay: item["messageOfTheDay"],
+        vnetSubnetID: item["vnetSubnetID"],
+        podSubnetID: item["podSubnetID"],
+        podIPAllocationMode: item["podIPAllocationMode"],
+        maxPods: item["maxPods"],
+        osType: item["osType"],
+        osSKU: item["osSKU"],
+        maxCount: item["maxCount"],
+        minCount: item["minCount"],
+        enableAutoScaling: item["enableAutoScaling"],
+        scaleDownMode: item["scaleDownMode"],
+        type: item["type"],
+        mode: item["mode"],
+        orchestratorVersion: item["orchestratorVersion"],
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : agentPoolUpgradeSettingsSerializer(item["upgradeSettings"]),
+        powerState: !item["powerState"] ? item["powerState"] : powerStateSerializer(item["powerState"]),
+        availabilityZones: !item["availabilityZones"]
+            ? item["availabilityZones"]
+            : item["availabilityZones"].map((p) => {
+                return p;
+            }),
+        enableNodePublicIP: item["enableNodePublicIP"],
+        nodePublicIPPrefixID: item["nodePublicIPPrefixID"],
+        scaleSetPriority: item["scaleSetPriority"],
+        scaleSetEvictionPolicy: item["scaleSetEvictionPolicy"],
+        spotMaxPrice: item["spotMaxPrice"],
+        tags: item["tags"],
+        nodeLabels: item["nodeLabels"],
+        nodeTaints: !item["nodeTaints"]
+            ? item["nodeTaints"]
+            : item["nodeTaints"].map((p) => {
+                return p;
+            }),
+        proximityPlacementGroupID: item["proximityPlacementGroupID"],
+        kubeletConfig: !item["kubeletConfig"]
+            ? item["kubeletConfig"]
+            : kubeletConfigSerializer(item["kubeletConfig"]),
+        linuxOSConfig: !item["linuxOSConfig"]
+            ? item["linuxOSConfig"]
+            : linuxOSConfigSerializer(item["linuxOSConfig"]),
+        enableEncryptionAtHost: item["enableEncryptionAtHost"],
+        enableUltraSSD: item["enableUltraSSD"],
+        enableFIPS: item["enableFips"],
+        gpuInstanceProfile: item["gpuInstanceProfile"],
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataSerializer(item["creationData"]),
+        capacityReservationGroupID: item["capacityReservationGroupID"],
+        hostGroupID: item["hostGroupID"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : agentPoolNetworkProfileSerializer(item["networkProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : agentPoolWindowsProfileSerializer(item["windowsProfile"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : agentPoolSecurityProfileSerializer(item["securityProfile"]),
+        gpuProfile: !item["gpuProfile"] ? item["gpuProfile"] : gpuProfileSerializer(item["gpuProfile"]),
+        gatewayProfile: !item["gatewayProfile"]
+            ? item["gatewayProfile"]
+            : agentPoolGatewayProfileSerializer(item["gatewayProfile"]),
+        virtualMachinesProfile: !item["virtualMachinesProfile"]
+            ? item["virtualMachinesProfile"]
+            : virtualMachinesProfileSerializer(item["virtualMachinesProfile"]),
+        virtualMachineNodesStatus: !item["virtualMachineNodesStatus"]
+            ? item["virtualMachineNodesStatus"]
+            : virtualMachineNodesArraySerializer(item["virtualMachineNodesStatus"]),
+        status: !item["status"] ? item["status"] : agentPoolStatusSerializer(item["status"]),
+        localDNSProfile: !item["localDNSProfile"]
+            ? item["localDNSProfile"]
+            : localDNSProfileSerializer(item["localDNSProfile"]),
+    };
+}
+export function managedClusterAgentPoolProfilePropertiesDeserializer(item) {
+    return {
+        eTag: item["eTag"],
+        count: item["count"],
+        vmSize: item["vmSize"],
+        osDiskSizeGB: item["osDiskSizeGB"],
+        osDiskType: item["osDiskType"],
+        kubeletDiskType: item["kubeletDiskType"],
+        workloadRuntime: item["workloadRuntime"],
+        messageOfTheDay: item["messageOfTheDay"],
+        vnetSubnetID: item["vnetSubnetID"],
+        podSubnetID: item["podSubnetID"],
+        podIPAllocationMode: item["podIPAllocationMode"],
+        maxPods: item["maxPods"],
+        osType: item["osType"],
+        osSKU: item["osSKU"],
+        maxCount: item["maxCount"],
+        minCount: item["minCount"],
+        enableAutoScaling: item["enableAutoScaling"],
+        scaleDownMode: item["scaleDownMode"],
+        type: item["type"],
+        mode: item["mode"],
+        orchestratorVersion: item["orchestratorVersion"],
+        currentOrchestratorVersion: item["currentOrchestratorVersion"],
+        nodeImageVersion: item["nodeImageVersion"],
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : agentPoolUpgradeSettingsDeserializer(item["upgradeSettings"]),
+        provisioningState: item["provisioningState"],
+        powerState: !item["powerState"]
+            ? item["powerState"]
+            : powerStateDeserializer(item["powerState"]),
+        availabilityZones: !item["availabilityZones"]
+            ? item["availabilityZones"]
+            : item["availabilityZones"].map((p) => {
+                return p;
+            }),
+        enableNodePublicIP: item["enableNodePublicIP"],
+        nodePublicIPPrefixID: item["nodePublicIPPrefixID"],
+        scaleSetPriority: item["scaleSetPriority"],
+        scaleSetEvictionPolicy: item["scaleSetEvictionPolicy"],
+        spotMaxPrice: item["spotMaxPrice"],
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        nodeLabels: !item["nodeLabels"]
+            ? item["nodeLabels"]
+            : Object.fromEntries(Object.entries(item["nodeLabels"]).map(([k, p]) => [k, p])),
+        nodeTaints: !item["nodeTaints"]
+            ? item["nodeTaints"]
+            : item["nodeTaints"].map((p) => {
+                return p;
+            }),
+        proximityPlacementGroupID: item["proximityPlacementGroupID"],
+        kubeletConfig: !item["kubeletConfig"]
+            ? item["kubeletConfig"]
+            : kubeletConfigDeserializer(item["kubeletConfig"]),
+        linuxOSConfig: !item["linuxOSConfig"]
+            ? item["linuxOSConfig"]
+            : linuxOSConfigDeserializer(item["linuxOSConfig"]),
+        enableEncryptionAtHost: item["enableEncryptionAtHost"],
+        enableUltraSSD: item["enableUltraSSD"],
+        enableFips: item["enableFIPS"],
+        gpuInstanceProfile: item["gpuInstanceProfile"],
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataDeserializer(item["creationData"]),
+        capacityReservationGroupID: item["capacityReservationGroupID"],
+        hostGroupID: item["hostGroupID"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : agentPoolNetworkProfileDeserializer(item["networkProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : agentPoolWindowsProfileDeserializer(item["windowsProfile"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : agentPoolSecurityProfileDeserializer(item["securityProfile"]),
+        gpuProfile: !item["gpuProfile"]
+            ? item["gpuProfile"]
+            : gpuProfileDeserializer(item["gpuProfile"]),
+        gatewayProfile: !item["gatewayProfile"]
+            ? item["gatewayProfile"]
+            : agentPoolGatewayProfileDeserializer(item["gatewayProfile"]),
+        virtualMachinesProfile: !item["virtualMachinesProfile"]
+            ? item["virtualMachinesProfile"]
+            : virtualMachinesProfileDeserializer(item["virtualMachinesProfile"]),
+        virtualMachineNodesStatus: !item["virtualMachineNodesStatus"]
+            ? item["virtualMachineNodesStatus"]
+            : virtualMachineNodesArrayDeserializer(item["virtualMachineNodesStatus"]),
+        status: !item["status"] ? item["status"] : agentPoolStatusDeserializer(item["status"]),
+        localDNSProfile: !item["localDNSProfile"]
+            ? item["localDNSProfile"]
+            : localDNSProfileDeserializer(item["localDNSProfile"]),
+    };
+}
+/** The OS disk type to be used for machines in the agent pool. The default is 'Ephemeral' if the VM supports it and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to 'Managed'. May not be changed after creation. For more information see [Ephemeral OS](https://docs.microsoft.com/azure/aks/cluster-configuration#ephemeral-os). */
+export var KnownOSDiskType;
+(function (KnownOSDiskType) {
+    /** Azure replicates the operating system disk for a virtual machine to Azure storage to avoid data loss should the VM need to be relocated to another host. Since containers aren't designed to have local state persisted, this behavior offers limited value while providing some drawbacks, including slower node provisioning and higher read/write latency. */
+    KnownOSDiskType["Managed"] = "Managed";
+    /** Ephemeral OS disks are stored only on the host machine, just like a temporary disk. This provides lower read/write latency, along with faster node scaling and cluster upgrades. */
+    KnownOSDiskType["Ephemeral"] = "Ephemeral";
+})(KnownOSDiskType || (KnownOSDiskType = {}));
+/** Determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. */
+export var KnownKubeletDiskType;
+(function (KnownKubeletDiskType) {
+    /** Kubelet will use the OS disk for its data. */
+    KnownKubeletDiskType["OS"] = "OS";
+    /** Kubelet will use the temporary disk for its data. */
+    KnownKubeletDiskType["Temporary"] = "Temporary";
+})(KnownKubeletDiskType || (KnownKubeletDiskType = {}));
+/** Determines the type of workload a node can run. */
+export var KnownWorkloadRuntime;
+(function (KnownWorkloadRuntime) {
+    /** Nodes will use Kubelet to run standard OCI container workloads. */
+    KnownWorkloadRuntime["OCIContainer"] = "OCIContainer";
+    /** Nodes will use Krustlet to run WASM workloads using the WASI provider (Preview). */
+    KnownWorkloadRuntime["WasmWasi"] = "WasmWasi";
+    /** Nodes can use (Kata + Cloud Hypervisor + Hyper-V) to enable Nested VM-based pods. Due to the use Hyper-V, AKS node OS itself is a nested VM (the root OS) of Hyper-V. Thus it can only be used with VM series that support Nested Virtualization such as Dv3 series. */
+    KnownWorkloadRuntime["KataVmIsolation"] = "KataVmIsolation";
+})(KnownWorkloadRuntime || (KnownWorkloadRuntime = {}));
+/** Pod IP Allocation Mode. The IP allocation mode for pods in the agent pool. Must be used with podSubnetId. The default is 'DynamicIndividual'. */
+export var KnownPodIPAllocationMode;
+(function (KnownPodIPAllocationMode) {
+    /** Each node gets allocated with a non-contiguous list of IP addresses assignable to pods. This is better for maximizing a small to medium subnet of size /16 or smaller. The Azure CNI cluster with dynamic IP allocation defaults to this mode if the customer does not explicitly specify a podIPAllocationMode */
+    KnownPodIPAllocationMode["DynamicIndividual"] = "DynamicIndividual";
+    /** Each node is statically allocated CIDR block(s) of size /28 = 16 IPs per block to satisfy the maxPods per node. Number of CIDR blocks >= (maxPods / 16). The block, rather than a single IP, counts against the Azure Vnet Private IP limit of 65K. Therefore block mode is suitable for running larger workloads with more than the current limit of 65K pods in a cluster. This mode is better suited to scale with larger subnets of /15 or bigger */
+    KnownPodIPAllocationMode["StaticBlock"] = "StaticBlock";
+})(KnownPodIPAllocationMode || (KnownPodIPAllocationMode = {}));
+/** The operating system type. The default is Linux. */
+export var KnownOSType;
+(function (KnownOSType) {
+    /** Use Linux. */
+    KnownOSType["Linux"] = "Linux";
+    /** Use Windows. */
+    KnownOSType["Windows"] = "Windows";
+})(KnownOSType || (KnownOSType = {}));
+/** Specifies the OS SKU used by the agent pool. The default is Ubuntu if OSType is Linux. The default is Windows2019 when Kubernetes <= 1.24 or Windows2022 when Kubernetes >= 1.25 if OSType is Windows. */
+export var KnownOssku;
+(function (KnownOssku) {
+    /** Use Ubuntu as the OS for node images. */
+    KnownOssku["Ubuntu"] = "Ubuntu";
+    /** Use AzureLinux as the OS for node images. Azure Linux is a container-optimized Linux distro built by Microsoft, visit https://aka.ms/azurelinux for more information. */
+    KnownOssku["AzureLinux"] = "AzureLinux";
+    /** Use AzureLinux3 as the OS for node images. Azure Linux is a container-optimized Linux distro built by Microsoft, visit https://aka.ms/azurelinux for more information. For limitations, visit https://aka.ms/aks/node-images. For OS migration guidance, see https://aka.ms/aks/upgrade-os-version. */
+    KnownOssku["AzureLinux3"] = "AzureLinux3";
+    /** Deprecated OSSKU. Microsoft recommends that new deployments choose 'AzureLinux' instead. */
+    KnownOssku["CBLMariner"] = "CBLMariner";
+    /** Use Windows2019 as the OS for node images. Unsupported for system node pools. Windows2019 only supports Windows2019 containers; it cannot run Windows2022 containers and vice versa. */
+    KnownOssku["Windows2019"] = "Windows2019";
+    /** Use Windows2022 as the OS for node images. Unsupported for system node pools. Windows2022 only supports Windows2022 containers; it cannot run Windows2019 containers and vice versa. */
+    KnownOssku["Windows2022"] = "Windows2022";
+    /** Use Ubuntu2204 as the OS for node images, however, Ubuntu 22.04 may not be supported for all nodepools. For limitations and supported kubernetes versions, see https://aka.ms/aks/supported-ubuntu-versions */
+    KnownOssku["Ubuntu2204"] = "Ubuntu2204";
+    /** Use Ubuntu2404 as the OS for node images, however, Ubuntu 24.04 may not be supported for all nodepools. For limitations and supported kubernetes versions, see see https://aka.ms/aks/supported-ubuntu-versions */
+    KnownOssku["Ubuntu2404"] = "Ubuntu2404";
+})(KnownOssku || (KnownOssku = {}));
+/** Describes how VMs are added to or removed from Agent Pools. See [billing states](https://docs.microsoft.com/azure/virtual-machines/states-billing). */
+export var KnownScaleDownMode;
+(function (KnownScaleDownMode) {
+    /** Create new instances during scale up and remove instances during scale down. */
+    KnownScaleDownMode["Delete"] = "Delete";
+    /** Attempt to start deallocated instances (if they exist) during scale up and deallocate instances during scale down. */
+    KnownScaleDownMode["Deallocate"] = "Deallocate";
+})(KnownScaleDownMode || (KnownScaleDownMode = {}));
+/** The type of Agent Pool. */
+export var KnownAgentPoolType;
+(function (KnownAgentPoolType) {
+    /** Create an Agent Pool backed by a Virtual Machine Scale Set. */
+    KnownAgentPoolType["VirtualMachineScaleSets"] = "VirtualMachineScaleSets";
+    /** Use of this is strongly discouraged. */
+    KnownAgentPoolType["AvailabilitySet"] = "AvailabilitySet";
+    /** Create an Agent Pool backed by a Single Instance VM orchestration mode. */
+    KnownAgentPoolType["VirtualMachines"] = "VirtualMachines";
+})(KnownAgentPoolType || (KnownAgentPoolType = {}));
+/** The mode of an agent pool. A cluster must have at least one 'System' Agent Pool at all times. For additional information on agent pool restrictions and best practices, see: https://docs.microsoft.com/azure/aks/use-system-pools */
+export var KnownAgentPoolMode;
+(function (KnownAgentPoolMode) {
+    /** System agent pools are primarily for hosting critical system pods such as CoreDNS and metrics-server. System agent pools osType must be Linux. System agent pools VM SKU must have at least 2vCPUs and 4GB of memory. */
+    KnownAgentPoolMode["System"] = "System";
+    /** User agent pools are primarily for hosting your application pods. */
+    KnownAgentPoolMode["User"] = "User";
+    /** Gateway agent pools are dedicated to providing static egress IPs to pods. For more details, see https://aka.ms/aks/static-egress-gateway. */
+    KnownAgentPoolMode["Gateway"] = "Gateway";
+})(KnownAgentPoolMode || (KnownAgentPoolMode = {}));
+export function agentPoolUpgradeSettingsSerializer(item) {
+    return {
+        maxSurge: item["maxSurge"],
+        maxUnavailable: item["maxUnavailable"],
+        drainTimeoutInMinutes: item["drainTimeoutInMinutes"],
+        nodeSoakDurationInMinutes: item["nodeSoakDurationInMinutes"],
+        undrainableNodeBehavior: item["undrainableNodeBehavior"],
+    };
+}
+export function agentPoolUpgradeSettingsDeserializer(item) {
+    return {
+        maxSurge: item["maxSurge"],
+        maxUnavailable: item["maxUnavailable"],
+        drainTimeoutInMinutes: item["drainTimeoutInMinutes"],
+        nodeSoakDurationInMinutes: item["nodeSoakDurationInMinutes"],
+        undrainableNodeBehavior: item["undrainableNodeBehavior"],
+    };
+}
+/** Defines the behavior for undrainable nodes during upgrade. The most common cause of undrainable nodes is Pod Disruption Budgets (PDBs), but other issues, such as pod termination grace period is exceeding the remaining per-node drain timeout or pod is still being in a running state, can also cause undrainable nodes. */
+export var KnownUndrainableNodeBehavior;
+(function (KnownUndrainableNodeBehavior) {
+    /** AKS will cordon the blocked nodes and replace them with surge nodes during upgrade. The blocked nodes will be cordoned and replaced by surge nodes. The blocked nodes will have label 'kubernetes.azure.com/upgrade-status:Quarantined'. A surge node will be retained for each blocked node. A best-effort attempt will be made to delete all other surge nodes. If there are enough surge nodes to replace blocked nodes, then the upgrade operation and the managed cluster will be in failed state. Otherwise, the upgrade operation and the managed cluster will be in canceled state. */
+    KnownUndrainableNodeBehavior["Cordon"] = "Cordon";
+    /** AKS will mark the blocked nodes schedulable, but the blocked nodes are not upgraded. A best-effort attempt will be made to delete all surge nodes. The upgrade operation and the managed cluster will be in failed state if there are any blocked nodes. */
+    KnownUndrainableNodeBehavior["Schedule"] = "Schedule";
+})(KnownUndrainableNodeBehavior || (KnownUndrainableNodeBehavior = {}));
+export function powerStateSerializer(item) {
+    return { code: item["code"] };
+}
+export function powerStateDeserializer(item) {
+    return {
+        code: item["code"],
+    };
+}
+/** Tells whether the cluster is Running or Stopped */
+export var KnownCode;
+(function (KnownCode) {
+    /** The cluster is running. */
+    KnownCode["Running"] = "Running";
+    /** The cluster is stopped. */
+    KnownCode["Stopped"] = "Stopped";
+})(KnownCode || (KnownCode = {}));
+/** The Virtual Machine Scale Set priority. */
+export var KnownScaleSetPriority;
+(function (KnownScaleSetPriority) {
+    /** Spot priority VMs will be used. There is no SLA for spot nodes. See [spot on AKS](https://docs.microsoft.com/azure/aks/spot-node-pool) for more information. */
+    KnownScaleSetPriority["Spot"] = "Spot";
+    /** Regular VMs will be used. */
+    KnownScaleSetPriority["Regular"] = "Regular";
+})(KnownScaleSetPriority || (KnownScaleSetPriority = {}));
+/** The Virtual Machine Scale Set eviction policy. The eviction policy specifies what to do with the VM when it is evicted. The default is Delete. For more information about eviction see [spot VMs](https://docs.microsoft.com/azure/virtual-machines/spot-vms) */
+export var KnownScaleSetEvictionPolicy;
+(function (KnownScaleSetEvictionPolicy) {
+    /** Nodes in the underlying Scale Set of the node pool are deleted when they're evicted. */
+    KnownScaleSetEvictionPolicy["Delete"] = "Delete";
+    /** Nodes in the underlying Scale Set of the node pool are set to the stopped-deallocated state upon eviction. Nodes in the stopped-deallocated state count against your compute quota and can cause issues with cluster scaling or upgrading. */
+    KnownScaleSetEvictionPolicy["Deallocate"] = "Deallocate";
+})(KnownScaleSetEvictionPolicy || (KnownScaleSetEvictionPolicy = {}));
+export function kubeletConfigSerializer(item) {
+    return {
+        cpuManagerPolicy: item["cpuManagerPolicy"],
+        cpuCfsQuota: item["cpuCfsQuota"],
+        cpuCfsQuotaPeriod: item["cpuCfsQuotaPeriod"],
+        imageGcHighThreshold: item["imageGcHighThreshold"],
+        imageGcLowThreshold: item["imageGcLowThreshold"],
+        topologyManagerPolicy: item["topologyManagerPolicy"],
+        allowedUnsafeSysctls: !item["allowedUnsafeSysctls"]
+            ? item["allowedUnsafeSysctls"]
+            : item["allowedUnsafeSysctls"].map((p) => {
+                return p;
+            }),
+        failSwapOn: item["failSwapOn"],
+        containerLogMaxSizeMB: item["containerLogMaxSizeMB"],
+        containerLogMaxFiles: item["containerLogMaxFiles"],
+        podMaxPids: item["podMaxPids"],
+    };
+}
+export function kubeletConfigDeserializer(item) {
+    return {
+        cpuManagerPolicy: item["cpuManagerPolicy"],
+        cpuCfsQuota: item["cpuCfsQuota"],
+        cpuCfsQuotaPeriod: item["cpuCfsQuotaPeriod"],
+        imageGcHighThreshold: item["imageGcHighThreshold"],
+        imageGcLowThreshold: item["imageGcLowThreshold"],
+        topologyManagerPolicy: item["topologyManagerPolicy"],
+        allowedUnsafeSysctls: !item["allowedUnsafeSysctls"]
+            ? item["allowedUnsafeSysctls"]
+            : item["allowedUnsafeSysctls"].map((p) => {
+                return p;
+            }),
+        failSwapOn: item["failSwapOn"],
+        containerLogMaxSizeMB: item["containerLogMaxSizeMB"],
+        containerLogMaxFiles: item["containerLogMaxFiles"],
+        podMaxPids: item["podMaxPids"],
+    };
+}
+export function linuxOSConfigSerializer(item) {
+    return {
+        sysctls: !item["sysctls"] ? item["sysctls"] : sysctlConfigSerializer(item["sysctls"]),
+        transparentHugePageEnabled: item["transparentHugePageEnabled"],
+        transparentHugePageDefrag: item["transparentHugePageDefrag"],
+        swapFileSizeMB: item["swapFileSizeMB"],
+    };
+}
+export function linuxOSConfigDeserializer(item) {
+    return {
+        sysctls: !item["sysctls"] ? item["sysctls"] : sysctlConfigDeserializer(item["sysctls"]),
+        transparentHugePageEnabled: item["transparentHugePageEnabled"],
+        transparentHugePageDefrag: item["transparentHugePageDefrag"],
+        swapFileSizeMB: item["swapFileSizeMB"],
+    };
+}
+export function sysctlConfigSerializer(item) {
+    return {
+        netCoreSomaxconn: item["netCoreSomaxconn"],
+        netCoreNetdevMaxBacklog: item["netCoreNetdevMaxBacklog"],
+        netCoreRmemDefault: item["netCoreRmemDefault"],
+        netCoreRmemMax: item["netCoreRmemMax"],
+        netCoreWmemDefault: item["netCoreWmemDefault"],
+        netCoreWmemMax: item["netCoreWmemMax"],
+        netCoreOptmemMax: item["netCoreOptmemMax"],
+        netIpv4TcpMaxSynBacklog: item["netIpv4TcpMaxSynBacklog"],
+        netIpv4TcpMaxTwBuckets: item["netIpv4TcpMaxTwBuckets"],
+        netIpv4TcpFinTimeout: item["netIpv4TcpFinTimeout"],
+        netIpv4TcpKeepaliveTime: item["netIpv4TcpKeepaliveTime"],
+        netIpv4TcpKeepaliveProbes: item["netIpv4TcpKeepaliveProbes"],
+        netIpv4TcpkeepaliveIntvl: item["netIpv4TcpkeepaliveIntvl"],
+        netIpv4TcpTwReuse: item["netIpv4TcpTwReuse"],
+        netIpv4IpLocalPortRange: item["netIpv4IpLocalPortRange"],
+        netIpv4NeighDefaultGcThresh1: item["netIpv4NeighDefaultGcThresh1"],
+        netIpv4NeighDefaultGcThresh2: item["netIpv4NeighDefaultGcThresh2"],
+        netIpv4NeighDefaultGcThresh3: item["netIpv4NeighDefaultGcThresh3"],
+        netNetfilterNfConntrackMax: item["netNetfilterNfConntrackMax"],
+        netNetfilterNfConntrackBuckets: item["netNetfilterNfConntrackBuckets"],
+        fsInotifyMaxUserWatches: item["fsInotifyMaxUserWatches"],
+        fsFileMax: item["fsFileMax"],
+        fsAioMaxNr: item["fsAioMaxNr"],
+        fsNrOpen: item["fsNrOpen"],
+        kernelThreadsMax: item["kernelThreadsMax"],
+        vmMaxMapCount: item["vmMaxMapCount"],
+        vmSwappiness: item["vmSwappiness"],
+        vmVfsCachePressure: item["vmVfsCachePressure"],
+    };
+}
+export function sysctlConfigDeserializer(item) {
+    return {
+        netCoreSomaxconn: item["netCoreSomaxconn"],
+        netCoreNetdevMaxBacklog: item["netCoreNetdevMaxBacklog"],
+        netCoreRmemDefault: item["netCoreRmemDefault"],
+        netCoreRmemMax: item["netCoreRmemMax"],
+        netCoreWmemDefault: item["netCoreWmemDefault"],
+        netCoreWmemMax: item["netCoreWmemMax"],
+        netCoreOptmemMax: item["netCoreOptmemMax"],
+        netIpv4TcpMaxSynBacklog: item["netIpv4TcpMaxSynBacklog"],
+        netIpv4TcpMaxTwBuckets: item["netIpv4TcpMaxTwBuckets"],
+        netIpv4TcpFinTimeout: item["netIpv4TcpFinTimeout"],
+        netIpv4TcpKeepaliveTime: item["netIpv4TcpKeepaliveTime"],
+        netIpv4TcpKeepaliveProbes: item["netIpv4TcpKeepaliveProbes"],
+        netIpv4TcpkeepaliveIntvl: item["netIpv4TcpkeepaliveIntvl"],
+        netIpv4TcpTwReuse: item["netIpv4TcpTwReuse"],
+        netIpv4IpLocalPortRange: item["netIpv4IpLocalPortRange"],
+        netIpv4NeighDefaultGcThresh1: item["netIpv4NeighDefaultGcThresh1"],
+        netIpv4NeighDefaultGcThresh2: item["netIpv4NeighDefaultGcThresh2"],
+        netIpv4NeighDefaultGcThresh3: item["netIpv4NeighDefaultGcThresh3"],
+        netNetfilterNfConntrackMax: item["netNetfilterNfConntrackMax"],
+        netNetfilterNfConntrackBuckets: item["netNetfilterNfConntrackBuckets"],
+        fsInotifyMaxUserWatches: item["fsInotifyMaxUserWatches"],
+        fsFileMax: item["fsFileMax"],
+        fsAioMaxNr: item["fsAioMaxNr"],
+        fsNrOpen: item["fsNrOpen"],
+        kernelThreadsMax: item["kernelThreadsMax"],
+        vmMaxMapCount: item["vmMaxMapCount"],
+        vmSwappiness: item["vmSwappiness"],
+        vmVfsCachePressure: item["vmVfsCachePressure"],
+    };
+}
+/** GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. */
+export var KnownGPUInstanceProfile;
+(function (KnownGPUInstanceProfile) {
+    /** MIG 1g GPU instance profile. */
+    KnownGPUInstanceProfile["MIG1G"] = "MIG1g";
+    /** MIG 2g GPU instance profile. */
+    KnownGPUInstanceProfile["MIG2G"] = "MIG2g";
+    /** MIG 3g GPU instance profile. */
+    KnownGPUInstanceProfile["MIG3G"] = "MIG3g";
+    /** MIG 4g GPU instance profile. */
+    KnownGPUInstanceProfile["MIG4G"] = "MIG4g";
+    /** MIG 7g GPU instance profile. */
+    KnownGPUInstanceProfile["MIG7G"] = "MIG7g";
+})(KnownGPUInstanceProfile || (KnownGPUInstanceProfile = {}));
+export function creationDataSerializer(item) {
+    return { sourceResourceId: item["sourceResourceId"] };
+}
+export function creationDataDeserializer(item) {
+    return {
+        sourceResourceId: item["sourceResourceId"],
+    };
+}
+export function agentPoolNetworkProfileSerializer(item) {
+    return {
+        nodePublicIPTags: !item["nodePublicIPTags"]
+            ? item["nodePublicIPTags"]
+            : ipTagArraySerializer(item["nodePublicIPTags"]),
+        allowedHostPorts: !item["allowedHostPorts"]
+            ? item["allowedHostPorts"]
+            : portRangeArraySerializer(item["allowedHostPorts"]),
+        applicationSecurityGroups: !item["applicationSecurityGroups"]
+            ? item["applicationSecurityGroups"]
+            : item["applicationSecurityGroups"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function agentPoolNetworkProfileDeserializer(item) {
+    return {
+        nodePublicIPTags: !item["nodePublicIPTags"]
+            ? item["nodePublicIPTags"]
+            : ipTagArrayDeserializer(item["nodePublicIPTags"]),
+        allowedHostPorts: !item["allowedHostPorts"]
+            ? item["allowedHostPorts"]
+            : portRangeArrayDeserializer(item["allowedHostPorts"]),
+        applicationSecurityGroups: !item["applicationSecurityGroups"]
+            ? item["applicationSecurityGroups"]
+            : item["applicationSecurityGroups"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function ipTagArraySerializer(result) {
+    return result.map((item) => {
+        return ipTagSerializer(item);
+    });
+}
+export function ipTagArrayDeserializer(result) {
+    return result.map((item) => {
+        return ipTagDeserializer(item);
+    });
+}
+export function ipTagSerializer(item) {
+    return { ipTagType: item["ipTagType"], tag: item["tag"] };
+}
+export function ipTagDeserializer(item) {
+    return {
+        ipTagType: item["ipTagType"],
+        tag: item["tag"],
+    };
+}
+export function portRangeArraySerializer(result) {
+    return result.map((item) => {
+        return portRangeSerializer(item);
+    });
+}
+export function portRangeArrayDeserializer(result) {
+    return result.map((item) => {
+        return portRangeDeserializer(item);
+    });
+}
+export function portRangeSerializer(item) {
+    return { portStart: item["portStart"], portEnd: item["portEnd"], protocol: item["protocol"] };
+}
+export function portRangeDeserializer(item) {
+    return {
+        portStart: item["portStart"],
+        portEnd: item["portEnd"],
+        protocol: item["protocol"],
+    };
+}
+/** The network protocol of the port. */
+export var KnownProtocol;
+(function (KnownProtocol) {
+    /** TCP protocol. */
+    KnownProtocol["TCP"] = "TCP";
+    /** UDP protocol. */
+    KnownProtocol["UDP"] = "UDP";
+})(KnownProtocol || (KnownProtocol = {}));
+export function agentPoolWindowsProfileSerializer(item) {
+    return { disableOutboundNat: item["disableOutboundNat"] };
+}
+export function agentPoolWindowsProfileDeserializer(item) {
+    return {
+        disableOutboundNat: item["disableOutboundNat"],
+    };
+}
+export function agentPoolSecurityProfileSerializer(item) {
+    return {
+        enableVTPM: item["enableVtpm"],
+        enableSecureBoot: item["enableSecureBoot"],
+        sshAccess: item["sshAccess"],
+    };
+}
+export function agentPoolSecurityProfileDeserializer(item) {
+    return {
+        enableVtpm: item["enableVTPM"],
+        enableSecureBoot: item["enableSecureBoot"],
+        sshAccess: item["sshAccess"],
+    };
+}
+/** SSH access method of an agent pool. */
+export var KnownAgentPoolSSHAccess;
+(function (KnownAgentPoolSSHAccess) {
+    /** Can SSH onto the node as a local user using private key. */
+    KnownAgentPoolSSHAccess["LocalUser"] = "LocalUser";
+    /** SSH service will be turned off on the node. */
+    KnownAgentPoolSSHAccess["Disabled"] = "Disabled";
+})(KnownAgentPoolSSHAccess || (KnownAgentPoolSSHAccess = {}));
+export function gpuProfileSerializer(item) {
+    return { driver: item["driver"] };
+}
+export function gpuProfileDeserializer(item) {
+    return {
+        driver: item["driver"],
+    };
+}
+/** Whether to install GPU drivers. When it's not specified, default is Install. */
+export var KnownGPUDriver;
+(function (KnownGPUDriver) {
+    /** Install driver. */
+    KnownGPUDriver["Install"] = "Install";
+    /** Skip driver install. */
+    KnownGPUDriver["None"] = "None";
+})(KnownGPUDriver || (KnownGPUDriver = {}));
+export function agentPoolGatewayProfileSerializer(item) {
+    return { publicIPPrefixSize: item["publicIPPrefixSize"] };
+}
+export function agentPoolGatewayProfileDeserializer(item) {
+    return {
+        publicIPPrefixSize: item["publicIPPrefixSize"],
+    };
+}
+export function virtualMachinesProfileSerializer(item) {
+    return { scale: !item["scale"] ? item["scale"] : scaleProfileSerializer(item["scale"]) };
+}
+export function virtualMachinesProfileDeserializer(item) {
+    return {
+        scale: !item["scale"] ? item["scale"] : scaleProfileDeserializer(item["scale"]),
+    };
+}
+export function scaleProfileSerializer(item) {
+    return {
+        manual: !item["manual"] ? item["manual"] : manualScaleProfileArraySerializer(item["manual"]),
+    };
+}
+export function scaleProfileDeserializer(item) {
+    return {
+        manual: !item["manual"] ? item["manual"] : manualScaleProfileArrayDeserializer(item["manual"]),
+    };
+}
+export function manualScaleProfileArraySerializer(result) {
+    return result.map((item) => {
+        return manualScaleProfileSerializer(item);
+    });
+}
+export function manualScaleProfileArrayDeserializer(result) {
+    return result.map((item) => {
+        return manualScaleProfileDeserializer(item);
+    });
+}
+export function manualScaleProfileSerializer(item) {
+    return { size: item["size"], count: item["count"] };
+}
+export function manualScaleProfileDeserializer(item) {
+    return {
+        size: item["size"],
+        count: item["count"],
+    };
+}
+export function virtualMachineNodesArraySerializer(result) {
+    return result.map((item) => {
+        return virtualMachineNodesSerializer(item);
+    });
+}
+export function virtualMachineNodesArrayDeserializer(result) {
+    return result.map((item) => {
+        return virtualMachineNodesDeserializer(item);
+    });
+}
+export function virtualMachineNodesSerializer(item) {
+    return { size: item["size"], count: item["count"] };
+}
+export function virtualMachineNodesDeserializer(item) {
+    return {
+        size: item["size"],
+        count: item["count"],
+    };
+}
+export function agentPoolStatusSerializer(item) {
+    return item;
+}
+export function agentPoolStatusDeserializer(item) {
+    return {
+        provisioningError: !item["provisioningError"]
+            ? item["provisioningError"]
+            : errorDetailDeserializer(item["provisioningError"]),
+    };
+}
+export function errorDetailDeserializer(item) {
+    return {
+        code: item["code"],
+        message: item["message"],
+        target: item["target"],
+        details: !item["details"] ? item["details"] : errorDetailArrayDeserializer(item["details"]),
+        additionalInfo: !item["additionalInfo"]
+            ? item["additionalInfo"]
+            : errorAdditionalInfoArrayDeserializer(item["additionalInfo"]),
+    };
+}
+export function errorDetailArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorDetailDeserializer(item);
+    });
+}
+export function errorAdditionalInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorAdditionalInfoDeserializer(item);
+    });
+}
+export function errorAdditionalInfoDeserializer(item) {
+    return {
+        type: item["type"],
+        info: item["info"],
+    };
+}
+export function localDNSProfileSerializer(item) {
+    return {
+        mode: item["mode"],
+        vnetDNSOverrides: !item["vnetDNSOverrides"]
+            ? item["vnetDNSOverrides"]
+            : localDNSOverrideRecordSerializer(item["vnetDNSOverrides"]),
+        kubeDNSOverrides: !item["kubeDNSOverrides"]
+            ? item["kubeDNSOverrides"]
+            : localDNSOverrideRecordSerializer(item["kubeDNSOverrides"]),
+    };
+}
+export function localDNSProfileDeserializer(item) {
+    return {
+        mode: item["mode"],
+        state: item["state"],
+        vnetDNSOverrides: !item["vnetDNSOverrides"]
+            ? item["vnetDNSOverrides"]
+            : localDNSOverrideRecordDeserializer(item["vnetDNSOverrides"]),
+        kubeDNSOverrides: !item["kubeDNSOverrides"]
+            ? item["kubeDNSOverrides"]
+            : localDNSOverrideRecordDeserializer(item["kubeDNSOverrides"]),
+    };
+}
+/** Mode of enablement for localDNS. */
+export var KnownLocalDNSMode;
+(function (KnownLocalDNSMode) {
+    /** If the current orchestrator version supports this feature, prefer enabling localDNS. */
+    KnownLocalDNSMode["Preferred"] = "Preferred";
+    /** Enable localDNS. */
+    KnownLocalDNSMode["Required"] = "Required";
+    /** Disable localDNS. */
+    KnownLocalDNSMode["Disabled"] = "Disabled";
+})(KnownLocalDNSMode || (KnownLocalDNSMode = {}));
+/** System-generated state of localDNS. */
+export var KnownLocalDNSState;
+(function (KnownLocalDNSState) {
+    /** localDNS is enabled. */
+    KnownLocalDNSState["Enabled"] = "Enabled";
+    /** localDNS is disabled. */
+    KnownLocalDNSState["Disabled"] = "Disabled";
+})(KnownLocalDNSState || (KnownLocalDNSState = {}));
+export function localDNSOverrideRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : localDNSOverrideSerializer(item[key]);
+    });
+    return result;
+}
+export function localDNSOverrideRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : localDNSOverrideDeserializer(item[key]);
+    });
+    return result;
+}
+export function localDNSOverrideSerializer(item) {
+    return {
+        queryLogging: item["queryLogging"],
+        protocol: item["protocol"],
+        forwardDestination: item["forwardDestination"],
+        forwardPolicy: item["forwardPolicy"],
+        maxConcurrent: item["maxConcurrent"],
+        cacheDurationInSeconds: item["cacheDurationInSeconds"],
+        serveStaleDurationInSeconds: item["serveStaleDurationInSeconds"],
+        serveStale: item["serveStale"],
+    };
+}
+export function localDNSOverrideDeserializer(item) {
+    return {
+        queryLogging: item["queryLogging"],
+        protocol: item["protocol"],
+        forwardDestination: item["forwardDestination"],
+        forwardPolicy: item["forwardPolicy"],
+        maxConcurrent: item["maxConcurrent"],
+        cacheDurationInSeconds: item["cacheDurationInSeconds"],
+        serveStaleDurationInSeconds: item["serveStaleDurationInSeconds"],
+        serveStale: item["serveStale"],
+    };
+}
+/** Log level for DNS queries in localDNS. */
+export var KnownLocalDNSQueryLogging;
+(function (KnownLocalDNSQueryLogging) {
+    /** Enables error logging in localDNS. See [errors plugin](https://coredns.io/plugins/errors) for more information. */
+    KnownLocalDNSQueryLogging["Error"] = "Error";
+    /** Enables query logging in localDNS. See [log plugin](https://coredns.io/plugins/log) for more information. */
+    KnownLocalDNSQueryLogging["Log"] = "Log";
+})(KnownLocalDNSQueryLogging || (KnownLocalDNSQueryLogging = {}));
+/** Enforce TCP or prefer UDP protocol for connections from localDNS to upstream DNS server. */
+export var KnownLocalDNSProtocol;
+(function (KnownLocalDNSProtocol) {
+    /** Prefer UDP protocol for connections from localDNS to upstream DNS server. */
+    KnownLocalDNSProtocol["PreferUDP"] = "PreferUDP";
+    /** Enforce TCP protocol for connections from localDNS to upstream DNS server. */
+    KnownLocalDNSProtocol["ForceTCP"] = "ForceTCP";
+})(KnownLocalDNSProtocol || (KnownLocalDNSProtocol = {}));
+/** Destination server for DNS queries to be forwarded from localDNS. */
+export var KnownLocalDNSForwardDestination;
+(function (KnownLocalDNSForwardDestination) {
+    /** Forward DNS queries from localDNS to cluster CoreDNS. */
+    KnownLocalDNSForwardDestination["ClusterCoreDNS"] = "ClusterCoreDNS";
+    /** Forward DNS queries from localDNS to DNS server configured in the VNET. A VNET can have multiple DNS servers configured. */
+    KnownLocalDNSForwardDestination["VnetDNS"] = "VnetDNS";
+})(KnownLocalDNSForwardDestination || (KnownLocalDNSForwardDestination = {}));
+/** Forward policy for selecting upstream DNS server. See [forward plugin](https://coredns.io/plugins/forward) for more information. */
+export var KnownLocalDNSForwardPolicy;
+(function (KnownLocalDNSForwardPolicy) {
+    /** Implements sequential upstream DNS server selection. See [forward plugin](https://coredns.io/plugins/forward) for more information. */
+    KnownLocalDNSForwardPolicy["Sequential"] = "Sequential";
+    /** Implements round robin upstream DNS server selection. See [forward plugin](https://coredns.io/plugins/forward) for more information. */
+    KnownLocalDNSForwardPolicy["RoundRobin"] = "RoundRobin";
+    /** Implements random upstream DNS server selection. See [forward plugin](https://coredns.io/plugins/forward) for more information. */
+    KnownLocalDNSForwardPolicy["Random"] = "Random";
+})(KnownLocalDNSForwardPolicy || (KnownLocalDNSForwardPolicy = {}));
+/** Policy for serving stale data. See [cache plugin](https://coredns.io/plugins/cache) for more information. */
+export var KnownLocalDNSServeStale;
+(function (KnownLocalDNSServeStale) {
+    /** Serve stale data with verification. First verify that an entry is still unavailable from the source before sending the expired entry to the client. See [cache plugin](https://coredns.io/plugins/cache) for more information. */
+    KnownLocalDNSServeStale["Verify"] = "Verify";
+    /** Serve stale data immediately. Send the expired entry to the client before checking to see if the entry is available from the source. See [cache plugin](https://coredns.io/plugins/cache) for more information. */
+    KnownLocalDNSServeStale["Immediate"] = "Immediate";
+    /** Disable serving stale data. */
+    KnownLocalDNSServeStale["Disable"] = "Disable";
+})(KnownLocalDNSServeStale || (KnownLocalDNSServeStale = {}));
+export function proxyResourceSerializer(item) {
+    return item;
+}
+export function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function resourceSerializer(item) {
+    return item;
+}
+export function resourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function systemDataDeserializer(item) {
+    return {
+        createdBy: item["createdBy"],
+        createdByType: item["createdByType"],
+        createdAt: !item["createdAt"] ? item["createdAt"] : new Date(item["createdAt"]),
+        lastModifiedBy: item["lastModifiedBy"],
+        lastModifiedByType: item["lastModifiedByType"],
+        lastModifiedAt: !item["lastModifiedAt"]
+            ? item["lastModifiedAt"]
+            : new Date(item["lastModifiedAt"]),
+    };
+}
+/** The kind of entity that created the resource. */
+export var KnownCreatedByType;
+(function (KnownCreatedByType) {
+    /** The entity was created by a user. */
+    KnownCreatedByType["User"] = "User";
+    /** The entity was created by an application. */
+    KnownCreatedByType["Application"] = "Application";
+    /** The entity was created by a managed identity. */
+    KnownCreatedByType["ManagedIdentity"] = "ManagedIdentity";
+    /** The entity was created by a key. */
+    KnownCreatedByType["Key"] = "Key";
+})(KnownCreatedByType || (KnownCreatedByType = {}));
+export function errorResponseDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"]),
+    };
+}
+export function _agentPoolListResultDeserializer(item) {
+    return {
+        value: agentPoolArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function agentPoolArraySerializer(result) {
+    return result.map((item) => {
+        return agentPoolSerializer(item);
+    });
+}
+export function agentPoolArrayDeserializer(result) {
+    return result.map((item) => {
+        return agentPoolDeserializer(item);
+    });
+}
+export function agentPoolDeleteMachinesParameterSerializer(item) {
+    return {
+        machineNames: item["machineNames"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function agentPoolAvailableVersionsDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        ..._agentPoolAvailableVersionsPropertiesDeserializer(item["properties"]),
+    };
+}
+export function agentPoolAvailableVersionsPropertiesDeserializer(item) {
+    return {
+        agentPoolVersions: !item["agentPoolVersions"]
+            ? item["agentPoolVersions"]
+            : agentPoolAvailableVersionsPropertiesAgentPoolVersionsItemArrayDeserializer(item["agentPoolVersions"]),
+    };
+}
+export function agentPoolAvailableVersionsPropertiesAgentPoolVersionsItemArrayDeserializer(result) {
+    return result.map((item) => {
+        return agentPoolAvailableVersionsPropertiesAgentPoolVersionsItemDeserializer(item);
+    });
+}
+export function agentPoolAvailableVersionsPropertiesAgentPoolVersionsItemDeserializer(item) {
+    return {
+        default: item["default"],
+        kubernetesVersion: item["kubernetesVersion"],
+        isPreview: item["isPreview"],
+    };
+}
+export function agentPoolUpgradeProfileDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ..._agentPoolUpgradeProfilePropertiesDeserializer(item["properties"]),
+    };
+}
+export function agentPoolUpgradeProfilePropertiesDeserializer(item) {
+    return {
+        kubernetesVersion: item["kubernetesVersion"],
+        osType: item["osType"],
+        upgrades: !item["upgrades"]
+            ? item["upgrades"]
+            : agentPoolUpgradeProfilePropertiesUpgradesItemArrayDeserializer(item["upgrades"]),
+        latestNodeImageVersion: item["latestNodeImageVersion"],
+    };
+}
+export function agentPoolUpgradeProfilePropertiesUpgradesItemArrayDeserializer(result) {
+    return result.map((item) => {
+        return agentPoolUpgradeProfilePropertiesUpgradesItemDeserializer(item);
+    });
+}
+export function agentPoolUpgradeProfilePropertiesUpgradesItemDeserializer(item) {
+    return {
+        kubernetesVersion: item["kubernetesVersion"],
+        isPreview: item["isPreview"],
+    };
+}
+export function managedClusterSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: areAllPropsUndefined(item, [
+            "kubernetesVersion",
+            "dnsPrefix",
+            "fqdnSubdomain",
+            "agentPoolProfiles",
+            "linuxProfile",
+            "windowsProfile",
+            "servicePrincipalProfile",
+            "addonProfiles",
+            "podIdentityProfile",
+            "oidcIssuerProfile",
+            "nodeResourceGroup",
+            "nodeResourceGroupProfile",
+            "enableRBAC",
+            "supportPlan",
+            "networkProfile",
+            "aadProfile",
+            "autoUpgradeProfile",
+            "upgradeSettings",
+            "autoScalerProfile",
+            "apiServerAccessProfile",
+            "diskEncryptionSetID",
+            "identityProfile",
+            "privateLinkResources",
+            "disableLocalAccounts",
+            "httpProxyConfig",
+            "securityProfile",
+            "storageProfile",
+            "ingressProfile",
+            "publicNetworkAccess",
+            "workloadAutoScalerProfile",
+            "azureMonitorProfile",
+            "serviceMeshProfile",
+            "metricsProfile",
+            "nodeProvisioningProfile",
+            "bootstrapProfile",
+            "aiToolchainOperatorProfile",
+            "status",
+        ])
+            ? undefined
+            : _managedClusterPropertiesSerializer(item),
+        sku: !item["sku"] ? item["sku"] : managedClusterSKUSerializer(item["sku"]),
+        extendedLocation: !item["extendedLocation"]
+            ? item["extendedLocation"]
+            : extendedLocationSerializer(item["extendedLocation"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedClusterIdentitySerializer(item["identity"]),
+        kind: item["kind"],
+    };
+}
+export function managedClusterDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _managedClusterPropertiesDeserializer(item["properties"])),
+        eTag: item["eTag"],
+        sku: !item["sku"] ? item["sku"] : managedClusterSKUDeserializer(item["sku"]),
+        extendedLocation: !item["extendedLocation"]
+            ? item["extendedLocation"]
+            : extendedLocationDeserializer(item["extendedLocation"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedClusterIdentityDeserializer(item["identity"]),
+        kind: item["kind"],
+    };
+}
+export function managedClusterPropertiesSerializer(item) {
+    return {
+        kubernetesVersion: item["kubernetesVersion"],
+        dnsPrefix: item["dnsPrefix"],
+        fqdnSubdomain: item["fqdnSubdomain"],
+        agentPoolProfiles: !item["agentPoolProfiles"]
+            ? item["agentPoolProfiles"]
+            : managedClusterAgentPoolProfileArraySerializer(item["agentPoolProfiles"]),
+        linuxProfile: !item["linuxProfile"]
+            ? item["linuxProfile"]
+            : containerServiceLinuxProfileSerializer(item["linuxProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : managedClusterWindowsProfileSerializer(item["windowsProfile"]),
+        servicePrincipalProfile: !item["servicePrincipalProfile"]
+            ? item["servicePrincipalProfile"]
+            : managedClusterServicePrincipalProfileSerializer(item["servicePrincipalProfile"]),
+        addonProfiles: !item["addonProfiles"]
+            ? item["addonProfiles"]
+            : managedClusterAddonProfileRecordSerializer(item["addonProfiles"]),
+        podIdentityProfile: !item["podIdentityProfile"]
+            ? item["podIdentityProfile"]
+            : managedClusterPodIdentityProfileSerializer(item["podIdentityProfile"]),
+        oidcIssuerProfile: !item["oidcIssuerProfile"]
+            ? item["oidcIssuerProfile"]
+            : managedClusterOidcIssuerProfileSerializer(item["oidcIssuerProfile"]),
+        nodeResourceGroup: item["nodeResourceGroup"],
+        nodeResourceGroupProfile: !item["nodeResourceGroupProfile"]
+            ? item["nodeResourceGroupProfile"]
+            : managedClusterNodeResourceGroupProfileSerializer(item["nodeResourceGroupProfile"]),
+        enableRBAC: item["enableRbac"],
+        supportPlan: item["supportPlan"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : containerServiceNetworkProfileSerializer(item["networkProfile"]),
+        aadProfile: !item["aadProfile"]
+            ? item["aadProfile"]
+            : managedClusterAADProfileSerializer(item["aadProfile"]),
+        autoUpgradeProfile: !item["autoUpgradeProfile"]
+            ? item["autoUpgradeProfile"]
+            : managedClusterAutoUpgradeProfileSerializer(item["autoUpgradeProfile"]),
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : clusterUpgradeSettingsSerializer(item["upgradeSettings"]),
+        autoScalerProfile: !item["autoScalerProfile"]
+            ? item["autoScalerProfile"]
+            : managedClusterPropertiesAutoScalerProfileSerializer(item["autoScalerProfile"]),
+        apiServerAccessProfile: !item["apiServerAccessProfile"]
+            ? item["apiServerAccessProfile"]
+            : managedClusterAPIServerAccessProfileSerializer(item["apiServerAccessProfile"]),
+        diskEncryptionSetID: item["diskEncryptionSetID"],
+        identityProfile: !item["identityProfile"]
+            ? item["identityProfile"]
+            : userAssignedIdentityRecordSerializer(item["identityProfile"]),
+        privateLinkResources: !item["privateLinkResources"]
+            ? item["privateLinkResources"]
+            : privateLinkResourceArraySerializer(item["privateLinkResources"]),
+        disableLocalAccounts: item["disableLocalAccounts"],
+        httpProxyConfig: !item["httpProxyConfig"]
+            ? item["httpProxyConfig"]
+            : managedClusterHttpProxyConfigSerializer(item["httpProxyConfig"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : managedClusterSecurityProfileSerializer(item["securityProfile"]),
+        storageProfile: !item["storageProfile"]
+            ? item["storageProfile"]
+            : managedClusterStorageProfileSerializer(item["storageProfile"]),
+        ingressProfile: !item["ingressProfile"]
+            ? item["ingressProfile"]
+            : managedClusterIngressProfileSerializer(item["ingressProfile"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+        workloadAutoScalerProfile: !item["workloadAutoScalerProfile"]
+            ? item["workloadAutoScalerProfile"]
+            : managedClusterWorkloadAutoScalerProfileSerializer(item["workloadAutoScalerProfile"]),
+        azureMonitorProfile: !item["azureMonitorProfile"]
+            ? item["azureMonitorProfile"]
+            : managedClusterAzureMonitorProfileSerializer(item["azureMonitorProfile"]),
+        serviceMeshProfile: !item["serviceMeshProfile"]
+            ? item["serviceMeshProfile"]
+            : serviceMeshProfileSerializer(item["serviceMeshProfile"]),
+        metricsProfile: !item["metricsProfile"]
+            ? item["metricsProfile"]
+            : managedClusterMetricsProfileSerializer(item["metricsProfile"]),
+        nodeProvisioningProfile: !item["nodeProvisioningProfile"]
+            ? item["nodeProvisioningProfile"]
+            : managedClusterNodeProvisioningProfileSerializer(item["nodeProvisioningProfile"]),
+        bootstrapProfile: !item["bootstrapProfile"]
+            ? item["bootstrapProfile"]
+            : managedClusterBootstrapProfileSerializer(item["bootstrapProfile"]),
+        aiToolchainOperatorProfile: !item["aiToolchainOperatorProfile"]
+            ? item["aiToolchainOperatorProfile"]
+            : managedClusterAIToolchainOperatorProfileSerializer(item["aiToolchainOperatorProfile"]),
+        status: !item["status"] ? item["status"] : managedClusterStatusSerializer(item["status"]),
+    };
+}
+export function managedClusterPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        powerState: !item["powerState"]
+            ? item["powerState"]
+            : powerStateDeserializer(item["powerState"]),
+        maxAgentPools: item["maxAgentPools"],
+        kubernetesVersion: item["kubernetesVersion"],
+        currentKubernetesVersion: item["currentKubernetesVersion"],
+        dnsPrefix: item["dnsPrefix"],
+        fqdnSubdomain: item["fqdnSubdomain"],
+        fqdn: item["fqdn"],
+        privateFqdn: item["privateFQDN"],
+        azurePortalFqdn: item["azurePortalFQDN"],
+        agentPoolProfiles: !item["agentPoolProfiles"]
+            ? item["agentPoolProfiles"]
+            : managedClusterAgentPoolProfileArrayDeserializer(item["agentPoolProfiles"]),
+        linuxProfile: !item["linuxProfile"]
+            ? item["linuxProfile"]
+            : containerServiceLinuxProfileDeserializer(item["linuxProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : managedClusterWindowsProfileDeserializer(item["windowsProfile"]),
+        servicePrincipalProfile: !item["servicePrincipalProfile"]
+            ? item["servicePrincipalProfile"]
+            : managedClusterServicePrincipalProfileDeserializer(item["servicePrincipalProfile"]),
+        addonProfiles: !item["addonProfiles"]
+            ? item["addonProfiles"]
+            : managedClusterAddonProfileRecordDeserializer(item["addonProfiles"]),
+        podIdentityProfile: !item["podIdentityProfile"]
+            ? item["podIdentityProfile"]
+            : managedClusterPodIdentityProfileDeserializer(item["podIdentityProfile"]),
+        oidcIssuerProfile: !item["oidcIssuerProfile"]
+            ? item["oidcIssuerProfile"]
+            : managedClusterOidcIssuerProfileDeserializer(item["oidcIssuerProfile"]),
+        nodeResourceGroup: item["nodeResourceGroup"],
+        nodeResourceGroupProfile: !item["nodeResourceGroupProfile"]
+            ? item["nodeResourceGroupProfile"]
+            : managedClusterNodeResourceGroupProfileDeserializer(item["nodeResourceGroupProfile"]),
+        enableRbac: item["enableRBAC"],
+        supportPlan: item["supportPlan"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : containerServiceNetworkProfileDeserializer(item["networkProfile"]),
+        aadProfile: !item["aadProfile"]
+            ? item["aadProfile"]
+            : managedClusterAADProfileDeserializer(item["aadProfile"]),
+        autoUpgradeProfile: !item["autoUpgradeProfile"]
+            ? item["autoUpgradeProfile"]
+            : managedClusterAutoUpgradeProfileDeserializer(item["autoUpgradeProfile"]),
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : clusterUpgradeSettingsDeserializer(item["upgradeSettings"]),
+        autoScalerProfile: !item["autoScalerProfile"]
+            ? item["autoScalerProfile"]
+            : managedClusterPropertiesAutoScalerProfileDeserializer(item["autoScalerProfile"]),
+        apiServerAccessProfile: !item["apiServerAccessProfile"]
+            ? item["apiServerAccessProfile"]
+            : managedClusterAPIServerAccessProfileDeserializer(item["apiServerAccessProfile"]),
+        diskEncryptionSetID: item["diskEncryptionSetID"],
+        identityProfile: !item["identityProfile"]
+            ? item["identityProfile"]
+            : userAssignedIdentityRecordDeserializer(item["identityProfile"]),
+        privateLinkResources: !item["privateLinkResources"]
+            ? item["privateLinkResources"]
+            : privateLinkResourceArrayDeserializer(item["privateLinkResources"]),
+        disableLocalAccounts: item["disableLocalAccounts"],
+        httpProxyConfig: !item["httpProxyConfig"]
+            ? item["httpProxyConfig"]
+            : managedClusterHttpProxyConfigDeserializer(item["httpProxyConfig"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : managedClusterSecurityProfileDeserializer(item["securityProfile"]),
+        storageProfile: !item["storageProfile"]
+            ? item["storageProfile"]
+            : managedClusterStorageProfileDeserializer(item["storageProfile"]),
+        ingressProfile: !item["ingressProfile"]
+            ? item["ingressProfile"]
+            : managedClusterIngressProfileDeserializer(item["ingressProfile"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+        workloadAutoScalerProfile: !item["workloadAutoScalerProfile"]
+            ? item["workloadAutoScalerProfile"]
+            : managedClusterWorkloadAutoScalerProfileDeserializer(item["workloadAutoScalerProfile"]),
+        azureMonitorProfile: !item["azureMonitorProfile"]
+            ? item["azureMonitorProfile"]
+            : managedClusterAzureMonitorProfileDeserializer(item["azureMonitorProfile"]),
+        serviceMeshProfile: !item["serviceMeshProfile"]
+            ? item["serviceMeshProfile"]
+            : serviceMeshProfileDeserializer(item["serviceMeshProfile"]),
+        resourceUID: item["resourceUID"],
+        metricsProfile: !item["metricsProfile"]
+            ? item["metricsProfile"]
+            : managedClusterMetricsProfileDeserializer(item["metricsProfile"]),
+        nodeProvisioningProfile: !item["nodeProvisioningProfile"]
+            ? item["nodeProvisioningProfile"]
+            : managedClusterNodeProvisioningProfileDeserializer(item["nodeProvisioningProfile"]),
+        bootstrapProfile: !item["bootstrapProfile"]
+            ? item["bootstrapProfile"]
+            : managedClusterBootstrapProfileDeserializer(item["bootstrapProfile"]),
+        aiToolchainOperatorProfile: !item["aiToolchainOperatorProfile"]
+            ? item["aiToolchainOperatorProfile"]
+            : managedClusterAIToolchainOperatorProfileDeserializer(item["aiToolchainOperatorProfile"]),
+        status: !item["status"] ? item["status"] : managedClusterStatusDeserializer(item["status"]),
+    };
+}
+export function managedClusterAgentPoolProfileArraySerializer(result) {
+    return result.map((item) => {
+        return managedClusterAgentPoolProfileSerializer(item);
+    });
+}
+export function managedClusterAgentPoolProfileArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedClusterAgentPoolProfileDeserializer(item);
+    });
+}
+export function managedClusterAgentPoolProfileSerializer(item) {
+    return {
+        count: item["count"],
+        vmSize: item["vmSize"],
+        osDiskSizeGB: item["osDiskSizeGB"],
+        osDiskType: item["osDiskType"],
+        kubeletDiskType: item["kubeletDiskType"],
+        workloadRuntime: item["workloadRuntime"],
+        messageOfTheDay: item["messageOfTheDay"],
+        vnetSubnetID: item["vnetSubnetID"],
+        podSubnetID: item["podSubnetID"],
+        podIPAllocationMode: item["podIPAllocationMode"],
+        maxPods: item["maxPods"],
+        osType: item["osType"],
+        osSKU: item["osSKU"],
+        maxCount: item["maxCount"],
+        minCount: item["minCount"],
+        enableAutoScaling: item["enableAutoScaling"],
+        scaleDownMode: item["scaleDownMode"],
+        type: item["type"],
+        mode: item["mode"],
+        orchestratorVersion: item["orchestratorVersion"],
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : agentPoolUpgradeSettingsSerializer(item["upgradeSettings"]),
+        powerState: !item["powerState"] ? item["powerState"] : powerStateSerializer(item["powerState"]),
+        availabilityZones: !item["availabilityZones"]
+            ? item["availabilityZones"]
+            : item["availabilityZones"].map((p) => {
+                return p;
+            }),
+        enableNodePublicIP: item["enableNodePublicIP"],
+        nodePublicIPPrefixID: item["nodePublicIPPrefixID"],
+        scaleSetPriority: item["scaleSetPriority"],
+        scaleSetEvictionPolicy: item["scaleSetEvictionPolicy"],
+        spotMaxPrice: item["spotMaxPrice"],
+        tags: item["tags"],
+        nodeLabels: item["nodeLabels"],
+        nodeTaints: !item["nodeTaints"]
+            ? item["nodeTaints"]
+            : item["nodeTaints"].map((p) => {
+                return p;
+            }),
+        proximityPlacementGroupID: item["proximityPlacementGroupID"],
+        kubeletConfig: !item["kubeletConfig"]
+            ? item["kubeletConfig"]
+            : kubeletConfigSerializer(item["kubeletConfig"]),
+        linuxOSConfig: !item["linuxOSConfig"]
+            ? item["linuxOSConfig"]
+            : linuxOSConfigSerializer(item["linuxOSConfig"]),
+        enableEncryptionAtHost: item["enableEncryptionAtHost"],
+        enableUltraSSD: item["enableUltraSSD"],
+        enableFIPS: item["enableFips"],
+        gpuInstanceProfile: item["gpuInstanceProfile"],
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataSerializer(item["creationData"]),
+        capacityReservationGroupID: item["capacityReservationGroupID"],
+        hostGroupID: item["hostGroupID"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : agentPoolNetworkProfileSerializer(item["networkProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : agentPoolWindowsProfileSerializer(item["windowsProfile"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : agentPoolSecurityProfileSerializer(item["securityProfile"]),
+        gpuProfile: !item["gpuProfile"] ? item["gpuProfile"] : gpuProfileSerializer(item["gpuProfile"]),
+        gatewayProfile: !item["gatewayProfile"]
+            ? item["gatewayProfile"]
+            : agentPoolGatewayProfileSerializer(item["gatewayProfile"]),
+        virtualMachinesProfile: !item["virtualMachinesProfile"]
+            ? item["virtualMachinesProfile"]
+            : virtualMachinesProfileSerializer(item["virtualMachinesProfile"]),
+        virtualMachineNodesStatus: !item["virtualMachineNodesStatus"]
+            ? item["virtualMachineNodesStatus"]
+            : virtualMachineNodesArraySerializer(item["virtualMachineNodesStatus"]),
+        status: !item["status"] ? item["status"] : agentPoolStatusSerializer(item["status"]),
+        localDNSProfile: !item["localDNSProfile"]
+            ? item["localDNSProfile"]
+            : localDNSProfileSerializer(item["localDNSProfile"]),
+        name: item["name"],
+    };
+}
+export function managedClusterAgentPoolProfileDeserializer(item) {
+    return {
+        eTag: item["eTag"],
+        count: item["count"],
+        vmSize: item["vmSize"],
+        osDiskSizeGB: item["osDiskSizeGB"],
+        osDiskType: item["osDiskType"],
+        kubeletDiskType: item["kubeletDiskType"],
+        workloadRuntime: item["workloadRuntime"],
+        messageOfTheDay: item["messageOfTheDay"],
+        vnetSubnetID: item["vnetSubnetID"],
+        podSubnetID: item["podSubnetID"],
+        podIPAllocationMode: item["podIPAllocationMode"],
+        maxPods: item["maxPods"],
+        osType: item["osType"],
+        osSKU: item["osSKU"],
+        maxCount: item["maxCount"],
+        minCount: item["minCount"],
+        enableAutoScaling: item["enableAutoScaling"],
+        scaleDownMode: item["scaleDownMode"],
+        type: item["type"],
+        mode: item["mode"],
+        orchestratorVersion: item["orchestratorVersion"],
+        currentOrchestratorVersion: item["currentOrchestratorVersion"],
+        nodeImageVersion: item["nodeImageVersion"],
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : agentPoolUpgradeSettingsDeserializer(item["upgradeSettings"]),
+        provisioningState: item["provisioningState"],
+        powerState: !item["powerState"]
+            ? item["powerState"]
+            : powerStateDeserializer(item["powerState"]),
+        availabilityZones: !item["availabilityZones"]
+            ? item["availabilityZones"]
+            : item["availabilityZones"].map((p) => {
+                return p;
+            }),
+        enableNodePublicIP: item["enableNodePublicIP"],
+        nodePublicIPPrefixID: item["nodePublicIPPrefixID"],
+        scaleSetPriority: item["scaleSetPriority"],
+        scaleSetEvictionPolicy: item["scaleSetEvictionPolicy"],
+        spotMaxPrice: item["spotMaxPrice"],
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        nodeLabels: !item["nodeLabels"]
+            ? item["nodeLabels"]
+            : Object.fromEntries(Object.entries(item["nodeLabels"]).map(([k, p]) => [k, p])),
+        nodeTaints: !item["nodeTaints"]
+            ? item["nodeTaints"]
+            : item["nodeTaints"].map((p) => {
+                return p;
+            }),
+        proximityPlacementGroupID: item["proximityPlacementGroupID"],
+        kubeletConfig: !item["kubeletConfig"]
+            ? item["kubeletConfig"]
+            : kubeletConfigDeserializer(item["kubeletConfig"]),
+        linuxOSConfig: !item["linuxOSConfig"]
+            ? item["linuxOSConfig"]
+            : linuxOSConfigDeserializer(item["linuxOSConfig"]),
+        enableEncryptionAtHost: item["enableEncryptionAtHost"],
+        enableUltraSSD: item["enableUltraSSD"],
+        enableFips: item["enableFIPS"],
+        gpuInstanceProfile: item["gpuInstanceProfile"],
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataDeserializer(item["creationData"]),
+        capacityReservationGroupID: item["capacityReservationGroupID"],
+        hostGroupID: item["hostGroupID"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : agentPoolNetworkProfileDeserializer(item["networkProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : agentPoolWindowsProfileDeserializer(item["windowsProfile"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : agentPoolSecurityProfileDeserializer(item["securityProfile"]),
+        gpuProfile: !item["gpuProfile"]
+            ? item["gpuProfile"]
+            : gpuProfileDeserializer(item["gpuProfile"]),
+        gatewayProfile: !item["gatewayProfile"]
+            ? item["gatewayProfile"]
+            : agentPoolGatewayProfileDeserializer(item["gatewayProfile"]),
+        virtualMachinesProfile: !item["virtualMachinesProfile"]
+            ? item["virtualMachinesProfile"]
+            : virtualMachinesProfileDeserializer(item["virtualMachinesProfile"]),
+        virtualMachineNodesStatus: !item["virtualMachineNodesStatus"]
+            ? item["virtualMachineNodesStatus"]
+            : virtualMachineNodesArrayDeserializer(item["virtualMachineNodesStatus"]),
+        status: !item["status"] ? item["status"] : agentPoolStatusDeserializer(item["status"]),
+        localDNSProfile: !item["localDNSProfile"]
+            ? item["localDNSProfile"]
+            : localDNSProfileDeserializer(item["localDNSProfile"]),
+        name: item["name"],
+    };
+}
+export function containerServiceLinuxProfileSerializer(item) {
+    return {
+        adminUsername: item["adminUsername"],
+        ssh: containerServiceSshConfigurationSerializer(item["ssh"]),
+    };
+}
+export function containerServiceLinuxProfileDeserializer(item) {
+    return {
+        adminUsername: item["adminUsername"],
+        ssh: containerServiceSshConfigurationDeserializer(item["ssh"]),
+    };
+}
+export function containerServiceSshConfigurationSerializer(item) {
+    return { publicKeys: containerServiceSshPublicKeyArraySerializer(item["publicKeys"]) };
+}
+export function containerServiceSshConfigurationDeserializer(item) {
+    return {
+        publicKeys: containerServiceSshPublicKeyArrayDeserializer(item["publicKeys"]),
+    };
+}
+export function containerServiceSshPublicKeyArraySerializer(result) {
+    return result.map((item) => {
+        return containerServiceSshPublicKeySerializer(item);
+    });
+}
+export function containerServiceSshPublicKeyArrayDeserializer(result) {
+    return result.map((item) => {
+        return containerServiceSshPublicKeyDeserializer(item);
+    });
+}
+export function containerServiceSshPublicKeySerializer(item) {
+    return { keyData: item["keyData"] };
+}
+export function containerServiceSshPublicKeyDeserializer(item) {
+    return {
+        keyData: item["keyData"],
+    };
+}
+export function managedClusterWindowsProfileSerializer(item) {
+    return {
+        adminUsername: item["adminUsername"],
+        adminPassword: item["adminPassword"],
+        licenseType: item["licenseType"],
+        enableCSIProxy: item["enableCSIProxy"],
+        gmsaProfile: !item["gmsaProfile"]
+            ? item["gmsaProfile"]
+            : windowsGmsaProfileSerializer(item["gmsaProfile"]),
+    };
+}
+export function managedClusterWindowsProfileDeserializer(item) {
+    return {
+        adminUsername: item["adminUsername"],
+        adminPassword: item["adminPassword"],
+        licenseType: item["licenseType"],
+        enableCSIProxy: item["enableCSIProxy"],
+        gmsaProfile: !item["gmsaProfile"]
+            ? item["gmsaProfile"]
+            : windowsGmsaProfileDeserializer(item["gmsaProfile"]),
+    };
+}
+/** The license type to use for Windows VMs. See [Azure Hybrid User Benefits](https://azure.microsoft.com/pricing/hybrid-benefit/faq/) for more details. */
+export var KnownLicenseType;
+(function (KnownLicenseType) {
+    /** No additional licensing is applied. */
+    KnownLicenseType["None"] = "None";
+    /** Enables Azure Hybrid User Benefits for Windows VMs. */
+    KnownLicenseType["WindowsServer"] = "Windows_Server";
+})(KnownLicenseType || (KnownLicenseType = {}));
+export function windowsGmsaProfileSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        dnsServer: item["dnsServer"],
+        rootDomainName: item["rootDomainName"],
+    };
+}
+export function windowsGmsaProfileDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        dnsServer: item["dnsServer"],
+        rootDomainName: item["rootDomainName"],
+    };
+}
+export function managedClusterServicePrincipalProfileSerializer(item) {
+    return { clientId: item["clientId"], secret: item["secret"] };
+}
+export function managedClusterServicePrincipalProfileDeserializer(item) {
+    return {
+        clientId: item["clientId"],
+        secret: item["secret"],
+    };
+}
+export function managedClusterAddonProfileRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : managedClusterAddonProfileSerializer(item[key]);
+    });
+    return result;
+}
+export function managedClusterAddonProfileRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : managedClusterAddonProfileDeserializer(item[key]);
+    });
+    return result;
+}
+export function managedClusterAddonProfileSerializer(item) {
+    return { enabled: item["enabled"], config: item["config"] };
+}
+export function managedClusterAddonProfileDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        config: !item["config"]
+            ? item["config"]
+            : Object.fromEntries(Object.entries(item["config"]).map(([k, p]) => [k, p])),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedClusterAddonProfileIdentityDeserializer(item["identity"]),
+    };
+}
+export function managedClusterAddonProfileIdentityDeserializer(item) {
+    return {
+        resourceId: item["resourceId"],
+        clientId: item["clientId"],
+        objectId: item["objectId"],
+    };
+}
+export function managedClusterPodIdentityProfileSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        allowNetworkPluginKubenet: item["allowNetworkPluginKubenet"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : managedClusterPodIdentityArraySerializer(item["userAssignedIdentities"]),
+        userAssignedIdentityExceptions: !item["userAssignedIdentityExceptions"]
+            ? item["userAssignedIdentityExceptions"]
+            : managedClusterPodIdentityExceptionArraySerializer(item["userAssignedIdentityExceptions"]),
+    };
+}
+export function managedClusterPodIdentityProfileDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        allowNetworkPluginKubenet: item["allowNetworkPluginKubenet"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : managedClusterPodIdentityArrayDeserializer(item["userAssignedIdentities"]),
+        userAssignedIdentityExceptions: !item["userAssignedIdentityExceptions"]
+            ? item["userAssignedIdentityExceptions"]
+            : managedClusterPodIdentityExceptionArrayDeserializer(item["userAssignedIdentityExceptions"]),
+    };
+}
+export function managedClusterPodIdentityArraySerializer(result) {
+    return result.map((item) => {
+        return managedClusterPodIdentitySerializer(item);
+    });
+}
+export function managedClusterPodIdentityArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedClusterPodIdentityDeserializer(item);
+    });
+}
+export function managedClusterPodIdentitySerializer(item) {
+    return {
+        name: item["name"],
+        namespace: item["namespace"],
+        bindingSelector: item["bindingSelector"],
+        identity: userAssignedIdentitySerializer(item["identity"]),
+    };
+}
+export function managedClusterPodIdentityDeserializer(item) {
+    return {
+        name: item["name"],
+        namespace: item["namespace"],
+        bindingSelector: item["bindingSelector"],
+        identity: userAssignedIdentityDeserializer(item["identity"]),
+        provisioningState: item["provisioningState"],
+        provisioningInfo: !item["provisioningInfo"]
+            ? item["provisioningInfo"]
+            : managedClusterPodIdentityProvisioningInfoDeserializer(item["provisioningInfo"]),
+    };
+}
+export function userAssignedIdentitySerializer(item) {
+    return { resourceId: item["resourceId"], clientId: item["clientId"], objectId: item["objectId"] };
+}
+export function userAssignedIdentityDeserializer(item) {
+    return {
+        resourceId: item["resourceId"],
+        clientId: item["clientId"],
+        objectId: item["objectId"],
+    };
+}
+/** The current provisioning state of the pod identity. */
+export var KnownManagedClusterPodIdentityProvisioningState;
+(function (KnownManagedClusterPodIdentityProvisioningState) {
+    /** Pod identity is assigned. */
+    KnownManagedClusterPodIdentityProvisioningState["Assigned"] = "Assigned";
+    /** Pod identity assignment was canceled. */
+    KnownManagedClusterPodIdentityProvisioningState["Canceled"] = "Canceled";
+    /** Pod identity is being deleted. */
+    KnownManagedClusterPodIdentityProvisioningState["Deleting"] = "Deleting";
+    /** Pod identity assignment failed. */
+    KnownManagedClusterPodIdentityProvisioningState["Failed"] = "Failed";
+    /** Pod identity assignment succeeded. */
+    KnownManagedClusterPodIdentityProvisioningState["Succeeded"] = "Succeeded";
+    /** Pod identity is being updated. */
+    KnownManagedClusterPodIdentityProvisioningState["Updating"] = "Updating";
+})(KnownManagedClusterPodIdentityProvisioningState || (KnownManagedClusterPodIdentityProvisioningState = {}));
+export function managedClusterPodIdentityProvisioningInfoDeserializer(item) {
+    return {
+        error: !item["error"]
+            ? item["error"]
+            : managedClusterPodIdentityProvisioningErrorDeserializer(item["error"]),
+    };
+}
+export function managedClusterPodIdentityProvisioningErrorDeserializer(item) {
+    return {
+        error: !item["error"]
+            ? item["error"]
+            : managedClusterPodIdentityProvisioningErrorBodyDeserializer(item["error"]),
+    };
+}
+export function managedClusterPodIdentityProvisioningErrorBodyDeserializer(item) {
+    return {
+        code: item["code"],
+        message: item["message"],
+        target: item["target"],
+        details: !item["details"]
+            ? item["details"]
+            : managedClusterPodIdentityProvisioningErrorBodyArrayDeserializer(item["details"]),
+    };
+}
+export function managedClusterPodIdentityProvisioningErrorBodyArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedClusterPodIdentityProvisioningErrorBodyDeserializer(item);
+    });
+}
+export function managedClusterPodIdentityExceptionArraySerializer(result) {
+    return result.map((item) => {
+        return managedClusterPodIdentityExceptionSerializer(item);
+    });
+}
+export function managedClusterPodIdentityExceptionArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedClusterPodIdentityExceptionDeserializer(item);
+    });
+}
+export function managedClusterPodIdentityExceptionSerializer(item) {
+    return { name: item["name"], namespace: item["namespace"], podLabels: item["podLabels"] };
+}
+export function managedClusterPodIdentityExceptionDeserializer(item) {
+    return {
+        name: item["name"],
+        namespace: item["namespace"],
+        podLabels: Object.fromEntries(Object.entries(item["podLabels"]).map(([k, p]) => [k, p])),
+    };
+}
+export function managedClusterOidcIssuerProfileSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterOidcIssuerProfileDeserializer(item) {
+    return {
+        issuerURL: item["issuerURL"],
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterNodeResourceGroupProfileSerializer(item) {
+    return { restrictionLevel: item["restrictionLevel"] };
+}
+export function managedClusterNodeResourceGroupProfileDeserializer(item) {
+    return {
+        restrictionLevel: item["restrictionLevel"],
+    };
+}
+/** The restriction level applied to the cluster's node resource group. If not specified, the default is 'Unrestricted' */
+export var KnownRestrictionLevel;
+(function (KnownRestrictionLevel) {
+    /** All RBAC permissions are allowed on the managed node resource group */
+    KnownRestrictionLevel["Unrestricted"] = "Unrestricted";
+    /** Only \*\/read RBAC permissions allowed on the managed node resource group */
+    KnownRestrictionLevel["ReadOnly"] = "ReadOnly";
+})(KnownRestrictionLevel || (KnownRestrictionLevel = {}));
+/** Different support tiers for AKS managed clusters */
+export var KnownKubernetesSupportPlan;
+(function (KnownKubernetesSupportPlan) {
+    /** Support for the version is the same as for the open source Kubernetes offering. Official Kubernetes open source community support versions for 1 year after release. */
+    KnownKubernetesSupportPlan["KubernetesOfficial"] = "KubernetesOfficial";
+    /** Support for the version extended past the KubernetesOfficial support of 1 year. AKS continues to patch CVEs for another 1 year, for a total of 2 years of support. */
+    KnownKubernetesSupportPlan["AKSLongTermSupport"] = "AKSLongTermSupport";
+})(KnownKubernetesSupportPlan || (KnownKubernetesSupportPlan = {}));
+export function containerServiceNetworkProfileSerializer(item) {
+    return {
+        networkPlugin: item["networkPlugin"],
+        networkPluginMode: item["networkPluginMode"],
+        networkPolicy: item["networkPolicy"],
+        networkMode: item["networkMode"],
+        networkDataplane: item["networkDataplane"],
+        advancedNetworking: !item["advancedNetworking"]
+            ? item["advancedNetworking"]
+            : advancedNetworkingSerializer(item["advancedNetworking"]),
+        podCidr: item["podCidr"],
+        serviceCidr: item["serviceCidr"],
+        dnsServiceIP: item["dnsServiceIP"],
+        outboundType: item["outboundType"],
+        loadBalancerSku: item["loadBalancerSku"],
+        loadBalancerProfile: !item["loadBalancerProfile"]
+            ? item["loadBalancerProfile"]
+            : managedClusterLoadBalancerProfileSerializer(item["loadBalancerProfile"]),
+        natGatewayProfile: !item["natGatewayProfile"]
+            ? item["natGatewayProfile"]
+            : managedClusterNATGatewayProfileSerializer(item["natGatewayProfile"]),
+        staticEgressGatewayProfile: !item["staticEgressGatewayProfile"]
+            ? item["staticEgressGatewayProfile"]
+            : managedClusterStaticEgressGatewayProfileSerializer(item["staticEgressGatewayProfile"]),
+        podCidrs: !item["podCidrs"]
+            ? item["podCidrs"]
+            : item["podCidrs"].map((p) => {
+                return p;
+            }),
+        serviceCidrs: !item["serviceCidrs"]
+            ? item["serviceCidrs"]
+            : item["serviceCidrs"].map((p) => {
+                return p;
+            }),
+        ipFamilies: !item["ipFamilies"]
+            ? item["ipFamilies"]
+            : item["ipFamilies"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function containerServiceNetworkProfileDeserializer(item) {
+    return {
+        networkPlugin: item["networkPlugin"],
+        networkPluginMode: item["networkPluginMode"],
+        networkPolicy: item["networkPolicy"],
+        networkMode: item["networkMode"],
+        networkDataplane: item["networkDataplane"],
+        advancedNetworking: !item["advancedNetworking"]
+            ? item["advancedNetworking"]
+            : advancedNetworkingDeserializer(item["advancedNetworking"]),
+        podCidr: item["podCidr"],
+        serviceCidr: item["serviceCidr"],
+        dnsServiceIP: item["dnsServiceIP"],
+        outboundType: item["outboundType"],
+        loadBalancerSku: item["loadBalancerSku"],
+        loadBalancerProfile: !item["loadBalancerProfile"]
+            ? item["loadBalancerProfile"]
+            : managedClusterLoadBalancerProfileDeserializer(item["loadBalancerProfile"]),
+        natGatewayProfile: !item["natGatewayProfile"]
+            ? item["natGatewayProfile"]
+            : managedClusterNATGatewayProfileDeserializer(item["natGatewayProfile"]),
+        staticEgressGatewayProfile: !item["staticEgressGatewayProfile"]
+            ? item["staticEgressGatewayProfile"]
+            : managedClusterStaticEgressGatewayProfileDeserializer(item["staticEgressGatewayProfile"]),
+        podCidrs: !item["podCidrs"]
+            ? item["podCidrs"]
+            : item["podCidrs"].map((p) => {
+                return p;
+            }),
+        serviceCidrs: !item["serviceCidrs"]
+            ? item["serviceCidrs"]
+            : item["serviceCidrs"].map((p) => {
+                return p;
+            }),
+        ipFamilies: !item["ipFamilies"]
+            ? item["ipFamilies"]
+            : item["ipFamilies"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** Network plugin used for building the Kubernetes network. */
+export var KnownNetworkPlugin;
+(function (KnownNetworkPlugin) {
+    /** Use the Azure CNI network plugin. See [Azure CNI (advanced) networking](https://docs.microsoft.com/azure/aks/concepts-network#azure-cni-advanced-networking) for more information. */
+    KnownNetworkPlugin["Azure"] = "azure";
+    /** Use the Kubenet network plugin. See [Kubenet (basic) networking](https://docs.microsoft.com/azure/aks/concepts-network#kubenet-basic-networking) for more information. */
+    KnownNetworkPlugin["Kubenet"] = "kubenet";
+    /** No CNI plugin is pre-installed. See [BYO CNI](https://docs.microsoft.com/en-us/azure/aks/use-byo-cni) for more information. */
+    KnownNetworkPlugin["None"] = "none";
+})(KnownNetworkPlugin || (KnownNetworkPlugin = {}));
+/** The mode the network plugin should use. */
+export var KnownNetworkPluginMode;
+(function (KnownNetworkPluginMode) {
+    /** Used with networkPlugin=azure, pods are given IPs from the PodCIDR address space but use Azure Routing Domains rather than Kubenet's method of route tables. For more information visit https://aka.ms/aks/azure-cni-overlay. */
+    KnownNetworkPluginMode["Overlay"] = "overlay";
+})(KnownNetworkPluginMode || (KnownNetworkPluginMode = {}));
+/** Network policy used for building the Kubernetes network. */
+export var KnownNetworkPolicy;
+(function (KnownNetworkPolicy) {
+    /** Network policies will not be enforced. This is the default value when NetworkPolicy is not specified. */
+    KnownNetworkPolicy["None"] = "none";
+    /** Use Calico network policies. See [differences between Azure and Calico policies](https://docs.microsoft.com/azure/aks/use-network-policies#differences-between-azure-and-calico-policies-and-their-capabilities) for more information. */
+    KnownNetworkPolicy["Calico"] = "calico";
+    /** Use Azure network policies. See [differences between Azure and Calico policies](https://docs.microsoft.com/azure/aks/use-network-policies#differences-between-azure-and-calico-policies-and-their-capabilities) for more information. */
+    KnownNetworkPolicy["Azure"] = "azure";
+    /** Use Cilium to enforce network policies. This requires networkDataplane to be 'cilium'. */
+    KnownNetworkPolicy["Cilium"] = "cilium";
+})(KnownNetworkPolicy || (KnownNetworkPolicy = {}));
+/** The network mode Azure CNI is configured with. This cannot be specified if networkPlugin is anything other than 'azure'. */
+export var KnownNetworkMode;
+(function (KnownNetworkMode) {
+    /** No bridge is created. Intra-VM Pod to Pod communication is through IP routes created by Azure CNI. See [Transparent Mode](https://docs.microsoft.com/azure/aks/faq#transparent-mode) for more information. */
+    KnownNetworkMode["Transparent"] = "transparent";
+    /** This is no longer supported */
+    KnownNetworkMode["Bridge"] = "bridge";
+})(KnownNetworkMode || (KnownNetworkMode = {}));
+/** Network dataplane used in the Kubernetes cluster. */
+export var KnownNetworkDataplane;
+(function (KnownNetworkDataplane) {
+    /** Use Azure network dataplane. */
+    KnownNetworkDataplane["Azure"] = "azure";
+    /** Use Cilium network dataplane. See [Azure CNI Powered by Cilium](https://learn.microsoft.com/azure/aks/azure-cni-powered-by-cilium) for more information. */
+    KnownNetworkDataplane["Cilium"] = "cilium";
+})(KnownNetworkDataplane || (KnownNetworkDataplane = {}));
+export function advancedNetworkingSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        observability: !item["observability"]
+            ? item["observability"]
+            : advancedNetworkingObservabilitySerializer(item["observability"]),
+        security: !item["security"]
+            ? item["security"]
+            : advancedNetworkingSecuritySerializer(item["security"]),
+        performance: !item["performance"]
+            ? item["performance"]
+            : advancedNetworkingPerformanceSerializer(item["performance"]),
+    };
+}
+export function advancedNetworkingDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        observability: !item["observability"]
+            ? item["observability"]
+            : advancedNetworkingObservabilityDeserializer(item["observability"]),
+        security: !item["security"]
+            ? item["security"]
+            : advancedNetworkingSecurityDeserializer(item["security"]),
+        performance: !item["performance"]
+            ? item["performance"]
+            : advancedNetworkingPerformanceDeserializer(item["performance"]),
+    };
+}
+export function advancedNetworkingObservabilitySerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function advancedNetworkingObservabilityDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function advancedNetworkingSecuritySerializer(item) {
+    return {
+        enabled: item["enabled"],
+        advancedNetworkPolicies: item["advancedNetworkPolicies"],
+        transitEncryption: !item["transitEncryption"]
+            ? item["transitEncryption"]
+            : advancedNetworkingSecurityTransitEncryptionSerializer(item["transitEncryption"]),
+    };
+}
+export function advancedNetworkingSecurityDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        advancedNetworkPolicies: item["advancedNetworkPolicies"],
+        transitEncryption: !item["transitEncryption"]
+            ? item["transitEncryption"]
+            : advancedNetworkingSecurityTransitEncryptionDeserializer(item["transitEncryption"]),
+    };
+}
+/** Enable advanced network policies. This allows users to configure Layer 7 network policies (FQDN, HTTP, Kafka). Policies themselves must be configured via the Cilium Network Policy resources, see https://docs.cilium.io/en/latest/security/policy/index.html. This can be enabled only on cilium-based clusters. If not specified, the default value is FQDN if security.enabled is set to true. */
+export var KnownAdvancedNetworkPolicies;
+(function (KnownAdvancedNetworkPolicies) {
+    /** Enable Layer7 network policies (FQDN, HTTP/S, Kafka). This option is a superset of the FQDN option. */
+    KnownAdvancedNetworkPolicies["L7"] = "L7";
+    /** Enable FQDN based network policies */
+    KnownAdvancedNetworkPolicies["Fqdn"] = "FQDN";
+    /** Disable Layer 7 network policies (FQDN, HTTP/S, Kafka) */
+    KnownAdvancedNetworkPolicies["None"] = "None";
+})(KnownAdvancedNetworkPolicies || (KnownAdvancedNetworkPolicies = {}));
+export function advancedNetworkingSecurityTransitEncryptionSerializer(item) {
+    return { type: item["type"] };
+}
+export function advancedNetworkingSecurityTransitEncryptionDeserializer(item) {
+    return {
+        type: item["type"],
+    };
+}
+/** Configures pod-to-pod encryption. This can be enabled only on Cilium-based clusters. If not specified, the default value is None. */
+export var KnownTransitEncryptionType;
+(function (KnownTransitEncryptionType) {
+    /** Enable WireGuard encryption. Refer to https://docs.cilium.io/en/latest/security/network/encryption-wireguard/ on use cases and implementation details */
+    KnownTransitEncryptionType["WireGuard"] = "WireGuard";
+    /** Disable Transit encryption */
+    KnownTransitEncryptionType["None"] = "None";
+})(KnownTransitEncryptionType || (KnownTransitEncryptionType = {}));
+export function advancedNetworkingPerformanceSerializer(item) {
+    return { accelerationMode: item["accelerationMode"] };
+}
+export function advancedNetworkingPerformanceDeserializer(item) {
+    return {
+        accelerationMode: item["accelerationMode"],
+    };
+}
+/** Enable advanced network acceleration options. This allows users to configure acceleration using BPF host routing. This can be enabled only with Cilium dataplane. If not specified, the default value is None (no acceleration). The acceleration mode can be changed on a pre-existing cluster. See https://aka.ms/acnsperformance for a detailed explanation */
+export var KnownAccelerationMode;
+(function (KnownAccelerationMode) {
+    /** Enable eBPF host routing with veth device mode. */
+    KnownAccelerationMode["BpfVeth"] = "BpfVeth";
+    /** Disable acceleration options. */
+    KnownAccelerationMode["None"] = "None";
+})(KnownAccelerationMode || (KnownAccelerationMode = {}));
+/** The outbound (egress) routing method. This can only be set at cluster creation time and cannot be changed later. For more information see [egress outbound type](https://docs.microsoft.com/azure/aks/egress-outboundtype). */
+export var KnownOutboundType;
+(function (KnownOutboundType) {
+    /** The load balancer is used for egress through an AKS assigned public IP. This supports Kubernetes services of type 'loadBalancer'. For more information see [outbound type loadbalancer](https://docs.microsoft.com/azure/aks/egress-outboundtype#outbound-type-of-loadbalancer). */
+    KnownOutboundType["LoadBalancer"] = "loadBalancer";
+    /** Egress paths must be defined by the user. This is an advanced scenario and requires proper network configuration. For more information see [outbound type userDefinedRouting](https://docs.microsoft.com/azure/aks/egress-outboundtype#outbound-type-of-userdefinedrouting). */
+    KnownOutboundType["UserDefinedRouting"] = "userDefinedRouting";
+    /** The AKS-managed NAT gateway is used for egress. */
+    KnownOutboundType["ManagedNATGateway"] = "managedNATGateway";
+    /** The user-assigned NAT gateway associated to the cluster subnet is used for egress. This is an advanced scenario and requires proper network configuration. */
+    KnownOutboundType["UserAssignedNATGateway"] = "userAssignedNATGateway";
+    /** The AKS cluster is not set with any outbound-type. All AKS nodes follows Azure VM default outbound behavior. Please refer to https://azure.microsoft.com/en-us/updates/default-outbound-access-for-vms-in-azure-will-be-retired-transition-to-a-new-method-of-internet-access/ */
+    KnownOutboundType["None"] = "none";
+})(KnownOutboundType || (KnownOutboundType = {}));
+/** The load balancer sku for the managed cluster. The default is 'standard'. See [Azure Load Balancer SKUs](https://docs.microsoft.com/azure/load-balancer/skus) for more information about the differences between load balancer SKUs. */
+export var KnownLoadBalancerSku;
+(function (KnownLoadBalancerSku) {
+    /** Use a a standard Load Balancer. This is the recommended Load Balancer SKU. For more information about on working with the load balancer in the managed cluster, see the [standard Load Balancer](https://docs.microsoft.com/azure/aks/load-balancer-standard) article. */
+    KnownLoadBalancerSku["Standard"] = "standard";
+    /** Use a basic Load Balancer with limited functionality. */
+    KnownLoadBalancerSku["Basic"] = "basic";
+})(KnownLoadBalancerSku || (KnownLoadBalancerSku = {}));
+export function managedClusterLoadBalancerProfileSerializer(item) {
+    return {
+        managedOutboundIPs: !item["managedOutboundIPs"]
+            ? item["managedOutboundIPs"]
+            : managedClusterLoadBalancerProfileManagedOutboundIPsSerializer(item["managedOutboundIPs"]),
+        outboundIPPrefixes: !item["outboundIPPrefixes"]
+            ? item["outboundIPPrefixes"]
+            : managedClusterLoadBalancerProfileOutboundIPPrefixesSerializer(item["outboundIPPrefixes"]),
+        outboundIPs: !item["outboundIPs"]
+            ? item["outboundIPs"]
+            : managedClusterLoadBalancerProfileOutboundIPsSerializer(item["outboundIPs"]),
+        allocatedOutboundPorts: item["allocatedOutboundPorts"],
+        idleTimeoutInMinutes: item["idleTimeoutInMinutes"],
+        enableMultipleStandardLoadBalancers: item["enableMultipleStandardLoadBalancers"],
+        backendPoolType: item["backendPoolType"],
+    };
+}
+export function managedClusterLoadBalancerProfileDeserializer(item) {
+    return {
+        managedOutboundIPs: !item["managedOutboundIPs"]
+            ? item["managedOutboundIPs"]
+            : managedClusterLoadBalancerProfileManagedOutboundIPsDeserializer(item["managedOutboundIPs"]),
+        outboundIPPrefixes: !item["outboundIPPrefixes"]
+            ? item["outboundIPPrefixes"]
+            : managedClusterLoadBalancerProfileOutboundIPPrefixesDeserializer(item["outboundIPPrefixes"]),
+        outboundIPs: !item["outboundIPs"]
+            ? item["outboundIPs"]
+            : managedClusterLoadBalancerProfileOutboundIPsDeserializer(item["outboundIPs"]),
+        effectiveOutboundIPs: !item["effectiveOutboundIPs"]
+            ? item["effectiveOutboundIPs"]
+            : resourceReferenceArrayDeserializer(item["effectiveOutboundIPs"]),
+        allocatedOutboundPorts: item["allocatedOutboundPorts"],
+        idleTimeoutInMinutes: item["idleTimeoutInMinutes"],
+        enableMultipleStandardLoadBalancers: item["enableMultipleStandardLoadBalancers"],
+        backendPoolType: item["backendPoolType"],
+    };
+}
+export function managedClusterLoadBalancerProfileManagedOutboundIPsSerializer(item) {
+    return { count: item["count"], countIPv6: item["countIPv6"] };
+}
+export function managedClusterLoadBalancerProfileManagedOutboundIPsDeserializer(item) {
+    return {
+        count: item["count"],
+        countIPv6: item["countIPv6"],
+    };
+}
+export function managedClusterLoadBalancerProfileOutboundIPPrefixesSerializer(item) {
+    return {
+        publicIPPrefixes: !item["publicIPPrefixes"]
+            ? item["publicIPPrefixes"]
+            : resourceReferenceArraySerializer(item["publicIPPrefixes"]),
+    };
+}
+export function managedClusterLoadBalancerProfileOutboundIPPrefixesDeserializer(item) {
+    return {
+        publicIPPrefixes: !item["publicIPPrefixes"]
+            ? item["publicIPPrefixes"]
+            : resourceReferenceArrayDeserializer(item["publicIPPrefixes"]),
+    };
+}
+export function resourceReferenceArraySerializer(result) {
+    return result.map((item) => {
+        return resourceReferenceSerializer(item);
+    });
+}
+export function resourceReferenceArrayDeserializer(result) {
+    return result.map((item) => {
+        return resourceReferenceDeserializer(item);
+    });
+}
+export function resourceReferenceSerializer(item) {
+    return { id: item["id"] };
+}
+export function resourceReferenceDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function managedClusterLoadBalancerProfileOutboundIPsSerializer(item) {
+    return {
+        publicIPs: !item["publicIPs"]
+            ? item["publicIPs"]
+            : resourceReferenceArraySerializer(item["publicIPs"]),
+    };
+}
+export function managedClusterLoadBalancerProfileOutboundIPsDeserializer(item) {
+    return {
+        publicIPs: !item["publicIPs"]
+            ? item["publicIPs"]
+            : resourceReferenceArrayDeserializer(item["publicIPs"]),
+    };
+}
+/** The type of the managed inbound Load Balancer BackendPool. */
+export var KnownBackendPoolType;
+(function (KnownBackendPoolType) {
+    /** The type of the managed inbound Load Balancer BackendPool. https://cloud-provider-azure.sigs.k8s.io/topics/loadbalancer/#configure-load-balancer-backend. */
+    KnownBackendPoolType["NodeIPConfiguration"] = "NodeIPConfiguration";
+    /** The type of the managed inbound Load Balancer BackendPool. https://cloud-provider-azure.sigs.k8s.io/topics/loadbalancer/#configure-load-balancer-backend. */
+    KnownBackendPoolType["NodeIP"] = "NodeIP";
+})(KnownBackendPoolType || (KnownBackendPoolType = {}));
+export function managedClusterNATGatewayProfileSerializer(item) {
+    return {
+        managedOutboundIPProfile: !item["managedOutboundIPProfile"]
+            ? item["managedOutboundIPProfile"]
+            : managedClusterManagedOutboundIPProfileSerializer(item["managedOutboundIPProfile"]),
+        idleTimeoutInMinutes: item["idleTimeoutInMinutes"],
+    };
+}
+export function managedClusterNATGatewayProfileDeserializer(item) {
+    return {
+        managedOutboundIPProfile: !item["managedOutboundIPProfile"]
+            ? item["managedOutboundIPProfile"]
+            : managedClusterManagedOutboundIPProfileDeserializer(item["managedOutboundIPProfile"]),
+        effectiveOutboundIPs: !item["effectiveOutboundIPs"]
+            ? item["effectiveOutboundIPs"]
+            : resourceReferenceArrayDeserializer(item["effectiveOutboundIPs"]),
+        idleTimeoutInMinutes: item["idleTimeoutInMinutes"],
+    };
+}
+export function managedClusterManagedOutboundIPProfileSerializer(item) {
+    return { count: item["count"] };
+}
+export function managedClusterManagedOutboundIPProfileDeserializer(item) {
+    return {
+        count: item["count"],
+    };
+}
+export function managedClusterStaticEgressGatewayProfileSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterStaticEgressGatewayProfileDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+/** To determine if address belongs IPv4 or IPv6 family */
+export var KnownIpFamily;
+(function (KnownIpFamily) {
+    /** IPv4 family */
+    KnownIpFamily["IPv4"] = "IPv4";
+    /** IPv6 family */
+    KnownIpFamily["IPv6"] = "IPv6";
+})(KnownIpFamily || (KnownIpFamily = {}));
+export function managedClusterAADProfileSerializer(item) {
+    return {
+        managed: item["managed"],
+        enableAzureRBAC: item["enableAzureRbac"],
+        adminGroupObjectIDs: !item["adminGroupObjectIDs"]
+            ? item["adminGroupObjectIDs"]
+            : item["adminGroupObjectIDs"].map((p) => {
+                return p;
+            }),
+        clientAppID: item["clientAppID"],
+        serverAppID: item["serverAppID"],
+        serverAppSecret: item["serverAppSecret"],
+        tenantID: item["tenantID"],
+    };
+}
+export function managedClusterAADProfileDeserializer(item) {
+    return {
+        managed: item["managed"],
+        enableAzureRbac: item["enableAzureRBAC"],
+        adminGroupObjectIDs: !item["adminGroupObjectIDs"]
+            ? item["adminGroupObjectIDs"]
+            : item["adminGroupObjectIDs"].map((p) => {
+                return p;
+            }),
+        clientAppID: item["clientAppID"],
+        serverAppID: item["serverAppID"],
+        serverAppSecret: item["serverAppSecret"],
+        tenantID: item["tenantID"],
+    };
+}
+export function managedClusterAutoUpgradeProfileSerializer(item) {
+    return {
+        upgradeChannel: item["upgradeChannel"],
+        nodeOSUpgradeChannel: item["nodeOSUpgradeChannel"],
+    };
+}
+export function managedClusterAutoUpgradeProfileDeserializer(item) {
+    return {
+        upgradeChannel: item["upgradeChannel"],
+        nodeOSUpgradeChannel: item["nodeOSUpgradeChannel"],
+    };
+}
+/** The upgrade channel for auto upgrade. The default is 'none'. For more information see [setting the AKS cluster auto-upgrade channel](https://docs.microsoft.com/azure/aks/upgrade-cluster#set-auto-upgrade-channel). */
+export var KnownUpgradeChannel;
+(function (KnownUpgradeChannel) {
+    /** Automatically upgrade the cluster to the latest supported patch release on the latest supported minor version. In cases where the cluster is at a version of Kubernetes that is at an N-2 minor version where N is the latest supported minor version, the cluster first upgrades to the latest supported patch version on N-1 minor version. For example, if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4, 1.18.6, and 1.19.1 are available, your cluster first is upgraded to 1.18.6, then is upgraded to 1.19.1. */
+    KnownUpgradeChannel["Rapid"] = "rapid";
+    /** Automatically upgrade the cluster to the latest supported patch release on minor version N-1, where N is the latest supported minor version. For example, if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4, 1.18.6, and 1.19.1 are available, your cluster is upgraded to 1.18.6. */
+    KnownUpgradeChannel["Stable"] = "stable";
+    /** Automatically upgrade the cluster to the latest supported patch version when it becomes available while keeping the minor version the same. For example, if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4, 1.18.6, and 1.19.1 are available, your cluster is upgraded to 1.17.9. */
+    KnownUpgradeChannel["Patch"] = "patch";
+    /** Automatically upgrade the node image to the latest version available. Consider using nodeOSUpgradeChannel instead as that allows you to configure node OS patching separate from Kubernetes version patching */
+    KnownUpgradeChannel["NodeImage"] = "node-image";
+    /** Disables auto-upgrades and keeps the cluster at its current version of Kubernetes. */
+    KnownUpgradeChannel["None"] = "none";
+})(KnownUpgradeChannel || (KnownUpgradeChannel = {}));
+/** Node OS Upgrade Channel. Manner in which the OS on your nodes is updated. The default is NodeImage. */
+export var KnownNodeOSUpgradeChannel;
+(function (KnownNodeOSUpgradeChannel) {
+    /** No attempt to update your machines OS will be made either by OS or by rolling VHDs. This means you are responsible for your security updates */
+    KnownNodeOSUpgradeChannel["None"] = "None";
+    /** OS updates will be applied automatically through the OS built-in patching infrastructure. Newly scaled in machines will be unpatched initially and will be patched at some point by the OS's infrastructure. Behavior of this option depends on the OS in question. Ubuntu and Mariner apply security patches through unattended upgrade roughly once a day around 06:00 UTC. Windows does not apply security patches automatically and so for them this option is equivalent to None till further notice */
+    KnownNodeOSUpgradeChannel["Unmanaged"] = "Unmanaged";
+    /** AKS will update the nodes with a newly patched VHD containing security fixes and bugfixes on a weekly cadence. With the VHD update machines will be rolling reimaged to that VHD following maintenance windows and surge settings. No extra VHD cost is incurred when choosing this option as AKS hosts the images. */
+    KnownNodeOSUpgradeChannel["NodeImage"] = "NodeImage";
+    /** AKS downloads and updates the nodes with tested security updates. These updates honor the maintenance window settings and produce a new VHD that is used on new nodes. On some occasions it's not possible to apply the updates in place, in such cases the existing nodes will also be re-imaged to the newly produced VHD in order to apply the changes. This option incurs an extra cost of hosting the new Security Patch VHDs in your resource group for just in time consumption. */
+    KnownNodeOSUpgradeChannel["SecurityPatch"] = "SecurityPatch";
+})(KnownNodeOSUpgradeChannel || (KnownNodeOSUpgradeChannel = {}));
+export function clusterUpgradeSettingsSerializer(item) {
+    return {
+        overrideSettings: !item["overrideSettings"]
+            ? item["overrideSettings"]
+            : upgradeOverrideSettingsSerializer(item["overrideSettings"]),
+    };
+}
+export function clusterUpgradeSettingsDeserializer(item) {
+    return {
+        overrideSettings: !item["overrideSettings"]
+            ? item["overrideSettings"]
+            : upgradeOverrideSettingsDeserializer(item["overrideSettings"]),
+    };
+}
+export function upgradeOverrideSettingsSerializer(item) {
+    return {
+        forceUpgrade: item["forceUpgrade"],
+        until: !item["until"] ? item["until"] : item["until"].toISOString(),
+    };
+}
+export function upgradeOverrideSettingsDeserializer(item) {
+    return {
+        forceUpgrade: item["forceUpgrade"],
+        until: !item["until"] ? item["until"] : new Date(item["until"]),
+    };
+}
+export function managedClusterPropertiesAutoScalerProfileSerializer(item) {
+    return {
+        "balance-similar-node-groups": item["balanceSimilarNodeGroups"],
+        "daemonset-eviction-for-empty-nodes": item["daemonsetEvictionForEmptyNodes"],
+        "daemonset-eviction-for-occupied-nodes": item["daemonsetEvictionForOccupiedNodes"],
+        "ignore-daemonsets-utilization": item["ignoreDaemonsetsUtilization"],
+        expander: item["expander"],
+        "max-empty-bulk-delete": item["maxEmptyBulkDelete"],
+        "max-graceful-termination-sec": item["maxGracefulTerminationSec"],
+        "max-node-provision-time": item["maxNodeProvisionTime"],
+        "max-total-unready-percentage": item["maxTotalUnreadyPercentage"],
+        "new-pod-scale-up-delay": item["newPodScaleUpDelay"],
+        "ok-total-unready-count": item["okTotalUnreadyCount"],
+        "scan-interval": item["scanInterval"],
+        "scale-down-delay-after-add": item["scaleDownDelayAfterAdd"],
+        "scale-down-delay-after-delete": item["scaleDownDelayAfterDelete"],
+        "scale-down-delay-after-failure": item["scaleDownDelayAfterFailure"],
+        "scale-down-unneeded-time": item["scaleDownUnneededTime"],
+        "scale-down-unready-time": item["scaleDownUnreadyTime"],
+        "scale-down-utilization-threshold": item["scaleDownUtilizationThreshold"],
+        "skip-nodes-with-local-storage": item["skipNodesWithLocalStorage"],
+        "skip-nodes-with-system-pods": item["skipNodesWithSystemPods"],
+    };
+}
+export function managedClusterPropertiesAutoScalerProfileDeserializer(item) {
+    return {
+        balanceSimilarNodeGroups: item["balance-similar-node-groups"],
+        daemonsetEvictionForEmptyNodes: item["daemonset-eviction-for-empty-nodes"],
+        daemonsetEvictionForOccupiedNodes: item["daemonset-eviction-for-occupied-nodes"],
+        ignoreDaemonsetsUtilization: item["ignore-daemonsets-utilization"],
+        expander: item["expander"],
+        maxEmptyBulkDelete: item["max-empty-bulk-delete"],
+        maxGracefulTerminationSec: item["max-graceful-termination-sec"],
+        maxNodeProvisionTime: item["max-node-provision-time"],
+        maxTotalUnreadyPercentage: item["max-total-unready-percentage"],
+        newPodScaleUpDelay: item["new-pod-scale-up-delay"],
+        okTotalUnreadyCount: item["ok-total-unready-count"],
+        scanInterval: item["scan-interval"],
+        scaleDownDelayAfterAdd: item["scale-down-delay-after-add"],
+        scaleDownDelayAfterDelete: item["scale-down-delay-after-delete"],
+        scaleDownDelayAfterFailure: item["scale-down-delay-after-failure"],
+        scaleDownUnneededTime: item["scale-down-unneeded-time"],
+        scaleDownUnreadyTime: item["scale-down-unready-time"],
+        scaleDownUtilizationThreshold: item["scale-down-utilization-threshold"],
+        skipNodesWithLocalStorage: item["skip-nodes-with-local-storage"],
+        skipNodesWithSystemPods: item["skip-nodes-with-system-pods"],
+    };
+}
+/** The expander to use when scaling up. If not specified, the default is 'random'. See [expanders](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/FAQ.md#what-are-expanders) for more information. */
+export var KnownExpander;
+(function (KnownExpander) {
+    /** Selects the node group that will have the least idle CPU (if tied, unused memory) after scale-up. This is useful when you have different classes of nodes, for example, high CPU or high memory nodes, and only want to expand those when there are pending pods that need a lot of those resources. */
+    KnownExpander["LeastWaste"] = "least-waste";
+    /** Selects the node group that would be able to schedule the most pods when scaling up. This is useful when you are using nodeSelector to make sure certain pods land on certain nodes. Note that this won't cause the autoscaler to select bigger nodes vs. smaller, as it can add multiple smaller nodes at once. */
+    KnownExpander["MostPods"] = "most-pods";
+    /** Selects the node group that has the highest priority assigned by the user. It's configuration is described in more details [here](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/expander/priority/readme.md). */
+    KnownExpander["Priority"] = "priority";
+    /** Used when you don't have a particular need for the node groups to scale differently. */
+    KnownExpander["Random"] = "random";
+})(KnownExpander || (KnownExpander = {}));
+export function managedClusterAPIServerAccessProfileSerializer(item) {
+    return {
+        authorizedIPRanges: !item["authorizedIPRanges"]
+            ? item["authorizedIPRanges"]
+            : item["authorizedIPRanges"].map((p) => {
+                return p;
+            }),
+        enablePrivateCluster: item["enablePrivateCluster"],
+        privateDNSZone: item["privateDNSZone"],
+        enablePrivateClusterPublicFQDN: item["enablePrivateClusterPublicFqdn"],
+        disableRunCommand: item["disableRunCommand"],
+        enableVnetIntegration: item["enableVnetIntegration"],
+        subnetId: item["subnetId"],
+    };
+}
+export function managedClusterAPIServerAccessProfileDeserializer(item) {
+    return {
+        authorizedIPRanges: !item["authorizedIPRanges"]
+            ? item["authorizedIPRanges"]
+            : item["authorizedIPRanges"].map((p) => {
+                return p;
+            }),
+        enablePrivateCluster: item["enablePrivateCluster"],
+        privateDNSZone: item["privateDNSZone"],
+        enablePrivateClusterPublicFqdn: item["enablePrivateClusterPublicFQDN"],
+        disableRunCommand: item["disableRunCommand"],
+        enableVnetIntegration: item["enableVnetIntegration"],
+        subnetId: item["subnetId"],
+    };
+}
+export function userAssignedIdentityRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentitySerializer(item[key]);
+    });
+    return result;
+}
+export function userAssignedIdentityRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentityDeserializer(item[key]);
+    });
+    return result;
+}
+export function privateLinkResourceArraySerializer(result) {
+    return result.map((item) => {
+        return privateLinkResourceSerializer(item);
+    });
+}
+export function privateLinkResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateLinkResourceDeserializer(item);
+    });
+}
+export function privateLinkResourceSerializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        groupId: item["groupId"],
+        requiredMembers: !item["requiredMembers"]
+            ? item["requiredMembers"]
+            : item["requiredMembers"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function privateLinkResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        groupId: item["groupId"],
+        requiredMembers: !item["requiredMembers"]
+            ? item["requiredMembers"]
+            : item["requiredMembers"].map((p) => {
+                return p;
+            }),
+        privateLinkServiceID: item["privateLinkServiceID"],
+    };
+}
+export function managedClusterHttpProxyConfigSerializer(item) {
+    return {
+        httpProxy: item["httpProxy"],
+        httpsProxy: item["httpsProxy"],
+        noProxy: !item["noProxy"]
+            ? item["noProxy"]
+            : item["noProxy"].map((p) => {
+                return p;
+            }),
+        trustedCa: item["trustedCa"],
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterHttpProxyConfigDeserializer(item) {
+    return {
+        httpProxy: item["httpProxy"],
+        httpsProxy: item["httpsProxy"],
+        noProxy: !item["noProxy"]
+            ? item["noProxy"]
+            : item["noProxy"].map((p) => {
+                return p;
+            }),
+        trustedCa: item["trustedCa"],
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterSecurityProfileSerializer(item) {
+    return {
+        defender: !item["defender"]
+            ? item["defender"]
+            : managedClusterSecurityProfileDefenderSerializer(item["defender"]),
+        azureKeyVaultKms: !item["azureKeyVaultKms"]
+            ? item["azureKeyVaultKms"]
+            : azureKeyVaultKmsSerializer(item["azureKeyVaultKms"]),
+        workloadIdentity: !item["workloadIdentity"]
+            ? item["workloadIdentity"]
+            : managedClusterSecurityProfileWorkloadIdentitySerializer(item["workloadIdentity"]),
+        imageCleaner: !item["imageCleaner"]
+            ? item["imageCleaner"]
+            : managedClusterSecurityProfileImageCleanerSerializer(item["imageCleaner"]),
+        customCATrustCertificates: !item["customCATrustCertificates"]
+            ? item["customCATrustCertificates"]
+            : item["customCATrustCertificates"].map((p) => {
+                return uint8ArrayToString(p, "base64");
+            }),
+    };
+}
+export function managedClusterSecurityProfileDeserializer(item) {
+    return {
+        defender: !item["defender"]
+            ? item["defender"]
+            : managedClusterSecurityProfileDefenderDeserializer(item["defender"]),
+        azureKeyVaultKms: !item["azureKeyVaultKms"]
+            ? item["azureKeyVaultKms"]
+            : azureKeyVaultKmsDeserializer(item["azureKeyVaultKms"]),
+        workloadIdentity: !item["workloadIdentity"]
+            ? item["workloadIdentity"]
+            : managedClusterSecurityProfileWorkloadIdentityDeserializer(item["workloadIdentity"]),
+        imageCleaner: !item["imageCleaner"]
+            ? item["imageCleaner"]
+            : managedClusterSecurityProfileImageCleanerDeserializer(item["imageCleaner"]),
+        customCATrustCertificates: !item["customCATrustCertificates"]
+            ? item["customCATrustCertificates"]
+            : item["customCATrustCertificates"].map((p) => {
+                return typeof p === "string" ? stringToUint8Array(p, "base64") : p;
+            }),
+    };
+}
+export function managedClusterSecurityProfileDefenderSerializer(item) {
+    return {
+        logAnalyticsWorkspaceResourceId: item["logAnalyticsWorkspaceResourceId"],
+        securityMonitoring: !item["securityMonitoring"]
+            ? item["securityMonitoring"]
+            : managedClusterSecurityProfileDefenderSecurityMonitoringSerializer(item["securityMonitoring"]),
+    };
+}
+export function managedClusterSecurityProfileDefenderDeserializer(item) {
+    return {
+        logAnalyticsWorkspaceResourceId: item["logAnalyticsWorkspaceResourceId"],
+        securityMonitoring: !item["securityMonitoring"]
+            ? item["securityMonitoring"]
+            : managedClusterSecurityProfileDefenderSecurityMonitoringDeserializer(item["securityMonitoring"]),
+    };
+}
+export function managedClusterSecurityProfileDefenderSecurityMonitoringSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterSecurityProfileDefenderSecurityMonitoringDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function azureKeyVaultKmsSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        keyId: item["keyId"],
+        keyVaultNetworkAccess: item["keyVaultNetworkAccess"],
+        keyVaultResourceId: item["keyVaultResourceId"],
+    };
+}
+export function azureKeyVaultKmsDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        keyId: item["keyId"],
+        keyVaultNetworkAccess: item["keyVaultNetworkAccess"],
+        keyVaultResourceId: item["keyVaultResourceId"],
+    };
+}
+/** Network access of the key vault. Network access of key vault. The possible values are `Public` and `Private`. `Public` means the key vault allows public access from all networks. `Private` means the key vault disables public access and enables private link. The default value is `Public`. */
+export var KnownKeyVaultNetworkAccessTypes;
+(function (KnownKeyVaultNetworkAccessTypes) {
+    /** Key vault allows public access from all networks. */
+    KnownKeyVaultNetworkAccessTypes["Public"] = "Public";
+    /** Key vault disables public access and enables private link. */
+    KnownKeyVaultNetworkAccessTypes["Private"] = "Private";
+})(KnownKeyVaultNetworkAccessTypes || (KnownKeyVaultNetworkAccessTypes = {}));
+export function managedClusterSecurityProfileWorkloadIdentitySerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterSecurityProfileWorkloadIdentityDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterSecurityProfileImageCleanerSerializer(item) {
+    return { enabled: item["enabled"], intervalHours: item["intervalHours"] };
+}
+export function managedClusterSecurityProfileImageCleanerDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        intervalHours: item["intervalHours"],
+    };
+}
+export function managedClusterStorageProfileSerializer(item) {
+    return {
+        diskCSIDriver: !item["diskCSIDriver"]
+            ? item["diskCSIDriver"]
+            : managedClusterStorageProfileDiskCSIDriverSerializer(item["diskCSIDriver"]),
+        fileCSIDriver: !item["fileCSIDriver"]
+            ? item["fileCSIDriver"]
+            : managedClusterStorageProfileFileCSIDriverSerializer(item["fileCSIDriver"]),
+        snapshotController: !item["snapshotController"]
+            ? item["snapshotController"]
+            : managedClusterStorageProfileSnapshotControllerSerializer(item["snapshotController"]),
+        blobCSIDriver: !item["blobCSIDriver"]
+            ? item["blobCSIDriver"]
+            : managedClusterStorageProfileBlobCSIDriverSerializer(item["blobCSIDriver"]),
+    };
+}
+export function managedClusterStorageProfileDeserializer(item) {
+    return {
+        diskCSIDriver: !item["diskCSIDriver"]
+            ? item["diskCSIDriver"]
+            : managedClusterStorageProfileDiskCSIDriverDeserializer(item["diskCSIDriver"]),
+        fileCSIDriver: !item["fileCSIDriver"]
+            ? item["fileCSIDriver"]
+            : managedClusterStorageProfileFileCSIDriverDeserializer(item["fileCSIDriver"]),
+        snapshotController: !item["snapshotController"]
+            ? item["snapshotController"]
+            : managedClusterStorageProfileSnapshotControllerDeserializer(item["snapshotController"]),
+        blobCSIDriver: !item["blobCSIDriver"]
+            ? item["blobCSIDriver"]
+            : managedClusterStorageProfileBlobCSIDriverDeserializer(item["blobCSIDriver"]),
+    };
+}
+export function managedClusterStorageProfileDiskCSIDriverSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterStorageProfileDiskCSIDriverDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterStorageProfileFileCSIDriverSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterStorageProfileFileCSIDriverDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterStorageProfileSnapshotControllerSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterStorageProfileSnapshotControllerDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterStorageProfileBlobCSIDriverSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterStorageProfileBlobCSIDriverDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterIngressProfileSerializer(item) {
+    return {
+        webAppRouting: !item["webAppRouting"]
+            ? item["webAppRouting"]
+            : managedClusterIngressProfileWebAppRoutingSerializer(item["webAppRouting"]),
+    };
+}
+export function managedClusterIngressProfileDeserializer(item) {
+    return {
+        webAppRouting: !item["webAppRouting"]
+            ? item["webAppRouting"]
+            : managedClusterIngressProfileWebAppRoutingDeserializer(item["webAppRouting"]),
+    };
+}
+export function managedClusterIngressProfileWebAppRoutingSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        dnsZoneResourceIds: !item["dnsZoneResourceIds"]
+            ? item["dnsZoneResourceIds"]
+            : item["dnsZoneResourceIds"].map((p) => {
+                return p;
+            }),
+        nginx: !item["nginx"]
+            ? item["nginx"]
+            : managedClusterIngressProfileNginxSerializer(item["nginx"]),
+    };
+}
+export function managedClusterIngressProfileWebAppRoutingDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        dnsZoneResourceIds: !item["dnsZoneResourceIds"]
+            ? item["dnsZoneResourceIds"]
+            : item["dnsZoneResourceIds"].map((p) => {
+                return p;
+            }),
+        nginx: !item["nginx"]
+            ? item["nginx"]
+            : managedClusterIngressProfileNginxDeserializer(item["nginx"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : userAssignedIdentityDeserializer(item["identity"]),
+    };
+}
+export function managedClusterIngressProfileNginxSerializer(item) {
+    return { defaultIngressControllerType: item["defaultIngressControllerType"] };
+}
+export function managedClusterIngressProfileNginxDeserializer(item) {
+    return {
+        defaultIngressControllerType: item["defaultIngressControllerType"],
+    };
+}
+/** Ingress type for the default NginxIngressController custom resource */
+export var KnownNginxIngressControllerType;
+(function (KnownNginxIngressControllerType) {
+    /** The default NginxIngressController will be created. Users can edit the default NginxIngressController Custom Resource to configure load balancer annotations. */
+    KnownNginxIngressControllerType["AnnotationControlled"] = "AnnotationControlled";
+    /** The default NginxIngressController will be created and the operator will provision an external loadbalancer with it. Any annotation to make the default loadbalancer internal will be overwritten. */
+    KnownNginxIngressControllerType["External"] = "External";
+    /** The default NginxIngressController will be created and the operator will provision an internal loadbalancer with it. Any annotation to make the default loadbalancer external will be overwritten. */
+    KnownNginxIngressControllerType["Internal"] = "Internal";
+    /** The default Ingress Controller will not be created. It will not be deleted by the system if it exists. Users should delete the default NginxIngressController Custom Resource manually if desired. */
+    KnownNginxIngressControllerType["None"] = "None";
+})(KnownNginxIngressControllerType || (KnownNginxIngressControllerType = {}));
+/** PublicNetworkAccess of the managedCluster. Allow or deny public network access for AKS */
+export var KnownPublicNetworkAccess;
+(function (KnownPublicNetworkAccess) {
+    /** Inbound/Outbound to the managedCluster is allowed. */
+    KnownPublicNetworkAccess["Enabled"] = "Enabled";
+    /** Inbound traffic to managedCluster is disabled, traffic from managedCluster is allowed. */
+    KnownPublicNetworkAccess["Disabled"] = "Disabled";
+})(KnownPublicNetworkAccess || (KnownPublicNetworkAccess = {}));
+export function managedClusterWorkloadAutoScalerProfileSerializer(item) {
+    return {
+        keda: !item["keda"]
+            ? item["keda"]
+            : managedClusterWorkloadAutoScalerProfileKedaSerializer(item["keda"]),
+        verticalPodAutoscaler: !item["verticalPodAutoscaler"]
+            ? item["verticalPodAutoscaler"]
+            : managedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerSerializer(item["verticalPodAutoscaler"]),
+    };
+}
+export function managedClusterWorkloadAutoScalerProfileDeserializer(item) {
+    return {
+        keda: !item["keda"]
+            ? item["keda"]
+            : managedClusterWorkloadAutoScalerProfileKedaDeserializer(item["keda"]),
+        verticalPodAutoscaler: !item["verticalPodAutoscaler"]
+            ? item["verticalPodAutoscaler"]
+            : managedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerDeserializer(item["verticalPodAutoscaler"]),
+    };
+}
+export function managedClusterWorkloadAutoScalerProfileKedaSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterWorkloadAutoScalerProfileKedaDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterAzureMonitorProfileSerializer(item) {
+    return {
+        metrics: !item["metrics"]
+            ? item["metrics"]
+            : managedClusterAzureMonitorProfileMetricsSerializer(item["metrics"]),
+    };
+}
+export function managedClusterAzureMonitorProfileDeserializer(item) {
+    return {
+        metrics: !item["metrics"]
+            ? item["metrics"]
+            : managedClusterAzureMonitorProfileMetricsDeserializer(item["metrics"]),
+    };
+}
+export function managedClusterAzureMonitorProfileMetricsSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        kubeStateMetrics: !item["kubeStateMetrics"]
+            ? item["kubeStateMetrics"]
+            : managedClusterAzureMonitorProfileKubeStateMetricsSerializer(item["kubeStateMetrics"]),
+    };
+}
+export function managedClusterAzureMonitorProfileMetricsDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        kubeStateMetrics: !item["kubeStateMetrics"]
+            ? item["kubeStateMetrics"]
+            : managedClusterAzureMonitorProfileKubeStateMetricsDeserializer(item["kubeStateMetrics"]),
+    };
+}
+export function managedClusterAzureMonitorProfileKubeStateMetricsSerializer(item) {
+    return {
+        metricLabelsAllowlist: item["metricLabelsAllowlist"],
+        metricAnnotationsAllowList: item["metricAnnotationsAllowList"],
+    };
+}
+export function managedClusterAzureMonitorProfileKubeStateMetricsDeserializer(item) {
+    return {
+        metricLabelsAllowlist: item["metricLabelsAllowlist"],
+        metricAnnotationsAllowList: item["metricAnnotationsAllowList"],
+    };
+}
+export function serviceMeshProfileSerializer(item) {
+    return {
+        mode: item["mode"],
+        istio: !item["istio"] ? item["istio"] : istioServiceMeshSerializer(item["istio"]),
+    };
+}
+export function serviceMeshProfileDeserializer(item) {
+    return {
+        mode: item["mode"],
+        istio: !item["istio"] ? item["istio"] : istioServiceMeshDeserializer(item["istio"]),
+    };
+}
+/** Mode of the service mesh. */
+export var KnownServiceMeshMode;
+(function (KnownServiceMeshMode) {
+    /** Istio deployed as an AKS addon. */
+    KnownServiceMeshMode["Istio"] = "Istio";
+    /** Mesh is disabled. */
+    KnownServiceMeshMode["Disabled"] = "Disabled";
+})(KnownServiceMeshMode || (KnownServiceMeshMode = {}));
+export function istioServiceMeshSerializer(item) {
+    return {
+        components: !item["components"]
+            ? item["components"]
+            : istioComponentsSerializer(item["components"]),
+        certificateAuthority: !item["certificateAuthority"]
+            ? item["certificateAuthority"]
+            : istioCertificateAuthoritySerializer(item["certificateAuthority"]),
+        revisions: !item["revisions"]
+            ? item["revisions"]
+            : item["revisions"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function istioServiceMeshDeserializer(item) {
+    return {
+        components: !item["components"]
+            ? item["components"]
+            : istioComponentsDeserializer(item["components"]),
+        certificateAuthority: !item["certificateAuthority"]
+            ? item["certificateAuthority"]
+            : istioCertificateAuthorityDeserializer(item["certificateAuthority"]),
+        revisions: !item["revisions"]
+            ? item["revisions"]
+            : item["revisions"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function istioComponentsSerializer(item) {
+    return {
+        ingressGateways: !item["ingressGateways"]
+            ? item["ingressGateways"]
+            : istioIngressGatewayArraySerializer(item["ingressGateways"]),
+        egressGateways: !item["egressGateways"]
+            ? item["egressGateways"]
+            : istioEgressGatewayArraySerializer(item["egressGateways"]),
+        proxyRedirectionMechanism: item["proxyRedirectionMechanism"],
+    };
+}
+export function istioComponentsDeserializer(item) {
+    return {
+        ingressGateways: !item["ingressGateways"]
+            ? item["ingressGateways"]
+            : istioIngressGatewayArrayDeserializer(item["ingressGateways"]),
+        egressGateways: !item["egressGateways"]
+            ? item["egressGateways"]
+            : istioEgressGatewayArrayDeserializer(item["egressGateways"]),
+        proxyRedirectionMechanism: item["proxyRedirectionMechanism"],
+    };
+}
+export function istioIngressGatewayArraySerializer(result) {
+    return result.map((item) => {
+        return istioIngressGatewaySerializer(item);
+    });
+}
+export function istioIngressGatewayArrayDeserializer(result) {
+    return result.map((item) => {
+        return istioIngressGatewayDeserializer(item);
+    });
+}
+export function istioIngressGatewaySerializer(item) {
+    return { mode: item["mode"], enabled: item["enabled"] };
+}
+export function istioIngressGatewayDeserializer(item) {
+    return {
+        mode: item["mode"],
+        enabled: item["enabled"],
+    };
+}
+/** Mode of an ingress gateway. */
+export var KnownIstioIngressGatewayMode;
+(function (KnownIstioIngressGatewayMode) {
+    /** The ingress gateway is assigned a public IP address and is publicly accessible. */
+    KnownIstioIngressGatewayMode["External"] = "External";
+    /** The ingress gateway is assigned an internal IP address and cannot is accessed publicly. */
+    KnownIstioIngressGatewayMode["Internal"] = "Internal";
+})(KnownIstioIngressGatewayMode || (KnownIstioIngressGatewayMode = {}));
+export function istioEgressGatewayArraySerializer(result) {
+    return result.map((item) => {
+        return istioEgressGatewaySerializer(item);
+    });
+}
+export function istioEgressGatewayArrayDeserializer(result) {
+    return result.map((item) => {
+        return istioEgressGatewayDeserializer(item);
+    });
+}
+export function istioEgressGatewaySerializer(item) {
+    return {
+        enabled: item["enabled"],
+        name: item["name"],
+        namespace: item["namespace"],
+        gatewayConfigurationName: item["gatewayConfigurationName"],
+    };
+}
+export function istioEgressGatewayDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+        name: item["name"],
+        namespace: item["namespace"],
+        gatewayConfigurationName: item["gatewayConfigurationName"],
+    };
+}
+/** Mode of traffic redirection. */
+export var KnownProxyRedirectionMechanism;
+(function (KnownProxyRedirectionMechanism) {
+    /** Istio will inject an init container into each pod to redirect traffic (requires NET_ADMIN and NET_RAW). */
+    KnownProxyRedirectionMechanism["InitContainers"] = "InitContainers";
+    /** Istio will install a chained CNI plugin to redirect traffic (recommended). */
+    KnownProxyRedirectionMechanism["CNIChaining"] = "CNIChaining";
+})(KnownProxyRedirectionMechanism || (KnownProxyRedirectionMechanism = {}));
+export function istioCertificateAuthoritySerializer(item) {
+    return {
+        plugin: !item["plugin"]
+            ? item["plugin"]
+            : istioPluginCertificateAuthoritySerializer(item["plugin"]),
+    };
+}
+export function istioCertificateAuthorityDeserializer(item) {
+    return {
+        plugin: !item["plugin"]
+            ? item["plugin"]
+            : istioPluginCertificateAuthorityDeserializer(item["plugin"]),
+    };
+}
+export function istioPluginCertificateAuthoritySerializer(item) {
+    return {
+        keyVaultId: item["keyVaultId"],
+        certObjectName: item["certObjectName"],
+        keyObjectName: item["keyObjectName"],
+        rootCertObjectName: item["rootCertObjectName"],
+        certChainObjectName: item["certChainObjectName"],
+    };
+}
+export function istioPluginCertificateAuthorityDeserializer(item) {
+    return {
+        keyVaultId: item["keyVaultId"],
+        certObjectName: item["certObjectName"],
+        keyObjectName: item["keyObjectName"],
+        rootCertObjectName: item["rootCertObjectName"],
+        certChainObjectName: item["certChainObjectName"],
+    };
+}
+export function managedClusterMetricsProfileSerializer(item) {
+    return {
+        costAnalysis: !item["costAnalysis"]
+            ? item["costAnalysis"]
+            : managedClusterCostAnalysisSerializer(item["costAnalysis"]),
+    };
+}
+export function managedClusterMetricsProfileDeserializer(item) {
+    return {
+        costAnalysis: !item["costAnalysis"]
+            ? item["costAnalysis"]
+            : managedClusterCostAnalysisDeserializer(item["costAnalysis"]),
+    };
+}
+export function managedClusterCostAnalysisSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterCostAnalysisDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterNodeProvisioningProfileSerializer(item) {
+    return { mode: item["mode"], defaultNodePools: item["defaultNodePools"] };
+}
+export function managedClusterNodeProvisioningProfileDeserializer(item) {
+    return {
+        mode: item["mode"],
+        defaultNodePools: item["defaultNodePools"],
+    };
+}
+/** The node provisioning mode. If not specified, the default is Manual. */
+export var KnownNodeProvisioningMode;
+(function (KnownNodeProvisioningMode) {
+    /** Nodes are provisioned manually by the user */
+    KnownNodeProvisioningMode["Manual"] = "Manual";
+    /** Nodes are provisioned automatically by AKS using Karpenter (See aka.ms/aks/nap for more details). Fixed size Node Pools can still be created, but autoscaling Node Pools cannot be. (See aka.ms/aks/nap for more details). */
+    KnownNodeProvisioningMode["Auto"] = "Auto";
+})(KnownNodeProvisioningMode || (KnownNodeProvisioningMode = {}));
+/** The set of default Karpenter NodePools (CRDs) configured for node provisioning. This field has no effect unless mode is 'Auto'. Warning: Changing this from Auto to None on an existing cluster will cause the default Karpenter NodePools to be deleted, which will drain and delete the nodes associated with those pools. It is strongly recommended to not do this unless there are idle nodes ready to take the pods evicted by that action. If not specified, the default is Auto. For more information see aka.ms/aks/nap#node-pools. */
+export var KnownNodeProvisioningDefaultNodePools;
+(function (KnownNodeProvisioningDefaultNodePools) {
+    /** No Karpenter NodePools are provisioned automatically. Automatic scaling will not happen unless the user creates one or more NodePool CRD instances. */
+    KnownNodeProvisioningDefaultNodePools["None"] = "None";
+    /** A standard set of Karpenter NodePools are provisioned */
+    KnownNodeProvisioningDefaultNodePools["Auto"] = "Auto";
+})(KnownNodeProvisioningDefaultNodePools || (KnownNodeProvisioningDefaultNodePools = {}));
+export function managedClusterBootstrapProfileSerializer(item) {
+    return {
+        artifactSource: item["artifactSource"],
+        containerRegistryId: item["containerRegistryId"],
+    };
+}
+export function managedClusterBootstrapProfileDeserializer(item) {
+    return {
+        artifactSource: item["artifactSource"],
+        containerRegistryId: item["containerRegistryId"],
+    };
+}
+/** The artifact source. The source where the artifacts are downloaded from. */
+export var KnownArtifactSource;
+(function (KnownArtifactSource) {
+    /** pull images from Azure Container Registry with cache */
+    KnownArtifactSource["Cache"] = "Cache";
+    /** pull images from Microsoft Artifact Registry */
+    KnownArtifactSource["Direct"] = "Direct";
+})(KnownArtifactSource || (KnownArtifactSource = {}));
+export function managedClusterAIToolchainOperatorProfileSerializer(item) {
+    return { enabled: item["enabled"] };
+}
+export function managedClusterAIToolchainOperatorProfileDeserializer(item) {
+    return {
+        enabled: item["enabled"],
+    };
+}
+export function managedClusterStatusSerializer(item) {
+    return item;
+}
+export function managedClusterStatusDeserializer(item) {
+    return {
+        provisioningError: !item["provisioningError"]
+            ? item["provisioningError"]
+            : errorDetailDeserializer(item["provisioningError"]),
+    };
+}
+export function managedClusterSKUSerializer(item) {
+    return { name: item["name"], tier: item["tier"] };
+}
+export function managedClusterSKUDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+    };
+}
+/** The name of a managed cluster SKU. */
+export var KnownManagedClusterSKUName;
+(function (KnownManagedClusterSKUName) {
+    /** Base option for the AKS control plane. */
+    KnownManagedClusterSKUName["Base"] = "Base";
+    /** Automatic clusters are optimized to run most production workloads with configuration that follows AKS best practices and recommendations for cluster and workload setup, scalability, and security. For more details about Automatic clusters see aka.ms/aks/automatic. */
+    KnownManagedClusterSKUName["Automatic"] = "Automatic";
+})(KnownManagedClusterSKUName || (KnownManagedClusterSKUName = {}));
+/** The tier of a managed cluster SKU. If not specified, the default is 'Free'. See [AKS Pricing Tier](https://learn.microsoft.com/azure/aks/free-standard-pricing-tiers) for more details. */
+export var KnownManagedClusterSKUTier;
+(function (KnownManagedClusterSKUTier) {
+    /** Cluster has premium capabilities in addition to all of the capabilities included in 'Standard'. Premium enables selection of LongTermSupport (aka.ms/aks/lts) for certain Kubernetes versions. */
+    KnownManagedClusterSKUTier["Premium"] = "Premium";
+    /** Recommended for mission-critical and production workloads. Includes Kubernetes control plane autoscaling, workload-intensive testing, and up to 5,000 nodes per cluster. Guarantees 99.95% availability of the Kubernetes API server endpoint for clusters that use Availability Zones and 99.9% of availability for clusters that don't use Availability Zones. */
+    KnownManagedClusterSKUTier["Standard"] = "Standard";
+    /** The cluster management is free, but charged for VM, storage, and networking usage. Best for experimenting, learning, simple testing, or workloads with fewer than 10 nodes. Not recommended for production use cases. */
+    KnownManagedClusterSKUTier["Free"] = "Free";
+})(KnownManagedClusterSKUTier || (KnownManagedClusterSKUTier = {}));
+export function extendedLocationSerializer(item) {
+    return { name: item["name"], type: item["type"] };
+}
+export function extendedLocationDeserializer(item) {
+    return {
+        name: item["name"],
+        type: item["type"],
+    };
+}
+/** The type of extendedLocation. */
+export var KnownExtendedLocationTypes;
+(function (KnownExtendedLocationTypes) {
+    /** Azure Edge Zone extended location type. */
+    KnownExtendedLocationTypes["EdgeZone"] = "EdgeZone";
+})(KnownExtendedLocationTypes || (KnownExtendedLocationTypes = {}));
+export function managedClusterIdentitySerializer(item) {
+    return {
+        type: item["type"],
+        delegatedResources: !item["delegatedResources"]
+            ? item["delegatedResources"]
+            : delegatedResourceRecordSerializer(item["delegatedResources"]),
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : managedServiceIdentityUserAssignedIdentitiesValueRecordSerializer(item["userAssignedIdentities"]),
+    };
+}
+export function managedClusterIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        tenantId: item["tenantId"],
+        type: item["type"],
+        delegatedResources: !item["delegatedResources"]
+            ? item["delegatedResources"]
+            : delegatedResourceRecordDeserializer(item["delegatedResources"]),
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : managedServiceIdentityUserAssignedIdentitiesValueRecordDeserializer(item["userAssignedIdentities"]),
+    };
+}
+/** The type of identity used for the managed cluster. For more information see [use managed identities in AKS](https://docs.microsoft.com/azure/aks/use-managed-identity). */
+export var KnownResourceIdentityType;
+(function (KnownResourceIdentityType) {
+    /** Use an implicitly created system assigned managed identity to manage cluster resources. Master components in the control plane such as kube-controller-manager will use the system assigned managed identity to manipulate Azure resources. */
+    KnownResourceIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** Use a user-specified identity to manage cluster resources. Master components in the control plane such as kube-controller-manager will use the specified user assigned managed identity to manipulate Azure resources. */
+    KnownResourceIdentityType["UserAssigned"] = "UserAssigned";
+    /** Do not use a managed identity for the Managed Cluster, service principal will be used instead. */
+    KnownResourceIdentityType["None"] = "None";
+})(KnownResourceIdentityType || (KnownResourceIdentityType = {}));
+export function delegatedResourceRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : delegatedResourceSerializer(item[key]);
+    });
+    return result;
+}
+export function delegatedResourceRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : delegatedResourceDeserializer(item[key]);
+    });
+    return result;
+}
+export function delegatedResourceSerializer(item) {
+    return {
+        resourceId: item["resourceId"],
+        tenantId: item["tenantId"],
+        referralResource: item["referralResource"],
+        location: item["location"],
+    };
+}
+export function delegatedResourceDeserializer(item) {
+    return {
+        resourceId: item["resourceId"],
+        tenantId: item["tenantId"],
+        referralResource: item["referralResource"],
+        location: item["location"],
+    };
+}
+export function managedServiceIdentityUserAssignedIdentitiesValueRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key]
+            ? item[key]
+            : managedServiceIdentityUserAssignedIdentitiesValueSerializer(item[key]);
+    });
+    return result;
+}
+export function managedServiceIdentityUserAssignedIdentitiesValueRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key]
+            ? item[key]
+            : managedServiceIdentityUserAssignedIdentitiesValueDeserializer(item[key]);
+    });
+    return result;
+}
+export function managedServiceIdentityUserAssignedIdentitiesValueSerializer(item) {
+    return item;
+}
+export function managedServiceIdentityUserAssignedIdentitiesValueDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+export function trackedResourceSerializer(item) {
+    return { tags: item["tags"], location: item["location"] };
+}
+export function trackedResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+    };
+}
+export function tagsObjectSerializer(item) {
+    return { tags: item["tags"] };
+}
+export function _managedClusterListResultDeserializer(item) {
+    return {
+        value: managedClusterArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function managedClusterArraySerializer(result) {
+    return result.map((item) => {
+        return managedClusterSerializer(item);
+    });
+}
+export function managedClusterArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedClusterDeserializer(item);
+    });
+}
+export function managedClusterAccessProfileDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _managedClusterAccessProfilePropertiesDeserializer(item["properties"])),
+    };
+}
+export function accessProfileDeserializer(item) {
+    return {
+        kubeConfig: !item["kubeConfig"]
+            ? item["kubeConfig"]
+            : typeof item["kubeConfig"] === "string"
+                ? stringToUint8Array(item["kubeConfig"], "base64")
+                : item["kubeConfig"],
+    };
+}
+export function credentialResultsDeserializer(item) {
+    return {
+        kubeconfigs: !item["kubeconfigs"]
+            ? item["kubeconfigs"]
+            : credentialResultArrayDeserializer(item["kubeconfigs"]),
+    };
+}
+export function credentialResultArrayDeserializer(result) {
+    return result.map((item) => {
+        return credentialResultDeserializer(item);
+    });
+}
+export function credentialResultDeserializer(item) {
+    return {
+        name: item["name"],
+        value: !item["value"]
+            ? item["value"]
+            : typeof item["value"] === "string"
+                ? stringToUint8Array(item["value"], "base64")
+                : item["value"],
+    };
+}
+export function runCommandRequestSerializer(item) {
+    return { command: item["command"], context: item["context"], clusterToken: item["clusterToken"] };
+}
+export function runCommandResultDeserializer(item) {
+    return {
+        id: item["id"],
+        ...(!item["properties"]
+            ? item["properties"]
+            : _runCommandResultPropertiesDeserializer(item["properties"])),
+    };
+}
+export function commandResultPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        exitCode: item["exitCode"],
+        startedAt: !item["startedAt"] ? item["startedAt"] : new Date(item["startedAt"]),
+        finishedAt: !item["finishedAt"] ? item["finishedAt"] : new Date(item["finishedAt"]),
+        logs: item["logs"],
+        reason: item["reason"],
+    };
+}
+export function _outboundEnvironmentEndpointCollectionDeserializer(item) {
+    return {
+        value: outboundEnvironmentEndpointArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function outboundEnvironmentEndpointArrayDeserializer(result) {
+    return result.map((item) => {
+        return outboundEnvironmentEndpointDeserializer(item);
+    });
+}
+export function outboundEnvironmentEndpointDeserializer(item) {
+    return {
+        category: item["category"],
+        endpoints: !item["endpoints"]
+            ? item["endpoints"]
+            : endpointDependencyArrayDeserializer(item["endpoints"]),
+    };
+}
+export function endpointDependencyArrayDeserializer(result) {
+    return result.map((item) => {
+        return endpointDependencyDeserializer(item);
+    });
+}
+export function endpointDependencyDeserializer(item) {
+    return {
+        domainName: item["domainName"],
+        endpointDetails: !item["endpointDetails"]
+            ? item["endpointDetails"]
+            : endpointDetailArrayDeserializer(item["endpointDetails"]),
+    };
+}
+export function endpointDetailArrayDeserializer(result) {
+    return result.map((item) => {
+        return endpointDetailDeserializer(item);
+    });
+}
+export function endpointDetailDeserializer(item) {
+    return {
+        ipAddress: item["ipAddress"],
+        port: item["port"],
+        protocol: item["protocol"],
+        description: item["description"],
+    };
+}
+export function managedClusterUpgradeProfileDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ..._managedClusterUpgradeProfilePropertiesDeserializer(item["properties"]),
+    };
+}
+export function managedClusterUpgradeProfilePropertiesDeserializer(item) {
+    return {
+        controlPlaneProfile: managedClusterPoolUpgradeProfileDeserializer(item["controlPlaneProfile"]),
+        agentPoolProfiles: managedClusterPoolUpgradeProfileArrayDeserializer(item["agentPoolProfiles"]),
+    };
+}
+export function managedClusterPoolUpgradeProfileDeserializer(item) {
+    return {
+        kubernetesVersion: item["kubernetesVersion"],
+        name: item["name"],
+        osType: item["osType"],
+        upgrades: !item["upgrades"]
+            ? item["upgrades"]
+            : managedClusterPoolUpgradeProfileUpgradesItemArrayDeserializer(item["upgrades"]),
+    };
+}
+export function managedClusterPoolUpgradeProfileUpgradesItemArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedClusterPoolUpgradeProfileUpgradesItemDeserializer(item);
+    });
+}
+export function managedClusterPoolUpgradeProfileUpgradesItemDeserializer(item) {
+    return {
+        kubernetesVersion: item["kubernetesVersion"],
+        isPreview: item["isPreview"],
+    };
+}
+export function managedClusterPoolUpgradeProfileArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedClusterPoolUpgradeProfileDeserializer(item);
+    });
+}
+export function meshRevisionProfileDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : meshRevisionProfilePropertiesDeserializer(item["properties"]),
+    };
+}
+export function meshRevisionProfilePropertiesDeserializer(item) {
+    return {
+        meshRevisions: !item["meshRevisions"]
+            ? item["meshRevisions"]
+            : meshRevisionArrayDeserializer(item["meshRevisions"]),
+    };
+}
+export function meshRevisionArrayDeserializer(result) {
+    return result.map((item) => {
+        return meshRevisionDeserializer(item);
+    });
+}
+export function meshRevisionDeserializer(item) {
+    return {
+        revision: item["revision"],
+        upgrades: !item["upgrades"]
+            ? item["upgrades"]
+            : item["upgrades"].map((p) => {
+                return p;
+            }),
+        compatibleWith: !item["compatibleWith"]
+            ? item["compatibleWith"]
+            : compatibleVersionsArrayDeserializer(item["compatibleWith"]),
+    };
+}
+export function compatibleVersionsArrayDeserializer(result) {
+    return result.map((item) => {
+        return compatibleVersionsDeserializer(item);
+    });
+}
+export function compatibleVersionsDeserializer(item) {
+    return {
+        name: item["name"],
+        versions: !item["versions"]
+            ? item["versions"]
+            : item["versions"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _meshRevisionProfileListDeserializer(item) {
+    return {
+        value: meshRevisionProfileArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function meshRevisionProfileArrayDeserializer(result) {
+    return result.map((item) => {
+        return meshRevisionProfileDeserializer(item);
+    });
+}
+export function meshUpgradeProfileDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : meshUpgradeProfilePropertiesDeserializer(item["properties"]),
+    };
+}
+export function meshUpgradeProfilePropertiesDeserializer(item) {
+    return {
+        revision: item["revision"],
+        upgrades: !item["upgrades"]
+            ? item["upgrades"]
+            : item["upgrades"].map((p) => {
+                return p;
+            }),
+        compatibleWith: !item["compatibleWith"]
+            ? item["compatibleWith"]
+            : compatibleVersionsArrayDeserializer(item["compatibleWith"]),
+    };
+}
+export function _meshUpgradeProfileListDeserializer(item) {
+    return {
+        value: meshUpgradeProfileArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function meshUpgradeProfileArrayDeserializer(result) {
+    return result.map((item) => {
+        return meshUpgradeProfileDeserializer(item);
+    });
+}
+export function kubernetesVersionListResultDeserializer(item) {
+    return {
+        values: !item["values"] ? item["values"] : kubernetesVersionArrayDeserializer(item["values"]),
+    };
+}
+export function kubernetesVersionArrayDeserializer(result) {
+    return result.map((item) => {
+        return kubernetesVersionDeserializer(item);
+    });
+}
+export function kubernetesVersionDeserializer(item) {
+    return {
+        version: item["version"],
+        capabilities: !item["capabilities"]
+            ? item["capabilities"]
+            : kubernetesVersionCapabilitiesDeserializer(item["capabilities"]),
+        isDefault: item["isDefault"],
+        isPreview: item["isPreview"],
+        patchVersions: !item["patchVersions"]
+            ? item["patchVersions"]
+            : kubernetesPatchVersionRecordDeserializer(item["patchVersions"]),
+    };
+}
+export function kubernetesVersionCapabilitiesDeserializer(item) {
+    return {
+        supportPlan: !item["supportPlan"]
+            ? item["supportPlan"]
+            : item["supportPlan"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function kubernetesPatchVersionRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : kubernetesPatchVersionDeserializer(item[key]);
+    });
+    return result;
+}
+export function kubernetesPatchVersionDeserializer(item) {
+    return {
+        upgrades: !item["upgrades"]
+            ? item["upgrades"]
+            : item["upgrades"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function maintenanceConfigurationSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["timeInWeek", "notAllowedTime", "maintenanceWindow"])
+            ? undefined
+            : _maintenanceConfigurationPropertiesSerializer(item),
+    };
+}
+export function maintenanceConfigurationDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _maintenanceConfigurationPropertiesDeserializer(item["properties"])),
+    };
+}
+export function maintenanceConfigurationPropertiesSerializer(item) {
+    return {
+        timeInWeek: !item["timeInWeek"]
+            ? item["timeInWeek"]
+            : timeInWeekArraySerializer(item["timeInWeek"]),
+        notAllowedTime: !item["notAllowedTime"]
+            ? item["notAllowedTime"]
+            : timeSpanArraySerializer(item["notAllowedTime"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowSerializer(item["maintenanceWindow"]),
+    };
+}
+export function maintenanceConfigurationPropertiesDeserializer(item) {
+    return {
+        timeInWeek: !item["timeInWeek"]
+            ? item["timeInWeek"]
+            : timeInWeekArrayDeserializer(item["timeInWeek"]),
+        notAllowedTime: !item["notAllowedTime"]
+            ? item["notAllowedTime"]
+            : timeSpanArrayDeserializer(item["notAllowedTime"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowDeserializer(item["maintenanceWindow"]),
+    };
+}
+export function timeInWeekArraySerializer(result) {
+    return result.map((item) => {
+        return timeInWeekSerializer(item);
+    });
+}
+export function timeInWeekArrayDeserializer(result) {
+    return result.map((item) => {
+        return timeInWeekDeserializer(item);
+    });
+}
+export function timeInWeekSerializer(item) {
+    return {
+        day: item["day"],
+        hourSlots: !item["hourSlots"]
+            ? item["hourSlots"]
+            : item["hourSlots"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function timeInWeekDeserializer(item) {
+    return {
+        day: item["day"],
+        hourSlots: !item["hourSlots"]
+            ? item["hourSlots"]
+            : item["hourSlots"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** The weekday enum. */
+export var KnownWeekDay;
+(function (KnownWeekDay) {
+    /** Represents Sunday. */
+    KnownWeekDay["Sunday"] = "Sunday";
+    /** Represents Monday. */
+    KnownWeekDay["Monday"] = "Monday";
+    /** Represents Tuesday. */
+    KnownWeekDay["Tuesday"] = "Tuesday";
+    /** Represents Wednesday. */
+    KnownWeekDay["Wednesday"] = "Wednesday";
+    /** Represents Thursday. */
+    KnownWeekDay["Thursday"] = "Thursday";
+    /** Represents Friday. */
+    KnownWeekDay["Friday"] = "Friday";
+    /** Represents Saturday. */
+    KnownWeekDay["Saturday"] = "Saturday";
+})(KnownWeekDay || (KnownWeekDay = {}));
+export function timeSpanArraySerializer(result) {
+    return result.map((item) => {
+        return timeSpanSerializer(item);
+    });
+}
+export function timeSpanArrayDeserializer(result) {
+    return result.map((item) => {
+        return timeSpanDeserializer(item);
+    });
+}
+export function timeSpanSerializer(item) {
+    return {
+        start: !item["start"] ? item["start"] : item["start"].toISOString(),
+        end: !item["end"] ? item["end"] : item["end"].toISOString(),
+    };
+}
+export function timeSpanDeserializer(item) {
+    return {
+        start: !item["start"] ? item["start"] : new Date(item["start"]),
+        end: !item["end"] ? item["end"] : new Date(item["end"]),
+    };
+}
+export function maintenanceWindowSerializer(item) {
+    return {
+        schedule: scheduleSerializer(item["schedule"]),
+        durationHours: item["durationHours"],
+        utcOffset: item["utcOffset"],
+        startDate: !item["startDate"]
+            ? item["startDate"]
+            : item["startDate"].toISOString().split("T")[0],
+        startTime: item["startTime"],
+        notAllowedDates: !item["notAllowedDates"]
+            ? item["notAllowedDates"]
+            : dateSpanArraySerializer(item["notAllowedDates"]),
+    };
+}
+export function maintenanceWindowDeserializer(item) {
+    return {
+        schedule: scheduleDeserializer(item["schedule"]),
+        durationHours: item["durationHours"],
+        utcOffset: item["utcOffset"],
+        startDate: !item["startDate"] ? item["startDate"] : new Date(item["startDate"]),
+        startTime: item["startTime"],
+        notAllowedDates: !item["notAllowedDates"]
+            ? item["notAllowedDates"]
+            : dateSpanArrayDeserializer(item["notAllowedDates"]),
+    };
+}
+export function scheduleSerializer(item) {
+    return {
+        daily: !item["daily"] ? item["daily"] : dailyScheduleSerializer(item["daily"]),
+        weekly: !item["weekly"] ? item["weekly"] : weeklyScheduleSerializer(item["weekly"]),
+        absoluteMonthly: !item["absoluteMonthly"]
+            ? item["absoluteMonthly"]
+            : absoluteMonthlyScheduleSerializer(item["absoluteMonthly"]),
+        relativeMonthly: !item["relativeMonthly"]
+            ? item["relativeMonthly"]
+            : relativeMonthlyScheduleSerializer(item["relativeMonthly"]),
+    };
+}
+export function scheduleDeserializer(item) {
+    return {
+        daily: !item["daily"] ? item["daily"] : dailyScheduleDeserializer(item["daily"]),
+        weekly: !item["weekly"] ? item["weekly"] : weeklyScheduleDeserializer(item["weekly"]),
+        absoluteMonthly: !item["absoluteMonthly"]
+            ? item["absoluteMonthly"]
+            : absoluteMonthlyScheduleDeserializer(item["absoluteMonthly"]),
+        relativeMonthly: !item["relativeMonthly"]
+            ? item["relativeMonthly"]
+            : relativeMonthlyScheduleDeserializer(item["relativeMonthly"]),
+    };
+}
+export function dailyScheduleSerializer(item) {
+    return { intervalDays: item["intervalDays"] };
+}
+export function dailyScheduleDeserializer(item) {
+    return {
+        intervalDays: item["intervalDays"],
+    };
+}
+export function weeklyScheduleSerializer(item) {
+    return { intervalWeeks: item["intervalWeeks"], dayOfWeek: item["dayOfWeek"] };
+}
+export function weeklyScheduleDeserializer(item) {
+    return {
+        intervalWeeks: item["intervalWeeks"],
+        dayOfWeek: item["dayOfWeek"],
+    };
+}
+export function absoluteMonthlyScheduleSerializer(item) {
+    return { intervalMonths: item["intervalMonths"], dayOfMonth: item["dayOfMonth"] };
+}
+export function absoluteMonthlyScheduleDeserializer(item) {
+    return {
+        intervalMonths: item["intervalMonths"],
+        dayOfMonth: item["dayOfMonth"],
+    };
+}
+export function relativeMonthlyScheduleSerializer(item) {
+    return {
+        intervalMonths: item["intervalMonths"],
+        weekIndex: item["weekIndex"],
+        dayOfWeek: item["dayOfWeek"],
+    };
+}
+export function relativeMonthlyScheduleDeserializer(item) {
+    return {
+        intervalMonths: item["intervalMonths"],
+        weekIndex: item["weekIndex"],
+        dayOfWeek: item["dayOfWeek"],
+    };
+}
+/** The week index. Specifies on which week of the month the dayOfWeek applies. */
+export var KnownType;
+(function (KnownType) {
+    /** First week of the month. */
+    KnownType["First"] = "First";
+    /** Second week of the month. */
+    KnownType["Second"] = "Second";
+    /** Third week of the month. */
+    KnownType["Third"] = "Third";
+    /** Fourth week of the month. */
+    KnownType["Fourth"] = "Fourth";
+    /** Last week of the month. */
+    KnownType["Last"] = "Last";
+})(KnownType || (KnownType = {}));
+export function dateSpanArraySerializer(result) {
+    return result.map((item) => {
+        return dateSpanSerializer(item);
+    });
+}
+export function dateSpanArrayDeserializer(result) {
+    return result.map((item) => {
+        return dateSpanDeserializer(item);
+    });
+}
+export function dateSpanSerializer(item) {
+    return {
+        start: item["start"].toISOString().split("T")[0],
+        end: item["end"].toISOString().split("T")[0],
+    };
+}
+export function dateSpanDeserializer(item) {
+    return {
+        start: new Date(item["start"]),
+        end: new Date(item["end"]),
+    };
+}
+export function _maintenanceConfigurationListResultDeserializer(item) {
+    return {
+        value: maintenanceConfigurationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function maintenanceConfigurationArraySerializer(result) {
+    return result.map((item) => {
+        return maintenanceConfigurationSerializer(item);
+    });
+}
+export function maintenanceConfigurationArrayDeserializer(result) {
+    return result.map((item) => {
+        return maintenanceConfigurationDeserializer(item);
+    });
+}
+export function managedNamespaceSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : namespacePropertiesSerializer(item["properties"]),
+    };
+}
+export function managedNamespaceDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : namespacePropertiesDeserializer(item["properties"]),
+        eTag: item["eTag"],
+    };
+}
+export function namespacePropertiesSerializer(item) {
+    return {
+        labels: item["labels"],
+        annotations: item["annotations"],
+        defaultResourceQuota: !item["defaultResourceQuota"]
+            ? item["defaultResourceQuota"]
+            : resourceQuotaSerializer(item["defaultResourceQuota"]),
+        defaultNetworkPolicy: !item["defaultNetworkPolicy"]
+            ? item["defaultNetworkPolicy"]
+            : networkPoliciesSerializer(item["defaultNetworkPolicy"]),
+        adoptionPolicy: item["adoptionPolicy"],
+        deletePolicy: item["deletePolicy"],
+    };
+}
+export function namespacePropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        labels: !item["labels"]
+            ? item["labels"]
+            : Object.fromEntries(Object.entries(item["labels"]).map(([k, p]) => [k, p])),
+        annotations: !item["annotations"]
+            ? item["annotations"]
+            : Object.fromEntries(Object.entries(item["annotations"]).map(([k, p]) => [k, p])),
+        portalFqdn: item["portalFqdn"],
+        defaultResourceQuota: !item["defaultResourceQuota"]
+            ? item["defaultResourceQuota"]
+            : resourceQuotaDeserializer(item["defaultResourceQuota"]),
+        defaultNetworkPolicy: !item["defaultNetworkPolicy"]
+            ? item["defaultNetworkPolicy"]
+            : networkPoliciesDeserializer(item["defaultNetworkPolicy"]),
+        adoptionPolicy: item["adoptionPolicy"],
+        deletePolicy: item["deletePolicy"],
+    };
+}
+/** The current provisioning state of the namespace. */
+export var KnownNamespaceProvisioningState;
+(function (KnownNamespaceProvisioningState) {
+    /** The namespace is being updated. */
+    KnownNamespaceProvisioningState["Updating"] = "Updating";
+    /** The namespace is being deleted. */
+    KnownNamespaceProvisioningState["Deleting"] = "Deleting";
+    /** The namespace is being created. */
+    KnownNamespaceProvisioningState["Creating"] = "Creating";
+    /** The namespace provisioning succeeded. */
+    KnownNamespaceProvisioningState["Succeeded"] = "Succeeded";
+    /** The namespace provisioning failed. */
+    KnownNamespaceProvisioningState["Failed"] = "Failed";
+    /** The namespace provisioning was canceled. */
+    KnownNamespaceProvisioningState["Canceled"] = "Canceled";
+})(KnownNamespaceProvisioningState || (KnownNamespaceProvisioningState = {}));
+export function resourceQuotaSerializer(item) {
+    return {
+        cpuRequest: item["cpuRequest"],
+        cpuLimit: item["cpuLimit"],
+        memoryRequest: item["memoryRequest"],
+        memoryLimit: item["memoryLimit"],
+    };
+}
+export function resourceQuotaDeserializer(item) {
+    return {
+        cpuRequest: item["cpuRequest"],
+        cpuLimit: item["cpuLimit"],
+        memoryRequest: item["memoryRequest"],
+        memoryLimit: item["memoryLimit"],
+    };
+}
+export function networkPoliciesSerializer(item) {
+    return { ingress: item["ingress"], egress: item["egress"] };
+}
+export function networkPoliciesDeserializer(item) {
+    return {
+        ingress: item["ingress"],
+        egress: item["egress"],
+    };
+}
+/** Enum representing different network policy rules. */
+export var KnownPolicyRule;
+(function (KnownPolicyRule) {
+    /** Deny all network traffic. */
+    KnownPolicyRule["DenyAll"] = "DenyAll";
+    /** Allow all network traffic. */
+    KnownPolicyRule["AllowAll"] = "AllowAll";
+    /** Allow traffic within the same namespace. */
+    KnownPolicyRule["AllowSameNamespace"] = "AllowSameNamespace";
+})(KnownPolicyRule || (KnownPolicyRule = {}));
+/** Action if Kubernetes namespace with same name already exists. */
+export var KnownAdoptionPolicy;
+(function (KnownAdoptionPolicy) {
+    /** If the namespace already exists in Kubernetes, attempts to create that same namespace in ARM will fail. */
+    KnownAdoptionPolicy["Never"] = "Never";
+    /** Take over the existing namespace to be managed by ARM, if there is no difference. */
+    KnownAdoptionPolicy["IfIdentical"] = "IfIdentical";
+    /** Always take over the existing namespace to be managed by ARM, some fields might be overwritten. */
+    KnownAdoptionPolicy["Always"] = "Always";
+})(KnownAdoptionPolicy || (KnownAdoptionPolicy = {}));
+/** Delete options of a namespace. */
+export var KnownDeletePolicy;
+(function (KnownDeletePolicy) {
+    /** Only delete the ARM resource, keep the Kubernetes namespace. Also delete the ManagedByARM label. */
+    KnownDeletePolicy["Keep"] = "Keep";
+    /** Delete both the ARM resource and the Kubernetes namespace together. */
+    KnownDeletePolicy["Delete"] = "Delete";
+})(KnownDeletePolicy || (KnownDeletePolicy = {}));
+export function _managedNamespaceListResultDeserializer(item) {
+    return {
+        value: managedNamespaceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function managedNamespaceArraySerializer(result) {
+    return result.map((item) => {
+        return managedNamespaceSerializer(item);
+    });
+}
+export function managedNamespaceArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedNamespaceDeserializer(item);
+    });
+}
+export function machineDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : machinePropertiesDeserializer(item["properties"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function machinePropertiesDeserializer(item) {
+    return {
+        network: !item["network"]
+            ? item["network"]
+            : machineNetworkPropertiesDeserializer(item["network"]),
+        resourceId: item["resourceId"],
+    };
+}
+export function machineNetworkPropertiesDeserializer(item) {
+    return {
+        ipAddresses: !item["ipAddresses"]
+            ? item["ipAddresses"]
+            : machineIpAddressArrayDeserializer(item["ipAddresses"]),
+    };
+}
+export function machineIpAddressArrayDeserializer(result) {
+    return result.map((item) => {
+        return machineIpAddressDeserializer(item);
+    });
+}
+export function machineIpAddressDeserializer(item) {
+    return {
+        family: item["family"],
+        ip: item["ip"],
+    };
+}
+export function _machineListResultDeserializer(item) {
+    return {
+        value: machineArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function machineArrayDeserializer(result) {
+    return result.map((item) => {
+        return machineDeserializer(item);
+    });
+}
+export function privateEndpointConnectionSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["privateEndpoint", "privateLinkServiceConnectionState"])
+            ? undefined
+            : _privateEndpointConnectionPropertiesSerializer(item),
+    };
+}
+export function privateEndpointConnectionDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _privateEndpointConnectionPropertiesDeserializer(item["properties"])),
+    };
+}
+export function privateEndpointConnectionPropertiesSerializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointSerializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: privateLinkServiceConnectionStateSerializer(item["privateLinkServiceConnectionState"]),
+    };
+}
+export function privateEndpointConnectionPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: privateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+    };
+}
+/** The current provisioning state. */
+export var KnownPrivateEndpointConnectionProvisioningState;
+(function (KnownPrivateEndpointConnectionProvisioningState) {
+    /** Private endpoint connection provisioning was canceled. */
+    KnownPrivateEndpointConnectionProvisioningState["Canceled"] = "Canceled";
+    /** Private endpoint connection is being created. */
+    KnownPrivateEndpointConnectionProvisioningState["Creating"] = "Creating";
+    /** Private endpoint connection is being deleted. */
+    KnownPrivateEndpointConnectionProvisioningState["Deleting"] = "Deleting";
+    /** Private endpoint connection provisioning failed. */
+    KnownPrivateEndpointConnectionProvisioningState["Failed"] = "Failed";
+    /** Private endpoint connection provisioning succeeded. */
+    KnownPrivateEndpointConnectionProvisioningState["Succeeded"] = "Succeeded";
+})(KnownPrivateEndpointConnectionProvisioningState || (KnownPrivateEndpointConnectionProvisioningState = {}));
+export function privateEndpointSerializer(item) {
+    return { id: item["id"] };
+}
+export function privateEndpointDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function privateLinkServiceConnectionStateSerializer(item) {
+    return { status: item["status"], description: item["description"] };
+}
+export function privateLinkServiceConnectionStateDeserializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+    };
+}
+/** The private link service connection status. */
+export var KnownConnectionStatus;
+(function (KnownConnectionStatus) {
+    /** Connection is pending approval. */
+    KnownConnectionStatus["Pending"] = "Pending";
+    /** Connection is approved. */
+    KnownConnectionStatus["Approved"] = "Approved";
+    /** Connection is rejected. */
+    KnownConnectionStatus["Rejected"] = "Rejected";
+    /** Connection is disconnected. */
+    KnownConnectionStatus["Disconnected"] = "Disconnected";
+})(KnownConnectionStatus || (KnownConnectionStatus = {}));
+export function privateEndpointConnectionListResultDeserializer(item) {
+    return {
+        value: !item["value"]
+            ? item["value"]
+            : privateEndpointConnectionArrayDeserializer(item["value"]),
+    };
+}
+export function privateEndpointConnectionArraySerializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionSerializer(item);
+    });
+}
+export function privateEndpointConnectionArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionDeserializer(item);
+    });
+}
+export function snapshotSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: areAllPropsUndefined(item, ["creationData", "snapshotType"])
+            ? undefined
+            : _snapshotPropertiesSerializer(item),
+    };
+}
+export function snapshotDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _snapshotPropertiesDeserializer(item["properties"])),
+    };
+}
+export function snapshotPropertiesSerializer(item) {
+    return {
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataSerializer(item["creationData"]),
+        snapshotType: item["snapshotType"],
+    };
+}
+export function snapshotPropertiesDeserializer(item) {
+    return {
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataDeserializer(item["creationData"]),
+        snapshotType: item["snapshotType"],
+        kubernetesVersion: item["kubernetesVersion"],
+        nodeImageVersion: item["nodeImageVersion"],
+        osType: item["osType"],
+        osSku: item["osSku"],
+        vmSize: item["vmSize"],
+        enableFips: item["enableFIPS"],
+    };
+}
+/** The type of a snapshot. The default is NodePool. */
+export var KnownSnapshotType;
+(function (KnownSnapshotType) {
+    /** The snapshot is a snapshot of a node pool. */
+    KnownSnapshotType["NodePool"] = "NodePool";
+})(KnownSnapshotType || (KnownSnapshotType = {}));
+export function _snapshotListResultDeserializer(item) {
+    return {
+        value: snapshotArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function snapshotArraySerializer(result) {
+    return result.map((item) => {
+        return snapshotSerializer(item);
+    });
+}
+export function snapshotArrayDeserializer(result) {
+    return result.map((item) => {
+        return snapshotDeserializer(item);
+    });
+}
+export function trustedAccessRoleBindingSerializer(item) {
+    return { properties: _trustedAccessRoleBindingPropertiesSerializer(item) };
+}
+export function trustedAccessRoleBindingDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ..._trustedAccessRoleBindingPropertiesDeserializer(item["properties"]),
+    };
+}
+export function trustedAccessRoleBindingPropertiesSerializer(item) {
+    return {
+        sourceResourceId: item["sourceResourceId"],
+        roles: item["roles"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function trustedAccessRoleBindingPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        sourceResourceId: item["sourceResourceId"],
+        roles: item["roles"].map((p) => {
+            return p;
+        }),
+    };
+}
+/** The current provisioning state of trusted access role binding. */
+export var KnownTrustedAccessRoleBindingProvisioningState;
+(function (KnownTrustedAccessRoleBindingProvisioningState) {
+    /** Trusted access role binding provisioning was canceled. */
+    KnownTrustedAccessRoleBindingProvisioningState["Canceled"] = "Canceled";
+    /** Trusted access role binding is being deleted. */
+    KnownTrustedAccessRoleBindingProvisioningState["Deleting"] = "Deleting";
+    /** Trusted access role binding provisioning failed. */
+    KnownTrustedAccessRoleBindingProvisioningState["Failed"] = "Failed";
+    /** Trusted access role binding provisioning succeeded. */
+    KnownTrustedAccessRoleBindingProvisioningState["Succeeded"] = "Succeeded";
+    /** Trusted access role binding is being updated. */
+    KnownTrustedAccessRoleBindingProvisioningState["Updating"] = "Updating";
+})(KnownTrustedAccessRoleBindingProvisioningState || (KnownTrustedAccessRoleBindingProvisioningState = {}));
+export function _trustedAccessRoleBindingListResultDeserializer(item) {
+    return {
+        value: trustedAccessRoleBindingArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function trustedAccessRoleBindingArraySerializer(result) {
+    return result.map((item) => {
+        return trustedAccessRoleBindingSerializer(item);
+    });
+}
+export function trustedAccessRoleBindingArrayDeserializer(result) {
+    return result.map((item) => {
+        return trustedAccessRoleBindingDeserializer(item);
+    });
+}
+export function _operationListResultDeserializer(item) {
+    return {
+        value: operationValueArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function operationValueArrayDeserializer(result) {
+    return result.map((item) => {
+        return operationValueDeserializer(item);
+    });
+}
+export function operationValueDeserializer(item) {
+    return {
+        origin: item["origin"],
+        name: item["name"],
+        ...(!item["display"] ? item["display"] : _operationValueDisplayDeserializer(item["display"])),
+    };
+}
+export function operationValueDisplayDeserializer(item) {
+    return {
+        operation: item["operation"],
+        resource: item["resource"],
+        description: item["description"],
+        provider: item["provider"],
+    };
+}
+export function privateLinkResourcesListResultDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : privateLinkResourceArrayDeserializer(item["value"]),
+    };
+}
+export function _trustedAccessRoleListResultDeserializer(item) {
+    return {
+        value: trustedAccessRoleArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function trustedAccessRoleArrayDeserializer(result) {
+    return result.map((item) => {
+        return trustedAccessRoleDeserializer(item);
+    });
+}
+export function trustedAccessRoleDeserializer(item) {
+    return {
+        sourceResourceType: item["sourceResourceType"],
+        name: item["name"],
+        rules: !item["rules"] ? item["rules"] : trustedAccessRoleRuleArrayDeserializer(item["rules"]),
+    };
+}
+export function trustedAccessRoleRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return trustedAccessRoleRuleDeserializer(item);
+    });
+}
+export function trustedAccessRoleRuleDeserializer(item) {
+    return {
+        verbs: !item["verbs"]
+            ? item["verbs"]
+            : item["verbs"].map((p) => {
+                return p;
+            }),
+        apiGroups: !item["apiGroups"]
+            ? item["apiGroups"]
+            : item["apiGroups"].map((p) => {
+                return p;
+            }),
+        resources: !item["resources"]
+            ? item["resources"]
+            : item["resources"].map((p) => {
+                return p;
+            }),
+        resourceNames: !item["resourceNames"]
+            ? item["resourceNames"]
+            : item["resourceNames"].map((p) => {
+                return p;
+            }),
+        nonResourceURLs: !item["nonResourceURLs"]
+            ? item["nonResourceURLs"]
+            : item["nonResourceURLs"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** The format of the kubeconfig credential. */
+export var KnownFormat;
+(function (KnownFormat) {
+    /** Return azure auth-provider kubeconfig. This format is deprecated in v1.22 and will be fully removed in v1.26. See: https://aka.ms/k8s/changes-1-26. */
+    KnownFormat["Azure"] = "azure";
+    /** Return exec format kubeconfig. This format requires kubelogin binary in the path. */
+    KnownFormat["Exec"] = "exec";
+})(KnownFormat || (KnownFormat = {}));
+/** The available API versions. */
+export var KnownVersions;
+(function (KnownVersions) {
+    /** The 2025-10-01 API version. */
+    KnownVersions["V20251001"] = "2025-10-01";
+    /** The 2026-01-01 API version. */
+    KnownVersions["V20260101"] = "2026-01-01";
+})(KnownVersions || (KnownVersions = {}));
+export function _agentPoolPropertiesSerializer(item) {
+    return {
+        count: item["count"],
+        vmSize: item["vmSize"],
+        osDiskSizeGB: item["osDiskSizeGB"],
+        osDiskType: item["osDiskType"],
+        kubeletDiskType: item["kubeletDiskType"],
+        workloadRuntime: item["workloadRuntime"],
+        messageOfTheDay: item["messageOfTheDay"],
+        vnetSubnetID: item["vnetSubnetID"],
+        podSubnetID: item["podSubnetID"],
+        podIPAllocationMode: item["podIPAllocationMode"],
+        maxPods: item["maxPods"],
+        osType: item["osType"],
+        osSKU: item["osSKU"],
+        maxCount: item["maxCount"],
+        minCount: item["minCount"],
+        enableAutoScaling: item["enableAutoScaling"],
+        scaleDownMode: item["scaleDownMode"],
+        type: item["typePropertiesType"],
+        mode: item["mode"],
+        orchestratorVersion: item["orchestratorVersion"],
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : agentPoolUpgradeSettingsSerializer(item["upgradeSettings"]),
+        powerState: !item["powerState"] ? item["powerState"] : powerStateSerializer(item["powerState"]),
+        availabilityZones: !item["availabilityZones"]
+            ? item["availabilityZones"]
+            : item["availabilityZones"].map((p) => {
+                return p;
+            }),
+        enableNodePublicIP: item["enableNodePublicIP"],
+        nodePublicIPPrefixID: item["nodePublicIPPrefixID"],
+        scaleSetPriority: item["scaleSetPriority"],
+        scaleSetEvictionPolicy: item["scaleSetEvictionPolicy"],
+        spotMaxPrice: item["spotMaxPrice"],
+        tags: item["tags"],
+        nodeLabels: item["nodeLabels"],
+        nodeTaints: !item["nodeTaints"]
+            ? item["nodeTaints"]
+            : item["nodeTaints"].map((p) => {
+                return p;
+            }),
+        proximityPlacementGroupID: item["proximityPlacementGroupID"],
+        kubeletConfig: !item["kubeletConfig"]
+            ? item["kubeletConfig"]
+            : kubeletConfigSerializer(item["kubeletConfig"]),
+        linuxOSConfig: !item["linuxOSConfig"]
+            ? item["linuxOSConfig"]
+            : linuxOSConfigSerializer(item["linuxOSConfig"]),
+        enableEncryptionAtHost: item["enableEncryptionAtHost"],
+        enableUltraSSD: item["enableUltraSSD"],
+        enableFIPS: item["enableFips"],
+        gpuInstanceProfile: item["gpuInstanceProfile"],
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataSerializer(item["creationData"]),
+        capacityReservationGroupID: item["capacityReservationGroupID"],
+        hostGroupID: item["hostGroupID"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : agentPoolNetworkProfileSerializer(item["networkProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : agentPoolWindowsProfileSerializer(item["windowsProfile"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : agentPoolSecurityProfileSerializer(item["securityProfile"]),
+        gpuProfile: !item["gpuProfile"] ? item["gpuProfile"] : gpuProfileSerializer(item["gpuProfile"]),
+        gatewayProfile: !item["gatewayProfile"]
+            ? item["gatewayProfile"]
+            : agentPoolGatewayProfileSerializer(item["gatewayProfile"]),
+        virtualMachinesProfile: !item["virtualMachinesProfile"]
+            ? item["virtualMachinesProfile"]
+            : virtualMachinesProfileSerializer(item["virtualMachinesProfile"]),
+        virtualMachineNodesStatus: !item["virtualMachineNodesStatus"]
+            ? item["virtualMachineNodesStatus"]
+            : virtualMachineNodesArraySerializer(item["virtualMachineNodesStatus"]),
+        status: !item["status"] ? item["status"] : agentPoolStatusSerializer(item["status"]),
+        localDNSProfile: !item["localDNSProfile"]
+            ? item["localDNSProfile"]
+            : localDNSProfileSerializer(item["localDNSProfile"]),
+    };
+}
+export function _agentPoolPropertiesDeserializer(item) {
+    return {
+        eTag: item["eTag"],
+        count: item["count"],
+        vmSize: item["vmSize"],
+        osDiskSizeGB: item["osDiskSizeGB"],
+        osDiskType: item["osDiskType"],
+        kubeletDiskType: item["kubeletDiskType"],
+        workloadRuntime: item["workloadRuntime"],
+        messageOfTheDay: item["messageOfTheDay"],
+        vnetSubnetID: item["vnetSubnetID"],
+        podSubnetID: item["podSubnetID"],
+        podIPAllocationMode: item["podIPAllocationMode"],
+        maxPods: item["maxPods"],
+        osType: item["osType"],
+        osSKU: item["osSKU"],
+        maxCount: item["maxCount"],
+        minCount: item["minCount"],
+        enableAutoScaling: item["enableAutoScaling"],
+        scaleDownMode: item["scaleDownMode"],
+        typePropertiesType: item["type"],
+        mode: item["mode"],
+        orchestratorVersion: item["orchestratorVersion"],
+        currentOrchestratorVersion: item["currentOrchestratorVersion"],
+        nodeImageVersion: item["nodeImageVersion"],
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : agentPoolUpgradeSettingsDeserializer(item["upgradeSettings"]),
+        provisioningState: item["provisioningState"],
+        powerState: !item["powerState"]
+            ? item["powerState"]
+            : powerStateDeserializer(item["powerState"]),
+        availabilityZones: !item["availabilityZones"]
+            ? item["availabilityZones"]
+            : item["availabilityZones"].map((p) => {
+                return p;
+            }),
+        enableNodePublicIP: item["enableNodePublicIP"],
+        nodePublicIPPrefixID: item["nodePublicIPPrefixID"],
+        scaleSetPriority: item["scaleSetPriority"],
+        scaleSetEvictionPolicy: item["scaleSetEvictionPolicy"],
+        spotMaxPrice: item["spotMaxPrice"],
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        nodeLabels: !item["nodeLabels"]
+            ? item["nodeLabels"]
+            : Object.fromEntries(Object.entries(item["nodeLabels"]).map(([k, p]) => [k, p])),
+        nodeTaints: !item["nodeTaints"]
+            ? item["nodeTaints"]
+            : item["nodeTaints"].map((p) => {
+                return p;
+            }),
+        proximityPlacementGroupID: item["proximityPlacementGroupID"],
+        kubeletConfig: !item["kubeletConfig"]
+            ? item["kubeletConfig"]
+            : kubeletConfigDeserializer(item["kubeletConfig"]),
+        linuxOSConfig: !item["linuxOSConfig"]
+            ? item["linuxOSConfig"]
+            : linuxOSConfigDeserializer(item["linuxOSConfig"]),
+        enableEncryptionAtHost: item["enableEncryptionAtHost"],
+        enableUltraSSD: item["enableUltraSSD"],
+        enableFips: item["enableFIPS"],
+        gpuInstanceProfile: item["gpuInstanceProfile"],
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataDeserializer(item["creationData"]),
+        capacityReservationGroupID: item["capacityReservationGroupID"],
+        hostGroupID: item["hostGroupID"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : agentPoolNetworkProfileDeserializer(item["networkProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : agentPoolWindowsProfileDeserializer(item["windowsProfile"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : agentPoolSecurityProfileDeserializer(item["securityProfile"]),
+        gpuProfile: !item["gpuProfile"]
+            ? item["gpuProfile"]
+            : gpuProfileDeserializer(item["gpuProfile"]),
+        gatewayProfile: !item["gatewayProfile"]
+            ? item["gatewayProfile"]
+            : agentPoolGatewayProfileDeserializer(item["gatewayProfile"]),
+        virtualMachinesProfile: !item["virtualMachinesProfile"]
+            ? item["virtualMachinesProfile"]
+            : virtualMachinesProfileDeserializer(item["virtualMachinesProfile"]),
+        virtualMachineNodesStatus: !item["virtualMachineNodesStatus"]
+            ? item["virtualMachineNodesStatus"]
+            : virtualMachineNodesArrayDeserializer(item["virtualMachineNodesStatus"]),
+        status: !item["status"] ? item["status"] : agentPoolStatusDeserializer(item["status"]),
+        localDNSProfile: !item["localDNSProfile"]
+            ? item["localDNSProfile"]
+            : localDNSProfileDeserializer(item["localDNSProfile"]),
+    };
+}
+export function _agentPoolAvailableVersionsPropertiesDeserializer(item) {
+    return {
+        agentPoolVersions: !item["agentPoolVersions"]
+            ? item["agentPoolVersions"]
+            : agentPoolAvailableVersionsPropertiesAgentPoolVersionsItemArrayDeserializer(item["agentPoolVersions"]),
+    };
+}
+export function _agentPoolUpgradeProfilePropertiesDeserializer(item) {
+    return {
+        kubernetesVersion: item["kubernetesVersion"],
+        osType: item["osType"],
+        upgrades: !item["upgrades"]
+            ? item["upgrades"]
+            : agentPoolUpgradeProfilePropertiesUpgradesItemArrayDeserializer(item["upgrades"]),
+        latestNodeImageVersion: item["latestNodeImageVersion"],
+    };
+}
+export function _managedClusterPropertiesSerializer(item) {
+    return {
+        kubernetesVersion: item["kubernetesVersion"],
+        dnsPrefix: item["dnsPrefix"],
+        fqdnSubdomain: item["fqdnSubdomain"],
+        agentPoolProfiles: !item["agentPoolProfiles"]
+            ? item["agentPoolProfiles"]
+            : managedClusterAgentPoolProfileArraySerializer(item["agentPoolProfiles"]),
+        linuxProfile: !item["linuxProfile"]
+            ? item["linuxProfile"]
+            : containerServiceLinuxProfileSerializer(item["linuxProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : managedClusterWindowsProfileSerializer(item["windowsProfile"]),
+        servicePrincipalProfile: !item["servicePrincipalProfile"]
+            ? item["servicePrincipalProfile"]
+            : managedClusterServicePrincipalProfileSerializer(item["servicePrincipalProfile"]),
+        addonProfiles: !item["addonProfiles"]
+            ? item["addonProfiles"]
+            : managedClusterAddonProfileRecordSerializer(item["addonProfiles"]),
+        podIdentityProfile: !item["podIdentityProfile"]
+            ? item["podIdentityProfile"]
+            : managedClusterPodIdentityProfileSerializer(item["podIdentityProfile"]),
+        oidcIssuerProfile: !item["oidcIssuerProfile"]
+            ? item["oidcIssuerProfile"]
+            : managedClusterOidcIssuerProfileSerializer(item["oidcIssuerProfile"]),
+        nodeResourceGroup: item["nodeResourceGroup"],
+        nodeResourceGroupProfile: !item["nodeResourceGroupProfile"]
+            ? item["nodeResourceGroupProfile"]
+            : managedClusterNodeResourceGroupProfileSerializer(item["nodeResourceGroupProfile"]),
+        enableRBAC: item["enableRbac"],
+        supportPlan: item["supportPlan"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : containerServiceNetworkProfileSerializer(item["networkProfile"]),
+        aadProfile: !item["aadProfile"]
+            ? item["aadProfile"]
+            : managedClusterAADProfileSerializer(item["aadProfile"]),
+        autoUpgradeProfile: !item["autoUpgradeProfile"]
+            ? item["autoUpgradeProfile"]
+            : managedClusterAutoUpgradeProfileSerializer(item["autoUpgradeProfile"]),
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : clusterUpgradeSettingsSerializer(item["upgradeSettings"]),
+        autoScalerProfile: !item["autoScalerProfile"]
+            ? item["autoScalerProfile"]
+            : managedClusterPropertiesAutoScalerProfileSerializer(item["autoScalerProfile"]),
+        apiServerAccessProfile: !item["apiServerAccessProfile"]
+            ? item["apiServerAccessProfile"]
+            : managedClusterAPIServerAccessProfileSerializer(item["apiServerAccessProfile"]),
+        diskEncryptionSetID: item["diskEncryptionSetID"],
+        identityProfile: !item["identityProfile"]
+            ? item["identityProfile"]
+            : userAssignedIdentityRecordSerializer(item["identityProfile"]),
+        privateLinkResources: !item["privateLinkResources"]
+            ? item["privateLinkResources"]
+            : privateLinkResourceArraySerializer(item["privateLinkResources"]),
+        disableLocalAccounts: item["disableLocalAccounts"],
+        httpProxyConfig: !item["httpProxyConfig"]
+            ? item["httpProxyConfig"]
+            : managedClusterHttpProxyConfigSerializer(item["httpProxyConfig"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : managedClusterSecurityProfileSerializer(item["securityProfile"]),
+        storageProfile: !item["storageProfile"]
+            ? item["storageProfile"]
+            : managedClusterStorageProfileSerializer(item["storageProfile"]),
+        ingressProfile: !item["ingressProfile"]
+            ? item["ingressProfile"]
+            : managedClusterIngressProfileSerializer(item["ingressProfile"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+        workloadAutoScalerProfile: !item["workloadAutoScalerProfile"]
+            ? item["workloadAutoScalerProfile"]
+            : managedClusterWorkloadAutoScalerProfileSerializer(item["workloadAutoScalerProfile"]),
+        azureMonitorProfile: !item["azureMonitorProfile"]
+            ? item["azureMonitorProfile"]
+            : managedClusterAzureMonitorProfileSerializer(item["azureMonitorProfile"]),
+        serviceMeshProfile: !item["serviceMeshProfile"]
+            ? item["serviceMeshProfile"]
+            : serviceMeshProfileSerializer(item["serviceMeshProfile"]),
+        metricsProfile: !item["metricsProfile"]
+            ? item["metricsProfile"]
+            : managedClusterMetricsProfileSerializer(item["metricsProfile"]),
+        nodeProvisioningProfile: !item["nodeProvisioningProfile"]
+            ? item["nodeProvisioningProfile"]
+            : managedClusterNodeProvisioningProfileSerializer(item["nodeProvisioningProfile"]),
+        bootstrapProfile: !item["bootstrapProfile"]
+            ? item["bootstrapProfile"]
+            : managedClusterBootstrapProfileSerializer(item["bootstrapProfile"]),
+        aiToolchainOperatorProfile: !item["aiToolchainOperatorProfile"]
+            ? item["aiToolchainOperatorProfile"]
+            : managedClusterAIToolchainOperatorProfileSerializer(item["aiToolchainOperatorProfile"]),
+        status: !item["status"] ? item["status"] : managedClusterStatusSerializer(item["status"]),
+    };
+}
+export function _managedClusterPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        powerState: !item["powerState"]
+            ? item["powerState"]
+            : powerStateDeserializer(item["powerState"]),
+        maxAgentPools: item["maxAgentPools"],
+        kubernetesVersion: item["kubernetesVersion"],
+        currentKubernetesVersion: item["currentKubernetesVersion"],
+        dnsPrefix: item["dnsPrefix"],
+        fqdnSubdomain: item["fqdnSubdomain"],
+        fqdn: item["fqdn"],
+        privateFqdn: item["privateFQDN"],
+        azurePortalFqdn: item["azurePortalFQDN"],
+        agentPoolProfiles: !item["agentPoolProfiles"]
+            ? item["agentPoolProfiles"]
+            : managedClusterAgentPoolProfileArrayDeserializer(item["agentPoolProfiles"]),
+        linuxProfile: !item["linuxProfile"]
+            ? item["linuxProfile"]
+            : containerServiceLinuxProfileDeserializer(item["linuxProfile"]),
+        windowsProfile: !item["windowsProfile"]
+            ? item["windowsProfile"]
+            : managedClusterWindowsProfileDeserializer(item["windowsProfile"]),
+        servicePrincipalProfile: !item["servicePrincipalProfile"]
+            ? item["servicePrincipalProfile"]
+            : managedClusterServicePrincipalProfileDeserializer(item["servicePrincipalProfile"]),
+        addonProfiles: !item["addonProfiles"]
+            ? item["addonProfiles"]
+            : managedClusterAddonProfileRecordDeserializer(item["addonProfiles"]),
+        podIdentityProfile: !item["podIdentityProfile"]
+            ? item["podIdentityProfile"]
+            : managedClusterPodIdentityProfileDeserializer(item["podIdentityProfile"]),
+        oidcIssuerProfile: !item["oidcIssuerProfile"]
+            ? item["oidcIssuerProfile"]
+            : managedClusterOidcIssuerProfileDeserializer(item["oidcIssuerProfile"]),
+        nodeResourceGroup: item["nodeResourceGroup"],
+        nodeResourceGroupProfile: !item["nodeResourceGroupProfile"]
+            ? item["nodeResourceGroupProfile"]
+            : managedClusterNodeResourceGroupProfileDeserializer(item["nodeResourceGroupProfile"]),
+        enableRbac: item["enableRBAC"],
+        supportPlan: item["supportPlan"],
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : containerServiceNetworkProfileDeserializer(item["networkProfile"]),
+        aadProfile: !item["aadProfile"]
+            ? item["aadProfile"]
+            : managedClusterAADProfileDeserializer(item["aadProfile"]),
+        autoUpgradeProfile: !item["autoUpgradeProfile"]
+            ? item["autoUpgradeProfile"]
+            : managedClusterAutoUpgradeProfileDeserializer(item["autoUpgradeProfile"]),
+        upgradeSettings: !item["upgradeSettings"]
+            ? item["upgradeSettings"]
+            : clusterUpgradeSettingsDeserializer(item["upgradeSettings"]),
+        autoScalerProfile: !item["autoScalerProfile"]
+            ? item["autoScalerProfile"]
+            : managedClusterPropertiesAutoScalerProfileDeserializer(item["autoScalerProfile"]),
+        apiServerAccessProfile: !item["apiServerAccessProfile"]
+            ? item["apiServerAccessProfile"]
+            : managedClusterAPIServerAccessProfileDeserializer(item["apiServerAccessProfile"]),
+        diskEncryptionSetID: item["diskEncryptionSetID"],
+        identityProfile: !item["identityProfile"]
+            ? item["identityProfile"]
+            : userAssignedIdentityRecordDeserializer(item["identityProfile"]),
+        privateLinkResources: !item["privateLinkResources"]
+            ? item["privateLinkResources"]
+            : privateLinkResourceArrayDeserializer(item["privateLinkResources"]),
+        disableLocalAccounts: item["disableLocalAccounts"],
+        httpProxyConfig: !item["httpProxyConfig"]
+            ? item["httpProxyConfig"]
+            : managedClusterHttpProxyConfigDeserializer(item["httpProxyConfig"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : managedClusterSecurityProfileDeserializer(item["securityProfile"]),
+        storageProfile: !item["storageProfile"]
+            ? item["storageProfile"]
+            : managedClusterStorageProfileDeserializer(item["storageProfile"]),
+        ingressProfile: !item["ingressProfile"]
+            ? item["ingressProfile"]
+            : managedClusterIngressProfileDeserializer(item["ingressProfile"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+        workloadAutoScalerProfile: !item["workloadAutoScalerProfile"]
+            ? item["workloadAutoScalerProfile"]
+            : managedClusterWorkloadAutoScalerProfileDeserializer(item["workloadAutoScalerProfile"]),
+        azureMonitorProfile: !item["azureMonitorProfile"]
+            ? item["azureMonitorProfile"]
+            : managedClusterAzureMonitorProfileDeserializer(item["azureMonitorProfile"]),
+        serviceMeshProfile: !item["serviceMeshProfile"]
+            ? item["serviceMeshProfile"]
+            : serviceMeshProfileDeserializer(item["serviceMeshProfile"]),
+        resourceUID: item["resourceUID"],
+        metricsProfile: !item["metricsProfile"]
+            ? item["metricsProfile"]
+            : managedClusterMetricsProfileDeserializer(item["metricsProfile"]),
+        nodeProvisioningProfile: !item["nodeProvisioningProfile"]
+            ? item["nodeProvisioningProfile"]
+            : managedClusterNodeProvisioningProfileDeserializer(item["nodeProvisioningProfile"]),
+        bootstrapProfile: !item["bootstrapProfile"]
+            ? item["bootstrapProfile"]
+            : managedClusterBootstrapProfileDeserializer(item["bootstrapProfile"]),
+        aiToolchainOperatorProfile: !item["aiToolchainOperatorProfile"]
+            ? item["aiToolchainOperatorProfile"]
+            : managedClusterAIToolchainOperatorProfileDeserializer(item["aiToolchainOperatorProfile"]),
+        status: !item["status"] ? item["status"] : managedClusterStatusDeserializer(item["status"]),
+    };
+}
+export function _managedClusterAccessProfilePropertiesDeserializer(item) {
+    return {
+        kubeConfig: !item["kubeConfig"]
+            ? item["kubeConfig"]
+            : typeof item["kubeConfig"] === "string"
+                ? stringToUint8Array(item["kubeConfig"], "base64")
+                : item["kubeConfig"],
+    };
+}
+export function _runCommandResultPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        exitCode: item["exitCode"],
+        startedAt: !item["startedAt"] ? item["startedAt"] : new Date(item["startedAt"]),
+        finishedAt: !item["finishedAt"] ? item["finishedAt"] : new Date(item["finishedAt"]),
+        logs: item["logs"],
+        reason: item["reason"],
+    };
+}
+export function _managedClusterUpgradeProfilePropertiesDeserializer(item) {
+    return {
+        controlPlaneProfile: managedClusterPoolUpgradeProfileDeserializer(item["controlPlaneProfile"]),
+        agentPoolProfiles: managedClusterPoolUpgradeProfileArrayDeserializer(item["agentPoolProfiles"]),
+    };
+}
+export function _maintenanceConfigurationPropertiesSerializer(item) {
+    return {
+        timeInWeek: !item["timeInWeek"]
+            ? item["timeInWeek"]
+            : timeInWeekArraySerializer(item["timeInWeek"]),
+        notAllowedTime: !item["notAllowedTime"]
+            ? item["notAllowedTime"]
+            : timeSpanArraySerializer(item["notAllowedTime"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowSerializer(item["maintenanceWindow"]),
+    };
+}
+export function _maintenanceConfigurationPropertiesDeserializer(item) {
+    return {
+        timeInWeek: !item["timeInWeek"]
+            ? item["timeInWeek"]
+            : timeInWeekArrayDeserializer(item["timeInWeek"]),
+        notAllowedTime: !item["notAllowedTime"]
+            ? item["notAllowedTime"]
+            : timeSpanArrayDeserializer(item["notAllowedTime"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowDeserializer(item["maintenanceWindow"]),
+    };
+}
+export function _privateEndpointConnectionPropertiesSerializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointSerializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateLinkServiceConnectionStateSerializer(item["privateLinkServiceConnectionState"]),
+    };
+}
+export function _privateEndpointConnectionPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+    };
+}
+export function _snapshotPropertiesSerializer(item) {
+    return {
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataSerializer(item["creationData"]),
+        snapshotType: item["snapshotType"],
+    };
+}
+export function _snapshotPropertiesDeserializer(item) {
+    return {
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : creationDataDeserializer(item["creationData"]),
+        snapshotType: item["snapshotType"],
+        kubernetesVersion: item["kubernetesVersion"],
+        nodeImageVersion: item["nodeImageVersion"],
+        osType: item["osType"],
+        osSku: item["osSku"],
+        vmSize: item["vmSize"],
+        enableFips: item["enableFIPS"],
+    };
+}
+export function _trustedAccessRoleBindingPropertiesSerializer(item) {
+    return {
+        sourceResourceId: item["sourceResourceId"],
+        roles: item["roles"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function _trustedAccessRoleBindingPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        sourceResourceId: item["sourceResourceId"],
+        roles: item["roles"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function _operationValueDisplayDeserializer(item) {
+    return {
+        operation: item["operation"],
+        resource: item["resource"],
+        description: item["description"],
+        provider: item["provider"],
+    };
+}
+//# sourceMappingURL=models.js.map