/*
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT License.
 *
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is regenerated.
 */

import {
  OperationParameter,
  OperationURLParameter,
  OperationQueryParameter
} from "@azure/core-client";
import {
  DataMaskingPolicy as DataMaskingPolicyMapper,
  DataMaskingRule as DataMaskingRuleMapper,
  GeoBackupPolicy as GeoBackupPolicyMapper,
  Database as DatabaseMapper,
  DatabaseUpdate as DatabaseUpdateMapper,
  ExportDatabaseDefinition as ExportDatabaseDefinitionMapper,
  ImportExistingDatabaseDefinition as ImportExistingDatabaseDefinitionMapper,
  ResourceMoveDefinition as ResourceMoveDefinitionMapper,
  ElasticPool as ElasticPoolMapper,
  ElasticPoolUpdate as ElasticPoolUpdateMapper,
  ServerCommunicationLink as ServerCommunicationLinkMapper,
  Advisor as AdvisorMapper,
  DatabaseAutomaticTuning as DatabaseAutomaticTuningMapper,
  RecommendedAction as RecommendedActionMapper,
  DatabaseSecurityAlertPolicy as DatabaseSecurityAlertPolicyMapper,
  DatabaseVulnerabilityAssessmentRuleBaseline as DatabaseVulnerabilityAssessmentRuleBaselineMapper,
  DatabaseVulnerabilityAssessment as DatabaseVulnerabilityAssessmentMapper,
  EncryptionProtector as EncryptionProtectorMapper,
  FailoverGroup as FailoverGroupMapper,
  FailoverGroupUpdate as FailoverGroupUpdateMapper,
  FirewallRule as FirewallRuleMapper,
  FirewallRuleList as FirewallRuleListMapper,
  InstancePool as InstancePoolMapper,
  InstancePoolUpdate as InstancePoolUpdateMapper,
  JobAgent as JobAgentMapper,
  JobAgentUpdate as JobAgentUpdateMapper,
  JobCredential as JobCredentialMapper,
  Job as JobMapper,
  JobStep as JobStepMapper,
  JobTargetGroup as JobTargetGroupMapper,
  LongTermRetentionPolicy as LongTermRetentionPolicyMapper,
  MaintenanceWindows as MaintenanceWindowsMapper,
  ManagedBackupShortTermRetentionPolicy as ManagedBackupShortTermRetentionPolicyMapper,
  ManagedDatabaseSecurityAlertPolicy as ManagedDatabaseSecurityAlertPolicyMapper,
  ManagedTransparentDataEncryption as ManagedTransparentDataEncryptionMapper,
  ManagedInstanceAdministrator as ManagedInstanceAdministratorMapper,
  ManagedInstanceAzureADOnlyAuthentication as ManagedInstanceAzureADOnlyAuthenticationMapper,
  ManagedInstanceEncryptionProtector as ManagedInstanceEncryptionProtectorMapper,
  ManagedInstanceKey as ManagedInstanceKeyMapper,
  ManagedInstanceLongTermRetentionPolicy as ManagedInstanceLongTermRetentionPolicyMapper,
  ManagedInstancePrivateEndpointConnection as ManagedInstancePrivateEndpointConnectionMapper,
  TdeCertificate as TdeCertificateMapper,
  ManagedInstanceVulnerabilityAssessment as ManagedInstanceVulnerabilityAssessmentMapper,
  ManagedServerSecurityAlertPolicy as ManagedServerSecurityAlertPolicyMapper,
  PrivateEndpointConnection as PrivateEndpointConnectionMapper,
  CreateDatabaseRestorePointDefinition as CreateDatabaseRestorePointDefinitionMapper,
  ServerAutomaticTuning as ServerAutomaticTuningMapper,
  ServerAzureADAdministrator as ServerAzureADAdministratorMapper,
  ServerAzureADOnlyAuthentication as ServerAzureADOnlyAuthenticationMapper,
  ServerDevOpsAuditingSettings as ServerDevOpsAuditingSettingsMapper,
  ServerDnsAliasAcquisition as ServerDnsAliasAcquisitionMapper,
  ServerKey as ServerKeyMapper,
  ServerSecurityAlertPolicy as ServerSecurityAlertPolicyMapper,
  ServerTrustGroup as ServerTrustGroupMapper,
  ServerVulnerabilityAssessment as ServerVulnerabilityAssessmentMapper,
  SqlAgentConfiguration as SqlAgentConfigurationMapper,
  SyncAgent as SyncAgentMapper,
  SyncGroup as SyncGroupMapper,
  SyncMember as SyncMemberMapper,
  VirtualNetworkRule as VirtualNetworkRuleMapper,
  WorkloadClassifier as WorkloadClassifierMapper,
  WorkloadGroup as WorkloadGroupMapper,
  BackupShortTermRetentionPolicy as BackupShortTermRetentionPolicyMapper,
  DatabaseExtensions as DatabaseExtensionsMapper,
  LedgerDigestUploads as LedgerDigestUploadsMapper,
  OutboundFirewallRule as OutboundFirewallRuleMapper,
  CopyLongTermRetentionBackupParameters as CopyLongTermRetentionBackupParametersMapper,
  UpdateLongTermRetentionBackupParameters as UpdateLongTermRetentionBackupParametersMapper,
  ServerConnectionPolicy as ServerConnectionPolicyMapper,
  DistributedAvailabilityGroup as DistributedAvailabilityGroupMapper,
  ServerTrustCertificate as ServerTrustCertificateMapper,
  IPv6FirewallRule as IPv6FirewallRuleMapper,
  SensitivityLabel as SensitivityLabelMapper,
  SensitivityLabelUpdateList as SensitivityLabelUpdateListMapper,
  RecommendedSensitivityLabelUpdateList as RecommendedSensitivityLabelUpdateListMapper,
  ServerBlobAuditingPolicy as ServerBlobAuditingPolicyMapper,
  DatabaseBlobAuditingPolicy as DatabaseBlobAuditingPolicyMapper,
  ExtendedDatabaseBlobAuditingPolicy as ExtendedDatabaseBlobAuditingPolicyMapper,
  ExtendedServerBlobAuditingPolicy as ExtendedServerBlobAuditingPolicyMapper,
  DatabaseAdvancedThreatProtection as DatabaseAdvancedThreatProtectionMapper,
  ServerAdvancedThreatProtection as ServerAdvancedThreatProtectionMapper,
  ManagedServerDnsAliasCreation as ManagedServerDnsAliasCreationMapper,
  ManagedServerDnsAliasAcquisition as ManagedServerDnsAliasAcquisitionMapper,
  DatabaseSqlVulnerabilityAssessmentRuleBaselineListInput as DatabaseSqlVulnerabilityAssessmentRuleBaselineListInputMapper,
  DatabaseSqlVulnerabilityAssessmentRuleBaselineInput as DatabaseSqlVulnerabilityAssessmentRuleBaselineInputMapper,
  ManagedDatabaseAdvancedThreatProtection as ManagedDatabaseAdvancedThreatProtectionMapper,
  ManagedInstanceAdvancedThreatProtection as ManagedInstanceAdvancedThreatProtectionMapper,
  SqlVulnerabilityAssessment as SqlVulnerabilityAssessmentMapper,
  ManagedInstanceDtc as ManagedInstanceDtcMapper,
  VirtualClusterUpdate as VirtualClusterUpdateMapper,
  InstanceFailoverGroup as InstanceFailoverGroupMapper,
  ManagedDatabase as ManagedDatabaseMapper,
  ManagedDatabaseUpdate as ManagedDatabaseUpdateMapper,
  ManagedDatabaseMoveDefinition as ManagedDatabaseMoveDefinitionMapper,
  CompleteDatabaseRestoreDefinition as CompleteDatabaseRestoreDefinitionMapper,
  ManagedDatabaseStartMoveDefinition as ManagedDatabaseStartMoveDefinitionMapper,
  ManagedInstance as ManagedInstanceMapper,
  ManagedInstanceUpdate as ManagedInstanceUpdateMapper,
  ManagedLedgerDigestUploads as ManagedLedgerDigestUploadsMapper,
  ServerConfigurationOption as ServerConfigurationOptionMapper,
  CheckNameAvailabilityRequest as CheckNameAvailabilityRequestMapper,
  Server as ServerMapper,
  ServerUpdate as ServerUpdateMapper,
  ImportNewDatabaseDefinition as ImportNewDatabaseDefinitionMapper,
  StartStopManagedInstanceSchedule as StartStopManagedInstanceScheduleMapper,
  LogicalDatabaseTransparentDataEncryption as LogicalDatabaseTransparentDataEncryptionMapper
} from "../models/mappers";

export const contentType: OperationParameter = {
  parameterPath: ["options", "contentType"],
  mapper: {
    defaultValue: "application/json",
    isConstant: true,
    serializedName: "Content-Type",
    type: {
      name: "String"
    }
  }
};

export const parameters: OperationParameter = {
  parameterPath: "parameters",
  mapper: DataMaskingPolicyMapper
};

export const accept: OperationParameter = {
  parameterPath: "accept",
  mapper: {
    defaultValue: "application/json",
    isConstant: true,
    serializedName: "Accept",
    type: {
      name: "String"
    }
  }
};

export const $host: OperationURLParameter = {
  parameterPath: "$host",
  mapper: {
    serializedName: "$host",
    required: true,
    type: {
      name: "String"
    }
  },
  skipEncoding: true
};

export const apiVersion: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2014-04-01",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const subscriptionId: OperationURLParameter = {
  parameterPath: "subscriptionId",
  mapper: {
    serializedName: "subscriptionId",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const resourceGroupName: OperationURLParameter = {
  parameterPath: "resourceGroupName",
  mapper: {
    serializedName: "resourceGroupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const serverName: OperationURLParameter = {
  parameterPath: "serverName",
  mapper: {
    serializedName: "serverName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const databaseName: OperationURLParameter = {
  parameterPath: "databaseName",
  mapper: {
    serializedName: "databaseName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const dataMaskingPolicyName: OperationURLParameter = {
  parameterPath: "dataMaskingPolicyName",
  mapper: {
    defaultValue: "Default",
    isConstant: true,
    serializedName: "dataMaskingPolicyName",
    type: {
      name: "String"
    }
  }
};

export const parameters1: OperationParameter = {
  parameterPath: "parameters",
  mapper: DataMaskingRuleMapper
};

export const dataMaskingRuleName: OperationURLParameter = {
  parameterPath: "dataMaskingRuleName",
  mapper: {
    serializedName: "dataMaskingRuleName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters2: OperationParameter = {
  parameterPath: "parameters",
  mapper: GeoBackupPolicyMapper
};

export const geoBackupPolicyName: OperationURLParameter = {
  parameterPath: "geoBackupPolicyName",
  mapper: {
    serializedName: "geoBackupPolicyName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const filter: OperationQueryParameter = {
  parameterPath: "filter",
  mapper: {
    serializedName: "$filter",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const skipToken: OperationQueryParameter = {
  parameterPath: ["options", "skipToken"],
  mapper: {
    serializedName: "$skipToken",
    type: {
      name: "String"
    }
  }
};

export const apiVersion1: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2022-08-01-preview",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const expand: OperationQueryParameter = {
  parameterPath: ["options", "expand"],
  mapper: {
    serializedName: "$expand",
    type: {
      name: "String"
    }
  }
};

export const filter1: OperationQueryParameter = {
  parameterPath: ["options", "filter"],
  mapper: {
    serializedName: "$filter",
    type: {
      name: "String"
    }
  }
};

export const parameters3: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseMapper
};

export const parameters4: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseUpdateMapper
};

export const parameters5: OperationParameter = {
  parameterPath: "parameters",
  mapper: ExportDatabaseDefinitionMapper
};

export const replicaType: OperationQueryParameter = {
  parameterPath: ["options", "replicaType"],
  mapper: {
    serializedName: "replicaType",
    type: {
      name: "String"
    }
  }
};

export const parameters6: OperationParameter = {
  parameterPath: "parameters",
  mapper: ImportExistingDatabaseDefinitionMapper
};

export const parameters7: OperationParameter = {
  parameterPath: "parameters",
  mapper: ResourceMoveDefinitionMapper
};

export const elasticPoolName: OperationURLParameter = {
  parameterPath: "elasticPoolName",
  mapper: {
    serializedName: "elasticPoolName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const nextLink: OperationURLParameter = {
  parameterPath: "nextLink",
  mapper: {
    serializedName: "nextLink",
    required: true,
    type: {
      name: "String"
    }
  },
  skipEncoding: true
};

export const skip: OperationQueryParameter = {
  parameterPath: ["options", "skip"],
  mapper: {
    serializedName: "$skip",
    type: {
      name: "Number"
    }
  }
};

export const apiVersion2: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2021-08-01-preview",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const parameters8: OperationParameter = {
  parameterPath: "parameters",
  mapper: ElasticPoolMapper
};

export const parameters9: OperationParameter = {
  parameterPath: "parameters",
  mapper: ElasticPoolUpdateMapper
};

export const communicationLinkName: OperationURLParameter = {
  parameterPath: "communicationLinkName",
  mapper: {
    serializedName: "communicationLinkName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters10: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerCommunicationLinkMapper
};

export const serviceObjectiveName: OperationURLParameter = {
  parameterPath: "serviceObjectiveName",
  mapper: {
    serializedName: "serviceObjectiveName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const apiVersion3: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2020-11-01-preview",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const advisorName: OperationURLParameter = {
  parameterPath: "advisorName",
  mapper: {
    serializedName: "advisorName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters11: OperationParameter = {
  parameterPath: "parameters",
  mapper: AdvisorMapper
};

export const parameters12: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseAutomaticTuningMapper
};

export const schema: OperationQueryParameter = {
  parameterPath: ["options", "schema"],
  mapper: {
    serializedName: "schema",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "String"
        }
      }
    }
  },
  collectionFormat: "Multi"
};

export const table: OperationQueryParameter = {
  parameterPath: ["options", "table"],
  mapper: {
    serializedName: "table",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "String"
        }
      }
    }
  },
  collectionFormat: "Multi"
};

export const column: OperationQueryParameter = {
  parameterPath: ["options", "column"],
  mapper: {
    serializedName: "column",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "String"
        }
      }
    }
  },
  collectionFormat: "Multi"
};

export const orderBy: OperationQueryParameter = {
  parameterPath: ["options", "orderBy"],
  mapper: {
    serializedName: "orderBy",
    type: {
      name: "Sequence",
      element: {
        type: {
          name: "String"
        }
      }
    }
  },
  collectionFormat: "Multi"
};

export const skiptoken: OperationQueryParameter = {
  parameterPath: ["options", "skiptoken"],
  mapper: {
    serializedName: "$skiptoken",
    type: {
      name: "String"
    }
  }
};

export const schemaName: OperationURLParameter = {
  parameterPath: "schemaName",
  mapper: {
    serializedName: "schemaName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const tableName: OperationURLParameter = {
  parameterPath: "tableName",
  mapper: {
    serializedName: "tableName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const columnName: OperationURLParameter = {
  parameterPath: "columnName",
  mapper: {
    serializedName: "columnName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const recommendedActionName: OperationURLParameter = {
  parameterPath: "recommendedActionName",
  mapper: {
    serializedName: "recommendedActionName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters13: OperationParameter = {
  parameterPath: "parameters",
  mapper: RecommendedActionMapper
};

export const securityAlertPolicyName: OperationURLParameter = {
  parameterPath: "securityAlertPolicyName",
  mapper: {
    serializedName: "securityAlertPolicyName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters14: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseSecurityAlertPolicyMapper
};

export const vulnerabilityAssessmentName: OperationURLParameter = {
  parameterPath: "vulnerabilityAssessmentName",
  mapper: {
    serializedName: "vulnerabilityAssessmentName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const ruleId: OperationURLParameter = {
  parameterPath: "ruleId",
  mapper: {
    serializedName: "ruleId",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const baselineName: OperationURLParameter = {
  parameterPath: "baselineName",
  mapper: {
    serializedName: "baselineName",
    required: true,
    type: {
      name: "Enum",
      allowedValues: ["master", "default"]
    }
  }
};

export const parameters15: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseVulnerabilityAssessmentRuleBaselineMapper
};

export const parameters16: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseVulnerabilityAssessmentMapper
};

export const scanId: OperationURLParameter = {
  parameterPath: "scanId",
  mapper: {
    serializedName: "scanId",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const dataWarehouseUserActivityName: OperationURLParameter = {
  parameterPath: "dataWarehouseUserActivityName",
  mapper: {
    serializedName: "dataWarehouseUserActivityName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const locationName: OperationURLParameter = {
  parameterPath: "locationName",
  mapper: {
    serializedName: "locationName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const deletedServerName: OperationURLParameter = {
  parameterPath: "deletedServerName",
  mapper: {
    serializedName: "deletedServerName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const operationId: OperationURLParameter = {
  parameterPath: "operationId",
  mapper: {
    serializedName: "operationId",
    required: true,
    type: {
      name: "Uuid"
    }
  }
};

export const encryptionProtectorName: OperationURLParameter = {
  parameterPath: "encryptionProtectorName",
  mapper: {
    serializedName: "encryptionProtectorName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters17: OperationParameter = {
  parameterPath: "parameters",
  mapper: EncryptionProtectorMapper
};

export const failoverGroupName: OperationURLParameter = {
  parameterPath: "failoverGroupName",
  mapper: {
    serializedName: "failoverGroupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters18: OperationParameter = {
  parameterPath: "parameters",
  mapper: FailoverGroupMapper
};

export const parameters19: OperationParameter = {
  parameterPath: "parameters",
  mapper: FailoverGroupUpdateMapper
};

export const firewallRuleName: OperationURLParameter = {
  parameterPath: "firewallRuleName",
  mapper: {
    serializedName: "firewallRuleName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters20: OperationParameter = {
  parameterPath: "parameters",
  mapper: FirewallRuleMapper
};

export const parameters21: OperationParameter = {
  parameterPath: "parameters",
  mapper: FirewallRuleListMapper
};

export const instancePoolName: OperationURLParameter = {
  parameterPath: "instancePoolName",
  mapper: {
    serializedName: "instancePoolName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters22: OperationParameter = {
  parameterPath: "parameters",
  mapper: InstancePoolMapper
};

export const parameters23: OperationParameter = {
  parameterPath: "parameters",
  mapper: InstancePoolUpdateMapper
};

export const jobAgentName: OperationURLParameter = {
  parameterPath: "jobAgentName",
  mapper: {
    serializedName: "jobAgentName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters24: OperationParameter = {
  parameterPath: "parameters",
  mapper: JobAgentMapper
};

export const parameters25: OperationParameter = {
  parameterPath: "parameters",
  mapper: JobAgentUpdateMapper
};

export const credentialName: OperationURLParameter = {
  parameterPath: "credentialName",
  mapper: {
    serializedName: "credentialName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters26: OperationParameter = {
  parameterPath: "parameters",
  mapper: JobCredentialMapper
};

export const createTimeMin: OperationQueryParameter = {
  parameterPath: ["options", "createTimeMin"],
  mapper: {
    serializedName: "createTimeMin",
    type: {
      name: "DateTime"
    }
  }
};

export const createTimeMax: OperationQueryParameter = {
  parameterPath: ["options", "createTimeMax"],
  mapper: {
    serializedName: "createTimeMax",
    type: {
      name: "DateTime"
    }
  }
};

export const endTimeMin: OperationQueryParameter = {
  parameterPath: ["options", "endTimeMin"],
  mapper: {
    serializedName: "endTimeMin",
    type: {
      name: "DateTime"
    }
  }
};

export const endTimeMax: OperationQueryParameter = {
  parameterPath: ["options", "endTimeMax"],
  mapper: {
    serializedName: "endTimeMax",
    type: {
      name: "DateTime"
    }
  }
};

export const isActive: OperationQueryParameter = {
  parameterPath: ["options", "isActive"],
  mapper: {
    serializedName: "isActive",
    type: {
      name: "Boolean"
    }
  }
};

export const top: OperationQueryParameter = {
  parameterPath: ["options", "top"],
  mapper: {
    serializedName: "$top",
    type: {
      name: "Number"
    }
  }
};

export const jobName: OperationURLParameter = {
  parameterPath: "jobName",
  mapper: {
    serializedName: "jobName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const jobExecutionId: OperationURLParameter = {
  parameterPath: "jobExecutionId",
  mapper: {
    serializedName: "jobExecutionId",
    required: true,
    type: {
      name: "Uuid"
    }
  }
};

export const parameters27: OperationParameter = {
  parameterPath: "parameters",
  mapper: JobMapper
};

export const stepName: OperationURLParameter = {
  parameterPath: "stepName",
  mapper: {
    serializedName: "stepName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const jobVersion: OperationURLParameter = {
  parameterPath: "jobVersion",
  mapper: {
    serializedName: "jobVersion",
    required: true,
    type: {
      name: "Number"
    }
  }
};

export const parameters28: OperationParameter = {
  parameterPath: "parameters",
  mapper: JobStepMapper
};

export const targetId: OperationURLParameter = {
  parameterPath: "targetId",
  mapper: {
    serializedName: "targetId",
    required: true,
    type: {
      name: "Uuid"
    }
  }
};

export const targetGroupName: OperationURLParameter = {
  parameterPath: "targetGroupName",
  mapper: {
    serializedName: "targetGroupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters29: OperationParameter = {
  parameterPath: "parameters",
  mapper: JobTargetGroupMapper
};

export const include: OperationQueryParameter = {
  parameterPath: ["options", "include"],
  mapper: {
    serializedName: "include",
    type: {
      name: "String"
    }
  }
};

export const policyName: OperationURLParameter = {
  parameterPath: "policyName",
  mapper: {
    serializedName: "policyName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters30: OperationParameter = {
  parameterPath: "parameters",
  mapper: LongTermRetentionPolicyMapper
};

export const maintenanceWindowOptionsName: OperationQueryParameter = {
  parameterPath: "maintenanceWindowOptionsName",
  mapper: {
    serializedName: "maintenanceWindowOptionsName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const maintenanceWindowName: OperationQueryParameter = {
  parameterPath: "maintenanceWindowName",
  mapper: {
    serializedName: "maintenanceWindowName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters31: OperationParameter = {
  parameterPath: "parameters",
  mapper: MaintenanceWindowsMapper
};

export const managedInstanceName: OperationURLParameter = {
  parameterPath: "managedInstanceName",
  mapper: {
    serializedName: "managedInstanceName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const policyName1: OperationURLParameter = {
  parameterPath: "policyName",
  mapper: {
    serializedName: "policyName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters32: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedBackupShortTermRetentionPolicyMapper
};

export const queryId: OperationURLParameter = {
  parameterPath: "queryId",
  mapper: {
    serializedName: "queryId",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const startTime: OperationQueryParameter = {
  parameterPath: ["options", "startTime"],
  mapper: {
    serializedName: "startTime",
    type: {
      name: "String"
    }
  }
};

export const endTime: OperationQueryParameter = {
  parameterPath: ["options", "endTime"],
  mapper: {
    serializedName: "endTime",
    type: {
      name: "String"
    }
  }
};

export const interval: OperationQueryParameter = {
  parameterPath: ["options", "interval"],
  mapper: {
    serializedName: "interval",
    type: {
      name: "String"
    }
  }
};

export const parameters33: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedDatabaseSecurityAlertPolicyMapper
};

export const tdeName: OperationURLParameter = {
  parameterPath: "tdeName",
  mapper: {
    serializedName: "tdeName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters34: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedTransparentDataEncryptionMapper
};

export const administratorName: OperationURLParameter = {
  parameterPath: "administratorName",
  mapper: {
    serializedName: "administratorName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters35: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceAdministratorMapper
};

export const authenticationName: OperationURLParameter = {
  parameterPath: "authenticationName",
  mapper: {
    serializedName: "authenticationName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters36: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceAzureADOnlyAuthenticationMapper
};

export const parameters37: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceEncryptionProtectorMapper
};

export const keyName: OperationURLParameter = {
  parameterPath: "keyName",
  mapper: {
    serializedName: "keyName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters38: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceKeyMapper
};

export const policyName2: OperationURLParameter = {
  parameterPath: "policyName",
  mapper: {
    serializedName: "policyName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters39: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceLongTermRetentionPolicyMapper
};

export const privateEndpointConnectionName: OperationURLParameter = {
  parameterPath: "privateEndpointConnectionName",
  mapper: {
    serializedName: "privateEndpointConnectionName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters40: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstancePrivateEndpointConnectionMapper
};

export const groupName: OperationURLParameter = {
  parameterPath: "groupName",
  mapper: {
    serializedName: "groupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters41: OperationParameter = {
  parameterPath: "parameters",
  mapper: TdeCertificateMapper
};

export const parameters42: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceVulnerabilityAssessmentMapper
};

export const restorableDroppedDatabaseId: OperationURLParameter = {
  parameterPath: "restorableDroppedDatabaseId",
  mapper: {
    serializedName: "restorableDroppedDatabaseId",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters43: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedServerSecurityAlertPolicyMapper
};

export const parameters44: OperationParameter = {
  parameterPath: "parameters",
  mapper: PrivateEndpointConnectionMapper
};

export const recoverableDatabaseName: OperationURLParameter = {
  parameterPath: "recoverableDatabaseName",
  mapper: {
    serializedName: "recoverableDatabaseName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters45: OperationParameter = {
  parameterPath: "parameters",
  mapper: CreateDatabaseRestorePointDefinitionMapper
};

export const restorePointName: OperationURLParameter = {
  parameterPath: "restorePointName",
  mapper: {
    serializedName: "restorePointName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters46: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerAutomaticTuningMapper
};

export const parameters47: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerAzureADAdministratorMapper
};

export const parameters48: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerAzureADOnlyAuthenticationMapper
};

export const apiVersion4: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2022-02-01-preview",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const devOpsAuditingSettingsName: OperationURLParameter = {
  parameterPath: "devOpsAuditingSettingsName",
  mapper: {
    serializedName: "devOpsAuditingSettingsName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters49: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerDevOpsAuditingSettingsMapper
};

export const dnsAliasName: OperationURLParameter = {
  parameterPath: "dnsAliasName",
  mapper: {
    serializedName: "dnsAliasName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters50: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerDnsAliasAcquisitionMapper
};

export const parameters51: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerKeyMapper
};

export const parameters52: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerSecurityAlertPolicyMapper
};

export const serverTrustGroupName: OperationURLParameter = {
  parameterPath: "serverTrustGroupName",
  mapper: {
    serializedName: "serverTrustGroupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters53: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerTrustGroupMapper
};

export const parameters54: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerVulnerabilityAssessmentMapper
};

export const parameters55: OperationParameter = {
  parameterPath: "parameters",
  mapper: SqlAgentConfigurationMapper
};

export const usageName: OperationURLParameter = {
  parameterPath: "usageName",
  mapper: {
    serializedName: "usageName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const syncAgentName: OperationURLParameter = {
  parameterPath: "syncAgentName",
  mapper: {
    serializedName: "syncAgentName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters56: OperationParameter = {
  parameterPath: "parameters",
  mapper: SyncAgentMapper
};

export const syncGroupName: OperationURLParameter = {
  parameterPath: "syncGroupName",
  mapper: {
    serializedName: "syncGroupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const startTime1: OperationQueryParameter = {
  parameterPath: "startTime",
  mapper: {
    serializedName: "startTime",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const endTime1: OperationQueryParameter = {
  parameterPath: "endTime",
  mapper: {
    serializedName: "endTime",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const typeParam: OperationQueryParameter = {
  parameterPath: "typeParam",
  mapper: {
    serializedName: "type",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const continuationToken: OperationQueryParameter = {
  parameterPath: ["options", "continuationToken"],
  mapper: {
    serializedName: "continuationToken",
    type: {
      name: "String"
    }
  }
};

export const parameters57: OperationParameter = {
  parameterPath: "parameters",
  mapper: SyncGroupMapper
};

export const syncMemberName: OperationURLParameter = {
  parameterPath: "syncMemberName",
  mapper: {
    serializedName: "syncMemberName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters58: OperationParameter = {
  parameterPath: "parameters",
  mapper: SyncMemberMapper
};

export const timeZoneId: OperationURLParameter = {
  parameterPath: "timeZoneId",
  mapper: {
    serializedName: "timeZoneId",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const virtualNetworkRuleName: OperationURLParameter = {
  parameterPath: "virtualNetworkRuleName",
  mapper: {
    serializedName: "virtualNetworkRuleName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters59: OperationParameter = {
  parameterPath: "parameters",
  mapper: VirtualNetworkRuleMapper
};

export const workloadGroupName: OperationURLParameter = {
  parameterPath: "workloadGroupName",
  mapper: {
    serializedName: "workloadGroupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const workloadClassifierName: OperationURLParameter = {
  parameterPath: "workloadClassifierName",
  mapper: {
    serializedName: "workloadClassifierName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters60: OperationParameter = {
  parameterPath: "parameters",
  mapper: WorkloadClassifierMapper
};

export const parameters61: OperationParameter = {
  parameterPath: "parameters",
  mapper: WorkloadGroupMapper
};

export const policyName3: OperationURLParameter = {
  parameterPath: "policyName",
  mapper: {
    serializedName: "policyName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const apiVersion5: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2021-02-01-preview",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const parameters62: OperationParameter = {
  parameterPath: "parameters",
  mapper: BackupShortTermRetentionPolicyMapper
};

export const extensionName: OperationURLParameter = {
  parameterPath: "extensionName",
  mapper: {
    serializedName: "extensionName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters63: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseExtensionsMapper
};

export const ledgerDigestUploads: OperationURLParameter = {
  parameterPath: "ledgerDigestUploads",
  mapper: {
    serializedName: "ledgerDigestUploads",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters64: OperationParameter = {
  parameterPath: "parameters",
  mapper: LedgerDigestUploadsMapper
};

export const outboundRuleFqdn: OperationURLParameter = {
  parameterPath: "outboundRuleFqdn",
  mapper: {
    serializedName: "outboundRuleFqdn",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters65: OperationParameter = {
  parameterPath: "parameters",
  mapper: OutboundFirewallRuleMapper
};

export const expandChildren: OperationQueryParameter = {
  parameterPath: ["options", "expandChildren"],
  mapper: {
    serializedName: "expandChildren",
    type: {
      name: "Boolean"
    }
  }
};

export const parameters66: OperationParameter = {
  parameterPath: "parameters",
  mapper: CopyLongTermRetentionBackupParametersMapper
};

export const longTermRetentionServerName: OperationURLParameter = {
  parameterPath: "longTermRetentionServerName",
  mapper: {
    serializedName: "longTermRetentionServerName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const longTermRetentionDatabaseName: OperationURLParameter = {
  parameterPath: "longTermRetentionDatabaseName",
  mapper: {
    serializedName: "longTermRetentionDatabaseName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const backupName: OperationURLParameter = {
  parameterPath: "backupName",
  mapper: {
    serializedName: "backupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const apiVersion6: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2021-05-01-preview",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const parameters67: OperationParameter = {
  parameterPath: "parameters",
  mapper: UpdateLongTermRetentionBackupParametersMapper
};

export const onlyLatestPerDatabase: OperationQueryParameter = {
  parameterPath: ["options", "onlyLatestPerDatabase"],
  mapper: {
    serializedName: "onlyLatestPerDatabase",
    type: {
      name: "Boolean"
    }
  }
};

export const databaseState: OperationQueryParameter = {
  parameterPath: ["options", "databaseState"],
  mapper: {
    serializedName: "databaseState",
    type: {
      name: "String"
    }
  }
};

export const connectionPolicyName: OperationURLParameter = {
  parameterPath: "connectionPolicyName",
  mapper: {
    serializedName: "connectionPolicyName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters68: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerConnectionPolicyMapper
};

export const apiVersion7: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2021-11-01-preview",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const distributedAvailabilityGroupName: OperationURLParameter = {
  parameterPath: "distributedAvailabilityGroupName",
  mapper: {
    serializedName: "distributedAvailabilityGroupName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters69: OperationParameter = {
  parameterPath: "parameters",
  mapper: DistributedAvailabilityGroupMapper
};

export const certificateName: OperationURLParameter = {
  parameterPath: "certificateName",
  mapper: {
    serializedName: "certificateName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters70: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerTrustCertificateMapper
};

export const parameters71: OperationParameter = {
  parameterPath: "parameters",
  mapper: IPv6FirewallRuleMapper
};

export const endpointType: OperationURLParameter = {
  parameterPath: "endpointType",
  mapper: {
    serializedName: "endpointType",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const sensitivityLabelSource: OperationURLParameter = {
  parameterPath: "sensitivityLabelSource",
  mapper: {
    serializedName: "sensitivityLabelSource",
    required: true,
    type: {
      name: "Enum",
      allowedValues: ["current", "recommended"]
    }
  }
};

export const parameters72: OperationParameter = {
  parameterPath: "parameters",
  mapper: SensitivityLabelMapper
};

export const sensitivityLabelSource1: OperationURLParameter = {
  parameterPath: "sensitivityLabelSource",
  mapper: {
    defaultValue: "current",
    isConstant: true,
    serializedName: "sensitivityLabelSource",
    type: {
      name: "String"
    }
  }
};

export const sensitivityLabelSource2: OperationURLParameter = {
  parameterPath: "sensitivityLabelSource",
  mapper: {
    defaultValue: "recommended",
    isConstant: true,
    serializedName: "sensitivityLabelSource",
    type: {
      name: "String"
    }
  }
};

export const count: OperationQueryParameter = {
  parameterPath: ["options", "count"],
  mapper: {
    serializedName: "$count",
    type: {
      name: "Boolean"
    }
  }
};

export const parameters73: OperationParameter = {
  parameterPath: "parameters",
  mapper: SensitivityLabelUpdateListMapper
};

export const includeDisabledRecommendations: OperationQueryParameter = {
  parameterPath: ["options", "includeDisabledRecommendations"],
  mapper: {
    serializedName: "includeDisabledRecommendations",
    type: {
      name: "Boolean"
    }
  }
};

export const parameters74: OperationParameter = {
  parameterPath: "parameters",
  mapper: RecommendedSensitivityLabelUpdateListMapper
};

export const blobAuditingPolicyName: OperationURLParameter = {
  parameterPath: "blobAuditingPolicyName",
  mapper: {
    defaultValue: "default",
    isConstant: true,
    serializedName: "blobAuditingPolicyName",
    type: {
      name: "String"
    }
  }
};

export const parameters75: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerBlobAuditingPolicyMapper
};

export const parameters76: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseBlobAuditingPolicyMapper
};

export const parameters77: OperationParameter = {
  parameterPath: "parameters",
  mapper: ExtendedDatabaseBlobAuditingPolicyMapper
};

export const parameters78: OperationParameter = {
  parameterPath: "parameters",
  mapper: ExtendedServerBlobAuditingPolicyMapper
};

export const advancedThreatProtectionName: OperationURLParameter = {
  parameterPath: "advancedThreatProtectionName",
  mapper: {
    serializedName: "advancedThreatProtectionName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters79: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseAdvancedThreatProtectionMapper
};

export const parameters80: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerAdvancedThreatProtectionMapper
};

export const parameters81: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedServerDnsAliasCreationMapper
};

export const parameters82: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedServerDnsAliasAcquisitionMapper
};

export const baselineName1: OperationURLParameter = {
  parameterPath: "baselineName",
  mapper: {
    serializedName: "baselineName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters83: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseSqlVulnerabilityAssessmentRuleBaselineListInputMapper
};

export const parameters84: OperationParameter = {
  parameterPath: "parameters",
  mapper: DatabaseSqlVulnerabilityAssessmentRuleBaselineInputMapper
};

export const vulnerabilityAssessmentName1: OperationURLParameter = {
  parameterPath: "vulnerabilityAssessmentName",
  mapper: {
    serializedName: "vulnerabilityAssessmentName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const scanResultId: OperationURLParameter = {
  parameterPath: "scanResultId",
  mapper: {
    serializedName: "scanResultId",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const vulnerabilityAssessmentName2: OperationURLParameter = {
  parameterPath: "vulnerabilityAssessmentName",
  mapper: {
    serializedName: "vulnerabilityAssessmentName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters85: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedDatabaseAdvancedThreatProtectionMapper
};

export const parameters86: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceAdvancedThreatProtectionMapper
};

export const linkId: OperationURLParameter = {
  parameterPath: "linkId",
  mapper: {
    serializedName: "linkId",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const systemDatabaseName: OperationQueryParameter = {
  parameterPath: "systemDatabaseName",
  mapper: {
    defaultValue: "master",
    isConstant: true,
    serializedName: "systemDatabaseName",
    type: {
      name: "String"
    }
  }
};

export const parameters87: OperationParameter = {
  parameterPath: "parameters",
  mapper: SqlVulnerabilityAssessmentMapper
};

export const apiVersion8: OperationQueryParameter = {
  parameterPath: "apiVersion",
  mapper: {
    defaultValue: "2022-05-01-preview",
    isConstant: true,
    serializedName: "api-version",
    type: {
      name: "String"
    }
  }
};

export const dtcName: OperationURLParameter = {
  parameterPath: "dtcName",
  mapper: {
    serializedName: "dtcName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters88: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceDtcMapper
};

export const virtualClusterName: OperationURLParameter = {
  parameterPath: "virtualClusterName",
  mapper: {
    serializedName: "virtualClusterName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters89: OperationParameter = {
  parameterPath: "parameters",
  mapper: VirtualClusterUpdateMapper
};

export const parameters90: OperationParameter = {
  parameterPath: "parameters",
  mapper: InstanceFailoverGroupMapper
};

export const restoreDetailsName: OperationURLParameter = {
  parameterPath: "restoreDetailsName",
  mapper: {
    serializedName: "restoreDetailsName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters91: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedDatabaseMapper
};

export const parameters92: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedDatabaseUpdateMapper
};

export const parameters93: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedDatabaseMoveDefinitionMapper
};

export const parameters94: OperationParameter = {
  parameterPath: "parameters",
  mapper: CompleteDatabaseRestoreDefinitionMapper
};

export const parameters95: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedDatabaseStartMoveDefinitionMapper
};

export const parameters96: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceMapper
};

export const parameters97: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedInstanceUpdateMapper
};

export const numberOfQueries: OperationQueryParameter = {
  parameterPath: ["options", "numberOfQueries"],
  mapper: {
    serializedName: "numberOfQueries",
    type: {
      name: "Number"
    }
  }
};

export const databases: OperationQueryParameter = {
  parameterPath: ["options", "databases"],
  mapper: {
    serializedName: "databases",
    type: {
      name: "String"
    }
  }
};

export const aggregationFunction: OperationQueryParameter = {
  parameterPath: ["options", "aggregationFunction"],
  mapper: {
    serializedName: "aggregationFunction",
    type: {
      name: "String"
    }
  }
};

export const observationMetric: OperationQueryParameter = {
  parameterPath: ["options", "observationMetric"],
  mapper: {
    serializedName: "observationMetric",
    type: {
      name: "String"
    }
  }
};

export const ledgerDigestUploads1: OperationURLParameter = {
  parameterPath: "ledgerDigestUploads",
  mapper: {
    serializedName: "ledgerDigestUploads",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters98: OperationParameter = {
  parameterPath: "parameters",
  mapper: ManagedLedgerDigestUploadsMapper
};

export const serverConfigurationOptionName: OperationURLParameter = {
  parameterPath: "serverConfigurationOptionName",
  mapper: {
    serializedName: "serverConfigurationOptionName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters99: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerConfigurationOptionMapper
};

export const parameters100: OperationParameter = {
  parameterPath: "parameters",
  mapper: CheckNameAvailabilityRequestMapper
};

export const parameters101: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerMapper
};

export const parameters102: OperationParameter = {
  parameterPath: "parameters",
  mapper: ServerUpdateMapper
};

export const parameters103: OperationParameter = {
  parameterPath: "parameters",
  mapper: ImportNewDatabaseDefinitionMapper
};

export const startStopScheduleName: OperationURLParameter = {
  parameterPath: "startStopScheduleName",
  mapper: {
    serializedName: "startStopScheduleName",
    required: true,
    type: {
      name: "String"
    }
  }
};

export const parameters104: OperationParameter = {
  parameterPath: "parameters",
  mapper: StartStopManagedInstanceScheduleMapper
};

export const parameters105: OperationParameter = {
  parameterPath: "parameters",
  mapper: LogicalDatabaseTransparentDataEncryptionMapper
};