@azure/arm-postgresql-flexible 9.0.0 → 10.0.0-beta.2

package/dist/browser/models/models.js

@@ -0,0 +1,3322 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { areAllPropsUndefined } from "../static-helpers/serialization/check-prop-undefined.js";
+export function _operationListDeserializer(item) {
+    return {
+        value: operationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function operationArrayDeserializer(result) {
+    return result.map((item) => {
+        return operationDeserializer(item);
+    });
+}
+export function operationDeserializer(item) {
+    return {
+        name: item["name"],
+        display: !item["display"] ? item["display"] : operationDisplayDeserializer(item["display"]),
+        isDataAction: item["isDataAction"],
+        origin: item["origin"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : operationPropertiesDeserializer(item["properties"]),
+    };
+}
+export function operationDisplayDeserializer(item) {
+    return {
+        provider: item["provider"],
+        resource: item["resource"],
+        operation: item["operation"],
+        description: item["description"],
+    };
+}
+/** Intended executor of the operation. */
+export var KnownOperationOrigin;
+(function (KnownOperationOrigin) {
+    /** NotSpecified */
+    KnownOperationOrigin["NotSpecified"] = "NotSpecified";
+    /** user */
+    KnownOperationOrigin["User"] = "user";
+    /** system */
+    KnownOperationOrigin["System"] = "system";
+})(KnownOperationOrigin || (KnownOperationOrigin = {}));
+export function operationPropertiesDeserializer(item) {
+    return {
+        serviceSpecification: !item["serviceSpecification"]
+            ? item["serviceSpecification"]
+            : serviceSpecificationDeserializer(item["serviceSpecification"]),
+    };
+}
+export function serviceSpecificationDeserializer(item) {
+    return {
+        metricSpecifications: !item["metricSpecifications"]
+            ? item["metricSpecifications"]
+            : metricSpecificationArrayDeserializer(item["metricSpecifications"]),
+        logSpecifications: !item["logSpecifications"]
+            ? item["logSpecifications"]
+            : logSpecificationArrayDeserializer(item["logSpecifications"]),
+    };
+}
+export function metricSpecificationArrayDeserializer(result) {
+    return result.map((item) => {
+        return metricSpecificationDeserializer(item);
+    });
+}
+export function metricSpecificationDeserializer(item) {
+    return {
+        name: item["name"],
+        displayName: item["displayName"],
+        displayDescription: item["displayDescription"],
+        unit: item["unit"],
+        aggregationType: item["aggregationType"],
+        supportedAggregationTypes: !item["supportedAggregationTypes"]
+            ? item["supportedAggregationTypes"]
+            : item["supportedAggregationTypes"].map((p) => {
+                return p;
+            }),
+        supportedTimeGrainTypes: !item["supportedTimeGrainTypes"]
+            ? item["supportedTimeGrainTypes"]
+            : item["supportedTimeGrainTypes"].map((p) => {
+                return p;
+            }),
+        category: item["category"],
+    };
+}
+export function logSpecificationArrayDeserializer(result) {
+    return result.map((item) => {
+        return logSpecificationDeserializer(item);
+    });
+}
+export function logSpecificationDeserializer(item) {
+    return {
+        name: item["name"],
+        displayName: item["displayName"],
+        blobDuration: item["blobDuration"],
+    };
+}
+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 migrationSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: areAllPropsUndefined(item, [
+            "migrationInstanceResourceId",
+            "migrationMode",
+            "migrationOption",
+            "sourceType",
+            "sslMode",
+            "sourceDbServerResourceId",
+            "sourceDbServerFullyQualifiedDomainName",
+            "targetDbServerFullyQualifiedDomainName",
+            "secretParameters",
+            "dbsToMigrate",
+            "setupLogicalReplicationOnSourceDbIfNeeded",
+            "overwriteDbsInTarget",
+            "migrationWindowStartTimeInUtc",
+            "migrationWindowEndTimeInUtc",
+            "migrateRoles",
+            "startDataMigration",
+            "triggerCutover",
+            "dbsToTriggerCutoverOn",
+            "cancel",
+            "dbsToCancelMigrationOn",
+        ])
+            ? undefined
+            : _migrationPropertiesSerializer(item),
+    };
+}
+export function migrationDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _migrationPropertiesDeserializer(item["properties"])),
+    };
+}
+export function migrationPropertiesSerializer(item) {
+    return {
+        migrationInstanceResourceId: item["migrationInstanceResourceId"],
+        migrationMode: item["migrationMode"],
+        migrationOption: item["migrationOption"],
+        sourceType: item["sourceType"],
+        sslMode: item["sslMode"],
+        sourceDbServerResourceId: item["sourceDbServerResourceId"],
+        sourceDbServerFullyQualifiedDomainName: item["sourceDbServerFullyQualifiedDomainName"],
+        targetDbServerFullyQualifiedDomainName: item["targetDbServerFullyQualifiedDomainName"],
+        secretParameters: !item["secretParameters"]
+            ? item["secretParameters"]
+            : migrationSecretParametersSerializer(item["secretParameters"]),
+        dbsToMigrate: !item["dbsToMigrate"]
+            ? item["dbsToMigrate"]
+            : item["dbsToMigrate"].map((p) => {
+                return p;
+            }),
+        setupLogicalReplicationOnSourceDbIfNeeded: item["setupLogicalReplicationOnSourceDbIfNeeded"],
+        overwriteDbsInTarget: item["overwriteDbsInTarget"],
+        migrationWindowStartTimeInUtc: !item["migrationWindowStartTimeInUtc"]
+            ? item["migrationWindowStartTimeInUtc"]
+            : item["migrationWindowStartTimeInUtc"].toISOString(),
+        migrationWindowEndTimeInUtc: !item["migrationWindowEndTimeInUtc"]
+            ? item["migrationWindowEndTimeInUtc"]
+            : item["migrationWindowEndTimeInUtc"].toISOString(),
+        migrateRoles: item["migrateRoles"],
+        startDataMigration: item["startDataMigration"],
+        triggerCutover: item["triggerCutover"],
+        dbsToTriggerCutoverOn: !item["dbsToTriggerCutoverOn"]
+            ? item["dbsToTriggerCutoverOn"]
+            : item["dbsToTriggerCutoverOn"].map((p) => {
+                return p;
+            }),
+        cancel: item["cancel"],
+        dbsToCancelMigrationOn: !item["dbsToCancelMigrationOn"]
+            ? item["dbsToCancelMigrationOn"]
+            : item["dbsToCancelMigrationOn"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function migrationPropertiesDeserializer(item) {
+    return {
+        migrationId: item["migrationId"],
+        currentStatus: !item["currentStatus"]
+            ? item["currentStatus"]
+            : migrationStatusDeserializer(item["currentStatus"]),
+        migrationInstanceResourceId: item["migrationInstanceResourceId"],
+        migrationMode: item["migrationMode"],
+        migrationOption: item["migrationOption"],
+        sourceType: item["sourceType"],
+        sslMode: item["sslMode"],
+        sourceDbServerMetadata: !item["sourceDbServerMetadata"]
+            ? item["sourceDbServerMetadata"]
+            : dbServerMetadataDeserializer(item["sourceDbServerMetadata"]),
+        targetDbServerMetadata: !item["targetDbServerMetadata"]
+            ? item["targetDbServerMetadata"]
+            : dbServerMetadataDeserializer(item["targetDbServerMetadata"]),
+        sourceDbServerResourceId: item["sourceDbServerResourceId"],
+        sourceDbServerFullyQualifiedDomainName: item["sourceDbServerFullyQualifiedDomainName"],
+        targetDbServerResourceId: item["targetDbServerResourceId"],
+        targetDbServerFullyQualifiedDomainName: item["targetDbServerFullyQualifiedDomainName"],
+        secretParameters: !item["secretParameters"]
+            ? item["secretParameters"]
+            : migrationSecretParametersDeserializer(item["secretParameters"]),
+        dbsToMigrate: !item["dbsToMigrate"]
+            ? item["dbsToMigrate"]
+            : item["dbsToMigrate"].map((p) => {
+                return p;
+            }),
+        setupLogicalReplicationOnSourceDbIfNeeded: item["setupLogicalReplicationOnSourceDbIfNeeded"],
+        overwriteDbsInTarget: item["overwriteDbsInTarget"],
+        migrationWindowStartTimeInUtc: !item["migrationWindowStartTimeInUtc"]
+            ? item["migrationWindowStartTimeInUtc"]
+            : new Date(item["migrationWindowStartTimeInUtc"]),
+        migrationWindowEndTimeInUtc: !item["migrationWindowEndTimeInUtc"]
+            ? item["migrationWindowEndTimeInUtc"]
+            : new Date(item["migrationWindowEndTimeInUtc"]),
+        migrateRoles: item["migrateRoles"],
+        startDataMigration: item["startDataMigration"],
+        triggerCutover: item["triggerCutover"],
+        dbsToTriggerCutoverOn: !item["dbsToTriggerCutoverOn"]
+            ? item["dbsToTriggerCutoverOn"]
+            : item["dbsToTriggerCutoverOn"].map((p) => {
+                return p;
+            }),
+        cancel: item["cancel"],
+        dbsToCancelMigrationOn: !item["dbsToCancelMigrationOn"]
+            ? item["dbsToCancelMigrationOn"]
+            : item["dbsToCancelMigrationOn"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function migrationStatusDeserializer(item) {
+    return {
+        state: item["state"],
+        error: item["error"],
+        currentSubStateDetails: !item["currentSubStateDetails"]
+            ? item["currentSubStateDetails"]
+            : migrationSubstateDetailsDeserializer(item["currentSubStateDetails"]),
+    };
+}
+/** State of migration. */
+export var KnownMigrationState;
+(function (KnownMigrationState) {
+    /** Migration is in progress. */
+    KnownMigrationState["InProgress"] = "InProgress";
+    /** Migration is waiting for user action. */
+    KnownMigrationState["WaitingForUserAction"] = "WaitingForUserAction";
+    /** Migration has been canceled. */
+    KnownMigrationState["Canceled"] = "Canceled";
+    /** Migration has failed. */
+    KnownMigrationState["Failed"] = "Failed";
+    /** Migration has succeeded. */
+    KnownMigrationState["Succeeded"] = "Succeeded";
+    /** Validation for migration has failed. */
+    KnownMigrationState["ValidationFailed"] = "ValidationFailed";
+    /** Migration is cleaning up resources. */
+    KnownMigrationState["CleaningUp"] = "CleaningUp";
+})(KnownMigrationState || (KnownMigrationState = {}));
+export function migrationSubstateDetailsDeserializer(item) {
+    return {
+        currentSubState: item["currentSubState"],
+        dbDetails: !item["dbDetails"]
+            ? item["dbDetails"]
+            : databaseMigrationStateRecordDeserializer(item["dbDetails"]),
+        validationDetails: !item["validationDetails"]
+            ? item["validationDetails"]
+            : validationDetailsDeserializer(item["validationDetails"]),
+    };
+}
+/** Substate of migration. */
+export var KnownMigrationSubstate;
+(function (KnownMigrationSubstate) {
+    /** Performing pre-requisite steps for migration. */
+    KnownMigrationSubstate["PerformingPreRequisiteSteps"] = "PerformingPreRequisiteSteps";
+    /** Waiting for logical replication setup request on source database. */
+    KnownMigrationSubstate["WaitingForLogicalReplicationSetupRequestOnSourceDB"] = "WaitingForLogicalReplicationSetupRequestOnSourceDB";
+    /** Waiting for databases to migrate specification. */
+    KnownMigrationSubstate["WaitingForDBsToMigrateSpecification"] = "WaitingForDBsToMigrateSpecification";
+    /** Waiting for target database overwrite confirmation. */
+    KnownMigrationSubstate["WaitingForTargetDBOverwriteConfirmation"] = "WaitingForTargetDBOverwriteConfirmation";
+    /** Waiting for data migration scheduling. */
+    KnownMigrationSubstate["WaitingForDataMigrationScheduling"] = "WaitingForDataMigrationScheduling";
+    /** Waiting for data migration window. */
+    KnownMigrationSubstate["WaitingForDataMigrationWindow"] = "WaitingForDataMigrationWindow";
+    /** Migrating data. */
+    KnownMigrationSubstate["MigratingData"] = "MigratingData";
+    /** Waiting for cutover trigger. */
+    KnownMigrationSubstate["WaitingForCutoverTrigger"] = "WaitingForCutoverTrigger";
+    /** Completing migration. */
+    KnownMigrationSubstate["CompletingMigration"] = "CompletingMigration";
+    /** Migration completed. */
+    KnownMigrationSubstate["Completed"] = "Completed";
+    /** Canceling requested database migrations. */
+    KnownMigrationSubstate["CancelingRequestedDBMigrations"] = "CancelingRequestedDBMigrations";
+    /** Validation in progress. */
+    KnownMigrationSubstate["ValidationInProgress"] = "ValidationInProgress";
+})(KnownMigrationSubstate || (KnownMigrationSubstate = {}));
+export function databaseMigrationStateRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : databaseMigrationStateDeserializer(item[key]);
+    });
+    return result;
+}
+export function databaseMigrationStateDeserializer(item) {
+    return {
+        databaseName: item["databaseName"],
+        migrationState: item["migrationState"],
+        migrationOperation: item["migrationOperation"],
+        startedOn: !item["startedOn"] ? item["startedOn"] : new Date(item["startedOn"]),
+        endedOn: !item["endedOn"] ? item["endedOn"] : new Date(item["endedOn"]),
+        fullLoadQueuedTables: item["fullLoadQueuedTables"],
+        fullLoadErroredTables: item["fullLoadErroredTables"],
+        fullLoadLoadingTables: item["fullLoadLoadingTables"],
+        fullLoadCompletedTables: item["fullLoadCompletedTables"],
+        cdcUpdateCounter: item["cdcUpdateCounter"],
+        cdcDeleteCounter: item["cdcDeleteCounter"],
+        cdcInsertCounter: item["cdcInsertCounter"],
+        appliedChanges: item["appliedChanges"],
+        incomingChanges: item["incomingChanges"],
+        latency: item["latency"],
+        message: item["message"],
+    };
+}
+/** Migration state of a database. */
+export var KnownMigrationDatabaseState;
+(function (KnownMigrationDatabaseState) {
+    /** Migration is in progress for the database. */
+    KnownMigrationDatabaseState["InProgress"] = "InProgress";
+    /** Migration is waiting for cutover trigger for the database. */
+    KnownMigrationDatabaseState["WaitingForCutoverTrigger"] = "WaitingForCutoverTrigger";
+    /** Migration has failed for the database. */
+    KnownMigrationDatabaseState["Failed"] = "Failed";
+    /** Migration has been canceled for the database. */
+    KnownMigrationDatabaseState["Canceled"] = "Canceled";
+    /** Migration has succeeded for the database. */
+    KnownMigrationDatabaseState["Succeeded"] = "Succeeded";
+    /** Migration is being canceled for the database. */
+    KnownMigrationDatabaseState["Canceling"] = "Canceling";
+})(KnownMigrationDatabaseState || (KnownMigrationDatabaseState = {}));
+export function validationDetailsDeserializer(item) {
+    return {
+        status: item["status"],
+        validationStartTimeInUtc: !item["validationStartTimeInUtc"]
+            ? item["validationStartTimeInUtc"]
+            : new Date(item["validationStartTimeInUtc"]),
+        validationEndTimeInUtc: !item["validationEndTimeInUtc"]
+            ? item["validationEndTimeInUtc"]
+            : new Date(item["validationEndTimeInUtc"]),
+        serverLevelValidationDetails: !item["serverLevelValidationDetails"]
+            ? item["serverLevelValidationDetails"]
+            : validationSummaryItemArrayDeserializer(item["serverLevelValidationDetails"]),
+        dbLevelValidationDetails: !item["dbLevelValidationDetails"]
+            ? item["dbLevelValidationDetails"]
+            : dbLevelValidationStatusArrayDeserializer(item["dbLevelValidationDetails"]),
+    };
+}
+/** Validation state for migration. */
+export var KnownValidationState;
+(function (KnownValidationState) {
+    /** Validation has failed. */
+    KnownValidationState["Failed"] = "Failed";
+    /** Validation has succeeded. */
+    KnownValidationState["Succeeded"] = "Succeeded";
+    /** Validation has succeeded with warnings. */
+    KnownValidationState["Warning"] = "Warning";
+})(KnownValidationState || (KnownValidationState = {}));
+export function validationSummaryItemArrayDeserializer(result) {
+    return result.map((item) => {
+        return validationSummaryItemDeserializer(item);
+    });
+}
+export function validationSummaryItemDeserializer(item) {
+    return {
+        type: item["type"],
+        state: item["state"],
+        messages: !item["messages"]
+            ? item["messages"]
+            : validationMessageArrayDeserializer(item["messages"]),
+    };
+}
+export function validationMessageArrayDeserializer(result) {
+    return result.map((item) => {
+        return validationMessageDeserializer(item);
+    });
+}
+export function validationMessageDeserializer(item) {
+    return {
+        state: item["state"],
+        message: item["message"],
+    };
+}
+export function dbLevelValidationStatusArrayDeserializer(result) {
+    return result.map((item) => {
+        return dbLevelValidationStatusDeserializer(item);
+    });
+}
+export function dbLevelValidationStatusDeserializer(item) {
+    return {
+        databaseName: item["databaseName"],
+        startedOn: !item["startedOn"] ? item["startedOn"] : new Date(item["startedOn"]),
+        endedOn: !item["endedOn"] ? item["endedOn"] : new Date(item["endedOn"]),
+        summary: !item["summary"]
+            ? item["summary"]
+            : validationSummaryItemArrayDeserializer(item["summary"]),
+    };
+}
+/** Mode used to perform the migration. */
+export var KnownMigrationMode;
+(function (KnownMigrationMode) {
+    /** Offline migration mode. */
+    KnownMigrationMode["Offline"] = "Offline";
+    /** Online migration mode. */
+    KnownMigrationMode["Online"] = "Online";
+})(KnownMigrationMode || (KnownMigrationMode = {}));
+/** Supported option for a migration. */
+export var KnownMigrationOption;
+(function (KnownMigrationOption) {
+    /** Validate the migration without performing it. */
+    KnownMigrationOption["Validate"] = "Validate";
+    /** Perform the migration. */
+    KnownMigrationOption["Migrate"] = "Migrate";
+    /** Validate and perform the migration. */
+    KnownMigrationOption["ValidateAndMigrate"] = "ValidateAndMigrate";
+})(KnownMigrationOption || (KnownMigrationOption = {}));
+/** Source server type used for the migration. */
+export var KnownSourceType;
+(function (KnownSourceType) {
+    /** On-premises PostgreSQL server. */
+    KnownSourceType["OnPremises"] = "OnPremises";
+    /** Amazon Web Services PostgreSQL server. */
+    KnownSourceType["AWS"] = "AWS";
+    /** Google Cloud Platform PostgreSQL server. */
+    KnownSourceType["GCP"] = "GCP";
+    /** Azure Virtual Machine PostgreSQL server. */
+    KnownSourceType["AzureVM"] = "AzureVM";
+    /** Azure Database for PostgreSQL single server. */
+    KnownSourceType["PostgreSQLSingleServer"] = "PostgreSQLSingleServer";
+    /** Amazon RDS for PostgreSQL. */
+    KnownSourceType["AWSRDS"] = "AWS_RDS";
+    /** Amazon Aurora for PostgreSQL. */
+    KnownSourceType["AWSAurora"] = "AWS_AURORA";
+    /** Amazon EC2 for PostgreSQL. */
+    KnownSourceType["AWSEC2"] = "AWS_EC2";
+    /** Google Cloud SQL for PostgreSQL. */
+    KnownSourceType["GCPCloudSQL"] = "GCP_CloudSQL";
+    /** Google Cloud AlloyDB for PostgreSQL. */
+    KnownSourceType["GCPAlloyDB"] = "GCP_AlloyDB";
+    /** Google Compute Engine for PostgreSQL. */
+    KnownSourceType["GCPCompute"] = "GCP_Compute";
+    /** EnterpriseDB PostgreSQL server. */
+    KnownSourceType["EDB"] = "EDB";
+    /** EnterpriseDB Oracle Server. */
+    KnownSourceType["EDBOracleServer"] = "EDB_Oracle_Server";
+    /** EnterpriseDB PostgreSQL server. */
+    KnownSourceType["EDBPostgreSQL"] = "EDB_PostgreSQL";
+    /** Azure Database for PostgreSQL flexible server. */
+    KnownSourceType["PostgreSQLFlexibleServer"] = "PostgreSQLFlexibleServer";
+    /** .NET Cosmos DB for PostgreSQL */
+    KnownSourceType["PostgreSQLCosmosDB"] = "PostgreSQLCosmosDB";
+    /** Huawei RDS for PostgreSQL */
+    KnownSourceType["HuaweiRDS"] = "Huawei_RDS";
+    /** Huawei Compute for PostgreSQL */
+    KnownSourceType["HuaweiCompute"] = "Huawei_Compute";
+    /** Heroku PostgreSQL */
+    KnownSourceType["HerokuPostgreSQL"] = "Heroku_PostgreSQL";
+    /** Crunchy PostgreSQL */
+    KnownSourceType["CrunchyPostgreSQL"] = "Crunchy_PostgreSQL";
+    /** ApsaraDB RDS for PostgreSQL */
+    KnownSourceType["ApsaraDBRDS"] = "ApsaraDB_RDS";
+    /** Digital Ocean Droplets for PostgreSQL */
+    KnownSourceType["DigitalOceanDroplets"] = "Digital_Ocean_Droplets";
+    /** Digital Ocean PostgreSQL */
+    KnownSourceType["DigitalOceanPostgreSQL"] = "Digital_Ocean_PostgreSQL";
+    /** Supabase PostgreSQL */
+    KnownSourceType["SupabasePostgreSQL"] = "Supabase_PostgreSQL";
+})(KnownSourceType || (KnownSourceType = {}));
+/** SSL mode used by a migration. Default SSL mode for 'PostgreSQLSingleServer' is 'VerifyFull'. Default SSL mode for other source types is 'Prefer'. */
+export var KnownSslMode;
+(function (KnownSslMode) {
+    /** Prefer SSL connection. If the server does not support SSL, the connection will be established without SSL. */
+    KnownSslMode["Prefer"] = "Prefer";
+    /** Require SSL connection. If the server does not support SSL, the connection will fail. */
+    KnownSslMode["Require"] = "Require";
+    /** Require SSL connection and verify the server certificate against the CA certificate. */
+    KnownSslMode["VerifyCA"] = "VerifyCA";
+    /** Require SSL connection, verify the server certificate against the CA certificate, and verify that the server hostname matches the certificate. */
+    KnownSslMode["VerifyFull"] = "VerifyFull";
+})(KnownSslMode || (KnownSslMode = {}));
+export function dbServerMetadataDeserializer(item) {
+    return {
+        location: item["location"],
+        version: item["version"],
+        storageMb: item["storageMb"],
+        sku: !item["sku"] ? item["sku"] : serverSkuDeserializer(item["sku"]),
+    };
+}
+export function serverSkuDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+    };
+}
+/** Tier of the compute assigned to a server. */
+export var KnownSkuTier;
+(function (KnownSkuTier) {
+    /** Cost-effective tier for infrequent CPU usage, ideal for development and testing workloads with low performance requirements. */
+    KnownSkuTier["Burstable"] = "Burstable";
+    /** Balanced compute and memory for most workloads, offering scalable performance and I/O throughput. */
+    KnownSkuTier["GeneralPurpose"] = "GeneralPurpose";
+    /** High memory-to-core ratio for demanding workloads needing fast in-memory processing and high concurrency. */
+    KnownSkuTier["MemoryOptimized"] = "MemoryOptimized";
+})(KnownSkuTier || (KnownSkuTier = {}));
+export function migrationSecretParametersSerializer(item) {
+    return {
+        adminCredentials: adminCredentialsSerializer(item["adminCredentials"]),
+        sourceServerUsername: item["sourceServerUsername"],
+        targetServerUsername: item["targetServerUsername"],
+    };
+}
+export function migrationSecretParametersDeserializer(item) {
+    return {
+        adminCredentials: adminCredentialsDeserializer(item["adminCredentials"]),
+        sourceServerUsername: item["sourceServerUsername"],
+        targetServerUsername: item["targetServerUsername"],
+    };
+}
+export function adminCredentialsSerializer(item) {
+    return {
+        sourceServerPassword: item["sourceServerPassword"],
+        targetServerPassword: item["targetServerPassword"],
+    };
+}
+export function adminCredentialsDeserializer(item) {
+    return {
+        sourceServerPassword: item["sourceServerPassword"],
+        targetServerPassword: item["targetServerPassword"],
+    };
+}
+/** Indicates whether to setup logical replication on source server, if needed. */
+export var KnownLogicalReplicationOnSourceServer;
+(function (KnownLogicalReplicationOnSourceServer) {
+    /** Logical replication will be set up on the source server. */
+    KnownLogicalReplicationOnSourceServer["True"] = "True";
+    /** Logical replication will not be set up on the source server. */
+    KnownLogicalReplicationOnSourceServer["False"] = "False";
+})(KnownLogicalReplicationOnSourceServer || (KnownLogicalReplicationOnSourceServer = {}));
+/** Indicates if databases on the target server can be overwritten when already present. */
+export var KnownOverwriteDatabasesOnTargetServer;
+(function (KnownOverwriteDatabasesOnTargetServer) {
+    /** Databases on the target server can be overwritten when already present. */
+    KnownOverwriteDatabasesOnTargetServer["True"] = "True";
+    /** Databases on the target server cannot be overwritten when already present. When the migration workflow detects that the database already exists on the target server, it will wait for a confirmation. */
+    KnownOverwriteDatabasesOnTargetServer["False"] = "False";
+})(KnownOverwriteDatabasesOnTargetServer || (KnownOverwriteDatabasesOnTargetServer = {}));
+/** Indicates if roles and permissions must be migrated. */
+export var KnownMigrateRolesAndPermissions;
+(function (KnownMigrateRolesAndPermissions) {
+    /** Roles and permissions will be migrated. */
+    KnownMigrateRolesAndPermissions["True"] = "True";
+    /** Roles and permissions will not be migrated. */
+    KnownMigrateRolesAndPermissions["False"] = "False";
+})(KnownMigrateRolesAndPermissions || (KnownMigrateRolesAndPermissions = {}));
+/** Indicates if data migration must start right away. */
+export var KnownStartDataMigration;
+(function (KnownStartDataMigration) {
+    /** Data migration must start right away. */
+    KnownStartDataMigration["True"] = "True";
+    /** Data migration must not start right away. */
+    KnownStartDataMigration["False"] = "False";
+})(KnownStartDataMigration || (KnownStartDataMigration = {}));
+/** Indicates if cutover must be triggered for the entire migration. */
+export var KnownTriggerCutover;
+(function (KnownTriggerCutover) {
+    /** Cutover must be triggered for the entire migration. */
+    KnownTriggerCutover["True"] = "True";
+    /** Cutover must not be triggered for the entire migration. */
+    KnownTriggerCutover["False"] = "False";
+})(KnownTriggerCutover || (KnownTriggerCutover = {}));
+/** Indicates if cancel must be triggered for the entire migration. */
+export var KnownCancel;
+(function (KnownCancel) {
+    /** Cancel must be triggered for the entire migration. */
+    KnownCancel["True"] = "True";
+    /** Cancel must not be triggered for the entire migration. */
+    KnownCancel["False"] = "False";
+})(KnownCancel || (KnownCancel = {}));
+export function trackedResourceSerializer(item) {
+    return { tags: item["tags"], location: item["location"] };
+}
+export function trackedResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+    };
+}
+export function resourceSerializer(_item) {
+    return {};
+}
+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 migrationResourceForPatchSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, [
+            "sourceDbServerResourceId",
+            "sourceDbServerFullyQualifiedDomainName",
+            "targetDbServerFullyQualifiedDomainName",
+            "secretParameters",
+            "dbsToMigrate",
+            "setupLogicalReplicationOnSourceDbIfNeeded",
+            "overwriteDbsInTarget",
+            "migrationWindowStartTimeInUtc",
+            "migrateRoles",
+            "startDataMigration",
+            "triggerCutover",
+            "dbsToTriggerCutoverOn",
+            "cancel",
+            "dbsToCancelMigrationOn",
+            "migrationMode",
+        ])
+            ? undefined
+            : _migrationResourceForPatchPropertiesSerializer(item),
+        tags: item["tags"],
+    };
+}
+export function migrationPropertiesForPatchSerializer(item) {
+    return {
+        sourceDbServerResourceId: item["sourceDbServerResourceId"],
+        sourceDbServerFullyQualifiedDomainName: item["sourceDbServerFullyQualifiedDomainName"],
+        targetDbServerFullyQualifiedDomainName: item["targetDbServerFullyQualifiedDomainName"],
+        secretParameters: !item["secretParameters"]
+            ? item["secretParameters"]
+            : migrationSecretParametersForPatchSerializer(item["secretParameters"]),
+        dbsToMigrate: !item["dbsToMigrate"]
+            ? item["dbsToMigrate"]
+            : item["dbsToMigrate"].map((p) => {
+                return p;
+            }),
+        setupLogicalReplicationOnSourceDbIfNeeded: item["setupLogicalReplicationOnSourceDbIfNeeded"],
+        overwriteDbsInTarget: item["overwriteDbsInTarget"],
+        migrationWindowStartTimeInUtc: !item["migrationWindowStartTimeInUtc"]
+            ? item["migrationWindowStartTimeInUtc"]
+            : item["migrationWindowStartTimeInUtc"].toISOString(),
+        migrateRoles: item["migrateRoles"],
+        startDataMigration: item["startDataMigration"],
+        triggerCutover: item["triggerCutover"],
+        dbsToTriggerCutoverOn: !item["dbsToTriggerCutoverOn"]
+            ? item["dbsToTriggerCutoverOn"]
+            : item["dbsToTriggerCutoverOn"].map((p) => {
+                return p;
+            }),
+        cancel: item["cancel"],
+        dbsToCancelMigrationOn: !item["dbsToCancelMigrationOn"]
+            ? item["dbsToCancelMigrationOn"]
+            : item["dbsToCancelMigrationOn"].map((p) => {
+                return p;
+            }),
+        migrationMode: item["migrationMode"],
+    };
+}
+export function migrationSecretParametersForPatchSerializer(item) {
+    return {
+        adminCredentials: !item["adminCredentials"]
+            ? item["adminCredentials"]
+            : adminCredentialsForPatchSerializer(item["adminCredentials"]),
+        sourceServerUsername: item["sourceServerUsername"],
+        targetServerUsername: item["targetServerUsername"],
+    };
+}
+export function adminCredentialsForPatchSerializer(item) {
+    return {
+        sourceServerPassword: item["sourceServerPassword"],
+        targetServerPassword: item["targetServerPassword"],
+    };
+}
+export function _migrationListDeserializer(item) {
+    return {
+        value: migrationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function migrationArraySerializer(result) {
+    return result.map((item) => {
+        return migrationSerializer(item);
+    });
+}
+export function migrationArrayDeserializer(result) {
+    return result.map((item) => {
+        return migrationDeserializer(item);
+    });
+}
+export function migrationNameAvailabilitySerializer(item) {
+    return { name: item["name"], type: item["type"] };
+}
+export function migrationNameAvailabilityDeserializer(item) {
+    return {
+        name: item["name"],
+        type: item["type"],
+        nameAvailable: item["nameAvailable"],
+        reason: item["reason"],
+        message: item["message"],
+    };
+}
+/** Migration name availability reason. */
+export var KnownMigrationNameAvailabilityReason;
+(function (KnownMigrationNameAvailabilityReason) {
+    /** Migration name is invalid. */
+    KnownMigrationNameAvailabilityReason["Invalid"] = "Invalid";
+    /** Migration name already exists. */
+    KnownMigrationNameAvailabilityReason["AlreadyExists"] = "AlreadyExists";
+})(KnownMigrationNameAvailabilityReason || (KnownMigrationNameAvailabilityReason = {}));
+export function serverSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: areAllPropsUndefined(item, [
+            "administratorLogin",
+            "administratorLoginPassword",
+            "version",
+            "storage",
+            "authConfig",
+            "dataEncryption",
+            "backup",
+            "network",
+            "highAvailability",
+            "maintenanceWindow",
+            "sourceServerResourceId",
+            "pointInTimeUTC",
+            "availabilityZone",
+            "replicationRole",
+            "replica",
+            "createMode",
+            "cluster",
+        ])
+            ? undefined
+            : _serverPropertiesSerializer(item),
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : userAssignedIdentitySerializer(item["identity"]),
+    };
+}
+export function serverDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _serverPropertiesDeserializer(item["properties"])),
+        sku: !item["sku"] ? item["sku"] : skuDeserializer(item["sku"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : userAssignedIdentityDeserializer(item["identity"]),
+    };
+}
+export function serverPropertiesSerializer(item) {
+    return {
+        administratorLogin: item["administratorLogin"],
+        administratorLoginPassword: item["administratorLoginPassword"],
+        version: item["version"],
+        storage: !item["storage"] ? item["storage"] : storageSerializer(item["storage"]),
+        authConfig: !item["authConfig"] ? item["authConfig"] : authConfigSerializer(item["authConfig"]),
+        dataEncryption: !item["dataEncryption"]
+            ? item["dataEncryption"]
+            : dataEncryptionSerializer(item["dataEncryption"]),
+        backup: !item["backup"] ? item["backup"] : backupSerializer(item["backup"]),
+        network: !item["network"] ? item["network"] : networkSerializer(item["network"]),
+        highAvailability: !item["highAvailability"]
+            ? item["highAvailability"]
+            : highAvailabilitySerializer(item["highAvailability"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowSerializer(item["maintenanceWindow"]),
+        sourceServerResourceId: item["sourceServerResourceId"],
+        pointInTimeUTC: !item["pointInTimeUTC"]
+            ? item["pointInTimeUTC"]
+            : item["pointInTimeUTC"].toISOString(),
+        availabilityZone: item["availabilityZone"],
+        replicationRole: item["replicationRole"],
+        replica: !item["replica"] ? item["replica"] : replicaSerializer(item["replica"]),
+        createMode: item["createMode"],
+        cluster: !item["cluster"] ? item["cluster"] : clusterSerializer(item["cluster"]),
+    };
+}
+export function serverPropertiesDeserializer(item) {
+    return {
+        administratorLogin: item["administratorLogin"],
+        administratorLoginPassword: item["administratorLoginPassword"],
+        version: item["version"],
+        minorVersion: item["minorVersion"],
+        state: item["state"],
+        fullyQualifiedDomainName: item["fullyQualifiedDomainName"],
+        storage: !item["storage"] ? item["storage"] : storageDeserializer(item["storage"]),
+        authConfig: !item["authConfig"]
+            ? item["authConfig"]
+            : authConfigDeserializer(item["authConfig"]),
+        dataEncryption: !item["dataEncryption"]
+            ? item["dataEncryption"]
+            : dataEncryptionDeserializer(item["dataEncryption"]),
+        backup: !item["backup"] ? item["backup"] : backupDeserializer(item["backup"]),
+        network: !item["network"] ? item["network"] : networkDeserializer(item["network"]),
+        highAvailability: !item["highAvailability"]
+            ? item["highAvailability"]
+            : highAvailabilityDeserializer(item["highAvailability"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowDeserializer(item["maintenanceWindow"]),
+        sourceServerResourceId: item["sourceServerResourceId"],
+        pointInTimeUTC: !item["pointInTimeUTC"]
+            ? item["pointInTimeUTC"]
+            : new Date(item["pointInTimeUTC"]),
+        availabilityZone: item["availabilityZone"],
+        replicationRole: item["replicationRole"],
+        replicaCapacity: item["replicaCapacity"],
+        replica: !item["replica"] ? item["replica"] : replicaDeserializer(item["replica"]),
+        createMode: item["createMode"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        cluster: !item["cluster"] ? item["cluster"] : clusterDeserializer(item["cluster"]),
+    };
+}
+/** Major version of PostgreSQL database engine. */
+export var KnownPostgresMajorVersion;
+(function (KnownPostgresMajorVersion) {
+    /** PostgreSQL 18. */
+    KnownPostgresMajorVersion["Eighteen"] = "18";
+    /** PostgreSQL 17. */
+    KnownPostgresMajorVersion["Seventeen"] = "17";
+    /** PostgreSQL 16. */
+    KnownPostgresMajorVersion["Sixteen"] = "16";
+    /** PostgreSQL 15. */
+    KnownPostgresMajorVersion["Fifteen"] = "15";
+    /** PostgreSQL 14. */
+    KnownPostgresMajorVersion["Fourteen"] = "14";
+    /** PostgreSQL 13. */
+    KnownPostgresMajorVersion["Thirteen"] = "13";
+    /** PostgreSQL 12. */
+    KnownPostgresMajorVersion["Twelve"] = "12";
+    /** PostgreSQL 11. */
+    KnownPostgresMajorVersion["Eleven"] = "11";
+})(KnownPostgresMajorVersion || (KnownPostgresMajorVersion = {}));
+/** State of a server. */
+export var KnownServerState;
+(function (KnownServerState) {
+    /** Server is healthy and not undergoing any operations at the management or control plane level. This doesn't mean that the server is fully operational at the data plane level. */
+    KnownServerState["Ready"] = "Ready";
+    /** Server is being deleted. */
+    KnownServerState["Dropping"] = "Dropping";
+    /** Server is disabled. Typical reasons include: the subscription on which the server is deployed is explicitly disabled or canceled by the administrator, the spending limit has been reached, or the bill is past due. May also happen when the server is being moved to another resource group or subscription. */
+    KnownServerState["Disabled"] = "Disabled";
+    /** PostgreSQL database engine is being restarted. */
+    KnownServerState["Starting"] = "Starting";
+    /** Compute resources associated with the server are being stopped and deallocated. If the server has high availability enabled, the compute resources of the standby server are also stopped and deallocated. */
+    KnownServerState["Stopping"] = "Stopping";
+    /** Compute resources associated with the server are being stopped and deallocated. */
+    KnownServerState["Stopped"] = "Stopped";
+    /** Server is undergoing some changes which may or may not impact the availability of the PostgreSQL database engine. For example, the compute resources of the server are being scaled up or down, which may cause temporary unavailability of the database engine. Or, for example, a firewall rule is being added or removed, which doesn't cause any unavailability of the database engine. */
+    KnownServerState["Updating"] = "Updating";
+    /** PostgreSQL database engine is being restarted. */
+    KnownServerState["Restarting"] = "Restarting";
+    /** Server isn't accessible, because the key provided to encrypt and decrypt the data is in invalid state. */
+    KnownServerState["Inaccessible"] = "Inaccessible";
+    /** Server is in the process of being created. */
+    KnownServerState["Provisioning"] = "Provisioning";
+})(KnownServerState || (KnownServerState = {}));
+export function storageSerializer(item) {
+    return {
+        storageSizeGB: item["storageSizeGB"],
+        autoGrow: item["autoGrow"],
+        tier: item["tier"],
+        iops: item["iops"],
+        throughput: item["throughput"],
+        type: item["type"],
+    };
+}
+export function storageDeserializer(item) {
+    return {
+        storageSizeGB: item["storageSizeGB"],
+        autoGrow: item["autoGrow"],
+        tier: item["tier"],
+        iops: item["iops"],
+        throughput: item["throughput"],
+        type: item["type"],
+    };
+}
+/** Indicates if the server is configured to automatically grow storage size when available space is nearing zero and conditions allow for automatic growing storage size. */
+export var KnownStorageAutoGrow;
+(function (KnownStorageAutoGrow) {
+    /** Server should automatically grow storage size when available space is nearing zero and conditions allow for automatically growing storage size. */
+    KnownStorageAutoGrow["Enabled"] = "Enabled";
+    /** Server should not automatically grow storage size when available space is nearing zero. */
+    KnownStorageAutoGrow["Disabled"] = "Disabled";
+})(KnownStorageAutoGrow || (KnownStorageAutoGrow = {}));
+/** Storage tier of a server. */
+export var KnownAzureManagedDiskPerformanceTier;
+(function (KnownAzureManagedDiskPerformanceTier) {
+    /** Entry-level SSD for minimal IOPS, ideal for light development or testing workloads. */
+    KnownAzureManagedDiskPerformanceTier["P1"] = "P1";
+    /** Slightly higher IOPS for small-scale applications needing consistent low latency. */
+    KnownAzureManagedDiskPerformanceTier["P2"] = "P2";
+    /** Balanced performance for basic production workloads with moderate throughput. */
+    KnownAzureManagedDiskPerformanceTier["P3"] = "P3";
+    /** Enhanced IOPS for growing apps with predictable performance needs. */
+    KnownAzureManagedDiskPerformanceTier["P4"] = "P4";
+    /** Mid-tier SSD for steady workloads requiring reliable throughput and latency. */
+    KnownAzureManagedDiskPerformanceTier["P6"] = "P6";
+    /** Popular choice for general-purpose production workloads with scalable performance. */
+    KnownAzureManagedDiskPerformanceTier["P10"] = "P10";
+    /** High IOPS tier for demanding apps with frequent read/write operations. */
+    KnownAzureManagedDiskPerformanceTier["P15"] = "P15";
+    /** Entry point for high-performance Solid State Disks (SSDs), suitable for small-scale I/O-intensive workloads. */
+    KnownAzureManagedDiskPerformanceTier["P20"] = "P20";
+    /** Balanced tier for moderate throughput and latency-sensitive applications. */
+    KnownAzureManagedDiskPerformanceTier["P30"] = "P30";
+    /** Enhanced performance for growing production workloads with consistent IOPS demands. */
+    KnownAzureManagedDiskPerformanceTier["P40"] = "P40";
+    /** Optimized for enterprise-grade applications needing sustained high throughput. */
+    KnownAzureManagedDiskPerformanceTier["P50"] = "P50";
+    /** High-capacity tier for large databases and analytics workloads with elevated IOPS. */
+    KnownAzureManagedDiskPerformanceTier["P60"] = "P60";
+    /** Designed for mission-critical systems requiring ultra-low latency and high concurrency. */
+    KnownAzureManagedDiskPerformanceTier["P70"] = "P70";
+    /** Top-tier SSD for maximum IOPS and throughput, ideal for the most demanding workloads. */
+    KnownAzureManagedDiskPerformanceTier["P80"] = "P80";
+})(KnownAzureManagedDiskPerformanceTier || (KnownAzureManagedDiskPerformanceTier = {}));
+/** Type of storage assigned to a server. If not specified, it defaults to Premium_LRS. */
+export var KnownStorageType;
+(function (KnownStorageType) {
+    /** Standard Solid State Disk (SSD) backed storage offering consistent performance for general purpose workloads. */
+    KnownStorageType["PremiumLRS"] = "Premium_LRS";
+    /** Next generation Solid State Disk (SSD) storage with improved scalability and performance for demanding enterprise workloads. */
+    KnownStorageType["PremiumV2LRS"] = "PremiumV2_LRS";
+    /** High-end Solid State Disk (SSD) storage designed for extreme IOPS and latency-sensitive applications. */
+    KnownStorageType["UltraSSDLRS"] = "UltraSSD_LRS";
+})(KnownStorageType || (KnownStorageType = {}));
+export function authConfigSerializer(item) {
+    return {
+        activeDirectoryAuth: item["activeDirectoryAuth"],
+        passwordAuth: item["passwordAuth"],
+        tenantId: item["tenantId"],
+    };
+}
+export function authConfigDeserializer(item) {
+    return {
+        activeDirectoryAuth: item["activeDirectoryAuth"],
+        passwordAuth: item["passwordAuth"],
+        tenantId: item["tenantId"],
+    };
+}
+/** Indicates if the server supports Microsoft Entra authentication. */
+export var KnownMicrosoftEntraAuth;
+(function (KnownMicrosoftEntraAuth) {
+    /** Server supports Microsoft Entra authentication. */
+    KnownMicrosoftEntraAuth["Enabled"] = "Enabled";
+    /** Server does not support Microsoft Entra authentication. */
+    KnownMicrosoftEntraAuth["Disabled"] = "Disabled";
+})(KnownMicrosoftEntraAuth || (KnownMicrosoftEntraAuth = {}));
+/** Indicates if the server supports password based authentication. */
+export var KnownPasswordBasedAuth;
+(function (KnownPasswordBasedAuth) {
+    /** Server supports password based authentication. */
+    KnownPasswordBasedAuth["Enabled"] = "Enabled";
+    /** Server does not support password based authentication. */
+    KnownPasswordBasedAuth["Disabled"] = "Disabled";
+})(KnownPasswordBasedAuth || (KnownPasswordBasedAuth = {}));
+export function dataEncryptionSerializer(item) {
+    return {
+        primaryKeyURI: item["primaryKeyURI"],
+        primaryUserAssignedIdentityId: item["primaryUserAssignedIdentityId"],
+        geoBackupKeyURI: item["geoBackupKeyURI"],
+        geoBackupUserAssignedIdentityId: item["geoBackupUserAssignedIdentityId"],
+        type: item["type"],
+        primaryFederatedIdentityClientId: item["primaryFederatedIdentityClientId"],
+        geoBackupFederatedIdentityClientId: item["geoBackupFederatedIdentityClientId"],
+    };
+}
+export function dataEncryptionDeserializer(item) {
+    return {
+        primaryKeyURI: item["primaryKeyURI"],
+        primaryUserAssignedIdentityId: item["primaryUserAssignedIdentityId"],
+        geoBackupKeyURI: item["geoBackupKeyURI"],
+        geoBackupUserAssignedIdentityId: item["geoBackupUserAssignedIdentityId"],
+        type: item["type"],
+        primaryEncryptionKeyStatus: item["primaryEncryptionKeyStatus"],
+        geoBackupEncryptionKeyStatus: item["geoBackupEncryptionKeyStatus"],
+        primaryFederatedIdentityClientId: item["primaryFederatedIdentityClientId"],
+        geoBackupFederatedIdentityClientId: item["geoBackupFederatedIdentityClientId"],
+    };
+}
+/** Data encryption type used by a server. */
+export var KnownDataEncryptionType;
+(function (KnownDataEncryptionType) {
+    /** Encryption managed by Azure using platform managed keys for simplicity and compliance. */
+    KnownDataEncryptionType["SystemManaged"] = "SystemManaged";
+    /** Encryption using customer managed keys stored in Azure Key Vault for enhanced control and security. */
+    KnownDataEncryptionType["AzureKeyVault"] = "AzureKeyVault";
+})(KnownDataEncryptionType || (KnownDataEncryptionType = {}));
+/** Status of key used by a server configured with data encryption based on customer managed key, to encrypt the primary storage associated to the server. */
+export var KnownEncryptionKeyStatus;
+(function (KnownEncryptionKeyStatus) {
+    /** Key is valid and can be used for encryption. */
+    KnownEncryptionKeyStatus["Valid"] = "Valid";
+    /** Key is invalid and cannot be used for encryption. Possible causes include key deletion, permission changes, key being disabled, key type not supported, or current date being outside of validity period associated to the key. */
+    KnownEncryptionKeyStatus["Invalid"] = "Invalid";
+})(KnownEncryptionKeyStatus || (KnownEncryptionKeyStatus = {}));
+export function backupSerializer(item) {
+    return {
+        backupRetentionDays: item["backupRetentionDays"],
+        geoRedundantBackup: item["geoRedundantBackup"],
+    };
+}
+export function backupDeserializer(item) {
+    return {
+        backupRetentionDays: item["backupRetentionDays"],
+        geoRedundantBackup: item["geoRedundantBackup"],
+        earliestRestoreDate: !item["earliestRestoreDate"]
+            ? item["earliestRestoreDate"]
+            : new Date(item["earliestRestoreDate"]),
+    };
+}
+/** Indicates if the server is configured to create geographically redundant backups. */
+export var KnownGeographicallyRedundantBackup;
+(function (KnownGeographicallyRedundantBackup) {
+    /** Server is configured to create geographically redundant backups. */
+    KnownGeographicallyRedundantBackup["Enabled"] = "Enabled";
+    /** Server is not configured to create geographically redundant backups. */
+    KnownGeographicallyRedundantBackup["Disabled"] = "Disabled";
+})(KnownGeographicallyRedundantBackup || (KnownGeographicallyRedundantBackup = {}));
+export function networkSerializer(item) {
+    return {
+        publicNetworkAccess: item["publicNetworkAccess"],
+        delegatedSubnetResourceId: item["delegatedSubnetResourceId"],
+        privateDnsZoneArmResourceId: item["privateDnsZoneArmResourceId"],
+    };
+}
+export function networkDeserializer(item) {
+    return {
+        publicNetworkAccess: item["publicNetworkAccess"],
+        delegatedSubnetResourceId: item["delegatedSubnetResourceId"],
+        privateDnsZoneArmResourceId: item["privateDnsZoneArmResourceId"],
+    };
+}
+/** Indicates if public network access is enabled or not. */
+export var KnownServerPublicNetworkAccessState;
+(function (KnownServerPublicNetworkAccessState) {
+    /** Public network access is enabled. This allows the server to be accessed from the public internet, provided the necessary firewall rule that allows incoming traffic originating from the connecting client is in place. This is compatible with the use of private endpoints to connect to this server. */
+    KnownServerPublicNetworkAccessState["Enabled"] = "Enabled";
+    /** Public network access is disabled. This means the server cannot be accessed from the public internet, but only via private endpoints. */
+    KnownServerPublicNetworkAccessState["Disabled"] = "Disabled";
+})(KnownServerPublicNetworkAccessState || (KnownServerPublicNetworkAccessState = {}));
+export function highAvailabilitySerializer(item) {
+    return { mode: item["mode"], standbyAvailabilityZone: item["standbyAvailabilityZone"] };
+}
+export function highAvailabilityDeserializer(item) {
+    return {
+        mode: item["mode"],
+        state: item["state"],
+        standbyAvailabilityZone: item["standbyAvailabilityZone"],
+    };
+}
+/** Mode of high availability supported for this compute. */
+export var KnownPostgreSqlFlexibleServerHighAvailabilityMode;
+(function (KnownPostgreSqlFlexibleServerHighAvailabilityMode) {
+    /** High availability is disabled for the server. */
+    KnownPostgreSqlFlexibleServerHighAvailabilityMode["Disabled"] = "Disabled";
+    /** High availability is enabled for the server, with standby server in a different availability zone than that of the primary. */
+    KnownPostgreSqlFlexibleServerHighAvailabilityMode["ZoneRedundant"] = "ZoneRedundant";
+    /** High availability is enabled for the server, with standby server in the same availability zone as the primary. */
+    KnownPostgreSqlFlexibleServerHighAvailabilityMode["SameZone"] = "SameZone";
+})(KnownPostgreSqlFlexibleServerHighAvailabilityMode || (KnownPostgreSqlFlexibleServerHighAvailabilityMode = {}));
+/** Possible states of the standby server created when high availability is set to SameZone or ZoneRedundant. */
+export var KnownHighAvailabilityState;
+(function (KnownHighAvailabilityState) {
+    /** High availability is not enabled for the server. */
+    KnownHighAvailabilityState["NotEnabled"] = "NotEnabled";
+    /** Standby server is being created. */
+    KnownHighAvailabilityState["CreatingStandby"] = "CreatingStandby";
+    /** Data is being replicated to the standby server. */
+    KnownHighAvailabilityState["ReplicatingData"] = "ReplicatingData";
+    /** Failover operation to the standby server is in progress. */
+    KnownHighAvailabilityState["FailingOver"] = "FailingOver";
+    /** Standby server is healthy and ready to take over in case of a failover. */
+    KnownHighAvailabilityState["Healthy"] = "Healthy";
+    /** Standby server is being removed. */
+    KnownHighAvailabilityState["RemovingStandby"] = "RemovingStandby";
+    /** Standby server is being recreated. */
+    KnownHighAvailabilityState["RecreatingStandby"] = "RecreatingStandby";
+    /** Compute is being updated due to a failover. */
+    KnownHighAvailabilityState["ComputeUpdatingByFailover"] = "ComputeUpdatingByFailover";
+})(KnownHighAvailabilityState || (KnownHighAvailabilityState = {}));
+export function maintenanceWindowSerializer(item) {
+    return {
+        customWindow: item["customWindow"],
+        startHour: item["startHour"],
+        startMinute: item["startMinute"],
+        dayOfWeek: item["dayOfWeek"],
+    };
+}
+export function maintenanceWindowDeserializer(item) {
+    return {
+        customWindow: item["customWindow"],
+        startHour: item["startHour"],
+        startMinute: item["startMinute"],
+        dayOfWeek: item["dayOfWeek"],
+    };
+}
+/** Role of the server in a replication set. */
+export var KnownReplicationRole;
+(function (KnownReplicationRole) {
+    /** No replication role assigned; the server operates independently. */
+    KnownReplicationRole["None"] = "None";
+    /** Acts as the source server for replication to one or more replicas. */
+    KnownReplicationRole["Primary"] = "Primary";
+    /** Receives data asynchronously from a primary server within the same region. */
+    KnownReplicationRole["AsyncReplica"] = "AsyncReplica";
+    /** Receives data asynchronously from a primary server in a different region for geographical redundancy. */
+    KnownReplicationRole["GeoAsyncReplica"] = "GeoAsyncReplica";
+})(KnownReplicationRole || (KnownReplicationRole = {}));
+export function replicaSerializer(item) {
+    return {
+        role: item["role"],
+        promoteMode: item["promoteMode"],
+        promoteOption: item["promoteOption"],
+    };
+}
+export function replicaDeserializer(item) {
+    return {
+        role: item["role"],
+        capacity: item["capacity"],
+        replicationState: item["replicationState"],
+        promoteMode: item["promoteMode"],
+        promoteOption: item["promoteOption"],
+    };
+}
+/** Indicates the replication state of a read replica. This property is returned only when the target server is a read replica. */
+export var KnownReplicationState;
+(function (KnownReplicationState) {
+    /** Read replica server is fully synchronized and actively replicating data from the primary server. */
+    KnownReplicationState["Active"] = "Active";
+    /** Read replica server is behind the primary server and is currently catching up with pending changes. */
+    KnownReplicationState["Catchup"] = "Catchup";
+    /** Read replica server is being created and is in process of getting initialized. */
+    KnownReplicationState["Provisioning"] = "Provisioning";
+    /** Read replica server is undergoing some changes it can be changing compute size of promoting it to primary server. */
+    KnownReplicationState["Updating"] = "Updating";
+    /** Replication has failed or been interrupted. */
+    KnownReplicationState["Broken"] = "Broken";
+    /** Read replica server is being reconfigured, possibly due to changes in source or settings. */
+    KnownReplicationState["Reconfiguring"] = "Reconfiguring";
+})(KnownReplicationState || (KnownReplicationState = {}));
+/** Type of operation to apply on the read replica. This property is write only. */
+export var KnownReadReplicaPromoteMode;
+(function (KnownReadReplicaPromoteMode) {
+    /** Read replica will become an independent server, and a completely independent entity from the replication set. */
+    KnownReadReplicaPromoteMode["Standalone"] = "Standalone";
+    /** Read replica will swap roles with primary server. */
+    KnownReadReplicaPromoteMode["Switchover"] = "Switchover";
+})(KnownReadReplicaPromoteMode || (KnownReadReplicaPromoteMode = {}));
+/** Data synchronization option to use when processing the operation specified in the promoteMode property. This property is write only. */
+export var KnownReadReplicaPromoteOption;
+(function (KnownReadReplicaPromoteOption) {
+    /** Wait for data in the read replica to be fully synchronized with its source server before it initiates the operation. */
+    KnownReadReplicaPromoteOption["Planned"] = "Planned";
+    /** Initiate the operation immediately, without waiting for data in the read replica to be synchronized with its source server. */
+    KnownReadReplicaPromoteOption["Forced"] = "Forced";
+})(KnownReadReplicaPromoteOption || (KnownReadReplicaPromoteOption = {}));
+/** Creation mode of a new server. */
+export var KnownCreateMode;
+(function (KnownCreateMode) {
+    /** If the operation is triggered on a non-existing server, it's equivalent to 'Create'. If the operation is triggered on an existing server, it's equivalent to 'Update'. */
+    KnownCreateMode["Default"] = "Default";
+    /** Operation creates a new server. */
+    KnownCreateMode["Create"] = "Create";
+    /** Operation updates an existing server. */
+    KnownCreateMode["Update"] = "Update";
+    /** Operation restores an existing backup of an existing server. This operation creates a new server, and then restores on it the backup of an existing server at a specific point in time. */
+    KnownCreateMode["PointInTimeRestore"] = "PointInTimeRestore";
+    /** Operation restores an existing backup of an existing server, on the paired region of the existing server. This operation creates a new server on the paired region of the existing server, and then restores on it the backup of an existing server at a specific point in time, in a different region. This operation is only supported on existing servers that were created with geographically redundant backups enabled. */
+    KnownCreateMode["GeoRestore"] = "GeoRestore";
+    /** Operation creates a replica of an existing server. This operation creates a new server, restores a base backup of the existing server (referred to as primary), and configures physical replication to asynchronously stream all changes which are recorded in the transaction log of the primary. */
+    KnownCreateMode["Replica"] = "Replica";
+    /** Operation creates a new server, initialized with the backup of a server that was recently deleted. */
+    KnownCreateMode["ReviveDropped"] = "ReviveDropped";
+})(KnownCreateMode || (KnownCreateMode = {}));
+export function privateEndpointConnectionArraySerializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionSerializer(item);
+    });
+}
+export function privateEndpointConnectionArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionDeserializer(item);
+    });
+}
+export function privateEndpointConnectionSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["privateEndpoint", "privateLinkServiceConnectionState"])
+            ? undefined
+            : _privateEndpointConnectionPropertiesSerializer(item),
+    };
+}
+export function privateEndpointConnectionDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _privateEndpointConnectionPropertiesDeserializer(item["properties"])),
+    };
+}
+export function privateEndpointConnectionPropertiesSerializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointSerializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: privateLinkServiceConnectionStateSerializer(item["privateLinkServiceConnectionState"]),
+    };
+}
+export function privateEndpointConnectionPropertiesDeserializer(item) {
+    return {
+        groupIds: !item["groupIds"]
+            ? item["groupIds"]
+            : item["groupIds"].map((p) => {
+                return p;
+            }),
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: privateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+        provisioningState: item["provisioningState"],
+    };
+}
+export function privateEndpointSerializer(_item) {
+    return {};
+}
+export function privateEndpointDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function privateLinkServiceConnectionStateSerializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+export function privateLinkServiceConnectionStateDeserializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+/** The private endpoint connection status. */
+export var KnownPrivateEndpointServiceConnectionStatus;
+(function (KnownPrivateEndpointServiceConnectionStatus) {
+    /** Connection waiting for approval or rejection */
+    KnownPrivateEndpointServiceConnectionStatus["Pending"] = "Pending";
+    /** Connection approved */
+    KnownPrivateEndpointServiceConnectionStatus["Approved"] = "Approved";
+    /** Connection Rejected */
+    KnownPrivateEndpointServiceConnectionStatus["Rejected"] = "Rejected";
+})(KnownPrivateEndpointServiceConnectionStatus || (KnownPrivateEndpointServiceConnectionStatus = {}));
+/** The current provisioning state. */
+export var KnownPrivateEndpointConnectionProvisioningState;
+(function (KnownPrivateEndpointConnectionProvisioningState) {
+    /** Connection has been provisioned */
+    KnownPrivateEndpointConnectionProvisioningState["Succeeded"] = "Succeeded";
+    /** Connection is being created */
+    KnownPrivateEndpointConnectionProvisioningState["Creating"] = "Creating";
+    /** Connection is being deleted */
+    KnownPrivateEndpointConnectionProvisioningState["Deleting"] = "Deleting";
+    /** Connection provisioning has failed */
+    KnownPrivateEndpointConnectionProvisioningState["Failed"] = "Failed";
+})(KnownPrivateEndpointConnectionProvisioningState || (KnownPrivateEndpointConnectionProvisioningState = {}));
+export function clusterSerializer(item) {
+    return { clusterSize: item["clusterSize"], defaultDatabaseName: item["defaultDatabaseName"] };
+}
+export function clusterDeserializer(item) {
+    return {
+        clusterSize: item["clusterSize"],
+        defaultDatabaseName: item["defaultDatabaseName"],
+    };
+}
+export function skuSerializer(item) {
+    return { name: item["name"], tier: item["tier"] };
+}
+export function skuDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+    };
+}
+export function userAssignedIdentitySerializer(item) {
+    return {
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userIdentityRecordSerializer(item["userAssignedIdentities"]),
+        principalId: item["principalId"],
+        type: item["type"],
+    };
+}
+export function userAssignedIdentityDeserializer(item) {
+    return {
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userIdentityRecordDeserializer(item["userAssignedIdentities"]),
+        principalId: item["principalId"],
+        type: item["type"],
+        tenantId: item["tenantId"],
+    };
+}
+export function userIdentityRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userIdentitySerializer(item[key]);
+    });
+    return result;
+}
+export function userIdentityRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userIdentityDeserializer(item[key]);
+    });
+    return result;
+}
+export function userIdentitySerializer(item) {
+    return { principalId: item["principalId"], clientId: item["clientId"] };
+}
+export function userIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+/** Types of identities associated with a server. */
+export var KnownIdentityType;
+(function (KnownIdentityType) {
+    /** No managed identity is assigned to the server. */
+    KnownIdentityType["None"] = "None";
+    /** One or more managed identities provided by the user are assigned to the server. */
+    KnownIdentityType["UserAssigned"] = "UserAssigned";
+    /** Azure automatically creates and manages the identity associated to the lifecycle of the server. */
+    KnownIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** Both system-assigned and user-assigned identities are assigned to the server. */
+    KnownIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned,UserAssigned";
+})(KnownIdentityType || (KnownIdentityType = {}));
+export function serverForPatchSerializer(item) {
+    return {
+        sku: !item["sku"] ? item["sku"] : skuForPatchSerializer(item["sku"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : userAssignedIdentitySerializer(item["identity"]),
+        properties: areAllPropsUndefined(item, [
+            "administratorLoginPassword",
+            "version",
+            "storage",
+            "backup",
+            "highAvailability",
+            "maintenanceWindow",
+            "authConfig",
+            "dataEncryption",
+            "availabilityZone",
+            "createMode",
+            "replicationRole",
+            "replica",
+            "network",
+            "cluster",
+        ])
+            ? undefined
+            : _serverForPatchPropertiesSerializer(item),
+        tags: item["tags"],
+    };
+}
+export function skuForPatchSerializer(item) {
+    return { name: item["name"], tier: item["tier"] };
+}
+export function serverPropertiesForPatchSerializer(item) {
+    return {
+        administratorLoginPassword: item["administratorLoginPassword"],
+        version: item["version"],
+        storage: !item["storage"] ? item["storage"] : storageSerializer(item["storage"]),
+        backup: !item["backup"] ? item["backup"] : backupForPatchSerializer(item["backup"]),
+        highAvailability: !item["highAvailability"]
+            ? item["highAvailability"]
+            : highAvailabilityForPatchSerializer(item["highAvailability"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowForPatchSerializer(item["maintenanceWindow"]),
+        authConfig: !item["authConfig"]
+            ? item["authConfig"]
+            : authConfigForPatchSerializer(item["authConfig"]),
+        dataEncryption: !item["dataEncryption"]
+            ? item["dataEncryption"]
+            : dataEncryptionSerializer(item["dataEncryption"]),
+        availabilityZone: item["availabilityZone"],
+        createMode: item["createMode"],
+        replicationRole: item["replicationRole"],
+        replica: !item["replica"] ? item["replica"] : replicaSerializer(item["replica"]),
+        network: !item["network"] ? item["network"] : networkSerializer(item["network"]),
+        cluster: !item["cluster"] ? item["cluster"] : clusterSerializer(item["cluster"]),
+    };
+}
+export function backupForPatchSerializer(item) {
+    return { backupRetentionDays: item["backupRetentionDays"] };
+}
+export function highAvailabilityForPatchSerializer(item) {
+    return { mode: item["mode"], standbyAvailabilityZone: item["standbyAvailabilityZone"] };
+}
+export function maintenanceWindowForPatchSerializer(item) {
+    return {
+        customWindow: item["customWindow"],
+        startHour: item["startHour"],
+        startMinute: item["startMinute"],
+        dayOfWeek: item["dayOfWeek"],
+    };
+}
+export function authConfigForPatchSerializer(item) {
+    return {
+        activeDirectoryAuth: item["activeDirectoryAuth"],
+        passwordAuth: item["passwordAuth"],
+        tenantId: item["tenantId"],
+    };
+}
+/** Update mode of an existing server. */
+export var KnownCreateModeForPatch;
+(function (KnownCreateModeForPatch) {
+    /** It's equivalent to 'Update'. */
+    KnownCreateModeForPatch["Default"] = "Default";
+    /** Operation updates an existing server. */
+    KnownCreateModeForPatch["Update"] = "Update";
+})(KnownCreateModeForPatch || (KnownCreateModeForPatch = {}));
+export function _serverListDeserializer(item) {
+    return {
+        value: serverArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function serverArraySerializer(result) {
+    return result.map((item) => {
+        return serverSerializer(item);
+    });
+}
+export function serverArrayDeserializer(result) {
+    return result.map((item) => {
+        return serverDeserializer(item);
+    });
+}
+export function restartParameterSerializer(item) {
+    return { restartWithFailover: item["restartWithFailover"], failoverMode: item["failoverMode"] };
+}
+/** Failover mode. */
+export var KnownFailoverMode;
+(function (KnownFailoverMode) {
+    /** Trigger a failover from primary to standby without killing the primary database process first. This is a graceful failover that attempts to preserve data consistency. */
+    KnownFailoverMode["PlannedFailover"] = "PlannedFailover";
+    /** Terminate the primary database process first, then triggers the failover. This is more aggressive and used when the primary is unresponsive or in an unhealthy state. */
+    KnownFailoverMode["ForcedFailover"] = "ForcedFailover";
+    /** Similar to 'PlannedFailover' but prefers a switch over operation where roles are swapped between primary and standby. */
+    KnownFailoverMode["PlannedSwitchover"] = "PlannedSwitchover";
+    /** Terminate the primary database process first, and then triggers a switch over with role swapping. */
+    KnownFailoverMode["ForcedSwitchover"] = "ForcedSwitchover";
+})(KnownFailoverMode || (KnownFailoverMode = {}));
+export function migrateNetworkStatusDeserializer(item) {
+    return {
+        subscriptionId: item["subscriptionId"],
+        resourceGroupName: item["resourceGroupName"],
+        serverName: item["serverName"],
+        state: item["state"],
+    };
+}
+/** State of the network migration operation. */
+export var KnownNetworkMigrationState;
+(function (KnownNetworkMigrationState) {
+    /** Network migration is pending. */
+    KnownNetworkMigrationState["Pending"] = "Pending";
+    /** Network migration is in progress. */
+    KnownNetworkMigrationState["InProgress"] = "InProgress";
+    /** Network migration succeeded. */
+    KnownNetworkMigrationState["Succeeded"] = "Succeeded";
+    /** Network migration failed. */
+    KnownNetworkMigrationState["Failed"] = "Failed";
+    /** Network migration cancellation is in progress. */
+    KnownNetworkMigrationState["CancelInProgress"] = "CancelInProgress";
+    /** Network migration was cancelled. */
+    KnownNetworkMigrationState["Cancelled"] = "Cancelled";
+})(KnownNetworkMigrationState || (KnownNetworkMigrationState = {}));
+export function startMajorVersionUpgradePrecheckRequestSerializer(item) {
+    return { targetVersion: item["targetVersion"] };
+}
+export function startMajorVersionUpgradePrecheckResponseDeserializer(item) {
+    return {
+        name: item["name"],
+        createTime: !item["createTime"] ? item["createTime"] : new Date(item["createTime"]),
+        status: item["status"],
+    };
+}
+/** The status of the major version upgrade precheck. */
+export var KnownMajorVersionUpgradePrecheckStatus;
+(function (KnownMajorVersionUpgradePrecheckStatus) {
+    /** Executing prechecks against the source server */
+    KnownMajorVersionUpgradePrecheckStatus["Validating"] = "Validating";
+    /** Validation succeeded */
+    KnownMajorVersionUpgradePrecheckStatus["Succeeded"] = "Succeeded";
+    /** Validation failed */
+    KnownMajorVersionUpgradePrecheckStatus["Failed"] = "Failed";
+    /** Validation canceled */
+    KnownMajorVersionUpgradePrecheckStatus["Canceled"] = "Canceled";
+})(KnownMajorVersionUpgradePrecheckStatus || (KnownMajorVersionUpgradePrecheckStatus = {}));
+export function configurationDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _configurationPropertiesDeserializer(item["properties"])),
+    };
+}
+export function configurationPropertiesSerializer(item) {
+    return { value: item["value"], source: item["source"] };
+}
+export function configurationPropertiesDeserializer(item) {
+    return {
+        value: item["value"],
+        description: item["description"],
+        defaultValue: item["defaultValue"],
+        dataType: item["dataType"],
+        allowedValues: item["allowedValues"],
+        source: item["source"],
+        isDynamicConfig: item["isDynamicConfig"],
+        isReadOnly: item["isReadOnly"],
+        isConfigPendingRestart: item["isConfigPendingRestart"],
+        unit: item["unit"],
+        documentationLink: item["documentationLink"],
+    };
+}
+/** Data type of the configuration (also known as server parameter). */
+export var KnownConfigurationDataType;
+(function (KnownConfigurationDataType) {
+    /** A boolean value. */
+    KnownConfigurationDataType["Boolean"] = "Boolean";
+    /** A numeric value. */
+    KnownConfigurationDataType["Numeric"] = "Numeric";
+    /** An integer value. */
+    KnownConfigurationDataType["Integer"] = "Integer";
+    /** An enumeration value. */
+    KnownConfigurationDataType["Enumeration"] = "Enumeration";
+    /** A string value. */
+    KnownConfigurationDataType["String"] = "String";
+    /** A set of values. */
+    KnownConfigurationDataType["Set"] = "Set";
+})(KnownConfigurationDataType || (KnownConfigurationDataType = {}));
+export function proxyResourceSerializer(_item) {
+    return {};
+}
+export function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function configurationForUpdateSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["value", "source"])
+            ? undefined
+            : _configurationForUpdatePropertiesSerializer(item),
+    };
+}
+export function _configurationListDeserializer(item) {
+    return {
+        value: configurationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function configurationArrayDeserializer(result) {
+    return result.map((item) => {
+        return configurationDeserializer(item);
+    });
+}
+export function databaseSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["charset", "collation"])
+            ? undefined
+            : _databasePropertiesSerializer(item),
+    };
+}
+export function databaseDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _databasePropertiesDeserializer(item["properties"])),
+    };
+}
+export function databasePropertiesSerializer(item) {
+    return { charset: item["charset"], collation: item["collation"] };
+}
+export function databasePropertiesDeserializer(item) {
+    return {
+        charset: item["charset"],
+        collation: item["collation"],
+    };
+}
+export function _databaseListDeserializer(item) {
+    return {
+        value: databaseArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function databaseArraySerializer(result) {
+    return result.map((item) => {
+        return databaseSerializer(item);
+    });
+}
+export function databaseArrayDeserializer(result) {
+    return result.map((item) => {
+        return databaseDeserializer(item);
+    });
+}
+export function firewallRuleSerializer(item) {
+    return { properties: _firewallRulePropertiesSerializer(item) };
+}
+export function firewallRuleDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ..._firewallRulePropertiesDeserializer(item["properties"]),
+    };
+}
+export function firewallRulePropertiesSerializer(item) {
+    return { startIpAddress: item["startIpAddress"], endIpAddress: item["endIpAddress"] };
+}
+export function firewallRulePropertiesDeserializer(item) {
+    return {
+        startIpAddress: item["startIpAddress"],
+        endIpAddress: item["endIpAddress"],
+    };
+}
+export function _firewallRuleListDeserializer(item) {
+    return {
+        value: firewallRuleArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function firewallRuleArraySerializer(result) {
+    return result.map((item) => {
+        return firewallRuleSerializer(item);
+    });
+}
+export function firewallRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return firewallRuleDeserializer(item);
+    });
+}
+export function _privateEndpointConnectionListDeserializer(item) {
+    return {
+        value: privateEndpointConnectionArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function privateLinkResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _privateLinkResourcePropertiesDeserializer(item["properties"])),
+    };
+}
+export function privateLinkResourcePropertiesDeserializer(item) {
+    return {
+        groupId: item["groupId"],
+        requiredMembers: !item["requiredMembers"]
+            ? item["requiredMembers"]
+            : item["requiredMembers"].map((p) => {
+                return p;
+            }),
+        requiredZoneNames: !item["requiredZoneNames"]
+            ? item["requiredZoneNames"]
+            : item["requiredZoneNames"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _privateLinkResourceListDeserializer(item) {
+    return {
+        value: privateLinkResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function privateLinkResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateLinkResourceDeserializer(item);
+    });
+}
+export function virtualEndpointSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["endpointType", "members"])
+            ? undefined
+            : _virtualEndpointPropertiesSerializer(item),
+    };
+}
+export function virtualEndpointDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _virtualEndpointPropertiesDeserializer(item["properties"])),
+    };
+}
+export function virtualEndpointResourcePropertiesSerializer(item) {
+    return {
+        endpointType: item["endpointType"],
+        members: !item["members"]
+            ? item["members"]
+            : item["members"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function virtualEndpointResourcePropertiesDeserializer(item) {
+    return {
+        endpointType: item["endpointType"],
+        members: !item["members"]
+            ? item["members"]
+            : item["members"].map((p) => {
+                return p;
+            }),
+        virtualEndpoints: !item["virtualEndpoints"]
+            ? item["virtualEndpoints"]
+            : item["virtualEndpoints"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** Type of endpoint for the virtual endpoints. */
+export var KnownVirtualEndpointType;
+(function (KnownVirtualEndpointType) {
+    /** Read-write endpoint. */
+    KnownVirtualEndpointType["ReadWrite"] = "ReadWrite";
+})(KnownVirtualEndpointType || (KnownVirtualEndpointType = {}));
+export function virtualEndpointResourceForPatchSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["endpointType", "members"])
+            ? undefined
+            : _virtualEndpointResourceForPatchPropertiesSerializer(item),
+    };
+}
+export function _virtualEndpointsListDeserializer(item) {
+    return {
+        value: virtualEndpointArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function virtualEndpointArraySerializer(result) {
+    return result.map((item) => {
+        return virtualEndpointSerializer(item);
+    });
+}
+export function virtualEndpointArrayDeserializer(result) {
+    return result.map((item) => {
+        return virtualEndpointDeserializer(item);
+    });
+}
+export function maintenanceEventResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : maintenanceEventResourcePropertiesDeserializer(item["properties"]),
+    };
+}
+export function maintenanceEventResourcePropertiesDeserializer(item) {
+    return {
+        maintenanceEventId: item["maintenanceEventId"],
+        maintenanceType: item["maintenanceType"],
+        description: item["description"],
+        status: item["status"],
+        startTime: new Date(item["startTime"]),
+        endTime: new Date(item["endTime"]),
+        estimatedDowntime: item["estimatedDowntime"],
+        deferrable: item["deferrable"],
+        deferralDeadline: !item["deferralDeadline"]
+            ? item["deferralDeadline"]
+            : new Date(item["deferralDeadline"]),
+        rescheduledFrom: !item["rescheduledFrom"]
+            ? item["rescheduledFrom"]
+            : new Date(item["rescheduledFrom"]),
+        lastUpdatedTime: !item["lastUpdatedTime"]
+            ? item["lastUpdatedTime"]
+            : new Date(item["lastUpdatedTime"]),
+        originalStartTime: new Date(item["originalStartTime"]),
+    };
+}
+/** Type of a maintenance event resource. */
+export var KnownMaintenanceType;
+(function (KnownMaintenanceType) {
+    /** Planned maintenance event. */
+    KnownMaintenanceType["PlannedMaintenance"] = "PlannedMaintenance";
+})(KnownMaintenanceType || (KnownMaintenanceType = {}));
+/** The status of a maintenance event. */
+export var KnownMaintenanceEventStatus;
+(function (KnownMaintenanceEventStatus) {
+    /** The maintenance event is scheduled and has not yet started. */
+    KnownMaintenanceEventStatus["Planned"] = "Planned";
+    /** The maintenance event is currently in progress. */
+    KnownMaintenanceEventStatus["InProgress"] = "InProgress";
+    /** The maintenance event has completed successfully. */
+    KnownMaintenanceEventStatus["Complete"] = "Complete";
+    /** The maintenance event has been rescheduled (postponed) by the customer. */
+    KnownMaintenanceEventStatus["Rescheduled"] = "Rescheduled";
+    /** The maintenance event was canceled, failed, or timed out. */
+    KnownMaintenanceEventStatus["Canceled"] = "Canceled";
+})(KnownMaintenanceEventStatus || (KnownMaintenanceEventStatus = {}));
+export function _maintenanceEventResourceListResultDeserializer(item) {
+    return {
+        value: maintenanceEventResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function maintenanceEventResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return maintenanceEventResourceDeserializer(item);
+    });
+}
+export function maintenanceEventRescheduleRequestSerializer(item) {
+    return { postponeToDateTime: item["postponeToDateTime"].toISOString() };
+}
+export function maintenanceEventActionResponseDeserializer(item) {
+    return {
+        maintenanceEventId: item["maintenanceEventId"],
+        serverId: item["serverId"],
+        status: item["status"],
+        plannedStartTime: !item["plannedStartTime"]
+            ? item["plannedStartTime"]
+            : new Date(item["plannedStartTime"]),
+        plannedEndTime: !item["plannedEndTime"]
+            ? item["plannedEndTime"]
+            : new Date(item["plannedEndTime"]),
+        appliedNow: item["appliedNow"],
+        lastUpdatedTime: !item["lastUpdatedTime"]
+            ? item["lastUpdatedTime"]
+            : new Date(item["lastUpdatedTime"]),
+    };
+}
+export function majorVersionUpgradePrecheckResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : majorVersionUpgradePrecheckResourcePropertiesDeserializer(item["properties"]),
+    };
+}
+export function majorVersionUpgradePrecheckResourcePropertiesDeserializer(item) {
+    return {
+        createTime: !item["createTime"] ? item["createTime"] : new Date(item["createTime"]),
+        status: item["status"],
+        precheckResult: !item["precheckResult"]
+            ? item["precheckResult"]
+            : precheckResultDeserializer(item["precheckResult"]),
+        targetVersion: item["targetVersion"],
+        policyDetails: !item["policyDetails"]
+            ? item["policyDetails"]
+            : policyDetailArrayDeserializer(item["policyDetails"]),
+    };
+}
+export function precheckResultDeserializer(item) {
+    return {
+        action: item["action"],
+        upgradeSequence: !item["upgradeSequence"]
+            ? item["upgradeSequence"]
+            : upgradeSequenceDeserializer(item["upgradeSequence"]),
+        errorInfo: !item["errorInfo"]
+            ? item["errorInfo"]
+            : precheckErrorInfoArrayDeserializer(item["errorInfo"]),
+    };
+}
+export function upgradeSequenceDeserializer(item) {
+    return {
+        sourceVersion: item["sourceVersion"],
+        targetVersion: item["targetVersion"],
+    };
+}
+export function precheckErrorInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return precheckErrorInfoDeserializer(item);
+    });
+}
+export function precheckErrorInfoDeserializer(item) {
+    return {
+        errorCode: item["errorCode"],
+        errorMessage: item["errorMessage"],
+    };
+}
+export function policyDetailArrayDeserializer(result) {
+    return result.map((item) => {
+        return policyDetailDeserializer(item);
+    });
+}
+export function policyDetailDeserializer(item) {
+    return {
+        policyName: item["policyName"],
+        passed: item["passed"],
+        errorCode: item["errorCode"],
+        errorMessage: item["errorMessage"],
+        policyDescription: item["policyDescription"],
+    };
+}
+export function _majorVersionUpgradePrecheckResourceListResultDeserializer(item) {
+    return {
+        value: majorVersionUpgradePrecheckResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function majorVersionUpgradePrecheckResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return majorVersionUpgradePrecheckResourceDeserializer(item);
+    });
+}
+export function administratorMicrosoftEntraDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ..._administratorMicrosoftEntraPropertiesDeserializer(item["properties"]),
+    };
+}
+export function administratorMicrosoftEntraPropertiesDeserializer(item) {
+    return {
+        principalType: item["principalType"],
+        principalName: item["principalName"],
+        objectId: item["objectId"],
+        tenantId: item["tenantId"],
+    };
+}
+/** Type of Microsoft Entra principal to which the server administrator is associated. */
+export var KnownPrincipalType;
+(function (KnownPrincipalType) {
+    /** Principal type is not known or not specified. */
+    KnownPrincipalType["Unknown"] = "Unknown";
+    /** A Microsoft Entra user. */
+    KnownPrincipalType["User"] = "User";
+    /** A Microsoft Entra group. */
+    KnownPrincipalType["Group"] = "Group";
+    /** A Microsoft Entra service principal, typically representing an application or service identity. */
+    KnownPrincipalType["ServicePrincipal"] = "ServicePrincipal";
+})(KnownPrincipalType || (KnownPrincipalType = {}));
+export function administratorMicrosoftEntraAddSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["principalType", "principalName", "tenantId"])
+            ? undefined
+            : _administratorMicrosoftEntraAddPropertiesSerializer(item),
+    };
+}
+export function administratorMicrosoftEntraPropertiesForAddSerializer(item) {
+    return {
+        principalType: item["principalType"],
+        principalName: item["principalName"],
+        tenantId: item["tenantId"],
+    };
+}
+export function _administratorMicrosoftEntraListDeserializer(item) {
+    return {
+        value: administratorMicrosoftEntraArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function administratorMicrosoftEntraArrayDeserializer(result) {
+    return result.map((item) => {
+        return administratorMicrosoftEntraDeserializer(item);
+    });
+}
+export function _capabilityListDeserializer(item) {
+    return {
+        value: capabilityArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function capabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return capabilityDeserializer(item);
+    });
+}
+export function capabilityDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+        name: item["name"],
+        supportedServerEditions: !item["supportedServerEditions"]
+            ? item["supportedServerEditions"]
+            : serverEditionCapabilityArrayDeserializer(item["supportedServerEditions"]),
+        supportedServerVersions: !item["supportedServerVersions"]
+            ? item["supportedServerVersions"]
+            : serverVersionCapabilityArrayDeserializer(item["supportedServerVersions"]),
+        supportedFeatures: !item["supportedFeatures"]
+            ? item["supportedFeatures"]
+            : supportedFeatureArrayDeserializer(item["supportedFeatures"]),
+        fastProvisioningSupported: item["fastProvisioningSupported"],
+        supportedFastProvisioningEditions: !item["supportedFastProvisioningEditions"]
+            ? item["supportedFastProvisioningEditions"]
+            : fastProvisioningEditionCapabilityArrayDeserializer(item["supportedFastProvisioningEditions"]),
+        geoBackupSupported: item["geoBackupSupported"],
+        zoneRedundantHaSupported: item["zoneRedundantHaSupported"],
+        zoneRedundantHaAndGeoBackupSupported: item["zoneRedundantHaAndGeoBackupSupported"],
+        storageAutoGrowthSupported: item["storageAutoGrowthSupported"],
+        onlineResizeSupported: item["onlineResizeSupported"],
+        restricted: item["restricted"],
+    };
+}
+export function serverEditionCapabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return serverEditionCapabilityDeserializer(item);
+    });
+}
+export function serverEditionCapabilityDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+        name: item["name"],
+        defaultSkuName: item["defaultSkuName"],
+        supportedStorageEditions: !item["supportedStorageEditions"]
+            ? item["supportedStorageEditions"]
+            : storageEditionCapabilityArrayDeserializer(item["supportedStorageEditions"]),
+        supportedServerSkus: !item["supportedServerSkus"]
+            ? item["supportedServerSkus"]
+            : serverSkuCapabilityArrayDeserializer(item["supportedServerSkus"]),
+    };
+}
+export function storageEditionCapabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageEditionCapabilityDeserializer(item);
+    });
+}
+export function storageEditionCapabilityDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+        name: item["name"],
+        defaultStorageSizeMb: item["defaultStorageSizeMb"],
+        supportedStorageMb: !item["supportedStorageMb"]
+            ? item["supportedStorageMb"]
+            : storageMbCapabilityArrayDeserializer(item["supportedStorageMb"]),
+    };
+}
+export function storageMbCapabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageMbCapabilityDeserializer(item);
+    });
+}
+export function storageMbCapabilityDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+        supportedIops: item["supportedIops"],
+        supportedMaximumIops: item["supportedMaximumIops"],
+        storageSizeMb: item["storageSizeMb"],
+        maximumStorageSizeMb: item["maximumStorageSizeMb"],
+        supportedThroughput: item["supportedThroughput"],
+        supportedMaximumThroughput: item["supportedMaximumThroughput"],
+        defaultIopsTier: item["defaultIopsTier"],
+        supportedIopsTiers: !item["supportedIopsTiers"]
+            ? item["supportedIopsTiers"]
+            : storageTierCapabilityArrayDeserializer(item["supportedIopsTiers"]),
+    };
+}
+export function storageTierCapabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageTierCapabilityDeserializer(item);
+    });
+}
+export function storageTierCapabilityDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+        name: item["name"],
+        iops: item["iops"],
+    };
+}
+export function serverSkuCapabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return serverSkuCapabilityDeserializer(item);
+    });
+}
+export function serverSkuCapabilityDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+        name: item["name"],
+        vCores: item["vCores"],
+        supportedIops: item["supportedIops"],
+        supportedMemoryPerVcoreMb: item["supportedMemoryPerVcoreMb"],
+        supportedZones: !item["supportedZones"]
+            ? item["supportedZones"]
+            : item["supportedZones"].map((p) => {
+                return p;
+            }),
+        supportedHaMode: !item["supportedHaMode"]
+            ? item["supportedHaMode"]
+            : item["supportedHaMode"].map((p) => {
+                return p;
+            }),
+        supportedFeatures: !item["supportedFeatures"]
+            ? item["supportedFeatures"]
+            : supportedFeatureArrayDeserializer(item["supportedFeatures"]),
+        securityProfile: item["securityProfile"],
+    };
+}
+/** Mode of high availability supported for this compute. */
+export var KnownHighAvailabilityMode;
+(function (KnownHighAvailabilityMode) {
+    /** High availability is supported for this compute, with standby server in a different availability zone than that of the primary. */
+    KnownHighAvailabilityMode["ZoneRedundant"] = "ZoneRedundant";
+    /** High availability is supported for this compute, with standby server in the same availability zone as the primary. */
+    KnownHighAvailabilityMode["SameZone"] = "SameZone";
+})(KnownHighAvailabilityMode || (KnownHighAvailabilityMode = {}));
+export function supportedFeatureArrayDeserializer(result) {
+    return result.map((item) => {
+        return supportedFeatureDeserializer(item);
+    });
+}
+export function supportedFeatureDeserializer(item) {
+    return {
+        name: item["name"],
+        status: item["status"],
+    };
+}
+/** Status of the feature. Indicates if the feature is enabled or not. */
+export var KnownFeatureStatus;
+(function (KnownFeatureStatus) {
+    /** Feature is enabled. */
+    KnownFeatureStatus["Enabled"] = "Enabled";
+    /** Feature is disabled. */
+    KnownFeatureStatus["Disabled"] = "Disabled";
+})(KnownFeatureStatus || (KnownFeatureStatus = {}));
+export function serverVersionCapabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return serverVersionCapabilityDeserializer(item);
+    });
+}
+export function serverVersionCapabilityDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+        name: item["name"],
+        supportedVersionsToUpgrade: !item["supportedVersionsToUpgrade"]
+            ? item["supportedVersionsToUpgrade"]
+            : item["supportedVersionsToUpgrade"].map((p) => {
+                return p;
+            }),
+        supportedFeatures: !item["supportedFeatures"]
+            ? item["supportedFeatures"]
+            : supportedFeatureArrayDeserializer(item["supportedFeatures"]),
+    };
+}
+/** Indicates if fast provisioning is supported. 'Enabled' means fast provisioning is supported. 'Disabled' stands for fast provisioning is not supported. Will be deprecated in the future. Look to Supported Features for 'FastProvisioning'. */
+export var KnownFastProvisioningSupport;
+(function (KnownFastProvisioningSupport) {
+    /** Fast provisioning is supported. */
+    KnownFastProvisioningSupport["Enabled"] = "Enabled";
+    /** Fast provisioning is not supported. */
+    KnownFastProvisioningSupport["Disabled"] = "Disabled";
+})(KnownFastProvisioningSupport || (KnownFastProvisioningSupport = {}));
+export function fastProvisioningEditionCapabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return fastProvisioningEditionCapabilityDeserializer(item);
+    });
+}
+export function fastProvisioningEditionCapabilityDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+        supportedTier: item["supportedTier"],
+        supportedSku: item["supportedSku"],
+        supportedStorageGb: item["supportedStorageGb"],
+        supportedServerVersions: item["supportedServerVersions"],
+        serverCount: item["serverCount"],
+    };
+}
+/** Indicates if geographically redundant backups are supported in this location. Will be deprecated in the future. Look to Supported Features for 'GeoBackup'. */
+export var KnownGeographicallyRedundantBackupSupport;
+(function (KnownGeographicallyRedundantBackupSupport) {
+    /** Geographically redundant backups are supported in this location. */
+    KnownGeographicallyRedundantBackupSupport["Enabled"] = "Enabled";
+    /** Geographically redundant backups are not supported in this location. */
+    KnownGeographicallyRedundantBackupSupport["Disabled"] = "Disabled";
+})(KnownGeographicallyRedundantBackupSupport || (KnownGeographicallyRedundantBackupSupport = {}));
+/** Indicates if high availability with zone redundancy is supported in this location. Will be deprecated in the future. Look to Supported Features for  'ZoneRedundantHa'. */
+export var KnownZoneRedundantHighAvailabilitySupport;
+(function (KnownZoneRedundantHighAvailabilitySupport) {
+    /** High availability with zone redundancy is supported. */
+    KnownZoneRedundantHighAvailabilitySupport["Enabled"] = "Enabled";
+    /** High availability with zone redundancy is not supported. */
+    KnownZoneRedundantHighAvailabilitySupport["Disabled"] = "Disabled";
+})(KnownZoneRedundantHighAvailabilitySupport || (KnownZoneRedundantHighAvailabilitySupport = {}));
+/** Indicates if high availability with zone redundancy is supported in conjunction with geographically redundant backups in this location. Will be deprecated in the future. Look to Supported Features for 'ZoneRedundantHaAndGeoBackup'. */
+export var KnownZoneRedundantHighAvailabilityAndGeographicallyRedundantBackupSupport;
+(function (KnownZoneRedundantHighAvailabilityAndGeographicallyRedundantBackupSupport) {
+    /** High availability with zone redundancy is supported in conjunction with geographically redundant backups. */
+    KnownZoneRedundantHighAvailabilityAndGeographicallyRedundantBackupSupport["Enabled"] = "Enabled";
+    /** High availability with zone redundancy is not supported in conjunction with geographically redundant backups. */
+    KnownZoneRedundantHighAvailabilityAndGeographicallyRedundantBackupSupport["Disabled"] = "Disabled";
+})(KnownZoneRedundantHighAvailabilityAndGeographicallyRedundantBackupSupport || (KnownZoneRedundantHighAvailabilityAndGeographicallyRedundantBackupSupport = {}));
+/** Indicates if storage autogrow is supported in this location. Will be deprecated in the future. Look to Supported Features for 'StorageAutoGrowth'. */
+export var KnownStorageAutoGrowthSupport;
+(function (KnownStorageAutoGrowthSupport) {
+    /** Storage autogrow is supported. */
+    KnownStorageAutoGrowthSupport["Enabled"] = "Enabled";
+    /** Storage autogrow is not supported. */
+    KnownStorageAutoGrowthSupport["Disabled"] = "Disabled";
+})(KnownStorageAutoGrowthSupport || (KnownStorageAutoGrowthSupport = {}));
+/** Indicates if resizing the storage, without interrupting the operation of the database engine, is supported in this location for the given subscription. Will be deprecated in the future. Look to Supported Features for 'OnlineResize'. */
+export var KnownOnlineStorageResizeSupport;
+(function (KnownOnlineStorageResizeSupport) {
+    /** Resizing the storage without interrupting the operation of the database engine is supported. */
+    KnownOnlineStorageResizeSupport["Enabled"] = "Enabled";
+    /** Resizing the storage without interrupting the operation of the database engine is not supported. */
+    KnownOnlineStorageResizeSupport["Disabled"] = "Disabled";
+})(KnownOnlineStorageResizeSupport || (KnownOnlineStorageResizeSupport = {}));
+/** Indicates if this location is restricted. Will be deprecated in the future. Look to Supported Features for 'Restricted'. */
+export var KnownLocationRestricted;
+(function (KnownLocationRestricted) {
+    /** Location is restricted. */
+    KnownLocationRestricted["Enabled"] = "Enabled";
+    /** Location is not restricted. */
+    KnownLocationRestricted["Disabled"] = "Disabled";
+})(KnownLocationRestricted || (KnownLocationRestricted = {}));
+export function capabilityBaseDeserializer(item) {
+    return {
+        status: item["status"],
+        reason: item["reason"],
+    };
+}
+export function _capturedLogListDeserializer(item) {
+    return {
+        value: capturedLogArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function capturedLogArrayDeserializer(result) {
+    return result.map((item) => {
+        return capturedLogDeserializer(item);
+    });
+}
+export function capturedLogDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _capturedLogPropertiesDeserializer(item["properties"])),
+    };
+}
+export function capturedLogPropertiesDeserializer(item) {
+    return {
+        createdTime: !item["createdTime"] ? item["createdTime"] : new Date(item["createdTime"]),
+        lastModifiedTime: !item["lastModifiedTime"]
+            ? item["lastModifiedTime"]
+            : new Date(item["lastModifiedTime"]),
+        sizeInKb: item["sizeInKb"],
+        type: item["type"],
+        url: item["url"],
+    };
+}
+export function ltrPreBackupRequestSerializer(item) {
+    return { backupSettings: backupSettingsSerializer(item["backupSettings"]) };
+}
+export function backupRequestBaseSerializer(item) {
+    return { backupSettings: backupSettingsSerializer(item["backupSettings"]) };
+}
+export function backupSettingsSerializer(item) {
+    return { backupName: item["backupName"] };
+}
+export function ltrPreBackupResponseDeserializer(item) {
+    return {
+        ..._ltrPreBackupResponsePropertiesDeserializer(item["properties"]),
+    };
+}
+export function backupsLongTermRetentionResponsePropertiesDeserializer(item) {
+    return {
+        numberOfContainers: item["numberOfContainers"],
+    };
+}
+export function backupsLongTermRetentionRequestSerializer(item) {
+    return {
+        backupSettings: backupSettingsSerializer(item["backupSettings"]),
+        targetDetails: backupStoreDetailsSerializer(item["targetDetails"]),
+    };
+}
+export function backupStoreDetailsSerializer(item) {
+    return {
+        sasUriList: item["sasUriList"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function backupsLongTermRetentionResponseDeserializer(item) {
+    return {
+        ...(!item["properties"]
+            ? item["properties"]
+            : _backupsLongTermRetentionResponsePropertiesDeserializer(item["properties"])),
+    };
+}
+export function ltrBackupOperationResponsePropertiesDeserializer(item) {
+    return {
+        datasourceSizeInBytes: item["datasourceSizeInBytes"],
+        dataTransferredInBytes: item["dataTransferredInBytes"],
+        backupName: item["backupName"],
+        backupMetadata: item["backupMetadata"],
+        status: item["status"],
+        startTime: new Date(item["startTime"]),
+        endTime: !item["endTime"] ? item["endTime"] : new Date(item["endTime"]),
+        percentComplete: item["percentComplete"],
+        errorCode: item["errorCode"],
+        errorMessage: item["errorMessage"],
+    };
+}
+/** Service-set extensible enumeration indicating the status of operation. */
+export var KnownExecutionStatus;
+(function (KnownExecutionStatus) {
+    /** Operation is currently running. */
+    KnownExecutionStatus["Running"] = "Running";
+    /** Operation has been cancelled. */
+    KnownExecutionStatus["Cancelled"] = "Cancelled";
+    /** Operation has failed. */
+    KnownExecutionStatus["Failed"] = "Failed";
+    /** Operation has succeeded. */
+    KnownExecutionStatus["Succeeded"] = "Succeeded";
+})(KnownExecutionStatus || (KnownExecutionStatus = {}));
+export function backupsLongTermRetentionOperationDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _backupsLongTermRetentionOperationPropertiesDeserializer(item["properties"])),
+    };
+}
+export function _ltrServerBackupOperationListDeserializer(item) {
+    return {
+        value: backupsLongTermRetentionOperationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function backupsLongTermRetentionOperationArrayDeserializer(result) {
+    return result.map((item) => {
+        return backupsLongTermRetentionOperationDeserializer(item);
+    });
+}
+export function advancedThreatProtectionSettingsModelSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["state"])
+            ? undefined
+            : _advancedThreatProtectionSettingsModelPropertiesSerializer(item),
+    };
+}
+export function advancedThreatProtectionSettingsModelDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _advancedThreatProtectionSettingsModelPropertiesDeserializer(item["properties"])),
+    };
+}
+export function advancedThreatProtectionSettingsPropertiesSerializer(item) {
+    return { state: item["state"] };
+}
+export function advancedThreatProtectionSettingsPropertiesDeserializer(item) {
+    return {
+        state: item["state"],
+        creationTime: !item["creationTime"] ? item["creationTime"] : new Date(item["creationTime"]),
+    };
+}
+/** Known values of {@link ThreatProtectionName} that the service accepts. */
+export var KnownThreatProtectionName;
+(function (KnownThreatProtectionName) {
+    /** Default advanced threat protection settings. */
+    KnownThreatProtectionName["Default"] = "Default";
+})(KnownThreatProtectionName || (KnownThreatProtectionName = {}));
+export function _advancedThreatProtectionSettingsListDeserializer(item) {
+    return {
+        value: advancedThreatProtectionSettingsModelArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function advancedThreatProtectionSettingsModelArraySerializer(result) {
+    return result.map((item) => {
+        return advancedThreatProtectionSettingsModelSerializer(item);
+    });
+}
+export function advancedThreatProtectionSettingsModelArrayDeserializer(result) {
+    return result.map((item) => {
+        return advancedThreatProtectionSettingsModelDeserializer(item);
+    });
+}
+export function backupAutomaticAndOnDemandDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _backupAutomaticAndOnDemandPropertiesDeserializer(item["properties"])),
+    };
+}
+export function backupAutomaticAndOnDemandPropertiesDeserializer(item) {
+    return {
+        backupType: item["backupType"],
+        completedTime: !item["completedTime"] ? item["completedTime"] : new Date(item["completedTime"]),
+        source: item["source"],
+    };
+}
+/** Type of backup. */
+export var KnownBackupType;
+(function (KnownBackupType) {
+    /** A full backup taken automatically by the service. These backups are retained for a period of time as defined by the backup retention policy, and they cannot be deleted by the customer. */
+    KnownBackupType["Full"] = "Full";
+    /** A full backup triggered by the customer. These backups are retained for a period of time as defined by the backup retention policy, and they can also be deleted by the customer. */
+    KnownBackupType["CustomerOnDemand"] = "Customer On-Demand";
+})(KnownBackupType || (KnownBackupType = {}));
+export function _backupAutomaticAndOnDemandListDeserializer(item) {
+    return {
+        value: backupAutomaticAndOnDemandArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function backupAutomaticAndOnDemandArrayDeserializer(result) {
+    return result.map((item) => {
+        return backupAutomaticAndOnDemandDeserializer(item);
+    });
+}
+export function tuningOptionsDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : tuningOptionsPropertiesDeserializer(item["properties"]),
+    };
+}
+export function tuningOptionsPropertiesDeserializer(item) {
+    return {
+        state: item["state"],
+    };
+}
+/** Name of the tuning option. */
+export var KnownTuningOptionParameterEnum;
+(function (KnownTuningOptionParameterEnum) {
+    /** Index related recommendations. */
+    KnownTuningOptionParameterEnum["Index"] = "index";
+    /** Table related recommendations. */
+    KnownTuningOptionParameterEnum["Table"] = "table";
+})(KnownTuningOptionParameterEnum || (KnownTuningOptionParameterEnum = {}));
+export function _tuningOptionsListDeserializer(item) {
+    return {
+        value: tuningOptionsArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function tuningOptionsArrayDeserializer(result) {
+    return result.map((item) => {
+        return tuningOptionsDeserializer(item);
+    });
+}
+export function _objectRecommendationListDeserializer(item) {
+    return {
+        value: objectRecommendationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function objectRecommendationArrayDeserializer(result) {
+    return result.map((item) => {
+        return objectRecommendationDeserializer(item);
+    });
+}
+export function objectRecommendationDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        kind: item["kind"],
+        ...(!item["properties"]
+            ? item["properties"]
+            : _objectRecommendationPropertiesDeserializer(item["properties"])),
+    };
+}
+export function objectRecommendationPropertiesDeserializer(item) {
+    return {
+        initialRecommendedTime: !item["initialRecommendedTime"]
+            ? item["initialRecommendedTime"]
+            : new Date(item["initialRecommendedTime"]),
+        lastRecommendedTime: !item["lastRecommendedTime"]
+            ? item["lastRecommendedTime"]
+            : new Date(item["lastRecommendedTime"]),
+        timesRecommended: item["timesRecommended"],
+        improvedQueryIds: !item["improvedQueryIds"]
+            ? item["improvedQueryIds"]
+            : item["improvedQueryIds"].map((p) => {
+                return p;
+            }),
+        recommendationReason: item["recommendationReason"],
+        currentState: item["currentState"],
+        recommendationType: item["recommendationType"],
+        implementationDetails: !item["implementationDetails"]
+            ? item["implementationDetails"]
+            : objectRecommendationPropertiesImplementationDetailsDeserializer(item["implementationDetails"]),
+        analyzedWorkload: !item["analyzedWorkload"]
+            ? item["analyzedWorkload"]
+            : objectRecommendationPropertiesAnalyzedWorkloadDeserializer(item["analyzedWorkload"]),
+        estimatedImpact: !item["estimatedImpact"]
+            ? item["estimatedImpact"]
+            : impactRecordArrayDeserializer(item["estimatedImpact"]),
+        details: !item["details"]
+            ? item["details"]
+            : objectRecommendationDetailsDeserializer(item["details"]),
+    };
+}
+/** Type for this recommendation. */
+export var KnownRecommendationTypeEnum;
+(function (KnownRecommendationTypeEnum) {
+    /** Recommendation to create an index to improve query performance. */
+    KnownRecommendationTypeEnum["CreateIndex"] = "CreateIndex";
+    /** Recommendation to drop an existing index because it's duplicate or unused. */
+    KnownRecommendationTypeEnum["DropIndex"] = "DropIndex";
+    /** Recommendation to reindex an existing invalid index. */
+    KnownRecommendationTypeEnum["ReIndex"] = "ReIndex";
+    /** Recommendation to analyze a table to update statistics for the query optimizer. */
+    KnownRecommendationTypeEnum["AnalyzeTable"] = "AnalyzeTable";
+    /** Recommendation to vacuum a table to reclaim storage and optimize performance. */
+    KnownRecommendationTypeEnum["VacuumTable"] = "VacuumTable";
+})(KnownRecommendationTypeEnum || (KnownRecommendationTypeEnum = {}));
+export function objectRecommendationPropertiesImplementationDetailsDeserializer(item) {
+    return {
+        method: item["method"],
+        script: item["script"],
+    };
+}
+export function objectRecommendationPropertiesAnalyzedWorkloadDeserializer(item) {
+    return {
+        startTime: !item["startTime"] ? item["startTime"] : new Date(item["startTime"]),
+        endTime: !item["endTime"] ? item["endTime"] : new Date(item["endTime"]),
+        queryCount: item["queryCount"],
+    };
+}
+export function impactRecordArrayDeserializer(result) {
+    return result.map((item) => {
+        return impactRecordDeserializer(item);
+    });
+}
+export function impactRecordDeserializer(item) {
+    return {
+        dimensionName: item["dimensionName"],
+        unit: item["unit"],
+        queryId: item["queryId"],
+        absoluteValue: item["absoluteValue"],
+    };
+}
+export function objectRecommendationDetailsDeserializer(item) {
+    return {
+        databaseName: item["databaseName"],
+        schema: item["schema"],
+        table: item["table"],
+        indexType: item["indexType"],
+        indexName: item["indexName"],
+        indexColumns: !item["indexColumns"]
+            ? item["indexColumns"]
+            : item["indexColumns"].map((p) => {
+                return p;
+            }),
+        includedColumns: !item["includedColumns"]
+            ? item["includedColumns"]
+            : item["includedColumns"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function checkNameAvailabilityRequestSerializer(item) {
+    return { name: item["name"], type: item["type"] };
+}
+export function nameAvailabilityModelDeserializer(item) {
+    return {
+        nameAvailable: item["nameAvailable"],
+        reason: item["reason"],
+        message: item["message"],
+        name: item["name"],
+        type: item["type"],
+    };
+}
+export function checkNameAvailabilityResponseDeserializer(item) {
+    return {
+        nameAvailable: item["nameAvailable"],
+        reason: item["reason"],
+        message: item["message"],
+    };
+}
+/** Possible reasons for a name not being available. */
+export var KnownCheckNameAvailabilityReason;
+(function (KnownCheckNameAvailabilityReason) {
+    /** Name is invalid. */
+    KnownCheckNameAvailabilityReason["Invalid"] = "Invalid";
+    /** Name already exists. */
+    KnownCheckNameAvailabilityReason["AlreadyExists"] = "AlreadyExists";
+})(KnownCheckNameAvailabilityReason || (KnownCheckNameAvailabilityReason = {}));
+export function _quotaUsageListDeserializer(item) {
+    return {
+        value: quotaUsageArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function quotaUsageArrayDeserializer(result) {
+    return result.map((item) => {
+        return quotaUsageDeserializer(item);
+    });
+}
+export function quotaUsageDeserializer(item) {
+    return {
+        name: !item["name"] ? item["name"] : namePropertyDeserializer(item["name"]),
+        limit: item["limit"],
+        unit: item["unit"],
+        currentValue: item["currentValue"],
+        id: item["id"],
+    };
+}
+export function namePropertyDeserializer(item) {
+    return {
+        value: item["value"],
+        localizedValue: item["localizedValue"],
+    };
+}
+export function virtualNetworkSubnetUsageParameterSerializer(item) {
+    return { virtualNetworkArmResourceId: item["virtualNetworkArmResourceId"] };
+}
+export function virtualNetworkSubnetUsageModelDeserializer(item) {
+    return {
+        delegatedSubnetsUsage: !item["delegatedSubnetsUsage"]
+            ? item["delegatedSubnetsUsage"]
+            : delegatedSubnetUsageArrayDeserializer(item["delegatedSubnetsUsage"]),
+        location: item["location"],
+        subscriptionId: item["subscriptionId"],
+    };
+}
+export function delegatedSubnetUsageArrayDeserializer(result) {
+    return result.map((item) => {
+        return delegatedSubnetUsageDeserializer(item);
+    });
+}
+export function delegatedSubnetUsageDeserializer(item) {
+    return {
+        subnetName: item["subnetName"],
+        usage: item["usage"],
+    };
+}
+/** Indicates the filter to apply when listing migrations. */
+export var KnownMigrationListFilter;
+(function (KnownMigrationListFilter) {
+    /** Only active (in-progress) migrations. */
+    KnownMigrationListFilter["Active"] = "Active";
+    /** All migrations. */
+    KnownMigrationListFilter["All"] = "All";
+})(KnownMigrationListFilter || (KnownMigrationListFilter = {}));
+/** Filter for maintenance event status. */
+export var KnownMaintenanceEventStatusFilter;
+(function (KnownMaintenanceEventStatusFilter) {
+    /** Return events that have a scheduled or in progress status. */
+    KnownMaintenanceEventStatusFilter["Upcoming"] = "Upcoming";
+    /** Return events that have a completed status. */
+    KnownMaintenanceEventStatusFilter["Past"] = "Past";
+})(KnownMaintenanceEventStatusFilter || (KnownMaintenanceEventStatusFilter = {}));
+/** Recommendations list filter. Retrieves recommendations based on type. */
+export var KnownRecommendationTypeParameterEnum;
+(function (KnownRecommendationTypeParameterEnum) {
+    /** Recommendation to create an index to improve query performance. */
+    KnownRecommendationTypeParameterEnum["CreateIndex"] = "CreateIndex";
+    /** Recommendation to drop an existing index because it's duplicate or unused. */
+    KnownRecommendationTypeParameterEnum["DropIndex"] = "DropIndex";
+    /** Recommendation to reindex an existing invalid index. */
+    KnownRecommendationTypeParameterEnum["ReIndex"] = "ReIndex";
+    /** Recommendation to analyze a table to update statistics for the query optimizer. */
+    KnownRecommendationTypeParameterEnum["AnalyzeTable"] = "AnalyzeTable";
+    /** Recommendation to vacuum a table to reclaim storage and optimize performance. */
+    KnownRecommendationTypeParameterEnum["VacuumTable"] = "VacuumTable";
+})(KnownRecommendationTypeParameterEnum || (KnownRecommendationTypeParameterEnum = {}));
+/** The available API versions. */
+export var KnownVersions;
+(function (KnownVersions) {
+    /** The 2025-08-01 API version. */
+    KnownVersions["V20250801"] = "2025-08-01";
+    /** The 2026-01-01-preview API version. */
+    KnownVersions["V20260101"] = "2026-01-01-preview";
+    /** The 2026-04-01-preview API version. */
+    KnownVersions["V20260401"] = "2026-04-01-preview";
+})(KnownVersions || (KnownVersions = {}));
+export function _migrationPropertiesSerializer(item) {
+    return {
+        migrationInstanceResourceId: item["migrationInstanceResourceId"],
+        migrationMode: item["migrationMode"],
+        migrationOption: item["migrationOption"],
+        sourceType: item["sourceType"],
+        sslMode: item["sslMode"],
+        sourceDbServerResourceId: item["sourceDbServerResourceId"],
+        sourceDbServerFullyQualifiedDomainName: item["sourceDbServerFullyQualifiedDomainName"],
+        targetDbServerFullyQualifiedDomainName: item["targetDbServerFullyQualifiedDomainName"],
+        secretParameters: !item["secretParameters"]
+            ? item["secretParameters"]
+            : migrationSecretParametersSerializer(item["secretParameters"]),
+        dbsToMigrate: !item["dbsToMigrate"]
+            ? item["dbsToMigrate"]
+            : item["dbsToMigrate"].map((p) => {
+                return p;
+            }),
+        setupLogicalReplicationOnSourceDbIfNeeded: item["setupLogicalReplicationOnSourceDbIfNeeded"],
+        overwriteDbsInTarget: item["overwriteDbsInTarget"],
+        migrationWindowStartTimeInUtc: !item["migrationWindowStartTimeInUtc"]
+            ? item["migrationWindowStartTimeInUtc"]
+            : item["migrationWindowStartTimeInUtc"].toISOString(),
+        migrationWindowEndTimeInUtc: !item["migrationWindowEndTimeInUtc"]
+            ? item["migrationWindowEndTimeInUtc"]
+            : item["migrationWindowEndTimeInUtc"].toISOString(),
+        migrateRoles: item["migrateRoles"],
+        startDataMigration: item["startDataMigration"],
+        triggerCutover: item["triggerCutover"],
+        dbsToTriggerCutoverOn: !item["dbsToTriggerCutoverOn"]
+            ? item["dbsToTriggerCutoverOn"]
+            : item["dbsToTriggerCutoverOn"].map((p) => {
+                return p;
+            }),
+        cancel: item["cancel"],
+        dbsToCancelMigrationOn: !item["dbsToCancelMigrationOn"]
+            ? item["dbsToCancelMigrationOn"]
+            : item["dbsToCancelMigrationOn"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _migrationPropertiesDeserializer(item) {
+    return {
+        migrationId: item["migrationId"],
+        currentStatus: !item["currentStatus"]
+            ? item["currentStatus"]
+            : migrationStatusDeserializer(item["currentStatus"]),
+        migrationInstanceResourceId: item["migrationInstanceResourceId"],
+        migrationMode: item["migrationMode"],
+        migrationOption: item["migrationOption"],
+        sourceType: item["sourceType"],
+        sslMode: item["sslMode"],
+        sourceDbServerMetadata: !item["sourceDbServerMetadata"]
+            ? item["sourceDbServerMetadata"]
+            : dbServerMetadataDeserializer(item["sourceDbServerMetadata"]),
+        targetDbServerMetadata: !item["targetDbServerMetadata"]
+            ? item["targetDbServerMetadata"]
+            : dbServerMetadataDeserializer(item["targetDbServerMetadata"]),
+        sourceDbServerResourceId: item["sourceDbServerResourceId"],
+        sourceDbServerFullyQualifiedDomainName: item["sourceDbServerFullyQualifiedDomainName"],
+        targetDbServerResourceId: item["targetDbServerResourceId"],
+        targetDbServerFullyQualifiedDomainName: item["targetDbServerFullyQualifiedDomainName"],
+        secretParameters: !item["secretParameters"]
+            ? item["secretParameters"]
+            : migrationSecretParametersDeserializer(item["secretParameters"]),
+        dbsToMigrate: !item["dbsToMigrate"]
+            ? item["dbsToMigrate"]
+            : item["dbsToMigrate"].map((p) => {
+                return p;
+            }),
+        setupLogicalReplicationOnSourceDbIfNeeded: item["setupLogicalReplicationOnSourceDbIfNeeded"],
+        overwriteDbsInTarget: item["overwriteDbsInTarget"],
+        migrationWindowStartTimeInUtc: !item["migrationWindowStartTimeInUtc"]
+            ? item["migrationWindowStartTimeInUtc"]
+            : new Date(item["migrationWindowStartTimeInUtc"]),
+        migrationWindowEndTimeInUtc: !item["migrationWindowEndTimeInUtc"]
+            ? item["migrationWindowEndTimeInUtc"]
+            : new Date(item["migrationWindowEndTimeInUtc"]),
+        migrateRoles: item["migrateRoles"],
+        startDataMigration: item["startDataMigration"],
+        triggerCutover: item["triggerCutover"],
+        dbsToTriggerCutoverOn: !item["dbsToTriggerCutoverOn"]
+            ? item["dbsToTriggerCutoverOn"]
+            : item["dbsToTriggerCutoverOn"].map((p) => {
+                return p;
+            }),
+        cancel: item["cancel"],
+        dbsToCancelMigrationOn: !item["dbsToCancelMigrationOn"]
+            ? item["dbsToCancelMigrationOn"]
+            : item["dbsToCancelMigrationOn"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _migrationResourceForPatchPropertiesSerializer(item) {
+    return {
+        sourceDbServerResourceId: item["sourceDbServerResourceId"],
+        sourceDbServerFullyQualifiedDomainName: item["sourceDbServerFullyQualifiedDomainName"],
+        targetDbServerFullyQualifiedDomainName: item["targetDbServerFullyQualifiedDomainName"],
+        secretParameters: !item["secretParameters"]
+            ? item["secretParameters"]
+            : migrationSecretParametersForPatchSerializer(item["secretParameters"]),
+        dbsToMigrate: !item["dbsToMigrate"]
+            ? item["dbsToMigrate"]
+            : item["dbsToMigrate"].map((p) => {
+                return p;
+            }),
+        setupLogicalReplicationOnSourceDbIfNeeded: item["setupLogicalReplicationOnSourceDbIfNeeded"],
+        overwriteDbsInTarget: item["overwriteDbsInTarget"],
+        migrationWindowStartTimeInUtc: !item["migrationWindowStartTimeInUtc"]
+            ? item["migrationWindowStartTimeInUtc"]
+            : item["migrationWindowStartTimeInUtc"].toISOString(),
+        migrateRoles: item["migrateRoles"],
+        startDataMigration: item["startDataMigration"],
+        triggerCutover: item["triggerCutover"],
+        dbsToTriggerCutoverOn: !item["dbsToTriggerCutoverOn"]
+            ? item["dbsToTriggerCutoverOn"]
+            : item["dbsToTriggerCutoverOn"].map((p) => {
+                return p;
+            }),
+        cancel: item["cancel"],
+        dbsToCancelMigrationOn: !item["dbsToCancelMigrationOn"]
+            ? item["dbsToCancelMigrationOn"]
+            : item["dbsToCancelMigrationOn"].map((p) => {
+                return p;
+            }),
+        migrationMode: item["migrationMode"],
+    };
+}
+export function _privateEndpointConnectionPropertiesSerializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointSerializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateLinkServiceConnectionStateSerializer(item["privateLinkServiceConnectionState"]),
+    };
+}
+export function _privateEndpointConnectionPropertiesDeserializer(item) {
+    return {
+        groupIds: !item["groupIds"]
+            ? item["groupIds"]
+            : item["groupIds"].map((p) => {
+                return p;
+            }),
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+        provisioningState: item["provisioningState"],
+    };
+}
+export function _serverPropertiesSerializer(item) {
+    return {
+        administratorLogin: item["administratorLogin"],
+        administratorLoginPassword: item["administratorLoginPassword"],
+        version: item["version"],
+        storage: !item["storage"] ? item["storage"] : storageSerializer(item["storage"]),
+        authConfig: !item["authConfig"] ? item["authConfig"] : authConfigSerializer(item["authConfig"]),
+        dataEncryption: !item["dataEncryption"]
+            ? item["dataEncryption"]
+            : dataEncryptionSerializer(item["dataEncryption"]),
+        backup: !item["backup"] ? item["backup"] : backupSerializer(item["backup"]),
+        network: !item["network"] ? item["network"] : networkSerializer(item["network"]),
+        highAvailability: !item["highAvailability"]
+            ? item["highAvailability"]
+            : highAvailabilitySerializer(item["highAvailability"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowSerializer(item["maintenanceWindow"]),
+        sourceServerResourceId: item["sourceServerResourceId"],
+        pointInTimeUTC: !item["pointInTimeUTC"]
+            ? item["pointInTimeUTC"]
+            : item["pointInTimeUTC"].toISOString(),
+        availabilityZone: item["availabilityZone"],
+        replicationRole: item["replicationRole"],
+        replica: !item["replica"] ? item["replica"] : replicaSerializer(item["replica"]),
+        createMode: item["createMode"],
+        cluster: !item["cluster"] ? item["cluster"] : clusterSerializer(item["cluster"]),
+    };
+}
+export function _serverPropertiesDeserializer(item) {
+    return {
+        administratorLogin: item["administratorLogin"],
+        administratorLoginPassword: item["administratorLoginPassword"],
+        version: item["version"],
+        minorVersion: item["minorVersion"],
+        state: item["state"],
+        fullyQualifiedDomainName: item["fullyQualifiedDomainName"],
+        storage: !item["storage"] ? item["storage"] : storageDeserializer(item["storage"]),
+        authConfig: !item["authConfig"]
+            ? item["authConfig"]
+            : authConfigDeserializer(item["authConfig"]),
+        dataEncryption: !item["dataEncryption"]
+            ? item["dataEncryption"]
+            : dataEncryptionDeserializer(item["dataEncryption"]),
+        backup: !item["backup"] ? item["backup"] : backupDeserializer(item["backup"]),
+        network: !item["network"] ? item["network"] : networkDeserializer(item["network"]),
+        highAvailability: !item["highAvailability"]
+            ? item["highAvailability"]
+            : highAvailabilityDeserializer(item["highAvailability"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowDeserializer(item["maintenanceWindow"]),
+        sourceServerResourceId: item["sourceServerResourceId"],
+        pointInTimeUTC: !item["pointInTimeUTC"]
+            ? item["pointInTimeUTC"]
+            : new Date(item["pointInTimeUTC"]),
+        availabilityZone: item["availabilityZone"],
+        replicationRole: item["replicationRole"],
+        replicaCapacity: item["replicaCapacity"],
+        replica: !item["replica"] ? item["replica"] : replicaDeserializer(item["replica"]),
+        createMode: item["createMode"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        cluster: !item["cluster"] ? item["cluster"] : clusterDeserializer(item["cluster"]),
+    };
+}
+export function _serverForPatchPropertiesSerializer(item) {
+    return {
+        administratorLoginPassword: item["administratorLoginPassword"],
+        version: item["version"],
+        storage: !item["storage"] ? item["storage"] : storageSerializer(item["storage"]),
+        backup: !item["backup"] ? item["backup"] : backupForPatchSerializer(item["backup"]),
+        highAvailability: !item["highAvailability"]
+            ? item["highAvailability"]
+            : highAvailabilityForPatchSerializer(item["highAvailability"]),
+        maintenanceWindow: !item["maintenanceWindow"]
+            ? item["maintenanceWindow"]
+            : maintenanceWindowForPatchSerializer(item["maintenanceWindow"]),
+        authConfig: !item["authConfig"]
+            ? item["authConfig"]
+            : authConfigForPatchSerializer(item["authConfig"]),
+        dataEncryption: !item["dataEncryption"]
+            ? item["dataEncryption"]
+            : dataEncryptionSerializer(item["dataEncryption"]),
+        availabilityZone: item["availabilityZone"],
+        createMode: item["createMode"],
+        replicationRole: item["replicationRole"],
+        replica: !item["replica"] ? item["replica"] : replicaSerializer(item["replica"]),
+        network: !item["network"] ? item["network"] : networkSerializer(item["network"]),
+        cluster: !item["cluster"] ? item["cluster"] : clusterSerializer(item["cluster"]),
+    };
+}
+export function _configurationPropertiesSerializer(item) {
+    return { value: item["value"], source: item["source"] };
+}
+export function _configurationPropertiesDeserializer(item) {
+    return {
+        value: item["value"],
+        description: item["description"],
+        defaultValue: item["defaultValue"],
+        dataType: item["dataType"],
+        allowedValues: item["allowedValues"],
+        source: item["source"],
+        isDynamicConfig: item["isDynamicConfig"],
+        isReadOnly: item["isReadOnly"],
+        isConfigPendingRestart: item["isConfigPendingRestart"],
+        unit: item["unit"],
+        documentationLink: item["documentationLink"],
+    };
+}
+export function _configurationForUpdatePropertiesSerializer(item) {
+    return { value: item["value"], source: item["source"] };
+}
+export function _configurationForUpdatePropertiesDeserializer(item) {
+    return {
+        value: item["value"],
+        description: item["description"],
+        defaultValue: item["defaultValue"],
+        dataType: item["dataType"],
+        allowedValues: item["allowedValues"],
+        source: item["source"],
+        isDynamicConfig: item["isDynamicConfig"],
+        isReadOnly: item["isReadOnly"],
+        isConfigPendingRestart: item["isConfigPendingRestart"],
+        unit: item["unit"],
+        documentationLink: item["documentationLink"],
+    };
+}
+export function _databasePropertiesSerializer(item) {
+    return { charset: item["charset"], collation: item["collation"] };
+}
+export function _databasePropertiesDeserializer(item) {
+    return {
+        charset: item["charset"],
+        collation: item["collation"],
+    };
+}
+export function _firewallRulePropertiesSerializer(item) {
+    return { startIpAddress: item["startIpAddress"], endIpAddress: item["endIpAddress"] };
+}
+export function _firewallRulePropertiesDeserializer(item) {
+    return {
+        startIpAddress: item["startIpAddress"],
+        endIpAddress: item["endIpAddress"],
+    };
+}
+export function _privateLinkResourcePropertiesDeserializer(item) {
+    return {
+        groupId: item["groupId"],
+        requiredMembers: !item["requiredMembers"]
+            ? item["requiredMembers"]
+            : item["requiredMembers"].map((p) => {
+                return p;
+            }),
+        requiredZoneNames: !item["requiredZoneNames"]
+            ? item["requiredZoneNames"]
+            : item["requiredZoneNames"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _virtualEndpointPropertiesSerializer(item) {
+    return {
+        endpointType: item["endpointType"],
+        members: !item["members"]
+            ? item["members"]
+            : item["members"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _virtualEndpointPropertiesDeserializer(item) {
+    return {
+        endpointType: item["endpointType"],
+        members: !item["members"]
+            ? item["members"]
+            : item["members"].map((p) => {
+                return p;
+            }),
+        virtualEndpoints: !item["virtualEndpoints"]
+            ? item["virtualEndpoints"]
+            : item["virtualEndpoints"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _virtualEndpointResourceForPatchPropertiesSerializer(item) {
+    return {
+        endpointType: item["endpointType"],
+        members: !item["members"]
+            ? item["members"]
+            : item["members"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _virtualEndpointResourceForPatchPropertiesDeserializer(item) {
+    return {
+        endpointType: item["endpointType"],
+        members: !item["members"]
+            ? item["members"]
+            : item["members"].map((p) => {
+                return p;
+            }),
+        virtualEndpoints: !item["virtualEndpoints"]
+            ? item["virtualEndpoints"]
+            : item["virtualEndpoints"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _administratorMicrosoftEntraPropertiesDeserializer(item) {
+    return {
+        principalType: item["principalType"],
+        principalName: item["principalName"],
+        objectId: item["objectId"],
+        tenantId: item["tenantId"],
+    };
+}
+export function _administratorMicrosoftEntraAddPropertiesSerializer(item) {
+    return {
+        principalType: item["principalType"],
+        principalName: item["principalName"],
+        tenantId: item["tenantId"],
+    };
+}
+export function _capturedLogPropertiesDeserializer(item) {
+    return {
+        createdTime: !item["createdTime"] ? item["createdTime"] : new Date(item["createdTime"]),
+        lastModifiedTime: !item["lastModifiedTime"]
+            ? item["lastModifiedTime"]
+            : new Date(item["lastModifiedTime"]),
+        sizeInKb: item["sizeInKb"],
+        typePropertiesType: item["type"],
+        url: item["url"],
+    };
+}
+export function _ltrPreBackupResponsePropertiesDeserializer(item) {
+    return {
+        numberOfContainers: item["numberOfContainers"],
+    };
+}
+export function _backupsLongTermRetentionResponsePropertiesDeserializer(item) {
+    return {
+        datasourceSizeInBytes: item["datasourceSizeInBytes"],
+        dataTransferredInBytes: item["dataTransferredInBytes"],
+        backupName: item["backupName"],
+        backupMetadata: item["backupMetadata"],
+        status: item["status"],
+        startTime: !item["startTime"] ? item["startTime"] : new Date(item["startTime"]),
+        endTime: !item["endTime"] ? item["endTime"] : new Date(item["endTime"]),
+        percentComplete: item["percentComplete"],
+        errorCode: item["errorCode"],
+        errorMessage: item["errorMessage"],
+    };
+}
+export function _backupsLongTermRetentionOperationPropertiesDeserializer(item) {
+    return {
+        datasourceSizeInBytes: item["datasourceSizeInBytes"],
+        dataTransferredInBytes: item["dataTransferredInBytes"],
+        backupName: item["backupName"],
+        backupMetadata: item["backupMetadata"],
+        status: item["status"],
+        startTime: !item["startTime"] ? item["startTime"] : new Date(item["startTime"]),
+        endTime: !item["endTime"] ? item["endTime"] : new Date(item["endTime"]),
+        percentComplete: item["percentComplete"],
+        errorCode: item["errorCode"],
+        errorMessage: item["errorMessage"],
+    };
+}
+export function _advancedThreatProtectionSettingsModelPropertiesSerializer(item) {
+    return { state: item["state"] };
+}
+export function _advancedThreatProtectionSettingsModelPropertiesDeserializer(item) {
+    return {
+        state: item["state"],
+        creationTime: !item["creationTime"] ? item["creationTime"] : new Date(item["creationTime"]),
+    };
+}
+export function _backupAutomaticAndOnDemandPropertiesDeserializer(item) {
+    return {
+        backupType: item["backupType"],
+        completedTime: !item["completedTime"] ? item["completedTime"] : new Date(item["completedTime"]),
+        source: item["source"],
+    };
+}
+export function _objectRecommendationPropertiesDeserializer(item) {
+    return {
+        initialRecommendedTime: !item["initialRecommendedTime"]
+            ? item["initialRecommendedTime"]
+            : new Date(item["initialRecommendedTime"]),
+        lastRecommendedTime: !item["lastRecommendedTime"]
+            ? item["lastRecommendedTime"]
+            : new Date(item["lastRecommendedTime"]),
+        timesRecommended: item["timesRecommended"],
+        improvedQueryIds: !item["improvedQueryIds"]
+            ? item["improvedQueryIds"]
+            : item["improvedQueryIds"].map((p) => {
+                return p;
+            }),
+        recommendationReason: item["recommendationReason"],
+        currentState: item["currentState"],
+        recommendationType: item["recommendationType"],
+        implementationDetails: !item["implementationDetails"]
+            ? item["implementationDetails"]
+            : objectRecommendationPropertiesImplementationDetailsDeserializer(item["implementationDetails"]),
+        analyzedWorkload: !item["analyzedWorkload"]
+            ? item["analyzedWorkload"]
+            : objectRecommendationPropertiesAnalyzedWorkloadDeserializer(item["analyzedWorkload"]),
+        estimatedImpact: !item["estimatedImpact"]
+            ? item["estimatedImpact"]
+            : impactRecordArrayDeserializer(item["estimatedImpact"]),
+        details: !item["details"]
+            ? item["details"]
+            : objectRecommendationDetailsDeserializer(item["details"]),
+    };
+}
+//# sourceMappingURL=models.js.map