@azure/arm-servicefabricmanagedclusters 1.0.0-beta.3 → 1.0.0-beta.4

package/dist/browser/models/models.js

@@ -0,0 +1,2931 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export function _operationListResultDeserializer(item) {
+    return {
+        value: operationResultArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function operationResultArrayDeserializer(result) {
+    return result.map((item) => {
+        return operationResultDeserializer(item);
+    });
+}
+export function operationResultDeserializer(item) {
+    return {
+        name: item["name"],
+        isDataAction: item["isDataAction"],
+        display: !item["display"]
+            ? item["display"]
+            : availableOperationDisplayDeserializer(item["display"]),
+        origin: item["origin"],
+        nextLink: item["nextLink"],
+    };
+}
+export function availableOperationDisplayDeserializer(item) {
+    return {
+        provider: item["provider"],
+        resource: item["resource"],
+        operation: item["operation"],
+        description: item["description"],
+    };
+}
+export function errorResponseDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"]),
+    };
+}
+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 applicationResourceSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : applicationResourcePropertiesSerializer(item["properties"]),
+        tags: item["tags"],
+        identity: !item["identity"] ? item["identity"] : managedIdentitySerializer(item["identity"]),
+        location: item["location"],
+    };
+}
+export function applicationResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : applicationResourcePropertiesDeserializer(item["properties"]),
+        tags: item["tags"],
+        identity: !item["identity"] ? item["identity"] : managedIdentityDeserializer(item["identity"]),
+        location: item["location"],
+    };
+}
+export function applicationResourcePropertiesSerializer(item) {
+    return {
+        managedIdentities: !item["managedIdentities"]
+            ? item["managedIdentities"]
+            : applicationUserAssignedIdentityArraySerializer(item["managedIdentities"]),
+        version: item["version"],
+        parameters: item["parameters"],
+        upgradePolicy: !item["upgradePolicy"]
+            ? item["upgradePolicy"]
+            : applicationUpgradePolicySerializer(item["upgradePolicy"]),
+    };
+}
+export function applicationResourcePropertiesDeserializer(item) {
+    return {
+        managedIdentities: !item["managedIdentities"]
+            ? item["managedIdentities"]
+            : applicationUserAssignedIdentityArrayDeserializer(item["managedIdentities"]),
+        provisioningState: item["provisioningState"],
+        version: item["version"],
+        parameters: item["parameters"],
+        upgradePolicy: !item["upgradePolicy"]
+            ? item["upgradePolicy"]
+            : applicationUpgradePolicyDeserializer(item["upgradePolicy"]),
+    };
+}
+export function applicationUserAssignedIdentityArraySerializer(result) {
+    return result.map((item) => {
+        return applicationUserAssignedIdentitySerializer(item);
+    });
+}
+export function applicationUserAssignedIdentityArrayDeserializer(result) {
+    return result.map((item) => {
+        return applicationUserAssignedIdentityDeserializer(item);
+    });
+}
+export function applicationUserAssignedIdentitySerializer(item) {
+    return { name: item["name"], principalId: item["principalId"] };
+}
+export function applicationUserAssignedIdentityDeserializer(item) {
+    return {
+        name: item["name"],
+        principalId: item["principalId"],
+    };
+}
+export function applicationUpgradePolicySerializer(item) {
+    return {
+        applicationHealthPolicy: !item["applicationHealthPolicy"]
+            ? item["applicationHealthPolicy"]
+            : applicationHealthPolicySerializer(item["applicationHealthPolicy"]),
+        forceRestart: item["forceRestart"],
+        rollingUpgradeMonitoringPolicy: !item["rollingUpgradeMonitoringPolicy"]
+            ? item["rollingUpgradeMonitoringPolicy"]
+            : rollingUpgradeMonitoringPolicySerializer(item["rollingUpgradeMonitoringPolicy"]),
+        instanceCloseDelayDuration: item["instanceCloseDelayDuration"],
+        upgradeMode: item["upgradeMode"],
+        upgradeReplicaSetCheckTimeout: item["upgradeReplicaSetCheckTimeout"],
+        recreateApplication: item["recreateApplication"],
+    };
+}
+export function applicationUpgradePolicyDeserializer(item) {
+    return {
+        applicationHealthPolicy: !item["applicationHealthPolicy"]
+            ? item["applicationHealthPolicy"]
+            : applicationHealthPolicyDeserializer(item["applicationHealthPolicy"]),
+        forceRestart: item["forceRestart"],
+        rollingUpgradeMonitoringPolicy: !item["rollingUpgradeMonitoringPolicy"]
+            ? item["rollingUpgradeMonitoringPolicy"]
+            : rollingUpgradeMonitoringPolicyDeserializer(item["rollingUpgradeMonitoringPolicy"]),
+        instanceCloseDelayDuration: item["instanceCloseDelayDuration"],
+        upgradeMode: item["upgradeMode"],
+        upgradeReplicaSetCheckTimeout: item["upgradeReplicaSetCheckTimeout"],
+        recreateApplication: item["recreateApplication"],
+    };
+}
+export function applicationHealthPolicySerializer(item) {
+    return {
+        considerWarningAsError: item["considerWarningAsError"],
+        maxPercentUnhealthyDeployedApplications: item["maxPercentUnhealthyDeployedApplications"],
+        defaultServiceTypeHealthPolicy: !item["defaultServiceTypeHealthPolicy"]
+            ? item["defaultServiceTypeHealthPolicy"]
+            : serviceTypeHealthPolicySerializer(item["defaultServiceTypeHealthPolicy"]),
+        serviceTypeHealthPolicyMap: !item["serviceTypeHealthPolicyMap"]
+            ? item["serviceTypeHealthPolicyMap"]
+            : serviceTypeHealthPolicyRecordSerializer(item["serviceTypeHealthPolicyMap"]),
+    };
+}
+export function applicationHealthPolicyDeserializer(item) {
+    return {
+        considerWarningAsError: item["considerWarningAsError"],
+        maxPercentUnhealthyDeployedApplications: item["maxPercentUnhealthyDeployedApplications"],
+        defaultServiceTypeHealthPolicy: !item["defaultServiceTypeHealthPolicy"]
+            ? item["defaultServiceTypeHealthPolicy"]
+            : serviceTypeHealthPolicyDeserializer(item["defaultServiceTypeHealthPolicy"]),
+        serviceTypeHealthPolicyMap: !item["serviceTypeHealthPolicyMap"]
+            ? item["serviceTypeHealthPolicyMap"]
+            : serviceTypeHealthPolicyRecordDeserializer(item["serviceTypeHealthPolicyMap"]),
+    };
+}
+export function serviceTypeHealthPolicySerializer(item) {
+    return {
+        maxPercentUnhealthyServices: item["maxPercentUnhealthyServices"],
+        maxPercentUnhealthyPartitionsPerService: item["maxPercentUnhealthyPartitionsPerService"],
+        maxPercentUnhealthyReplicasPerPartition: item["maxPercentUnhealthyReplicasPerPartition"],
+    };
+}
+export function serviceTypeHealthPolicyDeserializer(item) {
+    return {
+        maxPercentUnhealthyServices: item["maxPercentUnhealthyServices"],
+        maxPercentUnhealthyPartitionsPerService: item["maxPercentUnhealthyPartitionsPerService"],
+        maxPercentUnhealthyReplicasPerPartition: item["maxPercentUnhealthyReplicasPerPartition"],
+    };
+}
+export function serviceTypeHealthPolicyRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : serviceTypeHealthPolicySerializer(item[key]);
+    });
+    return result;
+}
+export function serviceTypeHealthPolicyRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : serviceTypeHealthPolicyDeserializer(item[key]);
+    });
+    return result;
+}
+export function rollingUpgradeMonitoringPolicySerializer(item) {
+    return {
+        failureAction: item["failureAction"],
+        healthCheckWaitDuration: item["healthCheckWaitDuration"],
+        healthCheckStableDuration: item["healthCheckStableDuration"],
+        healthCheckRetryTimeout: item["healthCheckRetryTimeout"],
+        upgradeTimeout: item["upgradeTimeout"],
+        upgradeDomainTimeout: item["upgradeDomainTimeout"],
+    };
+}
+export function rollingUpgradeMonitoringPolicyDeserializer(item) {
+    return {
+        failureAction: item["failureAction"],
+        healthCheckWaitDuration: item["healthCheckWaitDuration"],
+        healthCheckStableDuration: item["healthCheckStableDuration"],
+        healthCheckRetryTimeout: item["healthCheckRetryTimeout"],
+        upgradeTimeout: item["upgradeTimeout"],
+        upgradeDomainTimeout: item["upgradeDomainTimeout"],
+    };
+}
+/** The compensating action to perform when a Monitored upgrade encounters monitoring policy or health policy violations. Invalid indicates the failure action is invalid. Rollback specifies that the upgrade will start rolling back automatically. Manual indicates that the upgrade will switch to UnmonitoredManual upgrade mode. */
+export var KnownFailureAction;
+(function (KnownFailureAction) {
+    /** Indicates that a rollback of the upgrade will be performed by Service Fabric if the upgrade fails. */
+    KnownFailureAction["Rollback"] = "Rollback";
+    /** Indicates that a manual repair will need to be performed by the administrator if the upgrade fails. Service Fabric will not proceed to the next upgrade domain automatically. */
+    KnownFailureAction["Manual"] = "Manual";
+})(KnownFailureAction || (KnownFailureAction = {}));
+/** The mode used to monitor health during a rolling upgrade. The values are Monitored, and UnmonitoredAuto. */
+export var KnownRollingUpgradeMode;
+(function (KnownRollingUpgradeMode) {
+    /** The upgrade will stop after completing each upgrade domain and automatically monitor health before proceeding. The value is 0. */
+    KnownRollingUpgradeMode["Monitored"] = "Monitored";
+    /** The upgrade will proceed automatically without performing any health monitoring. The value is 1. */
+    KnownRollingUpgradeMode["UnmonitoredAuto"] = "UnmonitoredAuto";
+})(KnownRollingUpgradeMode || (KnownRollingUpgradeMode = {}));
+export function managedIdentitySerializer(item) {
+    return {
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentityRecordSerializer(item["userAssignedIdentities"]),
+    };
+}
+export function managedIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        tenantId: item["tenantId"],
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentityRecordDeserializer(item["userAssignedIdentities"]),
+    };
+}
+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 userAssignedIdentitySerializer(item) {
+    return item;
+}
+export function userAssignedIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+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 applicationUpdateParametersSerializer(item) {
+    return { tags: item["tags"] };
+}
+export function _applicationResourceListDeserializer(item) {
+    return {
+        value: applicationResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function applicationResourceArraySerializer(result) {
+    return result.map((item) => {
+        return applicationResourceSerializer(item);
+    });
+}
+export function applicationResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return applicationResourceDeserializer(item);
+    });
+}
+export function runtimeResumeApplicationUpgradeParametersSerializer(item) {
+    return { upgradeDomainName: item["upgradeDomainName"] };
+}
+export function applicationTypeResourceSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : applicationTypeResourcePropertiesSerializer(item["properties"]),
+        tags: item["tags"],
+        location: item["location"],
+    };
+}
+export function applicationTypeResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : applicationTypeResourcePropertiesDeserializer(item["properties"]),
+        tags: item["tags"],
+        location: item["location"],
+    };
+}
+export function applicationTypeResourcePropertiesSerializer(item) {
+    return item;
+}
+export function applicationTypeResourcePropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+    };
+}
+export function applicationTypeUpdateParametersSerializer(item) {
+    return { tags: item["tags"] };
+}
+export function _applicationTypeResourceListDeserializer(item) {
+    return {
+        value: applicationTypeResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function applicationTypeResourceArraySerializer(result) {
+    return result.map((item) => {
+        return applicationTypeResourceSerializer(item);
+    });
+}
+export function applicationTypeResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return applicationTypeResourceDeserializer(item);
+    });
+}
+export function applicationTypeVersionResourceSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : applicationTypeVersionResourcePropertiesSerializer(item["properties"]),
+        tags: item["tags"],
+        location: item["location"],
+    };
+}
+export function applicationTypeVersionResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : applicationTypeVersionResourcePropertiesDeserializer(item["properties"]),
+        tags: item["tags"],
+        location: item["location"],
+    };
+}
+export function applicationTypeVersionResourcePropertiesSerializer(item) {
+    return { appPackageUrl: item["appPackageUrl"] };
+}
+export function applicationTypeVersionResourcePropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        appPackageUrl: item["appPackageUrl"],
+    };
+}
+export function applicationTypeVersionUpdateParametersSerializer(item) {
+    return { tags: item["tags"] };
+}
+export function _applicationTypeVersionResourceListDeserializer(item) {
+    return {
+        value: applicationTypeVersionResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function applicationTypeVersionResourceArraySerializer(result) {
+    return result.map((item) => {
+        return applicationTypeVersionResourceSerializer(item);
+    });
+}
+export function applicationTypeVersionResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return applicationTypeVersionResourceDeserializer(item);
+    });
+}
+export function serviceResourceSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : serviceResourcePropertiesUnionSerializer(item["properties"]),
+        tags: item["tags"],
+        location: item["location"],
+    };
+}
+export function serviceResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : serviceResourcePropertiesUnionDeserializer(item["properties"]),
+        tags: item["tags"],
+        location: item["location"],
+    };
+}
+export function serviceResourcePropertiesSerializer(item) {
+    return {
+        placementConstraints: item["placementConstraints"],
+        correlationScheme: !item["correlationScheme"]
+            ? item["correlationScheme"]
+            : serviceCorrelationArraySerializer(item["correlationScheme"]),
+        serviceLoadMetrics: !item["serviceLoadMetrics"]
+            ? item["serviceLoadMetrics"]
+            : serviceLoadMetricArraySerializer(item["serviceLoadMetrics"]),
+        servicePlacementPolicies: !item["servicePlacementPolicies"]
+            ? item["servicePlacementPolicies"]
+            : servicePlacementPolicyUnionArraySerializer(item["servicePlacementPolicies"]),
+        defaultMoveCost: item["defaultMoveCost"],
+        scalingPolicies: !item["scalingPolicies"]
+            ? item["scalingPolicies"]
+            : scalingPolicyArraySerializer(item["scalingPolicies"]),
+        serviceKind: item["serviceKind"],
+        serviceTypeName: item["serviceTypeName"],
+        partitionDescription: partitionUnionSerializer(item["partitionDescription"]),
+        servicePackageActivationMode: item["servicePackageActivationMode"],
+        serviceDnsName: item["serviceDnsName"],
+    };
+}
+export function serviceResourcePropertiesDeserializer(item) {
+    return {
+        placementConstraints: item["placementConstraints"],
+        correlationScheme: !item["correlationScheme"]
+            ? item["correlationScheme"]
+            : serviceCorrelationArrayDeserializer(item["correlationScheme"]),
+        serviceLoadMetrics: !item["serviceLoadMetrics"]
+            ? item["serviceLoadMetrics"]
+            : serviceLoadMetricArrayDeserializer(item["serviceLoadMetrics"]),
+        servicePlacementPolicies: !item["servicePlacementPolicies"]
+            ? item["servicePlacementPolicies"]
+            : servicePlacementPolicyUnionArrayDeserializer(item["servicePlacementPolicies"]),
+        defaultMoveCost: item["defaultMoveCost"],
+        scalingPolicies: !item["scalingPolicies"]
+            ? item["scalingPolicies"]
+            : scalingPolicyArrayDeserializer(item["scalingPolicies"]),
+        provisioningState: item["provisioningState"],
+        serviceKind: item["serviceKind"],
+        serviceTypeName: item["serviceTypeName"],
+        partitionDescription: partitionUnionDeserializer(item["partitionDescription"]),
+        servicePackageActivationMode: item["servicePackageActivationMode"],
+        serviceDnsName: item["serviceDnsName"],
+    };
+}
+export function serviceResourcePropertiesUnionSerializer(item) {
+    switch (item.serviceKind) {
+        case "Stateful":
+            return statefulServicePropertiesSerializer(item);
+        case "Stateless":
+            return statelessServicePropertiesSerializer(item);
+        default:
+            return serviceResourcePropertiesSerializer(item);
+    }
+}
+export function serviceResourcePropertiesUnionDeserializer(item) {
+    switch (item.serviceKind) {
+        case "Stateful":
+            return statefulServicePropertiesDeserializer(item);
+        case "Stateless":
+            return statelessServicePropertiesDeserializer(item);
+        default:
+            return serviceResourcePropertiesDeserializer(item);
+    }
+}
+/** The kind of service (Stateless or Stateful). */
+export var KnownServiceKind;
+(function (KnownServiceKind) {
+    /** Does not use Service Fabric to make its state highly available or reliable. The value is 0. */
+    KnownServiceKind["Stateless"] = "Stateless";
+    /** Uses Service Fabric to make its state or part of its state highly available and reliable. The value is 1. */
+    KnownServiceKind["Stateful"] = "Stateful";
+})(KnownServiceKind || (KnownServiceKind = {}));
+export function partitionSerializer(item) {
+    return { partitionScheme: item["partitionScheme"] };
+}
+export function partitionDeserializer(item) {
+    return {
+        partitionScheme: item["partitionScheme"],
+    };
+}
+export function partitionUnionSerializer(item) {
+    switch (item.partitionScheme) {
+        case "UniformInt64Range":
+            return uniformInt64RangePartitionSchemeSerializer(item);
+        case "Singleton":
+            return singletonPartitionSchemeSerializer(item);
+        case "Named":
+            return namedPartitionSchemeSerializer(item);
+        default:
+            return partitionSerializer(item);
+    }
+}
+export function partitionUnionDeserializer(item) {
+    switch (item.partitionScheme) {
+        case "UniformInt64Range":
+            return uniformInt64RangePartitionSchemeDeserializer(item);
+        case "Singleton":
+            return singletonPartitionSchemeDeserializer(item);
+        case "Named":
+            return namedPartitionSchemeDeserializer(item);
+        default:
+            return partitionDeserializer(item);
+    }
+}
+/** Enumerates the ways that a service can be partitioned. */
+export var KnownPartitionScheme;
+(function (KnownPartitionScheme) {
+    /** Indicates that the partition is based on string names, and is a SingletonPartitionScheme object, The value is 0. */
+    KnownPartitionScheme["Singleton"] = "Singleton";
+    /** Indicates that the partition is based on Int64 key ranges, and is a UniformInt64RangePartitionScheme object. The value is 1. */
+    KnownPartitionScheme["UniformInt64Range"] = "UniformInt64Range";
+    /** Indicates that the partition is based on string names, and is a NamedPartitionScheme object. The value is 2. */
+    KnownPartitionScheme["Named"] = "Named";
+})(KnownPartitionScheme || (KnownPartitionScheme = {}));
+export function uniformInt64RangePartitionSchemeSerializer(item) {
+    return {
+        partitionScheme: item["partitionScheme"],
+        count: item["count"],
+        lowKey: item["lowKey"],
+        highKey: item["highKey"],
+    };
+}
+export function uniformInt64RangePartitionSchemeDeserializer(item) {
+    return {
+        partitionScheme: item["partitionScheme"],
+        count: item["count"],
+        lowKey: item["lowKey"],
+        highKey: item["highKey"],
+    };
+}
+export function singletonPartitionSchemeSerializer(item) {
+    return { partitionScheme: item["partitionScheme"] };
+}
+export function singletonPartitionSchemeDeserializer(item) {
+    return {
+        partitionScheme: item["partitionScheme"],
+    };
+}
+export function namedPartitionSchemeSerializer(item) {
+    return {
+        partitionScheme: item["partitionScheme"],
+        names: item["names"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function namedPartitionSchemeDeserializer(item) {
+    return {
+        partitionScheme: item["partitionScheme"],
+        names: item["names"].map((p) => {
+            return p;
+        }),
+    };
+}
+/** The activation Mode of the service package */
+export var KnownServicePackageActivationMode;
+(function (KnownServicePackageActivationMode) {
+    /** Indicates the application package activation mode will use shared process. */
+    KnownServicePackageActivationMode["SharedProcess"] = "SharedProcess";
+    /** Indicates the application package activation mode will use exclusive process. */
+    KnownServicePackageActivationMode["ExclusiveProcess"] = "ExclusiveProcess";
+})(KnownServicePackageActivationMode || (KnownServicePackageActivationMode = {}));
+export function statefulServicePropertiesSerializer(item) {
+    return {
+        serviceKind: item["serviceKind"],
+        serviceTypeName: item["serviceTypeName"],
+        partitionDescription: partitionUnionSerializer(item["partitionDescription"]),
+        servicePackageActivationMode: item["servicePackageActivationMode"],
+        serviceDnsName: item["serviceDnsName"],
+        placementConstraints: item["placementConstraints"],
+        correlationScheme: !item["correlationScheme"]
+            ? item["correlationScheme"]
+            : serviceCorrelationArraySerializer(item["correlationScheme"]),
+        serviceLoadMetrics: !item["serviceLoadMetrics"]
+            ? item["serviceLoadMetrics"]
+            : serviceLoadMetricArraySerializer(item["serviceLoadMetrics"]),
+        servicePlacementPolicies: !item["servicePlacementPolicies"]
+            ? item["servicePlacementPolicies"]
+            : servicePlacementPolicyUnionArraySerializer(item["servicePlacementPolicies"]),
+        defaultMoveCost: item["defaultMoveCost"],
+        scalingPolicies: !item["scalingPolicies"]
+            ? item["scalingPolicies"]
+            : scalingPolicyArraySerializer(item["scalingPolicies"]),
+        hasPersistedState: item["hasPersistedState"],
+        targetReplicaSetSize: item["targetReplicaSetSize"],
+        minReplicaSetSize: item["minReplicaSetSize"],
+        replicaRestartWaitDuration: item["replicaRestartWaitDuration"],
+        quorumLossWaitDuration: item["quorumLossWaitDuration"],
+        standByReplicaKeepDuration: item["standByReplicaKeepDuration"],
+        servicePlacementTimeLimit: item["servicePlacementTimeLimit"],
+    };
+}
+export function statefulServicePropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        serviceKind: item["serviceKind"],
+        serviceTypeName: item["serviceTypeName"],
+        partitionDescription: partitionUnionDeserializer(item["partitionDescription"]),
+        servicePackageActivationMode: item["servicePackageActivationMode"],
+        serviceDnsName: item["serviceDnsName"],
+        placementConstraints: item["placementConstraints"],
+        correlationScheme: !item["correlationScheme"]
+            ? item["correlationScheme"]
+            : serviceCorrelationArrayDeserializer(item["correlationScheme"]),
+        serviceLoadMetrics: !item["serviceLoadMetrics"]
+            ? item["serviceLoadMetrics"]
+            : serviceLoadMetricArrayDeserializer(item["serviceLoadMetrics"]),
+        servicePlacementPolicies: !item["servicePlacementPolicies"]
+            ? item["servicePlacementPolicies"]
+            : servicePlacementPolicyUnionArrayDeserializer(item["servicePlacementPolicies"]),
+        defaultMoveCost: item["defaultMoveCost"],
+        scalingPolicies: !item["scalingPolicies"]
+            ? item["scalingPolicies"]
+            : scalingPolicyArrayDeserializer(item["scalingPolicies"]),
+        hasPersistedState: item["hasPersistedState"],
+        targetReplicaSetSize: item["targetReplicaSetSize"],
+        minReplicaSetSize: item["minReplicaSetSize"],
+        replicaRestartWaitDuration: item["replicaRestartWaitDuration"],
+        quorumLossWaitDuration: item["quorumLossWaitDuration"],
+        standByReplicaKeepDuration: item["standByReplicaKeepDuration"],
+        servicePlacementTimeLimit: item["servicePlacementTimeLimit"],
+    };
+}
+export function statelessServicePropertiesSerializer(item) {
+    return {
+        serviceKind: item["serviceKind"],
+        serviceTypeName: item["serviceTypeName"],
+        partitionDescription: partitionUnionSerializer(item["partitionDescription"]),
+        servicePackageActivationMode: item["servicePackageActivationMode"],
+        serviceDnsName: item["serviceDnsName"],
+        placementConstraints: item["placementConstraints"],
+        correlationScheme: !item["correlationScheme"]
+            ? item["correlationScheme"]
+            : serviceCorrelationArraySerializer(item["correlationScheme"]),
+        serviceLoadMetrics: !item["serviceLoadMetrics"]
+            ? item["serviceLoadMetrics"]
+            : serviceLoadMetricArraySerializer(item["serviceLoadMetrics"]),
+        servicePlacementPolicies: !item["servicePlacementPolicies"]
+            ? item["servicePlacementPolicies"]
+            : servicePlacementPolicyUnionArraySerializer(item["servicePlacementPolicies"]),
+        defaultMoveCost: item["defaultMoveCost"],
+        scalingPolicies: !item["scalingPolicies"]
+            ? item["scalingPolicies"]
+            : scalingPolicyArraySerializer(item["scalingPolicies"]),
+        instanceCount: item["instanceCount"],
+        minInstanceCount: item["minInstanceCount"],
+        minInstancePercentage: item["minInstancePercentage"],
+    };
+}
+export function statelessServicePropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        serviceKind: item["serviceKind"],
+        serviceTypeName: item["serviceTypeName"],
+        partitionDescription: partitionUnionDeserializer(item["partitionDescription"]),
+        servicePackageActivationMode: item["servicePackageActivationMode"],
+        serviceDnsName: item["serviceDnsName"],
+        placementConstraints: item["placementConstraints"],
+        correlationScheme: !item["correlationScheme"]
+            ? item["correlationScheme"]
+            : serviceCorrelationArrayDeserializer(item["correlationScheme"]),
+        serviceLoadMetrics: !item["serviceLoadMetrics"]
+            ? item["serviceLoadMetrics"]
+            : serviceLoadMetricArrayDeserializer(item["serviceLoadMetrics"]),
+        servicePlacementPolicies: !item["servicePlacementPolicies"]
+            ? item["servicePlacementPolicies"]
+            : servicePlacementPolicyUnionArrayDeserializer(item["servicePlacementPolicies"]),
+        defaultMoveCost: item["defaultMoveCost"],
+        scalingPolicies: !item["scalingPolicies"]
+            ? item["scalingPolicies"]
+            : scalingPolicyArrayDeserializer(item["scalingPolicies"]),
+        instanceCount: item["instanceCount"],
+        minInstanceCount: item["minInstanceCount"],
+        minInstancePercentage: item["minInstancePercentage"],
+    };
+}
+export function serviceResourcePropertiesBaseSerializer(item) {
+    return {
+        placementConstraints: item["placementConstraints"],
+        correlationScheme: !item["correlationScheme"]
+            ? item["correlationScheme"]
+            : serviceCorrelationArraySerializer(item["correlationScheme"]),
+        serviceLoadMetrics: !item["serviceLoadMetrics"]
+            ? item["serviceLoadMetrics"]
+            : serviceLoadMetricArraySerializer(item["serviceLoadMetrics"]),
+        servicePlacementPolicies: !item["servicePlacementPolicies"]
+            ? item["servicePlacementPolicies"]
+            : servicePlacementPolicyUnionArraySerializer(item["servicePlacementPolicies"]),
+        defaultMoveCost: item["defaultMoveCost"],
+        scalingPolicies: !item["scalingPolicies"]
+            ? item["scalingPolicies"]
+            : scalingPolicyArraySerializer(item["scalingPolicies"]),
+    };
+}
+export function serviceResourcePropertiesBaseDeserializer(item) {
+    return {
+        placementConstraints: item["placementConstraints"],
+        correlationScheme: !item["correlationScheme"]
+            ? item["correlationScheme"]
+            : serviceCorrelationArrayDeserializer(item["correlationScheme"]),
+        serviceLoadMetrics: !item["serviceLoadMetrics"]
+            ? item["serviceLoadMetrics"]
+            : serviceLoadMetricArrayDeserializer(item["serviceLoadMetrics"]),
+        servicePlacementPolicies: !item["servicePlacementPolicies"]
+            ? item["servicePlacementPolicies"]
+            : servicePlacementPolicyUnionArrayDeserializer(item["servicePlacementPolicies"]),
+        defaultMoveCost: item["defaultMoveCost"],
+        scalingPolicies: !item["scalingPolicies"]
+            ? item["scalingPolicies"]
+            : scalingPolicyArrayDeserializer(item["scalingPolicies"]),
+    };
+}
+export function serviceCorrelationArraySerializer(result) {
+    return result.map((item) => {
+        return serviceCorrelationSerializer(item);
+    });
+}
+export function serviceCorrelationArrayDeserializer(result) {
+    return result.map((item) => {
+        return serviceCorrelationDeserializer(item);
+    });
+}
+export function serviceCorrelationSerializer(item) {
+    return { scheme: item["scheme"], serviceName: item["serviceName"] };
+}
+export function serviceCorrelationDeserializer(item) {
+    return {
+        scheme: item["scheme"],
+        serviceName: item["serviceName"],
+    };
+}
+/** The service correlation scheme. */
+export var KnownServiceCorrelationScheme;
+(function (KnownServiceCorrelationScheme) {
+    /** Aligned affinity ensures that the primaries of the partitions of the affinitized services are collocated on the same nodes. This is the default and is the same as selecting the Affinity scheme. The value is 0. */
+    KnownServiceCorrelationScheme["AlignedAffinity"] = "AlignedAffinity";
+    /** Non-Aligned affinity guarantees that all replicas of each service will be placed on the same nodes. Unlike Aligned Affinity, this does not guarantee that replicas of particular role will be collocated. The value is 1. */
+    KnownServiceCorrelationScheme["NonAlignedAffinity"] = "NonAlignedAffinity";
+})(KnownServiceCorrelationScheme || (KnownServiceCorrelationScheme = {}));
+export function serviceLoadMetricArraySerializer(result) {
+    return result.map((item) => {
+        return serviceLoadMetricSerializer(item);
+    });
+}
+export function serviceLoadMetricArrayDeserializer(result) {
+    return result.map((item) => {
+        return serviceLoadMetricDeserializer(item);
+    });
+}
+export function serviceLoadMetricSerializer(item) {
+    return {
+        name: item["name"],
+        weight: item["weight"],
+        primaryDefaultLoad: item["primaryDefaultLoad"],
+        secondaryDefaultLoad: item["secondaryDefaultLoad"],
+        defaultLoad: item["defaultLoad"],
+    };
+}
+export function serviceLoadMetricDeserializer(item) {
+    return {
+        name: item["name"],
+        weight: item["weight"],
+        primaryDefaultLoad: item["primaryDefaultLoad"],
+        secondaryDefaultLoad: item["secondaryDefaultLoad"],
+        defaultLoad: item["defaultLoad"],
+    };
+}
+/** Determines the metric weight relative to the other metrics that are configured for this service. During runtime, if two metrics end up in conflict, the Cluster Resource Manager prefers the metric with the higher weight. */
+export var KnownServiceLoadMetricWeight;
+(function (KnownServiceLoadMetricWeight) {
+    /** Disables resource balancing for this metric. This value is zero. */
+    KnownServiceLoadMetricWeight["Zero"] = "Zero";
+    /** Specifies the metric weight of the service load as Low. The value is 1. */
+    KnownServiceLoadMetricWeight["Low"] = "Low";
+    /** Specifies the metric weight of the service load as Medium. The value is 2. */
+    KnownServiceLoadMetricWeight["Medium"] = "Medium";
+    /** Specifies the metric weight of the service load as High. The value is 3. */
+    KnownServiceLoadMetricWeight["High"] = "High";
+})(KnownServiceLoadMetricWeight || (KnownServiceLoadMetricWeight = {}));
+export function servicePlacementPolicyUnionArraySerializer(result) {
+    return result.map((item) => {
+        return servicePlacementPolicyUnionSerializer(item);
+    });
+}
+export function servicePlacementPolicyUnionArrayDeserializer(result) {
+    return result.map((item) => {
+        return servicePlacementPolicyUnionDeserializer(item);
+    });
+}
+export function servicePlacementPolicySerializer(item) {
+    return { type: item["type"] };
+}
+export function servicePlacementPolicyDeserializer(item) {
+    return {
+        type: item["type"],
+    };
+}
+export function servicePlacementPolicyUnionSerializer(item) {
+    switch (item.type) {
+        case "InvalidDomain":
+            return servicePlacementInvalidDomainPolicySerializer(item);
+        case "RequiredDomain":
+            return servicePlacementRequiredDomainPolicySerializer(item);
+        case "PreferredPrimaryDomain":
+            return servicePlacementPreferPrimaryDomainPolicySerializer(item);
+        case "RequiredDomainDistribution":
+            return servicePlacementRequireDomainDistributionPolicySerializer(item);
+        case "NonPartiallyPlaceService":
+            return servicePlacementNonPartiallyPlaceServicePolicySerializer(item);
+        default:
+            return servicePlacementPolicySerializer(item);
+    }
+}
+export function servicePlacementPolicyUnionDeserializer(item) {
+    switch (item.type) {
+        case "InvalidDomain":
+            return servicePlacementInvalidDomainPolicyDeserializer(item);
+        case "RequiredDomain":
+            return servicePlacementRequiredDomainPolicyDeserializer(item);
+        case "PreferredPrimaryDomain":
+            return servicePlacementPreferPrimaryDomainPolicyDeserializer(item);
+        case "RequiredDomainDistribution":
+            return servicePlacementRequireDomainDistributionPolicyDeserializer(item);
+        case "NonPartiallyPlaceService":
+            return servicePlacementNonPartiallyPlaceServicePolicyDeserializer(item);
+        default:
+            return servicePlacementPolicyDeserializer(item);
+    }
+}
+/** The type of placement policy for a service fabric service. Following are the possible values. */
+export var KnownServicePlacementPolicyType;
+(function (KnownServicePlacementPolicyType) {
+    /** Indicates that the ServicePlacementPolicyDescription is of type ServicePlacementInvalidDomainPolicyDescription, which indicates that a particular fault or upgrade domain cannot be used for placement of this service. The value is 0. */
+    KnownServicePlacementPolicyType["InvalidDomain"] = "InvalidDomain";
+    /** Indicates that the ServicePlacementPolicyDescription is of type ServicePlacementRequireDomainDistributionPolicyDescription indicating that the replicas of the service must be placed in a specific domain. The value is 1. */
+    KnownServicePlacementPolicyType["RequiredDomain"] = "RequiredDomain";
+    /** Indicates that the ServicePlacementPolicyDescription is of type ServicePlacementPreferPrimaryDomainPolicyDescription, which indicates that if possible the Primary replica for the partitions of the service should be located in a particular domain as an optimization. The value is 2. */
+    KnownServicePlacementPolicyType["PreferredPrimaryDomain"] = "PreferredPrimaryDomain";
+    /** Indicates that the ServicePlacementPolicyDescription is of type ServicePlacementRequireDomainDistributionPolicyDescription, indicating that the system will disallow placement of any two replicas from the same partition in the same domain at any time. The value is 3. */
+    KnownServicePlacementPolicyType["RequiredDomainDistribution"] = "RequiredDomainDistribution";
+    /** Indicates that the ServicePlacementPolicyDescription is of type ServicePlacementNonPartiallyPlaceServicePolicyDescription, which indicates that if possible all replicas of a particular partition of the service should be placed atomically. The value is 4. */
+    KnownServicePlacementPolicyType["NonPartiallyPlaceService"] = "NonPartiallyPlaceService";
+})(KnownServicePlacementPolicyType || (KnownServicePlacementPolicyType = {}));
+export function servicePlacementInvalidDomainPolicySerializer(item) {
+    return { type: item["type"], domainName: item["domainName"] };
+}
+export function servicePlacementInvalidDomainPolicyDeserializer(item) {
+    return {
+        type: item["type"],
+        domainName: item["domainName"],
+    };
+}
+export function servicePlacementRequiredDomainPolicySerializer(item) {
+    return { type: item["type"], domainName: item["domainName"] };
+}
+export function servicePlacementRequiredDomainPolicyDeserializer(item) {
+    return {
+        type: item["type"],
+        domainName: item["domainName"],
+    };
+}
+export function servicePlacementPreferPrimaryDomainPolicySerializer(item) {
+    return { type: item["type"], domainName: item["domainName"] };
+}
+export function servicePlacementPreferPrimaryDomainPolicyDeserializer(item) {
+    return {
+        type: item["type"],
+        domainName: item["domainName"],
+    };
+}
+export function servicePlacementRequireDomainDistributionPolicySerializer(item) {
+    return { type: item["type"], domainName: item["domainName"] };
+}
+export function servicePlacementRequireDomainDistributionPolicyDeserializer(item) {
+    return {
+        type: item["type"],
+        domainName: item["domainName"],
+    };
+}
+export function servicePlacementNonPartiallyPlaceServicePolicySerializer(item) {
+    return { type: item["type"] };
+}
+export function servicePlacementNonPartiallyPlaceServicePolicyDeserializer(item) {
+    return {
+        type: item["type"],
+    };
+}
+/** Specifies the move cost for the service. */
+export var KnownMoveCost;
+(function (KnownMoveCost) {
+    /** Zero move cost. This value is zero. */
+    KnownMoveCost["Zero"] = "Zero";
+    /** Specifies the move cost of the service as Low. The value is 1. */
+    KnownMoveCost["Low"] = "Low";
+    /** Specifies the move cost of the service as Medium. The value is 2. */
+    KnownMoveCost["Medium"] = "Medium";
+    /** Specifies the move cost of the service as High. The value is 3. */
+    KnownMoveCost["High"] = "High";
+})(KnownMoveCost || (KnownMoveCost = {}));
+export function scalingPolicyArraySerializer(result) {
+    return result.map((item) => {
+        return scalingPolicySerializer(item);
+    });
+}
+export function scalingPolicyArrayDeserializer(result) {
+    return result.map((item) => {
+        return scalingPolicyDeserializer(item);
+    });
+}
+export function scalingPolicySerializer(item) {
+    return {
+        scalingMechanism: scalingMechanismUnionSerializer(item["scalingMechanism"]),
+        scalingTrigger: scalingTriggerUnionSerializer(item["scalingTrigger"]),
+    };
+}
+export function scalingPolicyDeserializer(item) {
+    return {
+        scalingMechanism: scalingMechanismUnionDeserializer(item["scalingMechanism"]),
+        scalingTrigger: scalingTriggerUnionDeserializer(item["scalingTrigger"]),
+    };
+}
+export function scalingMechanismSerializer(item) {
+    return { kind: item["kind"] };
+}
+export function scalingMechanismDeserializer(item) {
+    return {
+        kind: item["kind"],
+    };
+}
+export function scalingMechanismUnionSerializer(item) {
+    switch (item.kind) {
+        case "AddRemoveIncrementalNamedPartition":
+            return addRemoveIncrementalNamedPartitionScalingMechanismSerializer(item);
+        case "ScalePartitionInstanceCount":
+            return partitionInstanceCountScaleMechanismSerializer(item);
+        default:
+            return scalingMechanismSerializer(item);
+    }
+}
+export function scalingMechanismUnionDeserializer(item) {
+    switch (item.kind) {
+        case "AddRemoveIncrementalNamedPartition":
+            return addRemoveIncrementalNamedPartitionScalingMechanismDeserializer(item);
+        case "ScalePartitionInstanceCount":
+            return partitionInstanceCountScaleMechanismDeserializer(item);
+        default:
+            return scalingMechanismDeserializer(item);
+    }
+}
+/** Enumerates the ways that a service can be partitioned. */
+export var KnownServiceScalingMechanismKind;
+(function (KnownServiceScalingMechanismKind) {
+    /** Represents a scaling mechanism for adding or removing instances of stateless service partition. The value is 0. */
+    KnownServiceScalingMechanismKind["ScalePartitionInstanceCount"] = "ScalePartitionInstanceCount";
+    /** Represents a scaling mechanism for adding or removing named partitions of a stateless service. The value is 1. */
+    KnownServiceScalingMechanismKind["AddRemoveIncrementalNamedPartition"] = "AddRemoveIncrementalNamedPartition";
+})(KnownServiceScalingMechanismKind || (KnownServiceScalingMechanismKind = {}));
+export function addRemoveIncrementalNamedPartitionScalingMechanismSerializer(item) {
+    return {
+        kind: item["kind"],
+        minPartitionCount: item["minPartitionCount"],
+        maxPartitionCount: item["maxPartitionCount"],
+        scaleIncrement: item["scaleIncrement"],
+    };
+}
+export function addRemoveIncrementalNamedPartitionScalingMechanismDeserializer(item) {
+    return {
+        kind: item["kind"],
+        minPartitionCount: item["minPartitionCount"],
+        maxPartitionCount: item["maxPartitionCount"],
+        scaleIncrement: item["scaleIncrement"],
+    };
+}
+export function partitionInstanceCountScaleMechanismSerializer(item) {
+    return {
+        kind: item["kind"],
+        minInstanceCount: item["minInstanceCount"],
+        maxInstanceCount: item["maxInstanceCount"],
+        scaleIncrement: item["scaleIncrement"],
+    };
+}
+export function partitionInstanceCountScaleMechanismDeserializer(item) {
+    return {
+        kind: item["kind"],
+        minInstanceCount: item["minInstanceCount"],
+        maxInstanceCount: item["maxInstanceCount"],
+        scaleIncrement: item["scaleIncrement"],
+    };
+}
+export function scalingTriggerSerializer(item) {
+    return { kind: item["kind"] };
+}
+export function scalingTriggerDeserializer(item) {
+    return {
+        kind: item["kind"],
+    };
+}
+export function scalingTriggerUnionSerializer(item) {
+    switch (item.kind) {
+        case "AveragePartitionLoadTrigger":
+            return averagePartitionLoadScalingTriggerSerializer(item);
+        case "AverageServiceLoadTrigger":
+            return averageServiceLoadScalingTriggerSerializer(item);
+        default:
+            return scalingTriggerSerializer(item);
+    }
+}
+export function scalingTriggerUnionDeserializer(item) {
+    switch (item.kind) {
+        case "AveragePartitionLoadTrigger":
+            return averagePartitionLoadScalingTriggerDeserializer(item);
+        case "AverageServiceLoadTrigger":
+            return averageServiceLoadScalingTriggerDeserializer(item);
+        default:
+            return scalingTriggerDeserializer(item);
+    }
+}
+/** Enumerates the ways that a service can be partitioned. */
+export var KnownServiceScalingTriggerKind;
+(function (KnownServiceScalingTriggerKind) {
+    /** Represents a scaling trigger related to an average load of a metric/resource of a partition. The value is 0. */
+    KnownServiceScalingTriggerKind["AveragePartitionLoadTrigger"] = "AveragePartitionLoadTrigger";
+    /** Represents a scaling policy related to an average load of a metric/resource of a service. The value is 1. */
+    KnownServiceScalingTriggerKind["AverageServiceLoadTrigger"] = "AverageServiceLoadTrigger";
+})(KnownServiceScalingTriggerKind || (KnownServiceScalingTriggerKind = {}));
+export function averagePartitionLoadScalingTriggerSerializer(item) {
+    return {
+        kind: item["kind"],
+        metricName: item["metricName"],
+        lowerLoadThreshold: item["lowerLoadThreshold"],
+        upperLoadThreshold: item["upperLoadThreshold"],
+        scaleInterval: item["scaleInterval"],
+    };
+}
+export function averagePartitionLoadScalingTriggerDeserializer(item) {
+    return {
+        kind: item["kind"],
+        metricName: item["metricName"],
+        lowerLoadThreshold: item["lowerLoadThreshold"],
+        upperLoadThreshold: item["upperLoadThreshold"],
+        scaleInterval: item["scaleInterval"],
+    };
+}
+export function averageServiceLoadScalingTriggerSerializer(item) {
+    return {
+        kind: item["kind"],
+        metricName: item["metricName"],
+        lowerLoadThreshold: item["lowerLoadThreshold"],
+        upperLoadThreshold: item["upperLoadThreshold"],
+        scaleInterval: item["scaleInterval"],
+        useOnlyPrimaryLoad: item["useOnlyPrimaryLoad"],
+    };
+}
+export function averageServiceLoadScalingTriggerDeserializer(item) {
+    return {
+        kind: item["kind"],
+        metricName: item["metricName"],
+        lowerLoadThreshold: item["lowerLoadThreshold"],
+        upperLoadThreshold: item["upperLoadThreshold"],
+        scaleInterval: item["scaleInterval"],
+        useOnlyPrimaryLoad: item["useOnlyPrimaryLoad"],
+    };
+}
+export function serviceUpdateParametersSerializer(item) {
+    return { tags: item["tags"] };
+}
+export function _serviceResourceListDeserializer(item) {
+    return {
+        value: serviceResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function serviceResourceArraySerializer(result) {
+    return result.map((item) => {
+        return serviceResourceSerializer(item);
+    });
+}
+export function serviceResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return serviceResourceDeserializer(item);
+    });
+}
+export function managedClusterCodeVersionResultDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : managedClusterVersionDetailsDeserializer(item["properties"]),
+    };
+}
+export function managedClusterVersionDetailsDeserializer(item) {
+    return {
+        clusterCodeVersion: item["clusterCodeVersion"],
+        supportExpiryUtc: !item["supportExpiryUtc"]
+            ? item["supportExpiryUtc"]
+            : new Date(item["supportExpiryUtc"]),
+        osType: item["osType"],
+    };
+}
+/** Cluster operating system, the default will be Windows */
+export var KnownOsType;
+(function (KnownOsType) {
+    /** Indicates os is Windows. */
+    KnownOsType["Windows"] = "Windows";
+})(KnownOsType || (KnownOsType = {}));
+export function managedVMSizeDeserializer(item) {
+    return {
+        properties: !item["properties"] ? item["properties"] : vmSizeDeserializer(item["properties"]),
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+    };
+}
+export function vmSizeDeserializer(item) {
+    return {
+        size: item["size"],
+    };
+}
+export function _managedVMSizesResultDeserializer(item) {
+    return {
+        value: managedVMSizeArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function managedVMSizeArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedVMSizeDeserializer(item);
+    });
+}
+export function managedClusterSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : managedClusterPropertiesSerializer(item["properties"]),
+        sku: skuSerializer(item["sku"]),
+    };
+}
+export function managedClusterDeserializer(item) {
+    return {
+        tags: item["tags"],
+        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"]
+            : managedClusterPropertiesDeserializer(item["properties"]),
+        etag: item["etag"],
+        sku: skuDeserializer(item["sku"]),
+    };
+}
+export function managedClusterPropertiesSerializer(item) {
+    return {
+        dnsName: item["dnsName"],
+        clientConnectionPort: item["clientConnectionPort"],
+        httpGatewayConnectionPort: item["httpGatewayConnectionPort"],
+        adminUserName: item["adminUserName"],
+        adminPassword: item["adminPassword"],
+        loadBalancingRules: !item["loadBalancingRules"]
+            ? item["loadBalancingRules"]
+            : loadBalancingRuleArraySerializer(item["loadBalancingRules"]),
+        allowRdpAccess: item["allowRdpAccess"],
+        networkSecurityRules: !item["networkSecurityRules"]
+            ? item["networkSecurityRules"]
+            : networkSecurityRuleArraySerializer(item["networkSecurityRules"]),
+        clients: !item["clients"] ? item["clients"] : clientCertificateArraySerializer(item["clients"]),
+        azureActiveDirectory: !item["azureActiveDirectory"]
+            ? item["azureActiveDirectory"]
+            : azureActiveDirectorySerializer(item["azureActiveDirectory"]),
+        fabricSettings: !item["fabricSettings"]
+            ? item["fabricSettings"]
+            : settingsSectionDescriptionArraySerializer(item["fabricSettings"]),
+        clusterCodeVersion: item["clusterCodeVersion"],
+        clusterUpgradeMode: item["clusterUpgradeMode"],
+        clusterUpgradeCadence: item["clusterUpgradeCadence"],
+        addonFeatures: !item["addonFeatures"]
+            ? item["addonFeatures"]
+            : item["addonFeatures"].map((p) => {
+                return p;
+            }),
+        enableAutoOSUpgrade: item["enableAutoOSUpgrade"],
+        zonalResiliency: item["zonalResiliency"],
+        applicationTypeVersionsCleanupPolicy: !item["applicationTypeVersionsCleanupPolicy"]
+            ? item["applicationTypeVersionsCleanupPolicy"]
+            : applicationTypeVersionsCleanupPolicySerializer(item["applicationTypeVersionsCleanupPolicy"]),
+        enableIpv6: item["enableIpv6"],
+        subnetId: item["subnetId"],
+        ipTags: !item["ipTags"] ? item["ipTags"] : ipTagArraySerializer(item["ipTags"]),
+        enableServicePublicIP: item["enableServicePublicIP"],
+        auxiliarySubnets: !item["auxiliarySubnets"]
+            ? item["auxiliarySubnets"]
+            : subnetArraySerializer(item["auxiliarySubnets"]),
+        serviceEndpoints: !item["serviceEndpoints"]
+            ? item["serviceEndpoints"]
+            : serviceEndpointArraySerializer(item["serviceEndpoints"]),
+        zonalUpdateMode: item["zonalUpdateMode"],
+        useCustomVnet: item["useCustomVnet"],
+        publicIPPrefixId: item["publicIPPrefixId"],
+        publicIPv6PrefixId: item["publicIPv6PrefixId"],
+        ddosProtectionPlanId: item["ddosProtectionPlanId"],
+        upgradeDescription: !item["upgradeDescription"]
+            ? item["upgradeDescription"]
+            : clusterUpgradePolicySerializer(item["upgradeDescription"]),
+        httpGatewayTokenAuthConnectionPort: item["httpGatewayTokenAuthConnectionPort"],
+        enableHttpGatewayExclusiveAuthMode: item["enableHttpGatewayExclusiveAuthMode"],
+        autoGeneratedDomainNameLabelScope: item["autoGeneratedDomainNameLabelScope"],
+        allocatedOutboundPorts: item["allocatedOutboundPorts"],
+        VMImage: item["vmImage"],
+    };
+}
+export function managedClusterPropertiesDeserializer(item) {
+    return {
+        dnsName: item["dnsName"],
+        fqdn: item["fqdn"],
+        ipv4Address: item["ipv4Address"],
+        clusterId: item["clusterId"],
+        clusterState: item["clusterState"],
+        clusterCertificateThumbprints: !item["clusterCertificateThumbprints"]
+            ? item["clusterCertificateThumbprints"]
+            : item["clusterCertificateThumbprints"].map((p) => {
+                return p;
+            }),
+        clientConnectionPort: item["clientConnectionPort"],
+        httpGatewayConnectionPort: item["httpGatewayConnectionPort"],
+        adminUserName: item["adminUserName"],
+        adminPassword: item["adminPassword"],
+        loadBalancingRules: !item["loadBalancingRules"]
+            ? item["loadBalancingRules"]
+            : loadBalancingRuleArrayDeserializer(item["loadBalancingRules"]),
+        allowRdpAccess: item["allowRdpAccess"],
+        networkSecurityRules: !item["networkSecurityRules"]
+            ? item["networkSecurityRules"]
+            : networkSecurityRuleArrayDeserializer(item["networkSecurityRules"]),
+        clients: !item["clients"]
+            ? item["clients"]
+            : clientCertificateArrayDeserializer(item["clients"]),
+        azureActiveDirectory: !item["azureActiveDirectory"]
+            ? item["azureActiveDirectory"]
+            : azureActiveDirectoryDeserializer(item["azureActiveDirectory"]),
+        fabricSettings: !item["fabricSettings"]
+            ? item["fabricSettings"]
+            : settingsSectionDescriptionArrayDeserializer(item["fabricSettings"]),
+        provisioningState: item["provisioningState"],
+        clusterCodeVersion: item["clusterCodeVersion"],
+        clusterUpgradeMode: item["clusterUpgradeMode"],
+        clusterUpgradeCadence: item["clusterUpgradeCadence"],
+        addonFeatures: !item["addonFeatures"]
+            ? item["addonFeatures"]
+            : item["addonFeatures"].map((p) => {
+                return p;
+            }),
+        enableAutoOSUpgrade: item["enableAutoOSUpgrade"],
+        zonalResiliency: item["zonalResiliency"],
+        applicationTypeVersionsCleanupPolicy: !item["applicationTypeVersionsCleanupPolicy"]
+            ? item["applicationTypeVersionsCleanupPolicy"]
+            : applicationTypeVersionsCleanupPolicyDeserializer(item["applicationTypeVersionsCleanupPolicy"]),
+        enableIpv6: item["enableIpv6"],
+        subnetId: item["subnetId"],
+        ipTags: !item["ipTags"] ? item["ipTags"] : ipTagArrayDeserializer(item["ipTags"]),
+        ipv6Address: item["ipv6Address"],
+        enableServicePublicIP: item["enableServicePublicIP"],
+        auxiliarySubnets: !item["auxiliarySubnets"]
+            ? item["auxiliarySubnets"]
+            : subnetArrayDeserializer(item["auxiliarySubnets"]),
+        serviceEndpoints: !item["serviceEndpoints"]
+            ? item["serviceEndpoints"]
+            : serviceEndpointArrayDeserializer(item["serviceEndpoints"]),
+        zonalUpdateMode: item["zonalUpdateMode"],
+        useCustomVnet: item["useCustomVnet"],
+        publicIPPrefixId: item["publicIPPrefixId"],
+        publicIPv6PrefixId: item["publicIPv6PrefixId"],
+        ddosProtectionPlanId: item["ddosProtectionPlanId"],
+        upgradeDescription: !item["upgradeDescription"]
+            ? item["upgradeDescription"]
+            : clusterUpgradePolicyDeserializer(item["upgradeDescription"]),
+        httpGatewayTokenAuthConnectionPort: item["httpGatewayTokenAuthConnectionPort"],
+        enableHttpGatewayExclusiveAuthMode: item["enableHttpGatewayExclusiveAuthMode"],
+        autoGeneratedDomainNameLabelScope: item["autoGeneratedDomainNameLabelScope"],
+        allocatedOutboundPorts: item["allocatedOutboundPorts"],
+        vmImage: item["VMImage"],
+    };
+}
+/** The current state of the cluster. */
+export var KnownClusterState;
+(function (KnownClusterState) {
+    /** Indicates that the cluster resource is created and the resource provider is waiting for Service Fabric VM extension to boot up and report to it. */
+    KnownClusterState["WaitingForNodes"] = "WaitingForNodes";
+    /** Indicates that the Service Fabric runtime is being installed on the VMs. Cluster resource will be in this state until the cluster boots up and system services are up. */
+    KnownClusterState["Deploying"] = "Deploying";
+    /** Indicates that the cluster is upgrading to establishes the cluster version. This upgrade is automatically initiated when the cluster boots up for the first time. */
+    KnownClusterState["BaselineUpgrade"] = "BaselineUpgrade";
+    /** Indicates that the cluster is being upgraded with the user provided configuration. */
+    KnownClusterState["Upgrading"] = "Upgrading";
+    /** Indicates that the last upgrade for the cluster has failed. */
+    KnownClusterState["UpgradeFailed"] = "UpgradeFailed";
+    /** Indicates that the cluster is in a stable state. */
+    KnownClusterState["Ready"] = "Ready";
+})(KnownClusterState || (KnownClusterState = {}));
+export function loadBalancingRuleArraySerializer(result) {
+    return result.map((item) => {
+        return loadBalancingRuleSerializer(item);
+    });
+}
+export function loadBalancingRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return loadBalancingRuleDeserializer(item);
+    });
+}
+export function loadBalancingRuleSerializer(item) {
+    return {
+        frontendPort: item["frontendPort"],
+        backendPort: item["backendPort"],
+        protocol: item["protocol"],
+        probePort: item["probePort"],
+        probeProtocol: item["probeProtocol"],
+        probeRequestPath: item["probeRequestPath"],
+        loadDistribution: item["loadDistribution"],
+    };
+}
+export function loadBalancingRuleDeserializer(item) {
+    return {
+        frontendPort: item["frontendPort"],
+        backendPort: item["backendPort"],
+        protocol: item["protocol"],
+        probePort: item["probePort"],
+        probeProtocol: item["probeProtocol"],
+        probeRequestPath: item["probeRequestPath"],
+        loadDistribution: item["loadDistribution"],
+    };
+}
+/** The reference to the transport protocol used by the load balancing rule. */
+export var KnownProtocol;
+(function (KnownProtocol) {
+    /** Transport protocol is TCP. */
+    KnownProtocol["Tcp"] = "tcp";
+    /** Transport protocol is UDP. */
+    KnownProtocol["Udp"] = "udp";
+})(KnownProtocol || (KnownProtocol = {}));
+/** The reference to the load balancer probe used by the load balancing rule. */
+export var KnownProbeProtocol;
+(function (KnownProbeProtocol) {
+    /** Probe protocol is TCP. */
+    KnownProbeProtocol["Tcp"] = "tcp";
+    /** Probe protocol is HTTP. */
+    KnownProbeProtocol["Http"] = "http";
+    /** Probe protocol is HTTPS. */
+    KnownProbeProtocol["Https"] = "https";
+})(KnownProbeProtocol || (KnownProbeProtocol = {}));
+export function networkSecurityRuleArraySerializer(result) {
+    return result.map((item) => {
+        return networkSecurityRuleSerializer(item);
+    });
+}
+export function networkSecurityRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return networkSecurityRuleDeserializer(item);
+    });
+}
+export function networkSecurityRuleSerializer(item) {
+    return {
+        name: item["name"],
+        description: item["description"],
+        protocol: item["protocol"],
+        sourceAddressPrefixes: !item["sourceAddressPrefixes"]
+            ? item["sourceAddressPrefixes"]
+            : item["sourceAddressPrefixes"].map((p) => {
+                return p;
+            }),
+        destinationAddressPrefixes: !item["destinationAddressPrefixes"]
+            ? item["destinationAddressPrefixes"]
+            : item["destinationAddressPrefixes"].map((p) => {
+                return p;
+            }),
+        sourcePortRanges: !item["sourcePortRanges"]
+            ? item["sourcePortRanges"]
+            : item["sourcePortRanges"].map((p) => {
+                return p;
+            }),
+        destinationPortRanges: !item["destinationPortRanges"]
+            ? item["destinationPortRanges"]
+            : item["destinationPortRanges"].map((p) => {
+                return p;
+            }),
+        sourceAddressPrefix: item["sourceAddressPrefix"],
+        destinationAddressPrefix: item["destinationAddressPrefix"],
+        sourcePortRange: item["sourcePortRange"],
+        destinationPortRange: item["destinationPortRange"],
+        access: item["access"],
+        priority: item["priority"],
+        direction: item["direction"],
+    };
+}
+export function networkSecurityRuleDeserializer(item) {
+    return {
+        name: item["name"],
+        description: item["description"],
+        protocol: item["protocol"],
+        sourceAddressPrefixes: !item["sourceAddressPrefixes"]
+            ? item["sourceAddressPrefixes"]
+            : item["sourceAddressPrefixes"].map((p) => {
+                return p;
+            }),
+        destinationAddressPrefixes: !item["destinationAddressPrefixes"]
+            ? item["destinationAddressPrefixes"]
+            : item["destinationAddressPrefixes"].map((p) => {
+                return p;
+            }),
+        sourcePortRanges: !item["sourcePortRanges"]
+            ? item["sourcePortRanges"]
+            : item["sourcePortRanges"].map((p) => {
+                return p;
+            }),
+        destinationPortRanges: !item["destinationPortRanges"]
+            ? item["destinationPortRanges"]
+            : item["destinationPortRanges"].map((p) => {
+                return p;
+            }),
+        sourceAddressPrefix: item["sourceAddressPrefix"],
+        destinationAddressPrefix: item["destinationAddressPrefix"],
+        sourcePortRange: item["sourcePortRange"],
+        destinationPortRange: item["destinationPortRange"],
+        access: item["access"],
+        priority: item["priority"],
+        direction: item["direction"],
+    };
+}
+/** Network protocol this rule applies to. */
+export var KnownNsgProtocol;
+(function (KnownNsgProtocol) {
+    /** Protocol applies to HTTP. */
+    KnownNsgProtocol["Http"] = "http";
+    /** Protocol applies to HTTPS. */
+    KnownNsgProtocol["Https"] = "https";
+    /** Protocol applies to TCP. */
+    KnownNsgProtocol["Tcp"] = "tcp";
+    /** Protocol applies to UDP. */
+    KnownNsgProtocol["Udp"] = "udp";
+    /** Protocol applies to ICMP. */
+    KnownNsgProtocol["Icmp"] = "icmp";
+    /** Protocol applies to AH. */
+    KnownNsgProtocol["Ah"] = "ah";
+    /** Protocol applies to ESP. */
+    KnownNsgProtocol["Esp"] = "esp";
+})(KnownNsgProtocol || (KnownNsgProtocol = {}));
+/** The network traffic is allowed or denied. */
+export var KnownAccess;
+(function (KnownAccess) {
+    /** The network traffic is allowed. */
+    KnownAccess["Allow"] = "allow";
+    /** The network traffic is denied. */
+    KnownAccess["Deny"] = "deny";
+})(KnownAccess || (KnownAccess = {}));
+/** Network security rule direction. */
+export var KnownDirection;
+(function (KnownDirection) {
+    /** Inbound direction. */
+    KnownDirection["Inbound"] = "inbound";
+    /** Outbound direction. */
+    KnownDirection["Outbound"] = "outbound";
+})(KnownDirection || (KnownDirection = {}));
+export function clientCertificateArraySerializer(result) {
+    return result.map((item) => {
+        return clientCertificateSerializer(item);
+    });
+}
+export function clientCertificateArrayDeserializer(result) {
+    return result.map((item) => {
+        return clientCertificateDeserializer(item);
+    });
+}
+export function clientCertificateSerializer(item) {
+    return {
+        isAdmin: item["isAdmin"],
+        thumbprint: item["thumbprint"],
+        commonName: item["commonName"],
+        issuerThumbprint: item["issuerThumbprint"],
+    };
+}
+export function clientCertificateDeserializer(item) {
+    return {
+        isAdmin: item["isAdmin"],
+        thumbprint: item["thumbprint"],
+        commonName: item["commonName"],
+        issuerThumbprint: item["issuerThumbprint"],
+    };
+}
+export function azureActiveDirectorySerializer(item) {
+    return {
+        tenantId: item["tenantId"],
+        clusterApplication: item["clusterApplication"],
+        clientApplication: item["clientApplication"],
+    };
+}
+export function azureActiveDirectoryDeserializer(item) {
+    return {
+        tenantId: item["tenantId"],
+        clusterApplication: item["clusterApplication"],
+        clientApplication: item["clientApplication"],
+    };
+}
+export function settingsSectionDescriptionArraySerializer(result) {
+    return result.map((item) => {
+        return settingsSectionDescriptionSerializer(item);
+    });
+}
+export function settingsSectionDescriptionArrayDeserializer(result) {
+    return result.map((item) => {
+        return settingsSectionDescriptionDeserializer(item);
+    });
+}
+export function settingsSectionDescriptionSerializer(item) {
+    return {
+        name: item["name"],
+        parameters: settingsParameterDescriptionArraySerializer(item["parameters"]),
+    };
+}
+export function settingsSectionDescriptionDeserializer(item) {
+    return {
+        name: item["name"],
+        parameters: settingsParameterDescriptionArrayDeserializer(item["parameters"]),
+    };
+}
+export function settingsParameterDescriptionArraySerializer(result) {
+    return result.map((item) => {
+        return settingsParameterDescriptionSerializer(item);
+    });
+}
+export function settingsParameterDescriptionArrayDeserializer(result) {
+    return result.map((item) => {
+        return settingsParameterDescriptionDeserializer(item);
+    });
+}
+export function settingsParameterDescriptionSerializer(item) {
+    return { name: item["name"], value: item["value"] };
+}
+export function settingsParameterDescriptionDeserializer(item) {
+    return {
+        name: item["name"],
+        value: item["value"],
+    };
+}
+/** The provisioning state of the managed resource. */
+export var KnownManagedResourceProvisioningState;
+(function (KnownManagedResourceProvisioningState) {
+    /** The resource does not have a provisioning state. */
+    KnownManagedResourceProvisioningState["None"] = "None";
+    /** The resource is being created. */
+    KnownManagedResourceProvisioningState["Creating"] = "Creating";
+    /** The resource is created. */
+    KnownManagedResourceProvisioningState["Created"] = "Created";
+    /** The resource is being updated. */
+    KnownManagedResourceProvisioningState["Updating"] = "Updating";
+    /** The resource provisioning has succeeded. */
+    KnownManagedResourceProvisioningState["Succeeded"] = "Succeeded";
+    /** The resource provisioning has failed. */
+    KnownManagedResourceProvisioningState["Failed"] = "Failed";
+    /** The resource provisioning has been canceled. */
+    KnownManagedResourceProvisioningState["Canceled"] = "Canceled";
+    /** The resource is being deleted. */
+    KnownManagedResourceProvisioningState["Deleting"] = "Deleting";
+    /** The resource has been deleted. */
+    KnownManagedResourceProvisioningState["Deleted"] = "Deleted";
+    /** The resource provisioning state is a state other than the previously specified states. */
+    KnownManagedResourceProvisioningState["Other"] = "Other";
+})(KnownManagedResourceProvisioningState || (KnownManagedResourceProvisioningState = {}));
+/** The upgrade mode of the cluster when new Service Fabric runtime version is available. */
+export var KnownClusterUpgradeMode;
+(function (KnownClusterUpgradeMode) {
+    /** The cluster will be automatically upgraded to the latest Service Fabric runtime version, **clusterUpgradeCadence** will determine when the upgrade starts after the new version becomes available. */
+    KnownClusterUpgradeMode["Automatic"] = "Automatic";
+    /** The cluster will not be automatically upgraded to the latest Service Fabric runtime version. The cluster is upgraded by setting the **clusterCodeVersion** property in the cluster resource. */
+    KnownClusterUpgradeMode["Manual"] = "Manual";
+})(KnownClusterUpgradeMode || (KnownClusterUpgradeMode = {}));
+/** Indicates when new cluster runtime version upgrades will be applied after they are released. By default is Wave0. */
+export var KnownClusterUpgradeCadence;
+(function (KnownClusterUpgradeCadence) {
+    /** Cluster upgrade starts immediately after a new version is rolled out. Recommended for Test/Dev clusters. */
+    KnownClusterUpgradeCadence["Wave0"] = "Wave0";
+    /** Cluster upgrade starts 7 days after a new version is rolled out. Recommended for Pre-prod clusters. */
+    KnownClusterUpgradeCadence["Wave1"] = "Wave1";
+    /** Cluster upgrade starts 14 days after a new version is rolled out. Recommended for Production clusters. */
+    KnownClusterUpgradeCadence["Wave2"] = "Wave2";
+})(KnownClusterUpgradeCadence || (KnownClusterUpgradeCadence = {}));
+/** Available cluster add-on features */
+export var KnownManagedClusterAddOnFeature;
+(function (KnownManagedClusterAddOnFeature) {
+    /** Dns service */
+    KnownManagedClusterAddOnFeature["DnsService"] = "DnsService";
+    /** Backup and restore service */
+    KnownManagedClusterAddOnFeature["BackupRestoreService"] = "BackupRestoreService";
+    /** Resource monitor service */
+    KnownManagedClusterAddOnFeature["ResourceMonitorService"] = "ResourceMonitorService";
+})(KnownManagedClusterAddOnFeature || (KnownManagedClusterAddOnFeature = {}));
+export function applicationTypeVersionsCleanupPolicySerializer(item) {
+    return { maxUnusedVersionsToKeep: item["maxUnusedVersionsToKeep"] };
+}
+export function applicationTypeVersionsCleanupPolicyDeserializer(item) {
+    return {
+        maxUnusedVersionsToKeep: item["maxUnusedVersionsToKeep"],
+    };
+}
+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 subnetArraySerializer(result) {
+    return result.map((item) => {
+        return subnetSerializer(item);
+    });
+}
+export function subnetArrayDeserializer(result) {
+    return result.map((item) => {
+        return subnetDeserializer(item);
+    });
+}
+export function subnetSerializer(item) {
+    return {
+        name: item["name"],
+        enableIpv6: item["enableIpv6"],
+        privateEndpointNetworkPolicies: item["privateEndpointNetworkPolicies"],
+        privateLinkServiceNetworkPolicies: item["privateLinkServiceNetworkPolicies"],
+        networkSecurityGroupId: item["networkSecurityGroupId"],
+    };
+}
+export function subnetDeserializer(item) {
+    return {
+        name: item["name"],
+        enableIpv6: item["enableIpv6"],
+        privateEndpointNetworkPolicies: item["privateEndpointNetworkPolicies"],
+        privateLinkServiceNetworkPolicies: item["privateLinkServiceNetworkPolicies"],
+        networkSecurityGroupId: item["networkSecurityGroupId"],
+    };
+}
+/** Enable or Disable apply network policies on private end point in the subnet. */
+export var KnownPrivateEndpointNetworkPolicies;
+(function (KnownPrivateEndpointNetworkPolicies) {
+    /** Enable apply network policies on private end point in the subnet. */
+    KnownPrivateEndpointNetworkPolicies["Enabled"] = "enabled";
+    /** Disable apply network policies on private end point in the subnet. */
+    KnownPrivateEndpointNetworkPolicies["Disabled"] = "disabled";
+})(KnownPrivateEndpointNetworkPolicies || (KnownPrivateEndpointNetworkPolicies = {}));
+/** Enable or Disable apply network policies on private link service in the subnet. */
+export var KnownPrivateLinkServiceNetworkPolicies;
+(function (KnownPrivateLinkServiceNetworkPolicies) {
+    /** Enable apply network policies on private link service in the subnet. */
+    KnownPrivateLinkServiceNetworkPolicies["Enabled"] = "enabled";
+    /** Disable apply network policies on private link service in the subnet. */
+    KnownPrivateLinkServiceNetworkPolicies["Disabled"] = "disabled";
+})(KnownPrivateLinkServiceNetworkPolicies || (KnownPrivateLinkServiceNetworkPolicies = {}));
+export function serviceEndpointArraySerializer(result) {
+    return result.map((item) => {
+        return serviceEndpointSerializer(item);
+    });
+}
+export function serviceEndpointArrayDeserializer(result) {
+    return result.map((item) => {
+        return serviceEndpointDeserializer(item);
+    });
+}
+export function serviceEndpointSerializer(item) {
+    return {
+        service: item["service"],
+        locations: !item["locations"]
+            ? item["locations"]
+            : item["locations"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function serviceEndpointDeserializer(item) {
+    return {
+        service: item["service"],
+        locations: !item["locations"]
+            ? item["locations"]
+            : item["locations"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** Indicates the update mode for Cross Az clusters. */
+export var KnownZonalUpdateMode;
+(function (KnownZonalUpdateMode) {
+    /** The cluster will use 5 upgrade domains for Cross Az Node types. */
+    KnownZonalUpdateMode["Standard"] = "Standard";
+    /** The cluster will use a maximum of 3 upgrade domains per zone instead of 5 for Cross Az Node types for faster deployments. */
+    KnownZonalUpdateMode["Fast"] = "Fast";
+})(KnownZonalUpdateMode || (KnownZonalUpdateMode = {}));
+export function clusterUpgradePolicySerializer(item) {
+    return {
+        forceRestart: item["forceRestart"],
+        healthPolicy: !item["healthPolicy"]
+            ? item["healthPolicy"]
+            : clusterHealthPolicySerializer(item["healthPolicy"]),
+        deltaHealthPolicy: !item["deltaHealthPolicy"]
+            ? item["deltaHealthPolicy"]
+            : clusterUpgradeDeltaHealthPolicySerializer(item["deltaHealthPolicy"]),
+        monitoringPolicy: !item["monitoringPolicy"]
+            ? item["monitoringPolicy"]
+            : clusterMonitoringPolicySerializer(item["monitoringPolicy"]),
+        upgradeReplicaSetCheckTimeout: item["upgradeReplicaSetCheckTimeout"],
+    };
+}
+export function clusterUpgradePolicyDeserializer(item) {
+    return {
+        forceRestart: item["forceRestart"],
+        healthPolicy: !item["healthPolicy"]
+            ? item["healthPolicy"]
+            : clusterHealthPolicyDeserializer(item["healthPolicy"]),
+        deltaHealthPolicy: !item["deltaHealthPolicy"]
+            ? item["deltaHealthPolicy"]
+            : clusterUpgradeDeltaHealthPolicyDeserializer(item["deltaHealthPolicy"]),
+        monitoringPolicy: !item["monitoringPolicy"]
+            ? item["monitoringPolicy"]
+            : clusterMonitoringPolicyDeserializer(item["monitoringPolicy"]),
+        upgradeReplicaSetCheckTimeout: item["upgradeReplicaSetCheckTimeout"],
+    };
+}
+export function clusterHealthPolicySerializer(item) {
+    return {
+        maxPercentUnhealthyNodes: item["maxPercentUnhealthyNodes"],
+        maxPercentUnhealthyApplications: item["maxPercentUnhealthyApplications"],
+    };
+}
+export function clusterHealthPolicyDeserializer(item) {
+    return {
+        maxPercentUnhealthyNodes: item["maxPercentUnhealthyNodes"],
+        maxPercentUnhealthyApplications: item["maxPercentUnhealthyApplications"],
+    };
+}
+export function clusterUpgradeDeltaHealthPolicySerializer(item) {
+    return {
+        maxPercentDeltaUnhealthyNodes: item["maxPercentDeltaUnhealthyNodes"],
+        maxPercentUpgradeDomainDeltaUnhealthyNodes: item["maxPercentUpgradeDomainDeltaUnhealthyNodes"],
+        maxPercentDeltaUnhealthyApplications: item["maxPercentDeltaUnhealthyApplications"],
+    };
+}
+export function clusterUpgradeDeltaHealthPolicyDeserializer(item) {
+    return {
+        maxPercentDeltaUnhealthyNodes: item["maxPercentDeltaUnhealthyNodes"],
+        maxPercentUpgradeDomainDeltaUnhealthyNodes: item["maxPercentUpgradeDomainDeltaUnhealthyNodes"],
+        maxPercentDeltaUnhealthyApplications: item["maxPercentDeltaUnhealthyApplications"],
+    };
+}
+export function clusterMonitoringPolicySerializer(item) {
+    return {
+        healthCheckWaitDuration: item["healthCheckWaitDuration"],
+        healthCheckStableDuration: item["healthCheckStableDuration"],
+        healthCheckRetryTimeout: item["healthCheckRetryTimeout"],
+        upgradeTimeout: item["upgradeTimeout"],
+        upgradeDomainTimeout: item["upgradeDomainTimeout"],
+    };
+}
+export function clusterMonitoringPolicyDeserializer(item) {
+    return {
+        healthCheckWaitDuration: item["healthCheckWaitDuration"],
+        healthCheckStableDuration: item["healthCheckStableDuration"],
+        healthCheckRetryTimeout: item["healthCheckRetryTimeout"],
+        upgradeTimeout: item["upgradeTimeout"],
+        upgradeDomainTimeout: item["upgradeDomainTimeout"],
+    };
+}
+/**
+ * This enum is the entrypoint to using a certificate from a public CA for your cluster. This property was introduced to solve the
+ * domain squatting problem with new domains. A domain name will be generated in the following format: {clustername}.{hash}.{regionname}.sfmcdomain.
+ * The hash portion comes from Azure DNS' Deterministic Name Library. The library creates a hash using the cluster's Tenant, Subscription, Resource Group
+ * and Resource Name using the AutoGeneratedDomainNameLabelScope/reuse policy chosen.
+ */
+export var KnownAutoGeneratedDomainNameLabelScope;
+(function (KnownAutoGeneratedDomainNameLabelScope) {
+    /** TenantReuse allows for the same hash to be created if the resource is created in the same Tenant with the same resource name. */
+    KnownAutoGeneratedDomainNameLabelScope["TenantReuse"] = "TenantReuse";
+    /** SubscriptionReuse allows for the same hash to be created if the resource is created in the same Subscription with the same resource name. */
+    KnownAutoGeneratedDomainNameLabelScope["SubscriptionReuse"] = "SubscriptionReuse";
+    /** ResourceGroupReuse allows for the same hash to be created if the resource is created in the same Resource Group with the same resource name. */
+    KnownAutoGeneratedDomainNameLabelScope["ResourceGroupReuse"] = "ResourceGroupReuse";
+    /** NoReuse will create a new hash regardless of the Subscription, Resource Group, Tenant and Resource name. */
+    KnownAutoGeneratedDomainNameLabelScope["NoReuse"] = "NoReuse";
+})(KnownAutoGeneratedDomainNameLabelScope || (KnownAutoGeneratedDomainNameLabelScope = {}));
+export function skuSerializer(item) {
+    return { name: item["name"] };
+}
+export function skuDeserializer(item) {
+    return {
+        name: item["name"],
+    };
+}
+/** Sku Name. */
+export var KnownSkuName;
+(function (KnownSkuName) {
+    /** Basic requires a minimum of 3 nodes and allows only 1 node type. */
+    KnownSkuName["Basic"] = "Basic";
+    /** Requires a minimum of 5 nodes and allows 1 or more node type. */
+    KnownSkuName["Standard"] = "Standard";
+})(KnownSkuName || (KnownSkuName = {}));
+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"],
+        location: item["location"],
+    };
+}
+export function managedClusterUpdateParametersSerializer(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 faultSimulationIdContentSerializer(item) {
+    return { simulationId: item["simulationId"] };
+}
+export function faultSimulationDeserializer(item) {
+    return {
+        simulationId: item["simulationId"],
+        status: item["status"],
+        startTime: !item["startTime"] ? item["startTime"] : new Date(item["startTime"]),
+        endTime: !item["endTime"] ? item["endTime"] : new Date(item["endTime"]),
+        details: !item["details"]
+            ? item["details"]
+            : faultSimulationDetailsDeserializer(item["details"]),
+    };
+}
+/** Fault simulation status. */
+export var KnownFaultSimulationStatus;
+(function (KnownFaultSimulationStatus) {
+    /** Indicates the fault simulation is starting. The simulation will have this status while the start operation is in progress. */
+    KnownFaultSimulationStatus["Starting"] = "Starting";
+    /** Indicates the fault simulation is active. The simulation will have this status after the start operation has completed successfully. */
+    KnownFaultSimulationStatus["Active"] = "Active";
+    /** Indicates the fault simulation is stopping. The simulation will have this status while the stop operation is in progress. */
+    KnownFaultSimulationStatus["Stopping"] = "Stopping";
+    /** Indicates the fault simulation is done. The simulation will have this status after the stop operation has completed successfully. */
+    KnownFaultSimulationStatus["Done"] = "Done";
+    /** Indicates the fault simulation has failed on start. The simulation will have this status after the start operation fails. */
+    KnownFaultSimulationStatus["StartFailed"] = "StartFailed";
+    /** Indicates the fault simulation has failed on stop. The simulation will have this status after the stop operation fails. */
+    KnownFaultSimulationStatus["StopFailed"] = "StopFailed";
+})(KnownFaultSimulationStatus || (KnownFaultSimulationStatus = {}));
+export function faultSimulationDetailsDeserializer(item) {
+    return {
+        clusterId: item["clusterId"],
+        operationId: item["operationId"],
+        nodeTypeFaultSimulation: !item["nodeTypeFaultSimulation"]
+            ? item["nodeTypeFaultSimulation"]
+            : nodeTypeFaultSimulationArrayDeserializer(item["nodeTypeFaultSimulation"]),
+        parameters: !item["parameters"]
+            ? item["parameters"]
+            : faultSimulationContentUnionDeserializer(item["parameters"]),
+    };
+}
+export function nodeTypeFaultSimulationArrayDeserializer(result) {
+    return result.map((item) => {
+        return nodeTypeFaultSimulationDeserializer(item);
+    });
+}
+export function nodeTypeFaultSimulationDeserializer(item) {
+    return {
+        nodeTypeName: item["nodeTypeName"],
+        status: item["status"],
+        operationId: item["operationId"],
+        operationStatus: item["operationStatus"],
+    };
+}
+/** Sfmc operation status. */
+export var KnownSfmcOperationStatus;
+(function (KnownSfmcOperationStatus) {
+    /** Operation created. */
+    KnownSfmcOperationStatus["Created"] = "Created";
+    /** Operation started. */
+    KnownSfmcOperationStatus["Started"] = "Started";
+    /** Operation succeeded. */
+    KnownSfmcOperationStatus["Succeeded"] = "Succeeded";
+    /** Operation failed. */
+    KnownSfmcOperationStatus["Failed"] = "Failed";
+    /** Operation aborted. */
+    KnownSfmcOperationStatus["Aborted"] = "Aborted";
+    /** Operation canceled. */
+    KnownSfmcOperationStatus["Canceled"] = "Canceled";
+})(KnownSfmcOperationStatus || (KnownSfmcOperationStatus = {}));
+export function faultSimulationContentSerializer(item) {
+    return {
+        faultKind: item["faultKind"],
+        force: item["force"],
+        constraints: !item["constraints"]
+            ? item["constraints"]
+            : faultSimulationConstraintsSerializer(item["constraints"]),
+    };
+}
+export function faultSimulationContentDeserializer(item) {
+    return {
+        faultKind: item["faultKind"],
+        force: item["force"],
+        constraints: !item["constraints"]
+            ? item["constraints"]
+            : faultSimulationConstraintsDeserializer(item["constraints"]),
+    };
+}
+export function faultSimulationContentUnionSerializer(item) {
+    switch (item.faultKind) {
+        case "Zone":
+            return zoneFaultSimulationContentSerializer(item);
+        default:
+            return faultSimulationContentSerializer(item);
+    }
+}
+export function faultSimulationContentUnionDeserializer(item) {
+    switch (item.faultKind) {
+        case "Zone":
+            return zoneFaultSimulationContentDeserializer(item);
+        default:
+            return faultSimulationContentDeserializer(item);
+    }
+}
+/** The kind of fault simulation. */
+export var KnownFaultKind;
+(function (KnownFaultKind) {
+    /** Simulates an availability zone down. */
+    KnownFaultKind["Zone"] = "Zone";
+})(KnownFaultKind || (KnownFaultKind = {}));
+export function faultSimulationConstraintsSerializer(item) {
+    return {
+        expirationTime: !item["expirationTime"]
+            ? item["expirationTime"]
+            : item["expirationTime"].toISOString(),
+    };
+}
+export function faultSimulationConstraintsDeserializer(item) {
+    return {
+        expirationTime: !item["expirationTime"]
+            ? item["expirationTime"]
+            : new Date(item["expirationTime"]),
+    };
+}
+export function zoneFaultSimulationContentSerializer(item) {
+    return {
+        faultKind: item["faultKind"],
+        force: item["force"],
+        constraints: !item["constraints"]
+            ? item["constraints"]
+            : faultSimulationConstraintsSerializer(item["constraints"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function zoneFaultSimulationContentDeserializer(item) {
+    return {
+        faultKind: item["faultKind"],
+        force: item["force"],
+        constraints: !item["constraints"]
+            ? item["constraints"]
+            : faultSimulationConstraintsDeserializer(item["constraints"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _faultSimulationListResultDeserializer(item) {
+    return {
+        value: faultSimulationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function faultSimulationArrayDeserializer(result) {
+    return result.map((item) => {
+        return faultSimulationDeserializer(item);
+    });
+}
+export function faultSimulationContentWrapperSerializer(item) {
+    return {
+        parameters: faultSimulationContentUnionSerializer(item["parameters"]),
+    };
+}
+export function managedAzResiliencyStatusDeserializer(item) {
+    return {
+        baseResourceStatus: !item["baseResourceStatus"]
+            ? item["baseResourceStatus"]
+            : resourceAzStatusArrayDeserializer(item["baseResourceStatus"]),
+        isClusterZoneResilient: item["isClusterZoneResilient"],
+    };
+}
+export function resourceAzStatusArrayDeserializer(result) {
+    return result.map((item) => {
+        return resourceAzStatusDeserializer(item);
+    });
+}
+export function resourceAzStatusDeserializer(item) {
+    return {
+        resourceName: item["resourceName"],
+        resourceType: item["resourceType"],
+        isZoneResilient: item["isZoneResilient"],
+        details: item["details"],
+    };
+}
+export function managedMaintenanceWindowStatusDeserializer(item) {
+    return {
+        isWindowEnabled: item["isWindowEnabled"],
+        isRegionReady: item["isRegionReady"],
+        isWindowActive: item["isWindowActive"],
+        canApplyUpdates: item["canApplyUpdates"],
+        lastWindowStatusUpdateAtUTC: !item["lastWindowStatusUpdateAtUTC"]
+            ? item["lastWindowStatusUpdateAtUTC"]
+            : new Date(item["lastWindowStatusUpdateAtUTC"]),
+        lastWindowStartTimeUTC: !item["lastWindowStartTimeUTC"]
+            ? item["lastWindowStartTimeUTC"]
+            : new Date(item["lastWindowStartTimeUTC"]),
+        lastWindowEndTimeUTC: !item["lastWindowEndTimeUTC"]
+            ? item["lastWindowEndTimeUTC"]
+            : new Date(item["lastWindowEndTimeUTC"]),
+    };
+}
+export function nodeTypeSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : nodeTypePropertiesSerializer(item["properties"]),
+        tags: item["tags"],
+        sku: !item["sku"] ? item["sku"] : nodeTypeSkuSerializer(item["sku"]),
+    };
+}
+export function nodeTypeDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : nodeTypePropertiesDeserializer(item["properties"]),
+        tags: item["tags"],
+        sku: !item["sku"] ? item["sku"] : nodeTypeSkuDeserializer(item["sku"]),
+    };
+}
+export function nodeTypePropertiesSerializer(item) {
+    return {
+        isPrimary: item["isPrimary"],
+        vmInstanceCount: item["vmInstanceCount"],
+        dataDiskSizeGB: item["dataDiskSizeGB"],
+        dataDiskType: item["dataDiskType"],
+        dataDiskLetter: item["dataDiskLetter"],
+        placementProperties: item["placementProperties"],
+        capacities: item["capacities"],
+        applicationPorts: !item["applicationPorts"]
+            ? item["applicationPorts"]
+            : endpointRangeDescriptionSerializer(item["applicationPorts"]),
+        ephemeralPorts: !item["ephemeralPorts"]
+            ? item["ephemeralPorts"]
+            : endpointRangeDescriptionSerializer(item["ephemeralPorts"]),
+        vmSize: item["vmSize"],
+        vmImagePublisher: item["vmImagePublisher"],
+        vmImageOffer: item["vmImageOffer"],
+        vmImageSku: item["vmImageSku"],
+        vmImageVersion: item["vmImageVersion"],
+        vmSecrets: !item["vmSecrets"]
+            ? item["vmSecrets"]
+            : vaultSecretGroupArraySerializer(item["vmSecrets"]),
+        vmExtensions: !item["vmExtensions"]
+            ? item["vmExtensions"]
+            : vmssExtensionArraySerializer(item["vmExtensions"]),
+        vmManagedIdentity: !item["vmManagedIdentity"]
+            ? item["vmManagedIdentity"]
+            : vmManagedIdentitySerializer(item["vmManagedIdentity"]),
+        isStateless: item["isStateless"],
+        multiplePlacementGroups: item["multiplePlacementGroups"],
+        frontendConfigurations: !item["frontendConfigurations"]
+            ? item["frontendConfigurations"]
+            : frontendConfigurationArraySerializer(item["frontendConfigurations"]),
+        networkSecurityRules: !item["networkSecurityRules"]
+            ? item["networkSecurityRules"]
+            : networkSecurityRuleArraySerializer(item["networkSecurityRules"]),
+        additionalDataDisks: !item["additionalDataDisks"]
+            ? item["additionalDataDisks"]
+            : vmssDataDiskArraySerializer(item["additionalDataDisks"]),
+        enableEncryptionAtHost: item["enableEncryptionAtHost"],
+        enableAcceleratedNetworking: item["enableAcceleratedNetworking"],
+        useDefaultPublicLoadBalancer: item["useDefaultPublicLoadBalancer"],
+        useTempDataDisk: item["useTempDataDisk"],
+        enableOverProvisioning: item["enableOverProvisioning"],
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+        isSpotVM: item["isSpotVM"],
+        hostGroupId: item["hostGroupId"],
+        useEphemeralOSDisk: item["useEphemeralOSDisk"],
+        spotRestoreTimeout: item["spotRestoreTimeout"],
+        evictionPolicy: item["evictionPolicy"],
+        vmImageResourceId: item["vmImageResourceId"],
+        subnetId: item["subnetId"],
+        vmSetupActions: !item["vmSetupActions"]
+            ? item["vmSetupActions"]
+            : item["vmSetupActions"].map((p) => {
+                return p;
+            }),
+        securityType: item["securityType"],
+        securityEncryptionType: item["securityEncryptionType"],
+        secureBootEnabled: item["secureBootEnabled"],
+        enableNodePublicIP: item["enableNodePublicIP"],
+        enableNodePublicIPv6: item["enableNodePublicIPv6"],
+        vmSharedGalleryImageId: item["vmSharedGalleryImageId"],
+        natGatewayId: item["natGatewayId"],
+        natConfigurations: !item["natConfigurations"]
+            ? item["natConfigurations"]
+            : nodeTypeNatConfigArraySerializer(item["natConfigurations"]),
+        vmImagePlan: !item["vmImagePlan"]
+            ? item["vmImagePlan"]
+            : vmImagePlanSerializer(item["vmImagePlan"]),
+        serviceArtifactReferenceId: item["serviceArtifactReferenceId"],
+        dscpConfigurationId: item["dscpConfigurationId"],
+        additionalNetworkInterfaceConfigurations: !item["additionalNetworkInterfaceConfigurations"]
+            ? item["additionalNetworkInterfaceConfigurations"]
+            : additionalNetworkInterfaceConfigurationArraySerializer(item["additionalNetworkInterfaceConfigurations"]),
+        computerNamePrefix: item["computerNamePrefix"],
+        vmApplications: !item["vmApplications"]
+            ? item["vmApplications"]
+            : vmApplicationArraySerializer(item["vmApplications"]),
+        zoneBalance: item["zoneBalance"],
+    };
+}
+export function nodeTypePropertiesDeserializer(item) {
+    return {
+        isPrimary: item["isPrimary"],
+        vmInstanceCount: item["vmInstanceCount"],
+        dataDiskSizeGB: item["dataDiskSizeGB"],
+        dataDiskType: item["dataDiskType"],
+        dataDiskLetter: item["dataDiskLetter"],
+        placementProperties: item["placementProperties"],
+        capacities: item["capacities"],
+        applicationPorts: !item["applicationPorts"]
+            ? item["applicationPorts"]
+            : endpointRangeDescriptionDeserializer(item["applicationPorts"]),
+        ephemeralPorts: !item["ephemeralPorts"]
+            ? item["ephemeralPorts"]
+            : endpointRangeDescriptionDeserializer(item["ephemeralPorts"]),
+        vmSize: item["vmSize"],
+        vmImagePublisher: item["vmImagePublisher"],
+        vmImageOffer: item["vmImageOffer"],
+        vmImageSku: item["vmImageSku"],
+        vmImageVersion: item["vmImageVersion"],
+        vmSecrets: !item["vmSecrets"]
+            ? item["vmSecrets"]
+            : vaultSecretGroupArrayDeserializer(item["vmSecrets"]),
+        vmExtensions: !item["vmExtensions"]
+            ? item["vmExtensions"]
+            : vmssExtensionArrayDeserializer(item["vmExtensions"]),
+        vmManagedIdentity: !item["vmManagedIdentity"]
+            ? item["vmManagedIdentity"]
+            : vmManagedIdentityDeserializer(item["vmManagedIdentity"]),
+        isStateless: item["isStateless"],
+        multiplePlacementGroups: item["multiplePlacementGroups"],
+        frontendConfigurations: !item["frontendConfigurations"]
+            ? item["frontendConfigurations"]
+            : frontendConfigurationArrayDeserializer(item["frontendConfigurations"]),
+        networkSecurityRules: !item["networkSecurityRules"]
+            ? item["networkSecurityRules"]
+            : networkSecurityRuleArrayDeserializer(item["networkSecurityRules"]),
+        additionalDataDisks: !item["additionalDataDisks"]
+            ? item["additionalDataDisks"]
+            : vmssDataDiskArrayDeserializer(item["additionalDataDisks"]),
+        enableEncryptionAtHost: item["enableEncryptionAtHost"],
+        provisioningState: item["provisioningState"],
+        enableAcceleratedNetworking: item["enableAcceleratedNetworking"],
+        useDefaultPublicLoadBalancer: item["useDefaultPublicLoadBalancer"],
+        useTempDataDisk: item["useTempDataDisk"],
+        enableOverProvisioning: item["enableOverProvisioning"],
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+        isSpotVM: item["isSpotVM"],
+        hostGroupId: item["hostGroupId"],
+        useEphemeralOSDisk: item["useEphemeralOSDisk"],
+        spotRestoreTimeout: item["spotRestoreTimeout"],
+        evictionPolicy: item["evictionPolicy"],
+        vmImageResourceId: item["vmImageResourceId"],
+        subnetId: item["subnetId"],
+        vmSetupActions: !item["vmSetupActions"]
+            ? item["vmSetupActions"]
+            : item["vmSetupActions"].map((p) => {
+                return p;
+            }),
+        securityType: item["securityType"],
+        securityEncryptionType: item["securityEncryptionType"],
+        secureBootEnabled: item["secureBootEnabled"],
+        enableNodePublicIP: item["enableNodePublicIP"],
+        enableNodePublicIPv6: item["enableNodePublicIPv6"],
+        vmSharedGalleryImageId: item["vmSharedGalleryImageId"],
+        natGatewayId: item["natGatewayId"],
+        natConfigurations: !item["natConfigurations"]
+            ? item["natConfigurations"]
+            : nodeTypeNatConfigArrayDeserializer(item["natConfigurations"]),
+        vmImagePlan: !item["vmImagePlan"]
+            ? item["vmImagePlan"]
+            : vmImagePlanDeserializer(item["vmImagePlan"]),
+        serviceArtifactReferenceId: item["serviceArtifactReferenceId"],
+        dscpConfigurationId: item["dscpConfigurationId"],
+        additionalNetworkInterfaceConfigurations: !item["additionalNetworkInterfaceConfigurations"]
+            ? item["additionalNetworkInterfaceConfigurations"]
+            : additionalNetworkInterfaceConfigurationArrayDeserializer(item["additionalNetworkInterfaceConfigurations"]),
+        computerNamePrefix: item["computerNamePrefix"],
+        vmApplications: !item["vmApplications"]
+            ? item["vmApplications"]
+            : vmApplicationArrayDeserializer(item["vmApplications"]),
+        zoneBalance: item["zoneBalance"],
+    };
+}
+/** Managed data disk type. IOPS and throughput are given by the disk size, to see more information go to https://docs.microsoft.com/en-us/azure/virtual-machines/disks-types. */
+export var KnownDiskType;
+(function (KnownDiskType) {
+    /** Standard HDD locally redundant storage. Best for backup, non-critical, and infrequent access. */
+    KnownDiskType["StandardLRS"] = "Standard_LRS";
+    /** Standard SSD locally redundant storage. Best for web servers, lightly used enterprise applications and dev/test. */
+    KnownDiskType["StandardSSDLRS"] = "StandardSSD_LRS";
+    /** Premium SSD locally redundant storage. Best for production and performance sensitive workloads. */
+    KnownDiskType["PremiumLRS"] = "Premium_LRS";
+    /** Premium SSD V2 locally redundant storage. Best for production and performance sensitive workloads that consistently require low latency and high IOPS and throughput. */
+    KnownDiskType["PremiumV2LRS"] = "PremiumV2_LRS";
+    /** Standard SSD zone redundant storage. Best for web servers, lightly used enterprise applications and dev/test that need storage resiliency against zone failures. */
+    KnownDiskType["StandardSSDZRS"] = "StandardSSD_ZRS";
+    /** Premium SSD zone redundant storage. Best for production workloads that need storage resiliency against zone failures. */
+    KnownDiskType["PremiumZRS"] = "Premium_ZRS";
+})(KnownDiskType || (KnownDiskType = {}));
+export function endpointRangeDescriptionSerializer(item) {
+    return { startPort: item["startPort"], endPort: item["endPort"] };
+}
+export function endpointRangeDescriptionDeserializer(item) {
+    return {
+        startPort: item["startPort"],
+        endPort: item["endPort"],
+    };
+}
+export function vaultSecretGroupArraySerializer(result) {
+    return result.map((item) => {
+        return vaultSecretGroupSerializer(item);
+    });
+}
+export function vaultSecretGroupArrayDeserializer(result) {
+    return result.map((item) => {
+        return vaultSecretGroupDeserializer(item);
+    });
+}
+export function vaultSecretGroupSerializer(item) {
+    return {
+        sourceVault: subResourceSerializer(item["sourceVault"]),
+        vaultCertificates: vaultCertificateArraySerializer(item["vaultCertificates"]),
+    };
+}
+export function vaultSecretGroupDeserializer(item) {
+    return {
+        sourceVault: subResourceDeserializer(item["sourceVault"]),
+        vaultCertificates: vaultCertificateArrayDeserializer(item["vaultCertificates"]),
+    };
+}
+export function subResourceSerializer(item) {
+    return { id: item["id"] };
+}
+export function subResourceDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function vaultCertificateArraySerializer(result) {
+    return result.map((item) => {
+        return vaultCertificateSerializer(item);
+    });
+}
+export function vaultCertificateArrayDeserializer(result) {
+    return result.map((item) => {
+        return vaultCertificateDeserializer(item);
+    });
+}
+export function vaultCertificateSerializer(item) {
+    return {
+        certificateUrl: item["certificateUrl"],
+        certificateStore: item["certificateStore"],
+    };
+}
+export function vaultCertificateDeserializer(item) {
+    return {
+        certificateUrl: item["certificateUrl"],
+        certificateStore: item["certificateStore"],
+    };
+}
+export function vmssExtensionArraySerializer(result) {
+    return result.map((item) => {
+        return vmssExtensionSerializer(item);
+    });
+}
+export function vmssExtensionArrayDeserializer(result) {
+    return result.map((item) => {
+        return vmssExtensionDeserializer(item);
+    });
+}
+export function vmssExtensionSerializer(item) {
+    return {
+        name: item["name"],
+        properties: vmssExtensionPropertiesSerializer(item["properties"]),
+    };
+}
+export function vmssExtensionDeserializer(item) {
+    return {
+        name: item["name"],
+        properties: vmssExtensionPropertiesDeserializer(item["properties"]),
+    };
+}
+export function vmssExtensionPropertiesSerializer(item) {
+    return {
+        publisher: item["publisher"],
+        type: item["type"],
+        typeHandlerVersion: item["typeHandlerVersion"],
+        autoUpgradeMinorVersion: item["autoUpgradeMinorVersion"],
+        settings: item["settings"],
+        protectedSettings: item["protectedSettings"],
+        forceUpdateTag: item["forceUpdateTag"],
+        provisionAfterExtensions: !item["provisionAfterExtensions"]
+            ? item["provisionAfterExtensions"]
+            : item["provisionAfterExtensions"].map((p) => {
+                return p;
+            }),
+        enableAutomaticUpgrade: item["enableAutomaticUpgrade"],
+        setupOrder: !item["setupOrder"]
+            ? item["setupOrder"]
+            : item["setupOrder"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function vmssExtensionPropertiesDeserializer(item) {
+    return {
+        publisher: item["publisher"],
+        type: item["type"],
+        typeHandlerVersion: item["typeHandlerVersion"],
+        autoUpgradeMinorVersion: item["autoUpgradeMinorVersion"],
+        settings: item["settings"],
+        protectedSettings: item["protectedSettings"],
+        forceUpdateTag: item["forceUpdateTag"],
+        provisionAfterExtensions: !item["provisionAfterExtensions"]
+            ? item["provisionAfterExtensions"]
+            : item["provisionAfterExtensions"].map((p) => {
+                return p;
+            }),
+        provisioningState: item["provisioningState"],
+        enableAutomaticUpgrade: item["enableAutomaticUpgrade"],
+        setupOrder: !item["setupOrder"]
+            ? item["setupOrder"]
+            : item["setupOrder"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** Vm extension setup order. */
+export var KnownVmssExtensionSetupOrder;
+(function (KnownVmssExtensionSetupOrder) {
+    /** Indicates that the vm extension should run before the service fabric runtime starts. */
+    KnownVmssExtensionSetupOrder["BeforeSFRuntime"] = "BeforeSFRuntime";
+})(KnownVmssExtensionSetupOrder || (KnownVmssExtensionSetupOrder = {}));
+export function vmManagedIdentitySerializer(item) {
+    return {
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : item["userAssignedIdentities"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function vmManagedIdentityDeserializer(item) {
+    return {
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : item["userAssignedIdentities"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function frontendConfigurationArraySerializer(result) {
+    return result.map((item) => {
+        return frontendConfigurationSerializer(item);
+    });
+}
+export function frontendConfigurationArrayDeserializer(result) {
+    return result.map((item) => {
+        return frontendConfigurationDeserializer(item);
+    });
+}
+export function frontendConfigurationSerializer(item) {
+    return {
+        ipAddressType: item["ipAddressType"],
+        loadBalancerBackendAddressPoolId: item["loadBalancerBackendAddressPoolId"],
+        loadBalancerInboundNatPoolId: item["loadBalancerInboundNatPoolId"],
+        applicationGatewayBackendAddressPoolId: item["applicationGatewayBackendAddressPoolId"],
+    };
+}
+export function frontendConfigurationDeserializer(item) {
+    return {
+        ipAddressType: item["ipAddressType"],
+        loadBalancerBackendAddressPoolId: item["loadBalancerBackendAddressPoolId"],
+        loadBalancerInboundNatPoolId: item["loadBalancerInboundNatPoolId"],
+        applicationGatewayBackendAddressPoolId: item["applicationGatewayBackendAddressPoolId"],
+    };
+}
+/** The IP address type. */
+export var KnownIPAddressType;
+(function (KnownIPAddressType) {
+    /** IPv4 address type. */
+    KnownIPAddressType["IPv4"] = "IPv4";
+    /** IPv6 address type. */
+    KnownIPAddressType["IPv6"] = "IPv6";
+})(KnownIPAddressType || (KnownIPAddressType = {}));
+export function vmssDataDiskArraySerializer(result) {
+    return result.map((item) => {
+        return vmssDataDiskSerializer(item);
+    });
+}
+export function vmssDataDiskArrayDeserializer(result) {
+    return result.map((item) => {
+        return vmssDataDiskDeserializer(item);
+    });
+}
+export function vmssDataDiskSerializer(item) {
+    return {
+        lun: item["lun"],
+        diskSizeGB: item["diskSizeGB"],
+        diskType: item["diskType"],
+        diskLetter: item["diskLetter"],
+    };
+}
+export function vmssDataDiskDeserializer(item) {
+    return {
+        lun: item["lun"],
+        diskSizeGB: item["diskSizeGB"],
+        diskType: item["diskType"],
+        diskLetter: item["diskLetter"],
+    };
+}
+/** Specifies the eviction policy for virtual machines in a SPOT node type. */
+export var KnownEvictionPolicyType;
+(function (KnownEvictionPolicyType) {
+    /** Eviction policy will be Delete for SPOT vms. */
+    KnownEvictionPolicyType["Delete"] = "Delete";
+    /** Eviction policy will be Deallocate for SPOT vms. */
+    KnownEvictionPolicyType["Deallocate"] = "Deallocate";
+})(KnownEvictionPolicyType || (KnownEvictionPolicyType = {}));
+/** action to be performed on the vms before bootstrapping the service fabric runtime. */
+export var KnownVmSetupAction;
+(function (KnownVmSetupAction) {
+    /** Enable windows containers feature. */
+    KnownVmSetupAction["EnableContainers"] = "EnableContainers";
+    /** Enables windows HyperV feature. */
+    KnownVmSetupAction["EnableHyperV"] = "EnableHyperV";
+})(KnownVmSetupAction || (KnownVmSetupAction = {}));
+/** Specifies the security type of the nodeType. Only Standard and TrustedLaunch are currently supported */
+export var KnownSecurityType;
+(function (KnownSecurityType) {
+    /** Trusted Launch is a security type that secures generation 2 virtual machines. */
+    KnownSecurityType["TrustedLaunch"] = "TrustedLaunch";
+    /** Standard is the default security type for all machines. */
+    KnownSecurityType["Standard"] = "Standard";
+    /** ConfidentialVM provides hardware-based encryption, trusted execution environment (TEE) and isolation of the VM memory & CPU from host. */
+    KnownSecurityType["ConfidentialVM"] = "ConfidentialVM";
+})(KnownSecurityType || (KnownSecurityType = {}));
+/** Specifies the securityEncryptionType type of the nodeType. Only DiskWithVMGuestState and VMGuestStateOnly are currently supported */
+export var KnownSecurityEncryptionType;
+(function (KnownSecurityEncryptionType) {
+    /** For encryption of the managed disk along with VMGuestState blob. */
+    KnownSecurityEncryptionType["DiskWithVMGuestState"] = "DiskWithVMGuestState";
+    /** For encryption of just the VMGuestState blob. */
+    KnownSecurityEncryptionType["VMGuestStateOnly"] = "VMGuestStateOnly";
+})(KnownSecurityEncryptionType || (KnownSecurityEncryptionType = {}));
+export function nodeTypeNatConfigArraySerializer(result) {
+    return result.map((item) => {
+        return nodeTypeNatConfigSerializer(item);
+    });
+}
+export function nodeTypeNatConfigArrayDeserializer(result) {
+    return result.map((item) => {
+        return nodeTypeNatConfigDeserializer(item);
+    });
+}
+export function nodeTypeNatConfigSerializer(item) {
+    return {
+        backendPort: item["backendPort"],
+        frontendPortRangeStart: item["frontendPortRangeStart"],
+        frontendPortRangeEnd: item["frontendPortRangeEnd"],
+    };
+}
+export function nodeTypeNatConfigDeserializer(item) {
+    return {
+        backendPort: item["backendPort"],
+        frontendPortRangeStart: item["frontendPortRangeStart"],
+        frontendPortRangeEnd: item["frontendPortRangeEnd"],
+    };
+}
+export function vmImagePlanSerializer(item) {
+    return {
+        name: item["name"],
+        product: item["product"],
+        promotionCode: item["promotionCode"],
+        publisher: item["publisher"],
+    };
+}
+export function vmImagePlanDeserializer(item) {
+    return {
+        name: item["name"],
+        product: item["product"],
+        promotionCode: item["promotionCode"],
+        publisher: item["publisher"],
+    };
+}
+export function additionalNetworkInterfaceConfigurationArraySerializer(result) {
+    return result.map((item) => {
+        return additionalNetworkInterfaceConfigurationSerializer(item);
+    });
+}
+export function additionalNetworkInterfaceConfigurationArrayDeserializer(result) {
+    return result.map((item) => {
+        return additionalNetworkInterfaceConfigurationDeserializer(item);
+    });
+}
+export function additionalNetworkInterfaceConfigurationSerializer(item) {
+    return {
+        name: item["name"],
+        enableAcceleratedNetworking: item["enableAcceleratedNetworking"],
+        dscpConfiguration: !item["dscpConfiguration"]
+            ? item["dscpConfiguration"]
+            : subResourceSerializer(item["dscpConfiguration"]),
+        ipConfigurations: ipConfigurationArraySerializer(item["ipConfigurations"]),
+    };
+}
+export function additionalNetworkInterfaceConfigurationDeserializer(item) {
+    return {
+        name: item["name"],
+        enableAcceleratedNetworking: item["enableAcceleratedNetworking"],
+        dscpConfiguration: !item["dscpConfiguration"]
+            ? item["dscpConfiguration"]
+            : subResourceDeserializer(item["dscpConfiguration"]),
+        ipConfigurations: ipConfigurationArrayDeserializer(item["ipConfigurations"]),
+    };
+}
+export function ipConfigurationArraySerializer(result) {
+    return result.map((item) => {
+        return ipConfigurationSerializer(item);
+    });
+}
+export function ipConfigurationArrayDeserializer(result) {
+    return result.map((item) => {
+        return ipConfigurationDeserializer(item);
+    });
+}
+export function ipConfigurationSerializer(item) {
+    return {
+        name: item["name"],
+        applicationGatewayBackendAddressPools: !item["applicationGatewayBackendAddressPools"]
+            ? item["applicationGatewayBackendAddressPools"]
+            : subResourceArraySerializer(item["applicationGatewayBackendAddressPools"]),
+        loadBalancerBackendAddressPools: !item["loadBalancerBackendAddressPools"]
+            ? item["loadBalancerBackendAddressPools"]
+            : subResourceArraySerializer(item["loadBalancerBackendAddressPools"]),
+        loadBalancerInboundNatPools: !item["loadBalancerInboundNatPools"]
+            ? item["loadBalancerInboundNatPools"]
+            : subResourceArraySerializer(item["loadBalancerInboundNatPools"]),
+        subnet: !item["subnet"] ? item["subnet"] : subResourceSerializer(item["subnet"]),
+        privateIPAddressVersion: item["privateIPAddressVersion"],
+        publicIPAddressConfiguration: !item["publicIPAddressConfiguration"]
+            ? item["publicIPAddressConfiguration"]
+            : ipConfigurationPublicIPAddressConfigurationSerializer(item["publicIPAddressConfiguration"]),
+    };
+}
+export function ipConfigurationDeserializer(item) {
+    return {
+        name: item["name"],
+        applicationGatewayBackendAddressPools: !item["applicationGatewayBackendAddressPools"]
+            ? item["applicationGatewayBackendAddressPools"]
+            : subResourceArrayDeserializer(item["applicationGatewayBackendAddressPools"]),
+        loadBalancerBackendAddressPools: !item["loadBalancerBackendAddressPools"]
+            ? item["loadBalancerBackendAddressPools"]
+            : subResourceArrayDeserializer(item["loadBalancerBackendAddressPools"]),
+        loadBalancerInboundNatPools: !item["loadBalancerInboundNatPools"]
+            ? item["loadBalancerInboundNatPools"]
+            : subResourceArrayDeserializer(item["loadBalancerInboundNatPools"]),
+        subnet: !item["subnet"] ? item["subnet"] : subResourceDeserializer(item["subnet"]),
+        privateIPAddressVersion: item["privateIPAddressVersion"],
+        publicIPAddressConfiguration: !item["publicIPAddressConfiguration"]
+            ? item["publicIPAddressConfiguration"]
+            : ipConfigurationPublicIPAddressConfigurationDeserializer(item["publicIPAddressConfiguration"]),
+    };
+}
+export function subResourceArraySerializer(result) {
+    return result.map((item) => {
+        return subResourceSerializer(item);
+    });
+}
+export function subResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return subResourceDeserializer(item);
+    });
+}
+/** Specifies whether the IP configuration's private IP is IPv4 or IPv6. Default is IPv4. */
+export var KnownPrivateIPAddressVersion;
+(function (KnownPrivateIPAddressVersion) {
+    /** The IP configuration's private IP is IPv4. */
+    KnownPrivateIPAddressVersion["IPv4"] = "IPv4";
+    /** The IP configuration's private IP is IPv6. */
+    KnownPrivateIPAddressVersion["IPv6"] = "IPv6";
+})(KnownPrivateIPAddressVersion || (KnownPrivateIPAddressVersion = {}));
+export function ipConfigurationPublicIPAddressConfigurationSerializer(item) {
+    return {
+        name: item["name"],
+        ipTags: !item["ipTags"] ? item["ipTags"] : ipTagArraySerializer(item["ipTags"]),
+        publicIPAddressVersion: item["publicIPAddressVersion"],
+    };
+}
+export function ipConfigurationPublicIPAddressConfigurationDeserializer(item) {
+    return {
+        name: item["name"],
+        ipTags: !item["ipTags"] ? item["ipTags"] : ipTagArrayDeserializer(item["ipTags"]),
+        publicIPAddressVersion: item["publicIPAddressVersion"],
+    };
+}
+/** Specifies whether the IP configuration's public IP is IPv4 or IPv6. Default is IPv4. */
+export var KnownPublicIPAddressVersion;
+(function (KnownPublicIPAddressVersion) {
+    /** The IP configuration's public IP is IPv4. */
+    KnownPublicIPAddressVersion["IPv4"] = "IPv4";
+    /** The IP configuration's public IP is IPv6. */
+    KnownPublicIPAddressVersion["IPv6"] = "IPv6";
+})(KnownPublicIPAddressVersion || (KnownPublicIPAddressVersion = {}));
+export function vmApplicationArraySerializer(result) {
+    return result.map((item) => {
+        return vmApplicationSerializer(item);
+    });
+}
+export function vmApplicationArrayDeserializer(result) {
+    return result.map((item) => {
+        return vmApplicationDeserializer(item);
+    });
+}
+export function vmApplicationSerializer(item) {
+    return {
+        configurationReference: item["configurationReference"],
+        enableAutomaticUpgrade: item["enableAutomaticUpgrade"],
+        order: item["order"],
+        packageReferenceId: item["packageReferenceId"],
+        vmGalleryTags: item["vmGalleryTags"],
+        treatFailureAsDeploymentFailure: item["treatFailureAsDeploymentFailure"],
+    };
+}
+export function vmApplicationDeserializer(item) {
+    return {
+        configurationReference: item["configurationReference"],
+        enableAutomaticUpgrade: item["enableAutomaticUpgrade"],
+        order: item["order"],
+        packageReferenceId: item["packageReferenceId"],
+        vmGalleryTags: item["vmGalleryTags"],
+        treatFailureAsDeploymentFailure: item["treatFailureAsDeploymentFailure"],
+    };
+}
+export function nodeTypeSkuSerializer(item) {
+    return { name: item["name"], tier: item["tier"], capacity: item["capacity"] };
+}
+export function nodeTypeSkuDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        capacity: item["capacity"],
+    };
+}
+export function nodeTypeUpdateParametersSerializer(item) {
+    return {
+        tags: item["tags"],
+        sku: !item["sku"] ? item["sku"] : nodeTypeSkuSerializer(item["sku"]),
+    };
+}
+export function _nodeTypeListResultDeserializer(item) {
+    return {
+        value: nodeTypeArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function nodeTypeArraySerializer(result) {
+    return result.map((item) => {
+        return nodeTypeSerializer(item);
+    });
+}
+export function nodeTypeArrayDeserializer(result) {
+    return result.map((item) => {
+        return nodeTypeDeserializer(item);
+    });
+}
+export function nodeTypeActionParametersSerializer(item) {
+    return {
+        nodes: !item["nodes"]
+            ? item["nodes"]
+            : item["nodes"].map((p) => {
+                return p;
+            }),
+        force: item["force"],
+        updateType: item["updateType"],
+    };
+}
+/** Specifies the way the operation will be performed. */
+export var KnownUpdateType;
+(function (KnownUpdateType) {
+    /** The operation will proceed in all specified nodes at the same time. */
+    KnownUpdateType["Default"] = "Default";
+    /** The operation will proceed one upgrade domain at a time, checking the health in between each to continue. */
+    KnownUpdateType["ByUpgradeDomain"] = "ByUpgradeDomain";
+})(KnownUpdateType || (KnownUpdateType = {}));
+export function _nodeTypeListSkuResultDeserializer(item) {
+    return {
+        value: nodeTypeAvailableSkuArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function nodeTypeAvailableSkuArrayDeserializer(result) {
+    return result.map((item) => {
+        return nodeTypeAvailableSkuDeserializer(item);
+    });
+}
+export function nodeTypeAvailableSkuDeserializer(item) {
+    return {
+        resourceType: item["resourceType"],
+        sku: !item["sku"] ? item["sku"] : nodeTypeSupportedSkuDeserializer(item["sku"]),
+        capacity: !item["capacity"]
+            ? item["capacity"]
+            : nodeTypeSkuCapacityDeserializer(item["capacity"]),
+    };
+}
+export function nodeTypeSupportedSkuDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+    };
+}
+export function nodeTypeSkuCapacityDeserializer(item) {
+    return {
+        minimum: item["minimum"],
+        maximum: item["maximum"],
+        default: item["default"],
+        scaleType: item["scaleType"],
+    };
+}
+/** Node type capacity scale type. */
+export var KnownNodeTypeSkuScaleType;
+(function (KnownNodeTypeSkuScaleType) {
+    /** Node count is not adjustable in any way (e.g. it is fixed). */
+    KnownNodeTypeSkuScaleType["None"] = "None";
+    /** The user must manually scale out/in. */
+    KnownNodeTypeSkuScaleType["Manual"] = "Manual";
+    /** Automatic scale is allowed. */
+    KnownNodeTypeSkuScaleType["Automatic"] = "Automatic";
+})(KnownNodeTypeSkuScaleType || (KnownNodeTypeSkuScaleType = {}));
+export function longRunningOperationResultDeserializer(item) {
+    return {
+        name: item["name"],
+        startTime: !item["startTime"] ? item["startTime"] : new Date(item["startTime"]),
+        endTime: !item["endTime"] ? item["endTime"] : new Date(item["endTime"]),
+        percentComplete: item["percentComplete"],
+        status: item["status"],
+        error: !item["error"] ? item["error"] : errorModelErrorDeserializer(item["error"]),
+    };
+}
+export function errorModelErrorDeserializer(item) {
+    return {
+        code: item["code"],
+        message: item["message"],
+    };
+}
+/** The operating system of the cluster. The default means all. */
+export var KnownManagedClusterVersionEnvironment;
+(function (KnownManagedClusterVersionEnvironment) {
+    /** Indicates os is Windows. */
+    KnownManagedClusterVersionEnvironment["Windows"] = "Windows";
+})(KnownManagedClusterVersionEnvironment || (KnownManagedClusterVersionEnvironment = {}));
+/** The available API versions. */
+export var KnownVersions;
+(function (KnownVersions) {
+    /** The 2024-11-01-preview API version. */
+    KnownVersions["V20241101Preview"] = "2024-11-01-preview";
+    KnownVersions["V20250301Preview"] = "2025-03-01-preview";
+})(KnownVersions || (KnownVersions = {}));
+export function managedClusterCodeVersionResultArrayDeserializer(result) {
+    return result.map((item) => {
+        return managedClusterCodeVersionResultDeserializer(item);
+    });
+}
+//# sourceMappingURL=models.js.map