@azure/arm-appservice/dist/browser/models/parameters.js

A generated SDK for WebSiteManagementClient.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
import { AppServiceEnvironmentResource as AppServiceEnvironmentResourceMapper, AppServiceEnvironmentPatchResource as AppServiceEnvironmentPatchResourceMapper, VirtualNetworkProfile as VirtualNetworkProfileMapper, CustomDnsSuffixConfiguration as CustomDnsSuffixConfigurationMapper, AseV3NetworkingConfiguration as AseV3NetworkingConfigurationMapper, WorkerPoolResource as WorkerPoolResourceMapper, RemotePrivateEndpointConnectionARMResource as RemotePrivateEndpointConnectionARMResourceMapper, AppServicePlan as AppServicePlanMapper, AppServicePlanPatchResource as AppServicePlanPatchResourceMapper, VnetGateway as VnetGatewayMapper, VnetRoute as VnetRouteMapper, Certificate as CertificateMapper, CertificatePatchResource as CertificatePatchResourceMapper, KubeEnvironment as KubeEnvironmentMapper, KubeEnvironmentPatchResource as KubeEnvironmentPatchResourceMapper, User as UserMapper, SourceControl as SourceControlMapper, ResourceNameAvailabilityRequest as ResourceNameAvailabilityRequestMapper, NameIdentifier as NameIdentifierMapper, DnlResourceNameAvailabilityRequest as DnlResourceNameAvailabilityRequestMapper, VnetParameters as VnetParametersMapper, CsmMoveResourceEnvelope as CsmMoveResourceEnvelopeMapper, ValidateRequest as ValidateRequestMapper, StaticSitesWorkflowPreviewRequest as StaticSitesWorkflowPreviewRequestMapper, StaticSiteARMResource as StaticSiteARMResourceMapper, StaticSitePatchResource as StaticSitePatchResourceMapper, StaticSiteUserARMResource as StaticSiteUserARMResourceMapper, StringDictionary as StringDictionaryMapper, DatabaseConnection as DatabaseConnectionMapper, DatabaseConnectionPatchRequest as DatabaseConnectionPatchRequestMapper, StaticSiteUserProvidedFunctionAppARMResource as StaticSiteUserProvidedFunctionAppARMResourceMapper, StaticSiteZipDeploymentARMResource as StaticSiteZipDeploymentARMResourceMapper, StaticSiteBasicAuthPropertiesARMResource as StaticSiteBasicAuthPropertiesARMResourceMapper, StaticSiteUserInvitationRequestResource as StaticSiteUserInvitationRequestResourceMapper, StaticSiteCustomDomainRequestPropertiesARMResource as StaticSiteCustomDomainRequestPropertiesARMResourceMapper, StaticSiteResetPropertiesARMResource as StaticSiteResetPropertiesARMResourceMapper, StaticSiteLinkedBackendARMResource as StaticSiteLinkedBackendARMResourceMapper, Site as SiteMapper, SitePatchResource as SitePatchResourceMapper, CsmSlotEntity as CsmSlotEntityMapper, BackupRequest as BackupRequestMapper, RestoreRequest as RestoreRequestMapper, CsmPublishingCredentialsPoliciesEntity as CsmPublishingCredentialsPoliciesEntityMapper, SiteAuthSettings as SiteAuthSettingsMapper, SiteAuthSettingsV2 as SiteAuthSettingsV2Mapper, AzureStoragePropertyDictionaryResource as AzureStoragePropertyDictionaryResourceMapper, ConnectionStringDictionary as ConnectionStringDictionaryMapper, SiteLogsConfig as SiteLogsConfigMapper, PushSettings as PushSettingsMapper, SlotConfigNamesResource as SlotConfigNamesResourceMapper, SiteConfigResource as SiteConfigResourceMapper, Deployment as DeploymentMapper, Identifier as IdentifierMapper, MSDeploy as MSDeployMapper, FunctionEnvelope as FunctionEnvelopeMapper, KeyInfo as KeyInfoMapper, HostNameBinding as HostNameBindingMapper, HybridConnection as HybridConnectionMapper, RelayServiceConnectionEntity as RelayServiceConnectionEntityMapper, StorageMigrationOptions as StorageMigrationOptionsMapper, MigrateMySqlRequest as MigrateMySqlRequestMapper, SwiftVirtualNetwork as SwiftVirtualNetworkMapper, PremierAddOn as PremierAddOnMapper, PremierAddOnPatchResource as PremierAddOnPatchResourceMapper, PrivateAccess as PrivateAccessMapper, PublicCertificate as PublicCertificateMapper, CsmPublishingProfileOptions as CsmPublishingProfileOptionsMapper, DeletedAppRestoreRequest as DeletedAppRestoreRequestMapper, SnapshotRestoreRequest as SnapshotRestoreRequestMapper, SiteContainer as SiteContainerMapper, SiteSourceControl as SiteSourceControlMapper, VnetInfoResource as VnetInfoResourceMapper, WorkflowArtifacts as WorkflowArtifactsMapper, RegenerateActionParameter as RegenerateActionParameterMapper, Workflow as WorkflowMapper, } from "../models/mappers.js";
export const accept = {
    parameterPath: "accept",
    mapper: {
        defaultValue: "application/json",
        isConstant: true,
        serializedName: "Accept",
        type: {
            name: "String",
        },
    },
};
export const $host = {
    parameterPath: "$host",
    mapper: {
        serializedName: "$host",
        required: true,
        xmlName: "$host",
        type: {
            name: "String",
        },
    },
    skipEncoding: true,
};
export const subscriptionId = {
    parameterPath: "subscriptionId",
    mapper: {
        serializedName: "subscriptionId",
        required: true,
        xmlName: "subscriptionId",
        type: {
            name: "String",
        },
    },
};
export const apiVersion = {
    parameterPath: "apiVersion",
    mapper: {
        defaultValue: "2025-03-01",
        isConstant: true,
        serializedName: "api-version",
        type: {
            name: "String",
        },
    },
};
export const resourceGroupName = {
    parameterPath: "resourceGroupName",
    mapper: {
        constraints: {
            Pattern: new RegExp("^[-\\w\\._\\(\\)]+[^\\.]$"),
            MaxLength: 90,
            MinLength: 1,
        },
        serializedName: "resourceGroupName",
        required: true,
        xmlName: "resourceGroupName",
        type: {
            name: "String",
        },
    },
};
export const name = {
    parameterPath: "name",
    mapper: {
        serializedName: "name",
        required: true,
        xmlName: "name",
        type: {
            name: "String",
        },
    },
};
export const contentType = {
    parameterPath: ["options", "contentType"],
    mapper: {
        defaultValue: "application/json",
        isConstant: true,
        serializedName: "Content-Type",
        type: {
            name: "String",
        },
    },
};
export const hostingEnvironmentEnvelope = {
    parameterPath: "hostingEnvironmentEnvelope",
    mapper: AppServiceEnvironmentResourceMapper,
};
export const forceDelete = {
    parameterPath: ["options", "forceDelete"],
    mapper: {
        serializedName: "forceDelete",
        xmlName: "forceDelete",
        type: {
            name: "Boolean",
        },
    },
};
export const hostingEnvironmentEnvelope1 = {
    parameterPath: "hostingEnvironmentEnvelope",
    mapper: AppServiceEnvironmentPatchResourceMapper,
};
export const vnetInfo = {
    parameterPath: "vnetInfo",
    mapper: VirtualNetworkProfileMapper,
};
export const customDnsSuffixConfiguration = {
    parameterPath: "customDnsSuffixConfiguration",
    mapper: CustomDnsSuffixConfigurationMapper,
};
export const aseNetworkingConfiguration = {
    parameterPath: "aseNetworkingConfiguration",
    mapper: AseV3NetworkingConfigurationMapper,
};
export const diagnosticsName = {
    parameterPath: "diagnosticsName",
    mapper: {
        serializedName: "diagnosticsName",
        required: true,
        xmlName: "diagnosticsName",
        type: {
            name: "String",
        },
    },
};
export const multiRolePoolEnvelope = {
    parameterPath: "multiRolePoolEnvelope",
    mapper: WorkerPoolResourceMapper,
};
export const instance = {
    parameterPath: "instance",
    mapper: {
        serializedName: "instance",
        required: true,
        xmlName: "instance",
        type: {
            name: "String",
        },
    },
};
export const privateEndpointConnectionName = {
    parameterPath: "privateEndpointConnectionName",
    mapper: {
        serializedName: "privateEndpointConnectionName",
        required: true,
        xmlName: "privateEndpointConnectionName",
        type: {
            name: "String",
        },
    },
};
export const privateEndpointWrapper = {
    parameterPath: "privateEndpointWrapper",
    mapper: RemotePrivateEndpointConnectionARMResourceMapper,
};
export const propertiesToInclude = {
    parameterPath: ["options", "propertiesToInclude"],
    mapper: {
        serializedName: "propertiesToInclude",
        xmlName: "propertiesToInclude",
        type: {
            name: "String",
        },
    },
};
export const filter = {
    parameterPath: ["options", "filter"],
    mapper: {
        serializedName: "$filter",
        xmlName: "$filter",
        type: {
            name: "String",
        },
    },
    skipEncoding: true,
};
export const workerPoolName = {
    parameterPath: "workerPoolName",
    mapper: {
        serializedName: "workerPoolName",
        required: true,
        xmlName: "workerPoolName",
        type: {
            name: "String",
        },
    },
};
export const workerPoolEnvelope = {
    parameterPath: "workerPoolEnvelope",
    mapper: WorkerPoolResourceMapper,
};
export const nextLink = {
    parameterPath: "nextLink",
    mapper: {
        serializedName: "nextLink",
        required: true,
        xmlName: "nextLink",
        type: {
            name: "String",
        },
    },
    skipEncoding: true,
};
export const detailed = {
    parameterPath: ["options", "detailed"],
    mapper: {
        serializedName: "detailed",
        xmlName: "detailed",
        type: {
            name: "Boolean",
        },
    },
};
export const appServicePlan = {
    parameterPath: "appServicePlan",
    mapper: AppServicePlanMapper,
};
export const appServicePlan1 = {
    parameterPath: "appServicePlan",
    mapper: AppServicePlanPatchResourceMapper,
};
export const namespaceName = {
    parameterPath: "namespaceName",
    mapper: {
        serializedName: "namespaceName",
        required: true,
        xmlName: "namespaceName",
        type: {
            name: "String",
        },
    },
};
export const relayName = {
    parameterPath: "relayName",
    mapper: {
        serializedName: "relayName",
        required: true,
        xmlName: "relayName",
        type: {
            name: "String",
        },
    },
};
export const softRestart = {
    parameterPath: ["options", "softRestart"],
    mapper: {
        serializedName: "softRestart",
        xmlName: "softRestart",
        type: {
            name: "Boolean",
        },
    },
};
export const skipToken = {
    parameterPath: ["options", "skipToken"],
    mapper: {
        serializedName: "$skipToken",
        xmlName: "$skipToken",
        type: {
            name: "String",
        },
    },
};
export const top = {
    parameterPath: ["options", "top"],
    mapper: {
        serializedName: "$top",
        xmlName: "$top",
        type: {
            name: "String",
        },
    },
};
export const vnetName = {
    parameterPath: "vnetName",
    mapper: {
        serializedName: "vnetName",
        required: true,
        xmlName: "vnetName",
        type: {
            name: "String",
        },
    },
};
export const gatewayName = {
    parameterPath: "gatewayName",
    mapper: {
        serializedName: "gatewayName",
        required: true,
        xmlName: "gatewayName",
        type: {
            name: "String",
        },
    },
};
export const connectionEnvelope = {
    parameterPath: "connectionEnvelope",
    mapper: VnetGatewayMapper,
};
export const routeName = {
    parameterPath: "routeName",
    mapper: {
        serializedName: "routeName",
        required: true,
        xmlName: "routeName",
        type: {
            name: "String",
        },
    },
};
export const route = {
    parameterPath: "route",
    mapper: VnetRouteMapper,
};
export const workerName = {
    parameterPath: "workerName",
    mapper: {
        serializedName: "workerName",
        required: true,
        xmlName: "workerName",
        type: {
            name: "String",
        },
    },
};
export const workerName1 = {
    parameterPath: "workerName",
    mapper: {
        constraints: {
            Pattern: new RegExp("^[a-zA-Z0-9]+$"),
        },
        serializedName: "workerName",
        required: true,
        xmlName: "workerName",
        type: {
            name: "String",
        },
    },
};
export const certificateEnvelope = {
    parameterPath: "certificateEnvelope",
    mapper: CertificateMapper,
};
export const certificateEnvelope1 = {
    parameterPath: "certificateEnvelope",
    mapper: CertificatePatchResourceMapper,
};
export const location = {
    parameterPath: "location",
    mapper: {
        serializedName: "location",
        required: true,
        xmlName: "location",
        type: {
            name: "String",
        },
    },
};
export const deletedSiteId = {
    parameterPath: "deletedSiteId",
    mapper: {
        serializedName: "deletedSiteId",
        required: true,
        xmlName: "deletedSiteId",
        type: {
            name: "String",
        },
    },
};
export const detectorName = {
    parameterPath: "detectorName",
    mapper: {
        serializedName: "detectorName",
        required: true,
        xmlName: "detectorName",
        type: {
            name: "String",
        },
    },
};
export const startTime = {
    parameterPath: ["options", "startTime"],
    mapper: {
        serializedName: "startTime",
        xmlName: "startTime",
        type: {
            name: "DateTime",
        },
    },
};
export const endTime = {
    parameterPath: ["options", "endTime"],
    mapper: {
        serializedName: "endTime",
        xmlName: "endTime",
        type: {
            name: "DateTime",
        },
    },
};
export const timeGrain = {
    parameterPath: ["options", "timeGrain"],
    mapper: {
        constraints: {
            Pattern: new RegExp("PT[1-9][0-9]+[SMH]"),
        },
        serializedName: "timeGrain",
        xmlName: "timeGrain",
        type: {
            name: "String",
        },
    },
};
export const siteName = {
    parameterPath: "siteName",
    mapper: {
        serializedName: "siteName",
        required: true,
        xmlName: "siteName",
        type: {
            name: "String",
        },
    },
};
export const diagnosticCategory = {
    parameterPath: "diagnosticCategory",
    mapper: {
        serializedName: "diagnosticCategory",
        required: true,
        xmlName: "diagnosticCategory",
        type: {
            name: "String",
        },
    },
};
export const analysisName = {
    parameterPath: "analysisName",
    mapper: {
        serializedName: "analysisName",
        required: true,
        xmlName: "analysisName",
        type: {
            name: "String",
        },
    },
};
export const slot = {
    parameterPath: "slot",
    mapper: {
        serializedName: "slot",
        required: true,
        xmlName: "slot",
        type: {
            name: "String",
        },
    },
};
export const operationId = {
    parameterPath: "operationId",
    mapper: {
        serializedName: "operationId",
        required: true,
        xmlName: "operationId",
        type: {
            name: "String",
        },
    },
};
export const kubeEnvironmentEnvelope = {
    parameterPath: "kubeEnvironmentEnvelope",
    mapper: KubeEnvironmentMapper,
};
export const kubeEnvironmentEnvelope1 = {
    parameterPath: "kubeEnvironmentEnvelope",
    mapper: KubeEnvironmentPatchResourceMapper,
};
export const osTypeSelected = {
    parameterPath: ["options", "osTypeSelected"],
    mapper: {
        serializedName: "osTypeSelected",
        xmlName: "osTypeSelected",
        type: {
            name: "String",
        },
    },
};
export const stackOsType = {
    parameterPath: ["options", "stackOsType"],
    mapper: {
        serializedName: "stackOsType",
        xmlName: "stackOsType",
        type: {
            name: "String",
        },
    },
};
export const featured = {
    parameterPath: ["options", "featured"],
    mapper: {
        serializedName: "featured",
        xmlName: "featured",
        type: {
            name: "Boolean",
        },
    },
};
export const hostingEnvironmentName = {
    parameterPath: "hostingEnvironmentName",
    mapper: {
        serializedName: "hostingEnvironmentName",
        required: true,
        xmlName: "hostingEnvironmentName",
        type: {
            name: "String",
        },
    },
};
export const expiredOnly = {
    parameterPath: ["options", "expiredOnly"],
    mapper: {
        serializedName: "expiredOnly",
        xmlName: "expiredOnly",
        type: {
            name: "Boolean",
        },
    },
};
export const environmentName = {
    parameterPath: "environmentName",
    mapper: {
        serializedName: "environmentName",
        required: true,
        xmlName: "environmentName",
        type: {
            name: "String",
        },
    },
};
export const updateSeen = {
    parameterPath: ["options", "updateSeen"],
    mapper: {
        serializedName: "updateSeen",
        xmlName: "updateSeen",
        type: {
            name: "Boolean",
        },
    },
};
export const recommendationId = {
    parameterPath: ["options", "recommendationId"],
    mapper: {
        serializedName: "recommendationId",
        xmlName: "recommendationId",
        type: {
            name: "String",
        },
    },
};
export const userDetails = {
    parameterPath: "userDetails",
    mapper: UserMapper,
};
export const sourceControlType = {
    parameterPath: "sourceControlType",
    mapper: {
        serializedName: "sourceControlType",
        required: true,
        xmlName: "sourceControlType",
        type: {
            name: "String",
        },
    },
};
export const requestMessage = {
    parameterPath: "requestMessage",
    mapper: SourceControlMapper,
};
export const billingLocation = {
    parameterPath: ["options", "billingLocation"],
    mapper: {
        serializedName: "billingLocation",
        xmlName: "billingLocation",
        type: {
            name: "String",
        },
    },
};
export const osType = {
    parameterPath: ["options", "osType"],
    mapper: {
        serializedName: "osType",
        xmlName: "osType",
        type: {
            name: "String",
        },
    },
};
export const name1 = {
    parameterPath: "name",
    mapper: ResourceNameAvailabilityRequestMapper,
};
export const typeParam = {
    parameterPath: "typeParam",
    mapper: ResourceNameAvailabilityRequestMapper,
};
export const isFqdn = {
    parameterPath: ["options", "isFqdn"],
    mapper: ResourceNameAvailabilityRequestMapper,
};
export const environmentId = {
    parameterPath: ["options", "environmentId"],
    mapper: ResourceNameAvailabilityRequestMapper,
};
export const hostname = {
    parameterPath: ["options", "hostname"],
    mapper: {
        serializedName: "hostname",
        xmlName: "hostname",
        type: {
            name: "String",
        },
    },
};
export const sku = {
    parameterPath: ["options", "sku"],
    mapper: {
        serializedName: "sku",
        xmlName: "sku",
        type: {
            name: "String",
        },
    },
};
export const linuxWorkersEnabled = {
    parameterPath: ["options", "linuxWorkersEnabled"],
    mapper: {
        serializedName: "linuxWorkersEnabled",
        xmlName: "linuxWorkersEnabled",
        type: {
            name: "Boolean",
        },
    },
};
export const xenonWorkersEnabled = {
    parameterPath: ["options", "xenonWorkersEnabled"],
    mapper: {
        serializedName: "xenonWorkersEnabled",
        xmlName: "xenonWorkersEnabled",
        type: {
            name: "Boolean",
        },
    },
};
export const linuxDynamicWorkersEnabled = {
    parameterPath: ["options", "linuxDynamicWorkersEnabled"],
    mapper: {
        serializedName: "linuxDynamicWorkersEnabled",
        xmlName: "linuxDynamicWorkersEnabled",
        type: {
            name: "Boolean",
        },
    },
};
export const customModeWorkersEnabled = {
    parameterPath: ["options", "customModeWorkersEnabled"],
    mapper: {
        serializedName: "customModeWorkersEnabled ",
        xmlName: "customModeWorkersEnabled ",
        type: {
            name: "Boolean",
        },
    },
};
export const nameIdentifier = {
    parameterPath: "nameIdentifier",
    mapper: NameIdentifierMapper,
};
export const resourceGroupName1 = {
    parameterPath: ["options", "resourceGroupName"],
    mapper: DnlResourceNameAvailabilityRequestMapper,
};
export const autoGeneratedDomainNameLabelScope = {
    parameterPath: ["options", "autoGeneratedDomainNameLabelScope"],
    mapper: DnlResourceNameAvailabilityRequestMapper,
};
export const name2 = {
    parameterPath: "name",
    mapper: DnlResourceNameAvailabilityRequestMapper,
};
export const typeParam1 = {
    parameterPath: "typeParam",
    mapper: DnlResourceNameAvailabilityRequestMapper,
};
export const parameters = {
    parameterPath: "parameters",
    mapper: VnetParametersMapper,
};
export const moveResourceEnvelope = {
    parameterPath: "moveResourceEnvelope",
    mapper: CsmMoveResourceEnvelopeMapper,
};
export const validateRequest = {
    parameterPath: "validateRequest",
    mapper: ValidateRequestMapper,
};
export const location1 = {
    parameterPath: "location",
    mapper: {
        constraints: {
            MinLength: 1,
        },
        serializedName: "location",
        required: true,
        xmlName: "location",
        type: {
            name: "String",
        },
    },
};
export const resourceGroupName2 = {
    parameterPath: "resourceGroupName",
    mapper: {
        constraints: {
            MaxLength: 90,
            MinLength: 1,
        },
        serializedName: "resourceGroupName",
        required: true,
        xmlName: "resourceGroupName",
        type: {
            name: "String",
        },
    },
};
export const name3 = {
    parameterPath: "name",
    mapper: {
        constraints: {
            Pattern: new RegExp("^[A-z][A-z0-9]*$"),
        },
        serializedName: "name",
        required: true,
        xmlName: "name",
        type: {
            name: "String",
        },
    },
};
export const certificateName = {
    parameterPath: "certificateName",
    mapper: {
        constraints: {
            Pattern: new RegExp("^[A-z][A-z0-9]*$"),
        },
        serializedName: "certificateName",
        required: true,
        xmlName: "certificateName",
        type: {
            name: "String",
        },
    },
};
export const certificateName1 = {
    parameterPath: "certificateName",
    mapper: {
        serializedName: "certificateName",
        required: true,
        xmlName: "certificateName",
        type: {
            name: "String",
        },
    },
};
export const staticSitesWorkflowPreviewRequest = {
    parameterPath: "staticSitesWorkflowPreviewRequest",
    mapper: StaticSitesWorkflowPreviewRequestMapper,
};
export const staticSiteEnvelope = {
    parameterPath: "staticSiteEnvelope",
    mapper: StaticSiteARMResourceMapper,
};
export const staticSiteEnvelope1 = {
    parameterPath: "staticSiteEnvelope",
    mapper: StaticSitePatchResourceMapper,
};
export const authprovider = {
    parameterPath: "authprovider",
    mapper: {
        serializedName: "authprovider",
        required: true,
        xmlName: "authprovider",
        type: {
            name: "String",
        },
    },
};
export const userid = {
    parameterPath: "userid",
    mapper: {
        serializedName: "userid",
        required: true,
        xmlName: "userid",
        type: {
            name: "String",
        },
    },
};
export const staticSiteUserEnvelope = {
    parameterPath: "staticSiteUserEnvelope",
    mapper: StaticSiteUserARMResourceMapper,
};
export const environmentName1 = {
    parameterPath: "environmentName",
    mapper: {
        serializedName: "environmentName",
        required: true,
        xmlName: "environmentName",
        type: {
            name: "String",
        },
    },
};
export const appSettings = {
    parameterPath: "appSettings",
    mapper: StringDictionaryMapper,
};
export const environmentName2 = {
    parameterPath: "environmentName",
    mapper: {
        constraints: {
            Pattern: new RegExp("^[a-zA-Z0-9]+$"),
        },
        serializedName: "environmentName",
        required: true,
        xmlName: "environmentName",
        type: {
            name: "String",
        },
    },
};
export const databaseConnectionName = {
    parameterPath: "databaseConnectionName",
    mapper: {
        constraints: {
            Pattern: new RegExp("^[a-zA-Z0-9]+$"),
        },
        serializedName: "databaseConnectionName",
        required: true,
        xmlName: "databaseConnectionName",
        type: {
            name: "String",
        },
    },
};
export const databaseConnectionRequestEnvelope = {
    parameterPath: "databaseConnectionRequestEnvelope",
    mapper: DatabaseConnectionMapper,
};
export const databaseConnectionRequestEnvelope1 = {
    parameterPath: "databaseConnectionRequestEnvelope",
    mapper: DatabaseConnectionPatchRequestMapper,
};
export const functionAppName = {
    parameterPath: "functionAppName",
    mapper: {
        serializedName: "functionAppName",
        required: true,
        xmlName: "functionAppName",
        type: {
            name: "String",
        },
    },
};
export const staticSiteUserProvidedFunctionEnvelope = {
    parameterPath: "staticSiteUserProvidedFunctionEnvelope",
    mapper: StaticSiteUserProvidedFunctionAppARMResourceMapper,
};
export const isForced = {
    parameterPath: ["options", "isForced"],
    mapper: {
        serializedName: "isForced",
        xmlName: "isForced",
        type: {
            name: "Boolean",
        },
    },
};
export const staticSiteZipDeploymentEnvelope = {
    parameterPath: "staticSiteZipDeploymentEnvelope",
    mapper: StaticSiteZipDeploymentARMResourceMapper,
};
export const basicAuthName = {
    parameterPath: "basicAuthName",
    mapper: {
        serializedName: "basicAuthName",
        required: true,
        xmlName: "basicAuthName",
        type: {
            name: "String",
        },
    },
};
export const basicAuthEnvelope = {
    parameterPath: "basicAuthEnvelope",
    mapper: StaticSiteBasicAuthPropertiesARMResourceMapper,
};
export const staticSiteUserRolesInvitationEnvelope = {
    parameterPath: "staticSiteUserRolesInvitationEnvelope",
    mapper: StaticSiteUserInvitationRequestResourceMapper,
};
export const domainName = {
    parameterPath: "domainName",
    mapper: {
        serializedName: "domainName",
        required: true,
        xmlName: "domainName",
        type: {
            name: "String",
        },
    },
};
export const staticSiteCustomDomainRequestPropertiesEnvelope = {
    parameterPath: "staticSiteCustomDomainRequestPropertiesEnvelope",
    mapper: StaticSiteCustomDomainRequestPropertiesARMResourceMapper,
};
export const resetPropertiesEnvelope = {
    parameterPath: "resetPropertiesEnvelope",
    mapper: StaticSiteResetPropertiesARMResourceMapper,
};
export const staticSiteLinkedBackendEnvelope = {
    parameterPath: "staticSiteLinkedBackendEnvelope",
    mapper: StaticSiteLinkedBackendARMResourceMapper,
};
export const linkedBackendName = {
    parameterPath: "linkedBackendName",
    mapper: {
        serializedName: "linkedBackendName",
        required: true,
        xmlName: "linkedBackendName",
        type: {
            name: "String",
        },
    },
};
export const isCleaningAuthConfig = {
    parameterPath: ["options", "isCleaningAuthConfig"],
    mapper: {
        serializedName: "isCleaningAuthConfig",
        xmlName: "isCleaningAuthConfig",
        type: {
            name: "Boolean",
        },
    },
};
export const includeSlots = {
    parameterPath: ["options", "includeSlots"],
    mapper: {
        serializedName: "includeSlots",
        xmlName: "includeSlots",
        type: {
            name: "Boolean",
        },
    },
};
export const siteEnvelope = {
    parameterPath: "siteEnvelope",
    mapper: SiteMapper,
};
export const deleteMetrics = {
    parameterPath: ["options", "deleteMetrics"],
    mapper: {
        serializedName: "deleteMetrics",
        xmlName: "deleteMetrics",
        type: {
            name: "Boolean",
        },
    },
};
export const deleteEmptyServerFarm = {
    parameterPath: ["options", "deleteEmptyServerFarm"],
    mapper: {
        serializedName: "deleteEmptyServerFarm",
        xmlName: "deleteEmptyServerFarm",
        type: {
            name: "Boolean",
        },
    },
};
export const siteEnvelope1 = {
    parameterPath: "siteEnvelope",
    mapper: SitePatchResourceMapper,
};
export const hostName = {
    parameterPath: ["options", "hostName"],
    mapper: {
        serializedName: "hostName",
        xmlName: "hostName",
        type: {
            name: "String",
        },
    },
};
export const slotSwapEntity = {
    parameterPath: "slotSwapEntity",
    mapper: CsmSlotEntityMapper,
};
export const request2 = {
    parameterPath: "request",
    mapper: BackupRequestMapper,
};
export const backupId = {
    parameterPath: "backupId",
    mapper: {
        serializedName: "backupId",
        required: true,
        xmlName: "backupId",
        type: {
            name: "String",
        },
    },
};
export const request3 = {
    parameterPath: "request",
    mapper: RestoreRequestMapper,
};
export const csmPublishingAccessPoliciesEntity = {
    parameterPath: "csmPublishingAccessPoliciesEntity",
    mapper: CsmPublishingCredentialsPoliciesEntityMapper,
};
export const siteAuthSettings = {
    parameterPath: "siteAuthSettings",
    mapper: SiteAuthSettingsMapper,
};
export const siteAuthSettingsV2 = {
    parameterPath: "siteAuthSettingsV2",
    mapper: SiteAuthSettingsV2Mapper,
};
export const azureStorageAccounts = {
    parameterPath: "azureStorageAccounts",
    mapper: AzureStoragePropertyDictionaryResourceMapper,
};
export const appSettingKey = {
    parameterPath: "appSettingKey",
    mapper: {
        serializedName: "appSettingKey",
        required: true,
        xmlName: "appSettingKey",
        type: {
            name: "String",
        },
    },
};
export const connectionStringKey = {
    parameterPath: "connectionStringKey",
    mapper: {
        serializedName: "connectionStringKey",
        required: true,
        xmlName: "connectionStringKey",
        type: {
            name: "String",
        },
    },
};
export const connectionStrings = {
    parameterPath: "connectionStrings",
    mapper: ConnectionStringDictionaryMapper,
};
export const siteLogsConfig = {
    parameterPath: "siteLogsConfig",
    mapper: SiteLogsConfigMapper,
};
export const metadata = {
    parameterPath: "metadata",
    mapper: StringDictionaryMapper,
};
export const pushSettings = {
    parameterPath: "pushSettings",
    mapper: PushSettingsMapper,
};
export const slotConfigNames = {
    parameterPath: "slotConfigNames",
    mapper: SlotConfigNamesResourceMapper,
};
export const siteConfig = {
    parameterPath: "siteConfig",
    mapper: SiteConfigResourceMapper,
};
export const snapshotId = {
    parameterPath: "snapshotId",
    mapper: {
        serializedName: "snapshotId",
        required: true,
        xmlName: "snapshotId",
        type: {
            name: "String",
        },
    },
};
export const accept1 = {
    parameterPath: "accept",
    mapper: {
        defaultValue: "application/octet-stream",
        isConstant: true,
        serializedName: "Accept",
        type: {
            name: "String",
        },
    },
};
export const accept2 = {
    parameterPath: "accept",
    mapper: {
        defaultValue: "application/zip",
        isConstant: true,
        serializedName: "Accept",
        type: {
            name: "String",
        },
    },
};
export const webJobName = {
    parameterPath: "webJobName",
    mapper: {
        serializedName: "webJobName",
        required: true,
        xmlName: "webJobName",
        type: {
            name: "String",
        },
    },
};
export const deploymentStatusId = {
    parameterPath: "deploymentStatusId",
    mapper: {
        serializedName: "deploymentStatusId",
        required: true,
        xmlName: "deploymentStatusId",
        type: {
            name: "String",
        },
    },
};
export const id = {
    parameterPath: "id",
    mapper: {
        serializedName: "id",
        required: true,
        xmlName: "id",
        type: {
            name: "String",
        },
    },
};
export const deployment = {
    parameterPath: "deployment",
    mapper: DeploymentMapper,
};
export const domainOwnershipIdentifierName = {
    parameterPath: "domainOwnershipIdentifierName",
    mapper: {
        serializedName: "domainOwnershipIdentifierName",
        required: true,
        xmlName: "domainOwnershipIdentifierName",
        type: {
            name: "String",
        },
    },
};
export const domainOwnershipIdentifier = {
    parameterPath: "domainOwnershipIdentifier",
    mapper: IdentifierMapper,
};
export const mSDeploy = {
    parameterPath: "mSDeploy",
    mapper: MSDeployMapper,
};
export const functionName = {
    parameterPath: "functionName",
    mapper: {
        serializedName: "functionName",
        required: true,
        xmlName: "functionName",
        type: {
            name: "String",
        },
    },
};
export const functionEnvelope = {
    parameterPath: "functionEnvelope",
    mapper: FunctionEnvelopeMapper,
};
export const key = {
    parameterPath: "key",
    mapper: KeyInfoMapper,
};
export const keyName = {
    parameterPath: "keyName",
    mapper: {
        serializedName: "keyName",
        required: true,
        xmlName: "keyName",
        type: {
            name: "String",
        },
    },
};
export const keyType = {
    parameterPath: "keyType",
    mapper: {
        serializedName: "keyType",
        required: true,
        xmlName: "keyType",
        type: {
            name: "String",
        },
    },
};
export const hostName1 = {
    parameterPath: "hostName",
    mapper: {
        serializedName: "hostName",
        required: true,
        xmlName: "hostName",
        type: {
            name: "String",
        },
    },
};
export const hostNameBinding = {
    parameterPath: "hostNameBinding",
    mapper: HostNameBindingMapper,
};
export const connectionEnvelope1 = {
    parameterPath: "connectionEnvelope",
    mapper: HybridConnectionMapper,
};
export const entityName = {
    parameterPath: "entityName",
    mapper: {
        serializedName: "entityName",
        required: true,
        xmlName: "entityName",
        type: {
            name: "String",
        },
    },
};
export const connectionEnvelope2 = {
    parameterPath: "connectionEnvelope",
    mapper: RelayServiceConnectionEntityMapper,
};
export const instanceId = {
    parameterPath: "instanceId",
    mapper: {
        serializedName: "instanceId",
        required: true,
        xmlName: "instanceId",
        type: {
            name: "String",
        },
    },
};
export const processId = {
    parameterPath: "processId",
    mapper: {
        serializedName: "processId",
        required: true,
        xmlName: "processId",
        type: {
            name: "String",
        },
    },
};
export const baseAddress = {
    parameterPath: "baseAddress",
    mapper: {
        serializedName: "baseAddress",
        required: true,
        xmlName: "baseAddress",
        type: {
            name: "String",
        },
    },
};
export const migrationOptions = {
    parameterPath: "migrationOptions",
    mapper: StorageMigrationOptionsMapper,
};
export const subscriptionName = {
    parameterPath: "subscriptionName",
    mapper: {
        serializedName: "subscriptionName",
        required: true,
        xmlName: "subscriptionName",
        type: {
            name: "String",
        },
    },
};
export const migrationRequestEnvelope = {
    parameterPath: "migrationRequestEnvelope",
    mapper: MigrateMySqlRequestMapper,
};
export const connectionEnvelope3 = {
    parameterPath: "connectionEnvelope",
    mapper: SwiftVirtualNetworkMapper,
};
export const view = {
    parameterPath: "view",
    mapper: {
        serializedName: "view",
        required: true,
        xmlName: "view",
        type: {
            name: "String",
        },
    },
};
export const durationInSeconds = {
    parameterPath: ["options", "durationInSeconds"],
    mapper: {
        serializedName: "durationInSeconds",
        xmlName: "durationInSeconds",
        type: {
            name: "Number",
        },
    },
};
export const maxFrameLength = {
    parameterPath: ["options", "maxFrameLength"],
    mapper: {
        serializedName: "maxFrameLength",
        xmlName: "maxFrameLength",
        type: {
            name: "Number",
        },
    },
};
export const sasUrl = {
    parameterPath: ["options", "sasUrl"],
    mapper: {
        serializedName: "sasUrl",
        xmlName: "sasUrl",
        type: {
            name: "String",
        },
    },
};
export const premierAddOnName = {
    parameterPath: "premierAddOnName",
    mapper: {
        serializedName: "premierAddOnName",
        required: true,
        xmlName: "premierAddOnName",
        type: {
            name: "String",
        },
    },
};
export const premierAddOn = {
    parameterPath: "premierAddOn",
    mapper: PremierAddOnMapper,
};
export const premierAddOn1 = {
    parameterPath: "premierAddOn",
    mapper: PremierAddOnPatchResourceMapper,
};
export const access = {
    parameterPath: "access",
    mapper: PrivateAccessMapper,
};
export const publicCertificateName = {
    parameterPath: "publicCertificateName",
    mapper: {
        serializedName: "publicCertificateName",
        required: true,
        xmlName: "publicCertificateName",
        type: {
            name: "String",
        },
    },
};
export const publicCertificate = {
    parameterPath: "publicCertificate",
    mapper: PublicCertificateMapper,
};
export const publishingProfileOptions = {
    parameterPath: "publishingProfileOptions",
    mapper: CsmPublishingProfileOptionsMapper,
};
export const accept3 = {
    parameterPath: "accept",
    mapper: {
        defaultValue: "application/xml",
        isConstant: true,
        serializedName: "Accept",
        type: {
            name: "String",
        },
    },
};
export const synchronous = {
    parameterPath: ["options", "synchronous"],
    mapper: {
        serializedName: "synchronous",
        xmlName: "synchronous",
        type: {
            name: "Boolean",
        },
    },
};
export const restoreRequest = {
    parameterPath: "restoreRequest",
    mapper: DeletedAppRestoreRequestMapper,
};
export const restoreRequest1 = {
    parameterPath: "restoreRequest",
    mapper: SnapshotRestoreRequestMapper,
};
export const containerName = {
    parameterPath: "containerName",
    mapper: {
        constraints: {
            Pattern: new RegExp("(^[a-zA-Z0-9]$)|(^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]$)"),
        },
        serializedName: "containerName",
        required: true,
        xmlName: "containerName",
        type: {
            name: "String",
        },
    },
};
export const request4 = {
    parameterPath: "request",
    mapper: SiteContainerMapper,
};
export const siteExtensionId = {
    parameterPath: "siteExtensionId",
    mapper: {
        serializedName: "siteExtensionId",
        required: true,
        xmlName: "siteExtensionId",
        type: {
            name: "String",
        },
    },
};
export const siteSourceControl = {
    parameterPath: "siteSourceControl",
    mapper: SiteSourceControlMapper,
};
export const additionalFlags = {
    parameterPath: ["options", "additionalFlags"],
    mapper: {
        serializedName: "additionalFlags",
        xmlName: "additionalFlags",
        type: {
            name: "String",
        },
    },
};
export const connectionEnvelope4 = {
    parameterPath: "connectionEnvelope",
    mapper: VnetInfoResourceMapper,
};
export const workflowArtifacts = {
    parameterPath: ["options", "workflowArtifacts"],
    mapper: WorkflowArtifactsMapper,
};
export const workflowName = {
    parameterPath: "workflowName",
    mapper: {
        constraints: {
            Pattern: new RegExp("^[a-z][a-z0-9]*$"),
            MaxLength: 63,
            MinLength: 3,
        },
        serializedName: "workflowName",
        required: true,
        xmlName: "workflowName",
        type: {
            name: "String",
        },
    },
};
export const keyType1 = {
    parameterPath: "keyType",
    mapper: RegenerateActionParameterMapper,
};
export const workflowName1 = {
    parameterPath: "workflowName",
    mapper: {
        serializedName: "workflowName",
        required: true,
        xmlName: "workflowName",
        type: {
            name: "String",
        },
    },
};
export const validate = {
    parameterPath: "validate",
    mapper: WorkflowMapper,
};
export const top1 = {
    parameterPath: ["options", "top"],
    mapper: {
        serializedName: "$top",
        xmlName: "$top",
        type: {
            name: "Number",
        },
    },
};
export const filter1 = {
    parameterPath: ["options", "filter"],
    mapper: {
        serializedName: "$filter",
        xmlName: "$filter",
        type: {
            name: "String",
        },
    },
};
export const runName = {
    parameterPath: "runName",
    mapper: {
        serializedName: "runName",
        required: true,
        xmlName: "runName",
        type: {
            name: "String",
        },
    },
};
export const actionName = {
    parameterPath: "actionName",
    mapper: {
        serializedName: "actionName",
        required: true,
        xmlName: "actionName",
        type: {
            name: "String",
        },
    },
};
export const repetitionName = {
    parameterPath: "repetitionName",
    mapper: {
        serializedName: "repetitionName",
        required: true,
        xmlName: "repetitionName",
        type: {
            name: "String",
        },
    },
};
export const requestHistoryName = {
    parameterPath: "requestHistoryName",
    mapper: {
        serializedName: "requestHistoryName",
        required: true,
        xmlName: "requestHistoryName",
        type: {
            name: "String",
        },
    },
};
export const triggerName = {
    parameterPath: "triggerName",
    mapper: {
        serializedName: "triggerName",
        required: true,
        xmlName: "triggerName",
        type: {
            name: "String",
        },
    },
};
export const historyName = {
    parameterPath: "historyName",
    mapper: {
        serializedName: "historyName",
        required: true,
        xmlName: "historyName",
        type: {
            name: "String",
        },
    },
};
export const versionId = {
    parameterPath: "versionId",
    mapper: {
        serializedName: "versionId",
        required: true,
        xmlName: "versionId",
        type: {
            name: "String",
        },
    },
};
//# sourceMappingURL=parameters.js.map