@kengachu-pulumi/azure-native-web/types/input.d.ts

Pulumi Azure Native package for web

import * as enums from "./enums";
import * as pulumi from "@pulumi/pulumi";
/**
 * The configuration settings of the Allowed Audiences validation flow.
 */
export interface AllowedAudiencesValidationArgs {
    /**
     * The configuration settings of the allowed list of audiences from which to validate the JWT token.
     */
    allowedAudiences?: pulumi.Input<pulumi.Input<string>[]>;
}
/**
 * The configuration settings of the Azure Active Directory allowed principals.
 */
export interface AllowedPrincipalsArgs {
    /**
     * The list of the allowed groups.
     */
    groups?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The list of the allowed identities.
     */
    identities?: pulumi.Input<pulumi.Input<string>[]>;
}
export interface ApiConnectionDefinitionPropertiesArgs {
    api?: pulumi.Input<ApiReferenceArgs>;
    /**
     * Timestamp of last connection change
     */
    changedTime?: pulumi.Input<string>;
    /**
     * Timestamp of the connection creation
     */
    createdTime?: pulumi.Input<string>;
    /**
     * Dictionary of custom parameter values
     */
    customParameterValues?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Display name
     */
    displayName?: pulumi.Input<string>;
    /**
     * Dictionary of nonsecret parameter values
     */
    nonSecretParameterValues?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Dictionary of parameter values
     */
    parameterValues?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Status of the connection
     */
    statuses?: pulumi.Input<pulumi.Input<ConnectionStatusDefinitionArgs>[]>;
    /**
     * Links to test the API connection
     */
    testLinks?: pulumi.Input<pulumi.Input<ApiConnectionTestLinkArgs>[]>;
}
/**
 * API connection properties
 */
export interface ApiConnectionTestLinkArgs {
    /**
     * HTTP Method
     */
    method?: pulumi.Input<string>;
    /**
     * Test link request URI
     */
    requestUri?: pulumi.Input<string>;
}
/**
 * Information about the formal API definition for the app.
 */
export interface ApiDefinitionInfoArgs {
    /**
     * The URL of the API definition.
     */
    url?: pulumi.Input<string>;
}
/**
 * Azure API management (APIM) configuration linked to the app.
 */
export interface ApiManagementConfigArgs {
    /**
     * APIM-Api Identifier.
     */
    id?: pulumi.Input<string>;
}
/**
 * OAuth settings for the connection provider
 */
export interface ApiOAuthSettingsArgs {
    /**
     * Resource provider client id
     */
    clientId?: pulumi.Input<string>;
    /**
     * Client Secret needed for OAuth
     */
    clientSecret?: pulumi.Input<string>;
    /**
     * OAuth parameters key is the name of parameter
     */
    customParameters?: pulumi.Input<{
        [key: string]: pulumi.Input<ApiOAuthSettingsParameterArgs>;
    }>;
    /**
     * Identity provider
     */
    identityProvider?: pulumi.Input<string>;
    /**
     * Read only properties for this oauth setting.
     */
    properties?: any;
    /**
     * Url
     */
    redirectUrl?: pulumi.Input<string>;
    /**
     * OAuth scopes
     */
    scopes?: pulumi.Input<pulumi.Input<string>[]>;
}
/**
 * OAuth settings for the API
 */
export interface ApiOAuthSettingsParameterArgs {
    /**
     * Options available to this parameter
     */
    options?: any;
    /**
     * UI definitions per culture as caller can specify the culture
     */
    uiDefinition?: any;
    /**
     * Value of the setting
     */
    value?: pulumi.Input<string>;
}
export interface ApiReferenceArgs {
    /**
     * Brand color
     */
    brandColor?: pulumi.Input<string>;
    /**
     * The custom API description
     */
    description?: pulumi.Input<string>;
    /**
     * The display name
     */
    displayName?: pulumi.Input<string>;
    /**
     * The icon URI
     */
    iconUri?: pulumi.Input<string>;
    /**
     * Resource reference id
     */
    id?: pulumi.Input<string>;
    /**
     * The name of the API
     */
    name?: pulumi.Input<string>;
    /**
     * The JSON representation of the swagger
     */
    swagger?: any;
    /**
     * Resource reference type
     */
    type?: pulumi.Input<string>;
}
/**
 * The API backend service
 */
export interface ApiResourceBackendServiceArgs {
    /**
     * The service URL
     */
    serviceUrl?: pulumi.Input<string>;
}
/**
 * API Definitions
 */
export interface ApiResourceDefinitionsArgs {
    /**
     * The modified swagger URL
     */
    modifiedSwaggerUrl?: pulumi.Input<string>;
    /**
     * The original swagger URL
     */
    originalSwaggerUrl?: pulumi.Input<string>;
}
export interface AppLogsConfigurationArgs {
    destination?: pulumi.Input<string>;
    logAnalyticsConfiguration?: pulumi.Input<LogAnalyticsConfigurationArgs>;
}
/**
 * The configuration settings of the app registration for providers that have app ids and app secrets
 */
export interface AppRegistrationArgs {
    /**
     * The App ID of the app used for login.
     */
    appId?: pulumi.Input<string>;
    /**
     * The app setting name that contains the app secret.
     */
    appSecretSettingName?: pulumi.Input<string>;
}
/**
 * The configuration settings of the Apple provider.
 */
export interface AppleArgs {
    /**
     * <code>false</code> if the Apple provider should not be enabled despite the set registration; otherwise, <code>true</code>.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * The configuration settings of the login flow.
     */
    login?: pulumi.Input<LoginScopesArgs>;
    /**
     * The configuration settings of the Apple registration.
     */
    registration?: pulumi.Input<AppleRegistrationArgs>;
}
/**
 * The configuration settings of the registration for the Apple provider
 */
export interface AppleRegistrationArgs {
    /**
     * The Client ID of the app used for login.
     */
    clientId?: pulumi.Input<string>;
    /**
     * The app setting name that contains the client secret.
     */
    clientSecretSettingName?: pulumi.Input<string>;
}
/**
 * Application logs configuration.
 */
export interface ApplicationLogsConfigArgs {
    /**
     * Application logs to blob storage configuration.
     */
    azureBlobStorage?: pulumi.Input<AzureBlobStorageApplicationLogsConfigArgs>;
    /**
     * Application logs to azure table storage configuration.
     */
    azureTableStorage?: pulumi.Input<AzureTableStorageApplicationLogsConfigArgs>;
    /**
     * Application logs to file system configuration.
     */
    fileSystem?: pulumi.Input<FileSystemApplicationLogsConfigArgs>;
}
/**
 * applicationLogsConfigArgsProvideDefaults sets the appropriate defaults for ApplicationLogsConfigArgs
 */
export declare function applicationLogsConfigArgsProvideDefaults(val: ApplicationLogsConfigArgs): ApplicationLogsConfigArgs;
export interface ArcConfigurationArgs {
    artifactStorageAccessMode?: pulumi.Input<string>;
    artifactStorageClassName?: pulumi.Input<string>;
    artifactStorageMountPath?: pulumi.Input<string>;
    artifactStorageNodeName?: pulumi.Input<string>;
    artifactsStorageType?: pulumi.Input<enums.StorageType>;
    frontEndServiceConfiguration?: pulumi.Input<FrontEndConfigurationArgs>;
    kubeConfig?: pulumi.Input<string>;
}
/**
 * Full view of networking configuration for an ASE.
 */
export interface AseV3NetworkingConfigurationArgs {
    /**
     * Property to enable and disable new private endpoint connection creation on ASE
     */
    allowNewPrivateEndpointConnections?: pulumi.Input<boolean>;
    /**
     * Property to enable and disable FTP on ASEV3
     */
    ftpEnabled?: pulumi.Input<boolean>;
    /**
     * Customer provided Inbound IP Address. Only able to be set on Ase create.
     */
    inboundIpAddressOverride?: pulumi.Input<string>;
    /**
     * Kind of resource.
     */
    kind?: pulumi.Input<string>;
    /**
     * Property to enable and disable Remote Debug on ASEV3
     */
    remoteDebugEnabled?: pulumi.Input<boolean>;
}
/**
 * The configuration settings of the platform of App Service Authentication/Authorization.
 */
export interface AuthPlatformArgs {
    /**
     * The path of the config file containing auth settings if they come from a file.
     * If the path is relative, base will the site's root directory.
     */
    configFilePath?: pulumi.Input<string>;
    /**
     * <code>true</code> if the Authentication / Authorization feature is enabled for the current app; otherwise, <code>false</code>.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * The RuntimeVersion of the Authentication / Authorization feature in use for the current app.
     * The setting in this value can control the behavior of certain features in the Authentication / Authorization module.
     */
    runtimeVersion?: pulumi.Input<string>;
}
/**
 * Actions which to take by the auto-heal module when a rule is triggered.
 */
export interface AutoHealActionsArgs {
    /**
     * Predefined action to be taken.
     */
    actionType?: pulumi.Input<enums.AutoHealActionType>;
    /**
     * Custom action to be taken.
     */
    customAction?: pulumi.Input<AutoHealCustomActionArgs>;
    /**
     * Minimum time the process must execute
     * before taking the action
     */
    minProcessExecutionTime?: pulumi.Input<string>;
}
/**
 * Custom action to be executed
 * when an auto heal rule is triggered.
 */
export interface AutoHealCustomActionArgs {
    /**
     * Executable to be run.
     */
    exe?: pulumi.Input<string>;
    /**
     * Parameters for the executable.
     */
    parameters?: pulumi.Input<string>;
}
/**
 * Rules that can be defined for auto-heal.
 */
export interface AutoHealRulesArgs {
    /**
     * Actions to be executed when a rule is triggered.
     */
    actions?: pulumi.Input<AutoHealActionsArgs>;
    /**
     * Conditions that describe when to execute the auto-heal actions.
     */
    triggers?: pulumi.Input<AutoHealTriggersArgs>;
}
/**
 * Triggers for auto-heal.
 */
export interface AutoHealTriggersArgs {
    /**
     * A rule based on private bytes.
     */
    privateBytesInKB?: pulumi.Input<number>;
    /**
     * A rule based on total requests.
     */
    requests?: pulumi.Input<RequestsBasedTriggerArgs>;
    /**
     * A rule based on request execution time.
     */
    slowRequests?: pulumi.Input<SlowRequestsBasedTriggerArgs>;
    /**
     * A rule based on multiple Slow Requests Rule with path
     */
    slowRequestsWithPath?: pulumi.Input<pulumi.Input<SlowRequestsBasedTriggerArgs>[]>;
    /**
     * A rule based on status codes.
     */
    statusCodes?: pulumi.Input<pulumi.Input<StatusCodesBasedTriggerArgs>[]>;
    /**
     * A rule based on status codes ranges.
     */
    statusCodesRange?: pulumi.Input<pulumi.Input<StatusCodesRangeBasedTriggerArgs>[]>;
}
/**
 * The configuration settings of the Azure Active directory provider.
 */
export interface AzureActiveDirectoryArgs {
    /**
     * <code>false</code> if the Azure Active Directory provider should not be enabled despite the set registration; otherwise, <code>true</code>.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * Gets a value indicating whether the Azure AD configuration was auto-provisioned using 1st party tooling.
     * This is an internal flag primarily intended to support the Azure Management Portal. Users should not
     * read or write to this property.
     */
    isAutoProvisioned?: pulumi.Input<boolean>;
    /**
     * The configuration settings of the Azure Active Directory login flow.
     */
    login?: pulumi.Input<AzureActiveDirectoryLoginArgs>;
    /**
     * The configuration settings of the Azure Active Directory app registration.
     */
    registration?: pulumi.Input<AzureActiveDirectoryRegistrationArgs>;
    /**
     * The configuration settings of the Azure Active Directory token validation flow.
     */
    validation?: pulumi.Input<AzureActiveDirectoryValidationArgs>;
}
/**
 * The configuration settings of the Azure Active Directory login flow.
 */
export interface AzureActiveDirectoryLoginArgs {
    /**
     * <code>true</code> if the www-authenticate provider should be omitted from the request; otherwise, <code>false</code>.
     */
    disableWWWAuthenticate?: pulumi.Input<boolean>;
    /**
     * Login parameters to send to the OpenID Connect authorization endpoint when
     * a user logs in. Each parameter must be in the form "key=value".
     */
    loginParameters?: pulumi.Input<pulumi.Input<string>[]>;
}
/**
 * The configuration settings of the Azure Active Directory app registration.
 */
export interface AzureActiveDirectoryRegistrationArgs {
    /**
     * The Client ID of this relying party application, known as the client_id.
     * This setting is required for enabling OpenID Connection authentication with Azure Active Directory or
     * other 3rd party OpenID Connect providers.
     * More information on OpenID Connect: http://openid.net/specs/openid-connect-core-1_0.html
     */
    clientId?: pulumi.Input<string>;
    /**
     * An alternative to the client secret thumbprint, that is the issuer of a certificate used for signing purposes. This property acts as
     * a replacement for the Client Secret Certificate Thumbprint. It is also optional.
     */
    clientSecretCertificateIssuer?: pulumi.Input<string>;
    /**
     * An alternative to the client secret thumbprint, that is the subject alternative name of a certificate used for signing purposes. This property acts as
     * a replacement for the Client Secret Certificate Thumbprint. It is also optional.
     */
    clientSecretCertificateSubjectAlternativeName?: pulumi.Input<string>;
    /**
     * An alternative to the client secret, that is the thumbprint of a certificate used for signing purposes. This property acts as
     * a replacement for the Client Secret. It is also optional.
     */
    clientSecretCertificateThumbprint?: pulumi.Input<string>;
    /**
     * The app setting name that contains the client secret of the relying party application.
     */
    clientSecretSettingName?: pulumi.Input<string>;
    /**
     * The OpenID Connect Issuer URI that represents the entity which issues access tokens for this application.
     * When using Azure Active Directory, this value is the URI of the directory tenant, e.g. `https://login.microsoftonline.com/v2.0/{tenant-guid}/`.
     * This URI is a case-sensitive identifier for the token issuer.
     * More information on OpenID Connect Discovery: http://openid.net/specs/openid-connect-discovery-1_0.html
     */
    openIdIssuer?: pulumi.Input<string>;
}
/**
 * The configuration settings of the Azure Active Directory token validation flow.
 */
export interface AzureActiveDirectoryValidationArgs {
    /**
     * The list of audiences that can make successful authentication/authorization requests.
     */
    allowedAudiences?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The configuration settings of the default authorization policy.
     */
    defaultAuthorizationPolicy?: pulumi.Input<DefaultAuthorizationPolicyArgs>;
    /**
     * The configuration settings of the checks that should be made while validating the JWT Claims.
     */
    jwtClaimChecks?: pulumi.Input<JwtClaimChecksArgs>;
}
/**
 * Application logs azure blob storage configuration.
 */
export interface AzureBlobStorageApplicationLogsConfigArgs {
    /**
     * Log level.
     */
    level?: pulumi.Input<enums.LogLevel>;
    /**
     * Retention in days.
     * Remove blobs older than X days.
     * 0 or lower means no retention.
     */
    retentionInDays?: pulumi.Input<number>;
    /**
     * SAS url to a azure blob container with read/write/list/delete permissions.
     */
    sasUrl?: pulumi.Input<string>;
}
/**
 * Http logs to azure blob storage configuration.
 */
export interface AzureBlobStorageHttpLogsConfigArgs {
    /**
     * True if configuration is enabled, false if it is disabled and null if configuration is not set.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * Retention in days.
     * Remove blobs older than X days.
     * 0 or lower means no retention.
     */
    retentionInDays?: pulumi.Input<number>;
    /**
     * SAS url to a azure blob container with read/write/list/delete permissions.
     */
    sasUrl?: pulumi.Input<string>;
}
/**
 * The configuration settings of the Azure Static Web Apps provider.
 */
export interface AzureStaticWebAppsArgs {
    /**
     * <code>false</code> if the Azure Static Web Apps provider should not be enabled despite the set registration; otherwise, <code>true</code>.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * The configuration settings of the Azure Static Web Apps registration.
     */
    registration?: pulumi.Input<AzureStaticWebAppsRegistrationArgs>;
}
/**
 * The configuration settings of the registration for the Azure Static Web Apps provider
 */
export interface AzureStaticWebAppsRegistrationArgs {
    /**
     * The Client ID of the app used for login.
     */
    clientId?: pulumi.Input<string>;
}
/**
 * Azure Files or Blob Storage access information value for dictionary storage.
 */
export interface AzureStorageInfoValueArgs {
    /**
     * Access key for the storage account.
     */
    accessKey?: pulumi.Input<string>;
    /**
     * Name of the storage account.
     */
    accountName?: pulumi.Input<string>;
    /**
     * Path to mount the storage within the site's runtime environment.
     */
    mountPath?: pulumi.Input<string>;
    /**
     * Mounting protocol to use for the storage account.
     */
    protocol?: pulumi.Input<string | enums.AzureStorageProtocol>;
    /**
     * Name of the file share (container name, for Blob storage).
     */
    shareName?: pulumi.Input<string>;
    /**
     * Type of storage.
     */
    type?: pulumi.Input<enums.AzureStorageType>;
}
/**
 * Application logs to Azure table storage configuration.
 */
export interface AzureTableStorageApplicationLogsConfigArgs {
    /**
     * Log level.
     */
    level?: pulumi.Input<enums.LogLevel>;
    /**
     * SAS URL to an Azure table with add/query/delete permissions.
     */
    sasUrl: pulumi.Input<string>;
}
/**
 * Description of a backup schedule. Describes how often should be the backup performed and what should be the retention policy.
 */
export interface BackupSchedule {
    /**
     * How often the backup should be executed (e.g. for weekly backup, this should be set to 7 and FrequencyUnit should be set to Day)
     */
    frequencyInterval: number;
    /**
     * The unit of time for how often the backup should be executed (e.g. for weekly backup, this should be set to Day and FrequencyInterval should be set to 7)
     */
    frequencyUnit: enums.FrequencyUnit;
    /**
     * True if the retention policy should always keep at least one backup in the storage account, regardless how old it is; false otherwise.
     */
    keepAtLeastOneBackup: boolean;
    /**
     * After how many days backups should be deleted.
     */
    retentionPeriodInDays: number;
    /**
     * When the schedule should start working.
     */
    startTime?: string;
}
/**
 * backupScheduleProvideDefaults sets the appropriate defaults for BackupSchedule
 */
export declare function backupScheduleProvideDefaults(val: BackupSchedule): BackupSchedule;
/**
 * Description of a backup schedule. Describes how often should be the backup performed and what should be the retention policy.
 */
export interface BackupScheduleArgs {
    /**
     * How often the backup should be executed (e.g. for weekly backup, this should be set to 7 and FrequencyUnit should be set to Day)
     */
    frequencyInterval: pulumi.Input<number>;
    /**
     * The unit of time for how often the backup should be executed (e.g. for weekly backup, this should be set to Day and FrequencyInterval should be set to 7)
     */
    frequencyUnit: pulumi.Input<enums.FrequencyUnit>;
    /**
     * True if the retention policy should always keep at least one backup in the storage account, regardless how old it is; false otherwise.
     */
    keepAtLeastOneBackup: pulumi.Input<boolean>;
    /**
     * After how many days backups should be deleted.
     */
    retentionPeriodInDays: pulumi.Input<number>;
    /**
     * When the schedule should start working.
     */
    startTime?: pulumi.Input<string>;
}
/**
 * backupScheduleArgsProvideDefaults sets the appropriate defaults for BackupScheduleArgs
 */
export declare function backupScheduleArgsProvideDefaults(val: BackupScheduleArgs): BackupScheduleArgs;
/**
 * The configuration settings of the storage of the tokens if blob storage is used.
 */
export interface BlobStorageTokenStoreArgs {
    /**
     * The name of the app setting containing the SAS URL of the blob storage containing the tokens.
     */
    sasUrlSettingName?: pulumi.Input<string>;
}
/**
 * Describes the capabilities/features allowed for a specific SKU.
 */
export interface CapabilityArgs {
    /**
     * Name of the SKU capability.
     */
    name?: pulumi.Input<string>;
    /**
     * Reason of the SKU capability.
     */
    reason?: pulumi.Input<string>;
    /**
     * Value of the SKU capability.
     */
    value?: pulumi.Input<string>;
}
/**
 * The configuration settings of the app registration for providers that have client ids and client secrets
 */
export interface ClientRegistrationArgs {
    /**
     * The Client ID of the app used for login.
     */
    clientId?: pulumi.Input<string>;
    /**
     * The app setting name that contains the client secret.
     */
    clientSecretSettingName?: pulumi.Input<string>;
}
/**
 * Information needed for cloning operation.
 */
export interface CloningInfoArgs {
    /**
     * Application setting overrides for cloned app. If specified, these settings override the settings cloned
     * from source app. Otherwise, application settings from source app are retained.
     */
    appSettingsOverrides?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * <code>true</code> to clone custom hostnames from source app; otherwise, <code>false</code>.
     */
    cloneCustomHostNames?: pulumi.Input<boolean>;
    /**
     * <code>true</code> to clone source control from source app; otherwise, <code>false</code>.
     */
    cloneSourceControl?: pulumi.Input<boolean>;
    /**
     * <code>true</code> to configure load balancing for source and destination app.
     */
    configureLoadBalancing?: pulumi.Input<boolean>;
    /**
     * Correlation ID of cloning operation. This ID ties multiple cloning operations
     * together to use the same snapshot.
     */
    correlationId?: pulumi.Input<string>;
    /**
     * App Service Environment.
     */
    hostingEnvironment?: pulumi.Input<string>;
    /**
     * <code>true</code> to overwrite destination app; otherwise, <code>false</code>.
     */
    overwrite?: pulumi.Input<boolean>;
    /**
     * ARM resource ID of the source app. App resource ID is of the form
     * /subscriptions/{subId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{siteName} for production slots and
     * /subscriptions/{subId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{siteName}/slots/{slotName} for other slots.
     */
    sourceWebAppId: pulumi.Input<string>;
    /**
     * Location of source app ex: West US or North Europe
     */
    sourceWebAppLocation?: pulumi.Input<string>;
    /**
     * ARM resource ID of the Traffic Manager profile to use, if it exists. Traffic Manager resource ID is of the form
     * /subscriptions/{subId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/trafficManagerProfiles/{profileName}.
     */
    trafficManagerProfileId?: pulumi.Input<string>;
    /**
     * Name of Traffic Manager profile to create. This is only needed if Traffic Manager profile does not already exist.
     */
    trafficManagerProfileName?: pulumi.Input<string>;
}
/**
 * Database connection string information.
 */
export interface ConnStringInfoArgs {
    /**
     * Connection string value.
     */
    connectionString?: pulumi.Input<string>;
    /**
     * Name of connection string.
     */
    name?: pulumi.Input<string>;
    /**
     * Type of database.
     */
    type?: pulumi.Input<enums.ConnectionStringType>;
}
/**
 * Database connection string value to type pair.
 */
export interface ConnStringValueTypePairArgs {
    /**
     * Type of database.
     */
    type: pulumi.Input<enums.ConnectionStringType>;
    /**
     * Value of pair.
     */
    value: pulumi.Input<string>;
}
/**
 * Connection error
 */
export interface ConnectionErrorArgs {
    /**
     * Code of the status
     */
    code?: pulumi.Input<string>;
    /**
     * Resource ETag
     */
    etag?: pulumi.Input<string>;
    /**
     * Resource location
     */
    location?: pulumi.Input<string>;
    /**
     * Description of the status
     */
    message?: pulumi.Input<string>;
    /**
     * Resource tags
     */
    tags?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
}
export interface ConnectionGatewayDefinitionPropertiesArgs {
    /**
     * The URI of the backend
     */
    backendUri?: pulumi.Input<string>;
    /**
     * The gateway installation reference
     */
    connectionGatewayInstallation?: pulumi.Input<ConnectionGatewayReferenceArgs>;
    /**
     * The gateway admin
     */
    contactInformation?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The gateway description
     */
    description?: pulumi.Input<string>;
    /**
     * The gateway display name
     */
    displayName?: pulumi.Input<string>;
    /**
     * The machine name of the gateway
     */
    machineName?: pulumi.Input<string>;
    /**
     * The gateway status
     */
    status?: any;
}
/**
 * The gateway installation reference
 */
export interface ConnectionGatewayReferenceArgs {
    /**
     * Resource reference id
     */
    id?: pulumi.Input<string>;
    /**
     * Resource reference location
     */
    location?: pulumi.Input<string>;
    /**
     * Resource reference name
     */
    name?: pulumi.Input<string>;
    /**
     * Resource reference type
     */
    type?: pulumi.Input<string>;
}
/**
 * Connection provider parameters
 */
export interface ConnectionParameterArgs {
    /**
     * OAuth settings for the connection provider
     */
    oAuthSettings?: pulumi.Input<ApiOAuthSettingsArgs>;
    /**
     * Type of the parameter
     */
    type?: pulumi.Input<enums.ConnectionParameterType>;
}
/**
 * Connection status
 */
export interface ConnectionStatusDefinitionArgs {
    /**
     * Connection error
     */
    error?: pulumi.Input<ConnectionErrorArgs>;
    /**
     * The gateway status
     */
    status?: pulumi.Input<string>;
    /**
     * Target of the error
     */
    target?: pulumi.Input<string>;
}
/**
 * Consent link definition
 */
export interface ConsentLinkParameterDefinition {
    /**
     * AAD OID (user or group) if the principal type is ActiveDirectory. MSA PUID if the principal type is MicrosoftAccount
     */
    objectId?: string;
    /**
     * Name of the parameter in the connection provider's OAuth settings
     */
    parameterName?: string;
    /**
     * Name of the parameter in the connection provider's OAuth settings
     */
    redirectUrl?: string;
    /**
     * The tenant id
     */
    tenantId?: string;
}
/**
 * Consent link definition
 */
export interface ConsentLinkParameterDefinitionArgs {
    /**
     * AAD OID (user or group) if the principal type is ActiveDirectory. MSA PUID if the principal type is MicrosoftAccount
     */
    objectId?: pulumi.Input<string>;
    /**
     * Name of the parameter in the connection provider's OAuth settings
     */
    parameterName?: pulumi.Input<string>;
    /**
     * Name of the parameter in the connection provider's OAuth settings
     */
    redirectUrl?: pulumi.Input<string>;
    /**
     * The tenant id
     */
    tenantId?: pulumi.Input<string>;
}
export interface ContainerAppsConfigurationArgs {
    /**
     * Resource ID of a subnet for control plane infrastructure components. This subnet must be in the same VNET as the subnet defined in appSubnetResourceId. Must not overlap with the IP range defined in platformReservedCidr, if defined.
     */
    appSubnetResourceId?: pulumi.Input<string>;
    /**
     * Resource ID of a subnet for control plane infrastructure components. This subnet must be in the same VNET as the subnet defined in appSubnetResourceId. Must not overlap with the IP range defined in platformReservedCidr, if defined.
     */
    controlPlaneSubnetResourceId?: pulumi.Input<string>;
    /**
     * Azure Monitor instrumentation key used by Dapr to export Service to Service communication telemetry
     */
    daprAIInstrumentationKey?: pulumi.Input<string>;
    /**
     * CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the IP range defined in platformReservedCidr, if defined.
     */
    dockerBridgeCidr?: pulumi.Input<string>;
    /**
     * IP range in CIDR notation that can be reserved for environment infrastructure IP addresses. It must not overlap with any other Subnet IP ranges.
     */
    platformReservedCidr?: pulumi.Input<string>;
    /**
     * An IP address from the IP range defined by platformReservedCidr that will be reserved for the internal DNS server
     */
    platformReservedDnsIP?: pulumi.Input<string>;
}
/**
 * The configuration settings of the session cookie's expiration.
 */
export interface CookieExpirationArgs {
    /**
     * The convention used when determining the session cookie's expiration.
     */
    convention?: pulumi.Input<enums.CookieExpirationConvention>;
    /**
     * The time after the request is made when the session cookie should expire.
     */
    timeToExpiration?: pulumi.Input<string>;
}
/**
 * Cross-Origin Resource Sharing (CORS) settings for the app.
 */
export interface CorsSettingsArgs {
    /**
     * Gets or sets the list of origins that should be allowed to make cross-origin
     * calls (for example: http://example.com:12345). Use "*" to allow all.
     */
    allowedOrigins?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Gets or sets whether CORS requests with credentials are allowed. See
     * https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#Requests_with_credentials
     * for more details.
     */
    supportCredentials?: pulumi.Input<boolean>;
}
/**
 * Custom API properties
 */
export interface CustomApiPropertiesDefinitionArgs {
    /**
     * API Definitions
     */
    apiDefinitions?: pulumi.Input<ApiResourceDefinitionsArgs>;
    /**
     * The API type
     */
    apiType?: pulumi.Input<string | enums.ApiType>;
    /**
     * The API backend service
     */
    backendService?: pulumi.Input<ApiResourceBackendServiceArgs>;
    /**
     * Brand color
     */
    brandColor?: pulumi.Input<string>;
    /**
     * The custom API capabilities
     */
    capabilities?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Connection parameters
     */
    connectionParameters?: pulumi.Input<{
        [key: string]: pulumi.Input<ConnectionParameterArgs>;
    }>;
    /**
     * The custom API description
     */
    description?: pulumi.Input<string>;
    /**
     * The display name
     */
    displayName?: pulumi.Input<string>;
    /**
     * The icon URI
     */
    iconUri?: pulumi.Input<string>;
    /**
     * Runtime URLs
     */
    runtimeUrls?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The JSON representation of the swagger
     */
    swagger?: any;
    /**
     * The WSDL definition
     */
    wsdlDefinition?: pulumi.Input<WsdlDefinitionArgs>;
}
/**
 * Full view of the custom domain suffix configuration for ASEv3.
 */
export interface CustomDnsSuffixConfigurationArgs {
    /**
     * The URL referencing the Azure Key Vault certificate secret that should be used as the default SSL/TLS certificate for sites with the custom domain suffix.
     */
    certificateUrl?: pulumi.Input<string>;
    /**
     * The default custom domain suffix to use for all sites deployed on the ASE.
     */
    dnsSuffix?: pulumi.Input<string>;
    /**
     * The user-assigned identity to use for resolving the key vault certificate reference. If not specified, the system-assigned ASE identity will be used if available.
     */
    keyVaultReferenceIdentity?: pulumi.Input<string>;
    /**
     * Kind of resource.
     */
    kind?: pulumi.Input<string>;
}
/**
 * The configuration settings of the custom Open ID Connect provider.
 */
export interface CustomOpenIdConnectProviderArgs {
    /**
     * <code>false</code> if the custom Open ID provider provider should not be enabled; otherwise, <code>true</code>.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * The configuration settings of the login flow of the custom Open ID Connect provider.
     */
    login?: pulumi.Input<OpenIdConnectLoginArgs>;
    /**
     * The configuration settings of the app registration for the custom Open ID Connect provider.
     */
    registration?: pulumi.Input<OpenIdConnectRegistrationArgs>;
}
/**
 * App Dapr configuration.
 */
export interface DaprConfigArgs {
    /**
     * Dapr application identifier
     */
    appId?: pulumi.Input<string>;
    /**
     * Tells Dapr which port your application is listening on
     */
    appPort?: pulumi.Input<number>;
    /**
     * Enables API logging for the Dapr sidecar
     */
    enableApiLogging?: pulumi.Input<boolean>;
    /**
     * Boolean indicating if the Dapr side car is enabled
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * Increasing max size of request body http servers parameter in MB to handle uploading of big files. Default is 4 MB.
     */
    httpMaxRequestSize?: pulumi.Input<number>;
    /**
     * Dapr max size of http header read buffer in KB to handle when sending multi-KB headers. Default is 65KB.
     */
    httpReadBufferSize?: pulumi.Input<number>;
    /**
     * Sets the log level for the Dapr sidecar. Allowed values are debug, info, warn, error. Default is info.
     */
    logLevel?: pulumi.Input<string | enums.DaprLogLevel>;
}
/**
 * daprConfigArgsProvideDefaults sets the appropriate defaults for DaprConfigArgs
 */
export declare function daprConfigArgsProvideDefaults(val: DaprConfigArgs): DaprConfigArgs;
/**
 * Database backup settings.
 */
export interface DatabaseBackupSetting {
    /**
     * Contains a connection string to a database which is being backed up or restored. If the restore should happen to a new database, the database name inside is the new one.
     */
    connectionString?: string;
    /**
     * Contains a connection string name that is linked to the SiteConfig.ConnectionStrings.
     * This is used during restore with overwrite connection strings options.
     */
    connectionStringName?: string;
    /**
     * Database type (e.g. SqlAzure / MySql).
     */
    databaseType: string | enums.DatabaseType;
    name?: string;
}
/**
 * Database backup settings.
 */
export interface DatabaseBackupSettingArgs {
    /**
     * Contains a connection string to a database which is being backed up or restored. If the restore should happen to a new database, the database name inside is the new one.
     */
    connectionString?: pulumi.Input<string>;
    /**
     * Contains a connection string name that is linked to the SiteConfig.ConnectionStrings.
     * This is used during restore with overwrite connection strings options.
     */
    connectionStringName?: pulumi.Input<string>;
    /**
     * Database type (e.g. SqlAzure / MySql).
     */
    databaseType: pulumi.Input<string | enums.DatabaseType>;
    name?: pulumi.Input<string>;
}
/**
 * The configuration settings of the Azure Active Directory default authorization policy.
 */
export interface DefaultAuthorizationPolicyArgs {
    /**
     * The configuration settings of the Azure Active Directory allowed applications.
     */
    allowedApplications?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The configuration settings of the Azure Active Directory allowed principals.
     */
    allowedPrincipals?: pulumi.Input<AllowedPrincipalsArgs>;
}
/**
 * Enabled configuration.
 */
export interface EnabledConfigArgs {
    /**
     * True if configuration is enabled, false if it is disabled and null if configuration is not set.
     */
    enabled?: pulumi.Input<boolean>;
}
export interface EnvironmentVariableArgs {
    /**
     * Environment variable name
     */
    name: pulumi.Input<string>;
    /**
     * Environment variable value
     */
    value: pulumi.Input<string>;
}
/**
 * Routing rules in production experiments.
 */
export interface ExperimentsArgs {
    /**
     * List of ramp-up rules.
     */
    rampUpRules?: pulumi.Input<pulumi.Input<RampUpRuleArgs>[]>;
}
/**
 * Extended Location.
 */
export interface ExtendedLocationArgs {
    /**
     * Name of extended location.
     */
    name?: pulumi.Input<string>;
}
/**
 * The configuration settings of the Facebook provider.
 */
export interface FacebookArgs {
    /**
     * <code>false</code> if the Facebook provider should not be enabled despite the set registration; otherwise, <code>true</code>.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * The version of the Facebook api to be used while logging in.
     */
    graphApiVersion?: pulumi.Input<string>;
    /**
     * The configuration settings of the login flow.
     */
    login?: pulumi.Input<LoginScopesArgs>;
    /**
     * The configuration settings of the app registration for the Facebook provider.
     */
    registration?: pulumi.Input<AppRegistrationArgs>;
}
/**
 * Application logs to file system configuration.
 */
export interface FileSystemApplicationLogsConfigArgs {
    /**
     * Log level.
     */
    level?: pulumi.Input<enums.LogLevel>;
}
/**
 * fileSystemApplicationLogsConfigArgsProvideDefaults sets the appropriate defaults for FileSystemApplicationLogsConfigArgs
 */
export declare function fileSystemApplicationLogsConfigArgsProvideDefaults(val: FileSystemApplicationLogsConfigArgs): FileSystemApplicationLogsConfigArgs;
/**
 * Http logs to file system configuration.
 */
export interface FileSystemHttpLogsConfigArgs {
    /**
     * True if configuration is enabled, false if it is disabled and null if configuration is not set.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * Retention in days.
     * Remove files older than X days.
     * 0 or lower means no retention.
     */
    retentionInDays?: pulumi.Input<number>;
    /**
     * Maximum size in megabytes that http log files can use.
     * When reached old log files will be removed to make space for new ones.
     * Value can range between 25 and 100.
     */
    retentionInMb?: pulumi.Input<number>;
}
/**
 * The configuration settings of the storage of the tokens if a file system is used.
 */
export interface FileSystemTokenStoreArgs {
    /**
     * The directory in which the tokens will be stored.
     */
    directory?: pulumi.Input<string>;
}
/**
 * The configuration settings of a forward proxy used to make the requests.
 */
export interface ForwardProxyArgs {
    /**
     * The convention used to determine the url of the request made.
     */
    convention?: pulumi.Input<enums.ForwardProxyConvention>;
    /**
     * The name of the header containing the host of the request.
     */
    customHostHeaderName?: pulumi.Input<string>;
    /**
     * The name of the header containing the scheme of the request.
     */
    customProtoHeaderName?: pulumi.Input<string>;
}
export interface FrontEndConfigurationArgs {
    kind?: pulumi.Input<enums.FrontEndServiceType>;
}
/**
 * Function app configuration.
 */
export interface FunctionAppConfigArgs {
    /**
     * Function app deployment configuration.
     */
    deployment?: pulumi.Input<FunctionsDeploymentArgs>;
    /**
     * Function app runtime settings.
     */
    runtime?: pulumi.Input<FunctionsRuntimeArgs>;
    /**
     * Function app scale and concurrency settings.
     */
    scaleAndConcurrency?: pulumi.Input<FunctionsScaleAndConcurrencyArgs>;
}
/**
 * Sets the number of 'Always Ready' instances for a function group or a specific function.
 */
export interface FunctionsAlwaysReadyConfigArgs {
    /**
     * Sets the number of 'Always Ready' instances for a given function group or a specific function. For additional information see https://aka.ms/flexconsumption/alwaysready.
     */
    instanceCount?: pulumi.Input<number>;
    /**
     * Either a function group or a function name is required. For additional information see https://aka.ms/flexconsumption/alwaysready.
     */
    name?: pulumi.Input<string>;
}
/**
 * Configuration section for the function app deployment.
 */
export interface FunctionsDeploymentArgs {
    /**
     * Storage for deployed package used by the function app.
     */
    storage?: pulumi.Input<FunctionsDeploymentStorageArgs>;
}
/**
 * Authentication method to access the storage account for deployment.
 */
export interface FunctionsDeploymentAuthenticationArgs {
    /**
     * Use this property for StorageAccountConnectionString. Set the name of the app setting that has the storage account connection string. Do not set a value for this property when using other authentication type.
     */
    storageAccountConnectionStringName?: pulumi.Input<string>;
    /**
     * Property to select authentication type to access the selected storage account. Available options: SystemAssignedIdentity, UserAssignedIdentity, StorageAccountConnectionString.
     */
    type?: pulumi.Input<string | enums.AuthenticationType>;
    /**
     * Use this property for UserAssignedIdentity. Set the resource ID of the identity. Do not set a value for this property when using other authentication type.
     */
    userAssignedIdentityResourceId?: pulumi.Input<string>;
}
/**
 * Storage for deployed package used by the function app.
 */
export interface FunctionsDeploymentStorageArgs {
    /**
     * Authentication method to access the storage account for deployment.
     */
    authentication?: pulumi.Input<FunctionsDeploymentAuthenticationArgs>;
    /**
     * Property to select Azure Storage type. Available options: blobContainer.
     */
    type?: pulumi.Input<string | enums.FunctionsDeploymentStorageType>;
    /**
     * Property to set the URL for the selected Azure Storage type. Example: For blobContainer, the value could be https://<storageAccountName>.blob.core.windows.net/<containerName>.
     */
    value?: pulumi.Input<string>;
}
/**
 * Function app runtime name and version.
 */
export interface FunctionsRuntimeArgs {
    /**
     * Function app runtime name. Available options: dotnet-isolated, node, java, powershell, python, custom
     */
    name?: pulumi.Input<string | enums.RuntimeName>;
    /**
     * Function app runtime version. Example: 8 (for dotnet-isolated)
     */
    version?: pulumi.Input<string>;
}
/**
 * Scale and concurrency settings for the function app.
 */
export interface FunctionsScaleAndConcurrencyArgs {
    /**
     * 'Always Ready' configuration for the function app.
     */
    alwaysReady?: pulumi.Input<pulumi.Input<FunctionsAlwaysReadyConfigArgs>[]>;
    /**
     * Set the amount of memory allocated to each instance of the function app in MB. CPU and network bandwidth are allocated proportionally.
     */
    instanceMemoryMB?: pulumi.Input<number>;
    /**
     * The maximum number of instances for the function app.
     */
    maximumInstanceCount?: pulumi.Input<number>;
    /**
     * Scale and concurrency settings for the function app triggers.
     */
    triggers?: pulumi.Input<FunctionsScaleAndConcurrencyTriggersArgs>;
}
/**
 * Scale and concurrency settings for the HTTP trigger.
 */
export interface FunctionsScaleAndConcurrencyHttpArgs {
    /**
     * The maximum number of concurrent HTTP trigger invocations per instance.
     */
    perInstanceConcurrency?: pulumi.Input<number>;
}
/**
 * Scale and concurrency settings for the function app triggers.
 */
export interface FunctionsScaleAndConcurrencyTriggersArgs {
    /**
     * Scale and concurrency settings for the HTTP trigger.
     */
    http?: pulumi.Input<FunctionsScaleAndConcurrencyHttpArgs>;
}
/**
 * The configuration settings of the GitHub provider.
 */
export interface GitHubArgs {
    /**
     * <code>false</code> if the GitHub provider should not be enabled despite the set registration; otherwise, <code>true</code>.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * The configuration settings of the login flow.
     */
    login?: pulumi.Input<LoginScopesArgs>;
    /**
     * The configuration settings of the app registration for the GitHub provider.
     */
    registration?: pulumi.Input<ClientRegistrationArgs>;
}
/**
 * The GitHub action code configuration.
 */
export interface GitHubActionCodeConfigurationArgs {
    /**
     * Runtime stack is used to determine the workflow file content for code base apps.
     */
    runtimeStack?: pulumi.Input<string>;
    /**
     * Runtime version is used to determine what build version to set in the workflow file.
     */
    runtimeVersion?: pulumi.Input<string>;
}
/**
 * The GitHub action configuration.
 */
export interface GitHubActionConfigurationArgs {
    /**
     * GitHub Action code configuration.
     */
    codeConfiguration?: pulumi.Input<GitHubActionCodeConfigurationArgs>;
    /**
     * GitHub Action container configuration.
     */
    containerConfiguration?: pulumi.Input<GitHubActionContainerConfigurationArgs>;
    /**
     * Workflow option to determine whether the workflow file should be generated and written to the repository.
     */
    generateWorkflowFile?: pulumi.Input<boolean>;
    /**
     * This will help determine the workflow configuration to select.
     */
    isLinux?: pulumi.Input<boolean>;
}
/**
 * The GitHub action container configuration.
 */
export interface GitHubActionContainerConfigurationArgs {
    /**
     * The image name for the build.
     */
    imageName?: pulumi.Input<string>;
    /**
     * The password used to upload the image to the container registry.
     */
    password?: pulumi.Input<string>;
    /**
     * The server URL for the container registry where the build will be hosted.
     */
    serverUrl?: pulumi.Input<string>;
    /**
     * The username used to upload the image to the container registry.
     */
    username?: pulumi.Input<string>;
}
/**
 * The configuration settings that determines the validation flow of users using App Service Authentication/Authorization.
 */
export interface GlobalValidationArgs {
    /**
     * The paths for which unauthenticated flow would not be redirected to the login page.
     */
    excludedPaths?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The default authentication provider to use when multiple providers are configured.
     * This setting is only needed if multiple providers are configured and the unauthenticated client
     * action is set to "RedirectToLoginPage".
     */
    redirectToProvider?: pulumi.Input<string>;
    /**
     * <code>true</code> if the authentication flow is required any request is made; otherwise, <code>false</code>.
     */
    requireAuthentication?: pulumi.Input<boolean>;
    /**
     * The action to take when an unauthenticated client attempts to access the app.
     */
    unauthenticatedClientAction?: pulumi.Input<enums.UnauthenticatedClientActionV2>;
}
/**
 * The configuration settings of the Google provider.
 */
export interface GoogleArgs {
    /**
     * <code>false</code> if the Google provider should not be enabled despite the set registration; otherwise, <code>true</code>.
     */
    enabled?: pulumi.Input<boolean>;
    /**
     * The configuration settings of the login flow.
     */
    login?: pulumi.Input<LoginScopesArgs>;
    /**
     * The configuration settings of the app registration for the Google provider.
     */
    registration?: pulumi.Input<ClientRegistrationArgs>;
    /**
     * The configuration settings of the Azure Active Directory token validation flow.
     */
    validation?: pulumi.Input<AllowedAudiencesValidationArgs>;
}
/**
 * The IIS handler mappings used to define which handler processes HTTP requests with certain extension.
 * For example, it is used to configure php-cgi.exe process to handle all HTTP requests with *.php extension.
 */
export interface HandlerMappingArgs {
    /**
     * Command-line arguments to be passed to the script processor.
     */
    arguments?: pulumi.Input<string>;
    /**
     * Requests with this extension will be handled using the specified FastCGI application.
     */
    extension?: pulumi.Input<string>;
    /**
     * The absolute path to the FastCGI application.
     */
    scriptProcessor?: pulumi.Input<string>;
}
/**
 * SSL-enabled hostname.
 */
export interface HostNameSslStateArgs {
    /**
     * Indicates whether the hostname is a standard or repository hostname.
     */
    hostType?: pulumi.Input<enums.HostType>;
    /**
     * Hostname.
     */
    name?: pulumi.Input<string>;
    /**
     * SSL type.
     */
    sslState?: pulumi.Input<enums.SslState>;
    /**
     * SSL certificate thumbprint.
     */
    thumbprint?: pulumi.Input<string>;
    /**
     * Set to <code>true</code> to update existing hostname.
     */
    toUpdate?: pulumi.Input<boolean>;
    /**
     * Virtual IP address assigned to the hostname if IP based SSL is enabled.
     */
    virtualIP?: pulumi.Input<string>;
}
/**
 * Specification for an App Service Environment to use for this resource.
 */
export interface HostingEnvironmentProfileArgs {
    /**
     * Resource ID of the App Service Environment.
     */
    id?: pulumi.Input<string>;
}
/**
 * Http logs configuration.
 */
export interface HttpLogsConfigArgs {
    /**
     * Http logs to azure blob storage configuration.
     */
    azu