import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
export interface ProviderAssumeRole {
    /**
     * he TRN of the role to assume.
     */
    assumeRoleTrn: pulumi.Input<string>;
    /**
     * The duration of the session when making the AssumeRole call. Its value ranges from 900 to 43200(seconds), and default is 3600 seconds.
     */
    durationSeconds?: pulumi.Input<number>;
    /**
     * A more restrictive policy when making the AssumeRole call
     */
    policy?: pulumi.Input<string>;
}
export interface ProviderEndpoints {
    /**
     * Use this to override the default Cloud Control API service endpoint URL
     */
    cloudcontrolapi?: pulumi.Input<string>;
    /**
     * Use this to override the default STS service endpoint URL
     */
    sts?: pulumi.Input<string>;
}
export declare namespace alb {
    interface AclAclEntry {
        /**
         * Description of the IP entry. Cannot start with http:// or https://. Must start with a letter or Chinese character. Can include numbers, English commas (,), periods (.), underscores (_), spaces, equals signs (=), hyphens (-), Chinese commas (，), and Chinese periods (。). Length must be between 1 and 255 characters. If not specified, defaults to an empty string.
         */
        description?: pulumi.Input<string>;
        /**
         * IP entry address range. Only CIDR addresses are supported.
         */
        entry?: pulumi.Input<string>;
    }
    interface AclListener {
        /**
         * Listener control mode for this access control policy group. white: allowlist mode; black: denylist mode
         */
        aclType?: pulumi.Input<string>;
        /**
         * Listener ID
         */
        listenerId?: pulumi.Input<string>;
        /**
         * Listener name
         */
        listenerName?: pulumi.Input<string>;
        /**
         * Listener port
         */
        port?: pulumi.Input<number>;
        /**
         * Listener protocol
         */
        protocol?: pulumi.Input<string>;
    }
    interface AclTag {
        /**
         * Tag key for user tags. Length must be between 1 and 128 characters. Case sensitive. Cannot start with any combination of volc: or sys: in any case. Cannot start or end with a space. Can include characters from any language, numbers, spaces, underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @. Tag keys for the same resource must be unique.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value. Length must be between 0 and 256 characters. Case sensitive. Cannot start or end with a space. Supports characters from all languages, numbers, spaces (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @.
         */
        value?: pulumi.Input<string>;
    }
    interface CertificateTag {
        /**
         * User tag key
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value
         */
        value?: pulumi.Input<string>;
    }
    interface CustomizedCfgListener {
        /**
         * Listener ID.
         */
        listenerId?: pulumi.Input<string>;
        /**
         * Listener name.
         */
        listenerName?: pulumi.Input<string>;
        /**
         * Listener port.
         */
        port?: pulumi.Input<number>;
        /**
         * Listener protocol.
         */
        protocol?: pulumi.Input<string>;
    }
    interface CustomizedCfgTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface HealthCheckTemplateTag {
        /**
         * Tag key for user tags. Rules: Length must be 1–128 characters. Case-sensitive. Cannot start with any case combination of sys:. Cannot start or end with a space. May include characters from any language, numbers, spaces, underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @. Tag keys for the same resource must be unique.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for the user tag. If you specify this parameter, you must first specify Tags.N.Key. Rules: Length must be between 0 and 256 characters. Case-sensitive. Cannot start or end with a space. Supports characters from all languages, numbers, spaces, underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @.
         */
        value?: pulumi.Input<string>;
    }
    interface ListenerDomainExtension {
        /**
         * Server certificate ID used by the domain name. Effective when the certificate source is cert_center.
         */
        certCenterCertificateId?: pulumi.Input<string>;
        /**
         * Server certificate ID used by the domain. Effective when the certificate source is alb.
         */
        certificateId?: pulumi.Input<string>;
        /**
         * Source of the server certificate used by the domain. Values: alb: certificate uploaded via ALB. cert_center: SSL certificate purchased or uploaded via Volcano Engine Certificate Center.
         */
        certificateSource?: pulumi.Input<string>;
        /**
         * Domain name. Usually cannot be empty. If the instance supports automatic selection of extension certificates (SniAutoMatch is on), Domain must be set to an empty string. Must contain at least one '.' and cannot start or end with '.'. Only lowercase letters, digits, '.', '-', and '*' are allowed. Length limit: 1–128 characters. Wildcard domain: use '*' to replace one or more characters. '*' must be at the beginning or end of the domain name. '*' cannot appear twice in the same domain name. No characters other than '.' can appear before or after '*'. Exact domain: an exact domain name that complies with domain name specifications. Domain names under the same HTTPS listener cannot be duplicated. Domain name matching is case-insensitive.
         */
        domain?: pulumi.Input<string>;
        /**
         * Private leaf certificate ID associated with the HTTPS listener. Required when creating an HTTPS listener and the certificate source is pca_leaf.
         */
        pcaLeafCertificateId?: pulumi.Input<string>;
        /**
         * If the instance supports automatic selection of extension certificates, that is, when SniAutoMatch is set to on, Domain is an empty string. San refers to the certificate's extension domain names, separated by commas.
         */
        san?: pulumi.Input<string>;
    }
    interface ListenerServerGroup {
        /**
         * Server group ID.
         */
        serverGroupId?: pulumi.Input<string>;
        /**
         * Server group name.
         */
        serverGroupName?: pulumi.Input<string>;
    }
    interface ListenerTag {
        /**
         * User tag key. Rules: Length must be between 1 and 128 characters. Case sensitive. Cannot start with any case combination of volc:. Cannot start or end with a space. Allowed characters include all languages, numbers, spaces, parentheses (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @. Tag keys for the same resource cannot be duplicated.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value. Rules: Length must be between 0 and 256 characters. Case sensitive. Cannot start or end with a space. Allowed characters include all languages, numbers, spaces, parentheses (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @.
         */
        value?: pulumi.Input<string>;
    }
    interface LoadBalancerEipBillingConfig {
        /**
         * Peak bandwidth of EIP, in Mbps.
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * EIP billing method: 2 for bandwidth-based, 3 for traffic-based.
         */
        billingType?: pulumi.Input<number>;
        /**
         * Line type of the public IP, BGP indicates multi-line.
         */
        isp?: pulumi.Input<string>;
        /**
         * When creating an ALB public instance, if IP protection resources are used, you must specify a DDoS native protection instance ID.
         */
        securityProtectionInstanceId?: pulumi.Input<number>;
        /**
         * When creating a public ALB instance, ALB allows you to purchase multiple public IP protection resources. The rules for public IP protection resources are as follows: separate multiple protection resources with a comma (,). The values for protection resources are: AntiDDoS_Enhanced: You are requesting an enhanced protection type public IP, which can be added to a native DDoS protection instance. If not specified: You are requesting a basic protection type public IP.
         */
        securityProtectionTypes?: pulumi.Input<string>;
    }
    interface LoadBalancerGlobalAccelerator {
        /**
         * ID of the bound Global Accelerator instance.
         */
        acceleratorId?: pulumi.Input<string>;
        /**
         * ID of the bound Global Accelerator listener.
         */
        acceleratorListenerId?: pulumi.Input<string>;
        /**
         * ID of the bound endpoint group.
         */
        endpointGroupId?: pulumi.Input<string>;
        /**
         * Weight of the backend server, determines traffic distribution ratio.
         */
        weight?: pulumi.Input<number>;
    }
    interface LoadBalancerHealthLog {
        /**
         * Whether to enable access log
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * TLS project ID bound to access log
         */
        projectId?: pulumi.Input<string>;
        /**
         * TLS subject ID bound to access log
         */
        topicId?: pulumi.Input<string>;
    }
    interface LoadBalancerIpv6EipBillingConfig {
        /**
         * Peak bandwidth of IPv6 EIP, in Mbps.
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Billing method for IPv6 EIP: 2 for bandwidth-based, 3 for traffic-based.
         */
        billingType?: pulumi.Input<number>;
        /**
         * Line type of IPv6 public IP; BGP indicates multi-line.
         */
        isp?: pulumi.Input<string>;
    }
    interface LoadBalancerTag {
        /**
         * Tag key, used to identify the tag category.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value used to identify the specific tag content.
         */
        value?: pulumi.Input<string>;
    }
    interface LoadBalancerTlsAccessLog {
        /**
         * Whether to enable access log
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * TLS project ID bound to access log
         */
        projectId?: pulumi.Input<string>;
        /**
         * TLS subject ID bound to access log
         */
        topicId?: pulumi.Input<string>;
    }
    interface LoadBalancerZoneMapping {
        /**
         * Subnet ID providing services within the availability zone.
         */
        subnetId?: pulumi.Input<string>;
        /**
         * Unique identifier of the availability zone.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface RuleForwardGroupConfig {
        serverGroupTuples?: pulumi.Input<pulumi.Input<inputs.alb.RuleForwardGroupConfigServerGroupTuple>[]>;
        /**
         * Whether to enable inter-group session persistence. on: enabled. off: disabled.
         */
        stickySessionEnabled?: pulumi.Input<string>;
        /**
         * Component session stickiness timeout. Unit: seconds.
         */
        stickySessionTimeout?: pulumi.Input<number>;
    }
    interface RuleForwardGroupConfigServerGroupTuple {
        /**
         * Destination server group ID.
         */
        serverGroupId?: pulumi.Input<string>;
        /**
         * Server group weight.
         */
        weight?: pulumi.Input<number>;
    }
    interface RuleRedirectConfig {
        /**
         * Redirect domain name. If the redirect domain name is left empty when creating or modifying a redirect forwarding rule, the API returns ${host}, which means the redirect domain matches the request domain. However, setting the redirect domain to ${host} is not supported when creating or modifying rules.
         */
        redirectDomain?: pulumi.Input<string>;
        /**
         * Redirect status codes: 301, 302, 307, 308.
         */
        redirectHttpCode?: pulumi.Input<string>;
        /**
         * Redirect port. If the redirect port is left empty when creating or modifying a redirect forwarding rule, the API returns ${port}, which means the redirect port matches the request port (listener port). However, setting the redirect port to ${port} is not supported when creating or modifying rules.
         */
        redirectPort?: pulumi.Input<string>;
        /**
         * Protocol used for redirect. HTTP, HTTPS.
         */
        redirectProtocol?: pulumi.Input<string>;
        /**
         * Redirect URI. If the redirect URI is left empty when creating or modifying a redirect forwarding rule, the API returns ${request*uri}, which means the redirect URI matches the request URI. However, setting the redirect URI to ${request*uri} is not supported when creating or modifying rules.
         */
        redirectUri?: pulumi.Input<string>;
    }
    interface RuleRewriteConfig {
        /**
         * Rewrite path.
         */
        rewritePath?: pulumi.Input<string>;
    }
    interface RuleRuleAction {
        /**
         * FixedResponseConfig
         */
        fixedResponseConfig?: pulumi.Input<inputs.alb.RuleRuleActionFixedResponseConfig>;
        /**
         * ForwardGroupConfig
         */
        forwardGroupConfig?: pulumi.Input<inputs.alb.RuleRuleActionForwardGroupConfig>;
        /**
         * RedirectConfig
         */
        redirectConfig?: pulumi.Input<inputs.alb.RuleRuleActionRedirectConfig>;
        /**
         * RewriteConfig
         */
        rewriteConfig?: pulumi.Input<inputs.alb.RuleRuleActionRewriteConfig>;
        /**
         * TrafficLimitConfig
         */
        trafficLimitConfig?: pulumi.Input<inputs.alb.RuleRuleActionTrafficLimitConfig>;
        /**
         * Forwarding rule action types. ForwardGroup: forward to multiple virtual server groups. Redirect: redirect. Rewrite: rewrite. TrafficLimit: traffic limiting.
         */
        type?: pulumi.Input<string>;
    }
    interface RuleRuleActionFixedResponseConfig {
        /**
         * Fixed response content.
         */
        content?: pulumi.Input<string>;
        /**
         * Format of fixed response content. text/plain, text/css, text/html, application/javascript, application/json
         */
        contentType?: pulumi.Input<string>;
        /**
         * Returned HTTP status code.
         */
        httpCode?: pulumi.Input<string>;
    }
    interface RuleRuleActionForwardGroupConfig {
        /**
         * ServerGroupStickySession
         */
        serverGroupStickySession?: pulumi.Input<inputs.alb.RuleRuleActionForwardGroupConfigServerGroupStickySession>;
        serverGroupTuples?: pulumi.Input<pulumi.Input<inputs.alb.RuleRuleActionForwardGroupConfigServerGroupTuple>[]>;
    }
    interface RuleRuleActionForwardGroupConfigServerGroupStickySession {
        /**
         * Whether to enable inter-group session persistence. on: enabled. off: disabled.
         */
        enabled?: pulumi.Input<string>;
        /**
         * Component session stickiness timeout. Unit: seconds.
         */
        timeout?: pulumi.Input<number>;
    }
    interface RuleRuleActionForwardGroupConfigServerGroupTuple {
        /**
         * Destination server group ID.
         */
        serverGroupId?: pulumi.Input<string>;
        /**
         * Server group weight.
         */
        weight?: pulumi.Input<number>;
    }
    interface RuleRuleActionRedirectConfig {
        /**
         * Redirect domain. Only exact domains are supported.
         */
        host?: pulumi.Input<string>;
        /**
         * Redirect status codes supported: 301, 302, 307, 308.
         */
        httpCode?: pulumi.Input<string>;
        /**
         * Redirect URI..
         */
        path?: pulumi.Input<string>;
        /**
         * Redirect port.
         */
        port?: pulumi.Input<string>;
        /**
         * Protocol used for redirect. Supports HTTP and HTTPS.
         */
        protocol?: pulumi.Input<string>;
    }
    interface RuleRuleActionRewriteConfig {
        /**
         * Rewrite path.
         */
        path?: pulumi.Input<string>;
    }
    interface RuleRuleActionTrafficLimitConfig {
        /**
         * Requests per second.
         */
        qps?: pulumi.Input<number>;
    }
    interface RuleRuleCondition {
        /**
         * HeaderConfig。
         */
        headerConfig?: pulumi.Input<inputs.alb.RuleRuleConditionHeaderConfig>;
        /**
         * HostConfig。
         */
        hostConfig?: pulumi.Input<inputs.alb.RuleRuleConditionHostConfig>;
        /**
         * MethodConfig。
         */
        methodConfig?: pulumi.Input<inputs.alb.RuleRuleConditionMethodConfig>;
        /**
         * PathConfig。
         */
        pathConfig?: pulumi.Input<inputs.alb.RuleRuleConditionPathConfig>;
        /**
         * QueryStringConfig。
         */
        queryStringConfig?: pulumi.Input<inputs.alb.RuleRuleConditionQueryStringConfig>;
        /**
         * Standard forwarding rule condition types. Host: domain name. Path: path. Header: HTTP header field. Method: request method. QueryString: query parameter.
         */
        type?: pulumi.Input<string>;
    }
    interface RuleRuleConditionHeaderConfig {
        /**
         * Header field key.
         */
        key?: pulumi.Input<string>;
        /**
         * Header field value.
         */
        values?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface RuleRuleConditionHostConfig {
        /**
         * Domain name of the forwarding rule. Supports wildcard and exact domains.
         */
        values?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface RuleRuleConditionMethodConfig {
        /**
         * Request method. Supports HEAD, GET, POST, OPTIONS, PUT, PATCH, DELETE.
         */
        values?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface RuleRuleConditionPathConfig {
        /**
         * Forwarding rule URL. Only absolute paths are supported.
         */
        values?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface RuleRuleConditionQueryStringConfig {
        values?: pulumi.Input<pulumi.Input<inputs.alb.RuleRuleConditionQueryStringConfigValue>[]>;
    }
    interface RuleRuleConditionQueryStringConfigValue {
        /**
         * Query string key.
         */
        key?: pulumi.Input<string>;
        /**
         * Query string value.
         */
        value?: pulumi.Input<string>;
    }
    interface ServerGroupHealthCheck {
        /**
         * The domain name for health checks must be configured as the actual address used by the backend server to provide external services. This parameter is only effective when HealthCheck.Protocol is set to HTTP. The domain name must contain at least one '.', and cannot start or end with a '.'. Each level of the domain name can include letters, numbers, '-', and '.' characters, but '-' cannot appear at the beginning or end of any level. Length must be between 1 and 128 characters. If this parameter is not provided or no value is specified, it defaults to empty, meaning the load balancer uses the private IP address of each backend server for health checks.
         */
        domain?: pulumi.Input<string>;
        /**
         * Whether the listener has enabled health check. Values: on: enabled (default), off: disabled.
         */
        enabled?: pulumi.Input<string>;
        /**
         * Health check threshold. Indicates that a backend server is considered healthy if it passes the specified number of consecutive health checks. Unit: checks. Range: 2–10. Default: 3.
         */
        healthyThreshold?: pulumi.Input<number>;
        /**
         * HTTP status codes indicating a successful health check. Use commas to separate multiple codes. This parameter is only available when HealthCheck.Protocol is set to HTTP. Valid values: http*2xx (default), http*3xx (default), http*4xx, http*5xx.
         */
        httpCode?: pulumi.Input<string>;
        /**
         * HTTP protocol version for health checks. This parameter is only available when HealthCheck.Protocol is set to HTTP. Values: HTTP1.0 (default when using API), HTTP1.1.
         */
        httpVersion?: pulumi.Input<string>;
        /**
         * After enabling health check, the interval for performing health checks. Unit: seconds. Range: 1–300s. Default: 2.
         */
        interval?: pulumi.Input<number>;
        /**
         * After enabling health check, the health check method. This parameter is effective only when HealthCheck.Protocol is set to HTTP. Values: GET: server must support the GET method. HEAD (default): server returns only HEAD header information, which can reduce backend performance consumption, but the server must support the HEAD method.
         */
        method?: pulumi.Input<string>;
        /**
         * Health check port. Supported values: 0 (default): Use the backend server port for health checks. 1–65535: Use the specified port for health checks.
         */
        port?: pulumi.Input<number>;
        /**
         * Health check protocol. Currently supports HTTP and TCP. Default: HTTP.
         */
        protocol?: pulumi.Input<string>;
        /**
         * Health check response timeout. If the backend server does not respond correctly within the specified time, it is considered a health check failure. Unit: seconds; range: 1~60; default: 2.
         */
        timeout?: pulumi.Input<number>;
        /**
         * Unhealthy threshold for health checks. If a backend server fails the specified number of consecutive health checks, it will be considered unhealthy. Unit: times. Value range: 2–10. Default: 3.
         */
        unhealthyThreshold?: pulumi.Input<number>;
        /**
         * Health check path, which must be configured as the actual path provided by the backend server. This parameter is effective only when HealthCheck.Protocol is set to HTTP. Must start with '/'. Only letters, numbers, '-', '_', '/', '.', '%', '?', '#', '&', '=' are allowed. Length must be between 1 and 128 characters. If this parameter is not specified or no value is provided, the default is '/'.
         */
        uri?: pulumi.Input<string>;
    }
    interface ServerGroupListener {
        /**
         * Listener ID.
         */
        listenerId?: pulumi.Input<string>;
    }
    interface ServerGroupServer {
        /**
         * Description of the backend server.
         */
        description?: pulumi.Input<string>;
        /**
         * ID of the cloud server instance or network interface.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Private IP address of the backend server.
         */
        ip?: pulumi.Input<string>;
        /**
         * Port number on which the backend server receives requests.
         */
        port?: pulumi.Input<number>;
        /**
         * Enable remote IP feature. This field is valid when the backend server instance type is IP address, that is, when Type is set to ip. Values: on: enabled. off (default): disabled.
         */
        remoteEnabled?: pulumi.Input<string>;
        /**
         * Backend server ID.
         */
        serverId?: pulumi.Input<string>;
        /**
         * Backend server instance type. ECS: cloud server instance; ENI: secondary network interface; IP: IP address (only valid for IP-type server groups).
         */
        type?: pulumi.Input<string>;
        /**
         * Backend server weight.
         */
        weight?: pulumi.Input<number>;
    }
    interface ServerGroupStickySessionConfig {
        /**
         * Session persistence cookie name configured for the service. Only valid when session persistence is enabled and cookie rewrite is selected. Rules: Cookie name length must be 1–200 characters. The name can only contain ASCII letters and numbers, cannot include commas (,), semicolons (;), or spaces, and cannot start with a dollar sign ($). When stickySessionConfig.StickySessionEnabled is on and StickySessionConfig.StickySessionType is server, this parameter is required. When StickySessionConfig.StickySessionEnabled is on and StickySessionConfig.StickySessionType is insert, this parameter is invalid.
         */
        cookie?: pulumi.Input<string>;
        /**
         * Session persistence cookie timeout. Only effective when session persistence is enabled and cookie insertion is selected. Unit: seconds. Rules: timeout range: 1~86400; default: 1000. This parameter is required when StickySessionConfig.StickySessionEnabled is on and StickySessionConfig.StickySessionType is insert. This parameter is invalid when StickySessionConfig.StickySessionEnabled is on and StickySessionType is server.
         */
        cookieTimeout?: pulumi.Input<number>;
        /**
         * Enable session persistence. on: Enable; off (default): Disable.
         */
        stickySessionEnabled?: pulumi.Input<string>;
        /**
         * Cookie handling method. When StickySessionConfig.StickySessionEnabled is set to on, this field is required. Values: insert: Insert a Cookie. ALB records the backend server to which the client's first request is forwarded. ALB inserts a Cookie in the response, and subsequent client requests carrying this Cookie are forwarded to the previously recorded backend server. server: Rewrite the Cookie. When session persistence with Cookie rewriting is enabled, after the client's first request is forwarded to the backend server, if ALB finds your custom Cookie in the response, it rewrites the original Cookie. Subsequent client requests carrying the rewritten Cookie are forwarded to the previously recorded backend server.
         */
        stickySessionType?: pulumi.Input<string>;
    }
    interface ServerGroupTag {
        /**
         * Tag key. Duplicate tag keys are not allowed for the same resource.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace apig {
    interface GatewayBackendSpec {
        /**
         * Whether VKE Flannel CNI is supported
         */
        isVkeWithFlannelCniSupported?: pulumi.Input<boolean>;
        /**
         * VKE Pod CIDR。
         */
        vkePodCidr?: pulumi.Input<string>;
    }
    interface GatewayCustomLog {
        customVariables?: pulumi.Input<pulumi.Input<inputs.apig.GatewayCustomLogCustomVariable>[]>;
        requestHeaders?: pulumi.Input<pulumi.Input<inputs.apig.GatewayCustomLogRequestHeader>[]>;
        responseHeaders?: pulumi.Input<pulumi.Input<inputs.apig.GatewayCustomLogResponseHeader>[]>;
    }
    interface GatewayCustomLogCustomVariable {
        /**
         * Field alias
         */
        aliasesInLog?: pulumi.Input<string>;
        /**
         * Request header key
         */
        key?: pulumi.Input<string>;
    }
    interface GatewayCustomLogRequestHeader {
        /**
         * Field alias
         */
        aliasesInLog?: pulumi.Input<string>;
        /**
         * Request header key
         */
        key?: pulumi.Input<string>;
    }
    interface GatewayCustomLogResponseHeader {
        /**
         * Field alias
         */
        aliasesInLog?: pulumi.Input<string>;
        /**
         * Request header key
         */
        key?: pulumi.Input<string>;
    }
    interface GatewayEvent {
        /**
         * Event code
         */
        code?: pulumi.Input<string>;
        /**
         * Event creation time
         */
        createdTime?: pulumi.Input<string>;
        /**
         * Additional information
         */
        data?: pulumi.Input<string>;
        /**
         * Event description
         */
        description?: pulumi.Input<string>;
    }
    interface GatewayLogSpec {
        /**
         * Whether to enable log service
         */
        enable?: pulumi.Input<boolean>;
        /**
         * Log project ID
         */
        projectId?: pulumi.Input<string>;
        /**
         * Log topic ID. ProjectId specifies the log topic within the project
         */
        topicId?: pulumi.Input<string>;
    }
    interface GatewayMonitorSpec {
        /**
         * Managed Prometheus (VMP) service
         */
        enable?: pulumi.Input<boolean>;
        /**
         * Prometheus workspace ID
         */
        workspaceId?: pulumi.Input<string>;
    }
    interface GatewayNetworkSpec {
        subnets?: pulumi.Input<pulumi.Input<inputs.apig.GatewayNetworkSpecSubnet>[]>;
        /**
         * VPC ID。
         */
        vpcId?: pulumi.Input<string>;
        /**
         * VPC name
         */
        vpcName?: pulumi.Input<string>;
    }
    interface GatewayNetworkSpecSubnet {
        /**
         * Availability zone
         */
        az?: pulumi.Input<string>;
        /**
         * Subnet ID
         */
        subnetId?: pulumi.Input<string>;
        /**
         * Subnet name
         */
        subnetName?: pulumi.Input<string>;
    }
    interface GatewayResourceSpec {
        /**
         * CLB specification code. CLB specifications. Options: small*1: Small I; small*2: Small II; medium*1: Medium I; medium*2: Medium II; large*1: Large I; large*2: Large II
         */
        clbSpecCode?: pulumi.Input<string>;
        /**
         * Node specifications. Options: 1c2g, 2c4g, 4c8g, 8c16g
         */
        instanceSpecCode?: pulumi.Input<string>;
        /**
         * Network type. Default value: enable public network, enable private network
         */
        networkType?: pulumi.Input<inputs.apig.GatewayResourceSpecNetworkType>;
        /**
         * Public network bandwidth limit. This field is only used for the 'bandwidth limit billing' public network billing method. Unit: Mbps. Value range: 0–500. Default value: 0
         */
        publicNetworkBandwidth?: pulumi.Input<number>;
        /**
         * Public network billing method. Options: traffic: billed by actual traffic; bandwidth: billed by bandwidth limit
         */
        publicNetworkBillingType?: pulumi.Input<string>;
        /**
         * Node count. Value range: 2–100
         */
        replicas?: pulumi.Input<number>;
    }
    interface GatewayResourceSpecNetworkType {
        /**
         * Whether to enable private network
         */
        enablePrivateNetwork?: pulumi.Input<boolean>;
        /**
         * Whether to enable public network
         */
        enablePublicNetwork?: pulumi.Input<boolean>;
    }
    interface GatewayServiceAuthSpec {
        /**
         * Whether authentication is enabled.
         */
        enable?: pulumi.Input<boolean>;
    }
    interface GatewayServiceCustomDomain {
    }
    interface GatewayServiceDomain {
        /**
         * Domain.
         */
        domain?: pulumi.Input<string>;
        /**
         * Domain type. Options: public: Public network. private: Private network.
         */
        type?: pulumi.Input<string>;
    }
    interface GatewayServiceDomainSpec {
        /**
         * Enable public resolution for private network domains.
         */
        enablePublicResolution?: pulumi.Input<boolean>;
    }
    interface GatewayServiceServiceNetworkSpec {
        /**
         * Enable private network.
         */
        enablePrivateNetwork?: pulumi.Input<boolean>;
        /**
         * Enable public network.
         */
        enablePublicNetwork?: pulumi.Input<boolean>;
        /**
         * Target IP for private network domain resolution.
         */
        privateNetworkIps?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface GatewayTraceSpec {
        /**
         * Application performance monitoring full-link trace configuration
         */
        apmTraceSpec?: pulumi.Input<inputs.apig.GatewayTraceSpecApmTraceSpec>;
        /**
         * Whether to enable trace
         */
        enable?: pulumi.Input<boolean>;
        /**
         * Link tracing configuration information.
         */
        tlsTraceSpec?: pulumi.Input<inputs.apig.GatewayTraceSpecTlsTraceSpec>;
        /**
         * Link tracing type. Possible values: tls: Log Service. apm: Application Performance Monitoring (APM) end-to-end version.
         */
        traceType?: pulumi.Input<string>;
    }
    interface GatewayTraceSpecApmTraceSpec {
        /**
         * API Key。
         */
        apiKey?: pulumi.Input<string>;
    }
    interface GatewayTraceSpecTlsTraceSpec {
        /**
         * Access key。
         */
        iamUserAk?: pulumi.Input<string>;
        /**
         * Secret key。
         */
        iamUserSk?: pulumi.Input<string>;
        /**
         * Log project ID
         */
        projectId?: pulumi.Input<string>;
        /**
         * Trace ID。
         */
        traceId?: pulumi.Input<string>;
    }
    interface UpstreamBackendTarget {
        /**
         * Health Check Status
         */
        healthStatus?: pulumi.Input<string>;
        /**
         * Backend node IP
         */
        ip?: pulumi.Input<string>;
        /**
         * Backend node port
         */
        port?: pulumi.Input<number>;
    }
    interface UpstreamCircuitBreakingSettings {
        /**
         * Minimum pop time, in milliseconds. Value range: 1–86400000. Default: 30 seconds
         */
        baseEjectionTime?: pulumi.Input<number>;
        /**
         * Consecutive failure count. Value range: 1~100. Default: 5
         */
        consecutiveErrors?: pulumi.Input<number>;
        /**
         * Enable
         */
        enable?: pulumi.Input<boolean>;
        /**
         * Calculation cycle, in milliseconds. Value range: 1–86400000. Default: 10 seconds
         */
        interval?: pulumi.Input<number>;
        /**
         * Maximum circuit breaking ratio. Value range: 1~100. Default: 20%
         */
        maxEjectionPercent?: pulumi.Input<number>;
        /**
         * Minimum health ratio. Value range: 0~100. Default: 60%
         */
        minHealthPercent?: pulumi.Input<number>;
    }
    interface UpstreamConnectionPoolSettings {
        /**
         * Enable
         */
        enable?: pulumi.Input<boolean>;
        /**
         * Maximum HTTP/1 pending requests. Value range: 0~2^31-1. 0 means unlimited
         */
        http1MaxPendingRequests?: pulumi.Input<number>;
        /**
         * Idle timeout, in seconds. Value range: 0–2^31-1. 0 means no limit
         */
        idleTimeout?: pulumi.Input<number>;
        /**
         * Maximum TCP connections. Value range: 0~2^31-1. 0 means unlimited
         */
        maxConnections?: pulumi.Input<number>;
    }
    interface UpstreamLoadBalancerSettings {
        /**
         * Consistent Hash Load Balancing
         */
        consistentHashLb?: pulumi.Input<inputs.apig.UpstreamLoadBalancerSettingsConsistentHashLb>;
        /**
         * Load balancing policy. Options: SimpleLB: simple load balancing. ConsistentHashLB: consistent hash load balancing
         */
        lbPolicy?: pulumi.Input<string>;
        /**
         * Simple load balancing. Options: ROUND*ROBIN: round robin. LEAST*CONN: least connections. RANDOM: random
         */
        simpleLb?: pulumi.Input<string>;
        /**
         * Warm-up time (seconds)
         */
        warmupDuration?: pulumi.Input<number>;
    }
    interface UpstreamLoadBalancerSettingsConsistentHashLb {
        /**
         * Overload protection parameter. Value range: 100–200. When set to 120, overload protection is triggered if the current active request count of an upstream node exceeds 120% of the average active request count. When overload protection is triggered, even if the request hash matches a specific upstream node, the load balancer will randomly select an upstream node
         */
        hashBalanceFactor?: pulumi.Input<number>;
        /**
         * Consistent hash method. Options: UseSourceIp: based on source IP address. HttpQueryParameterName: based on parameter. HttpHeaderName: based on header. HTTPCookie: based on cookie
         */
        hashKey?: pulumi.Input<string>;
        /**
         * Cookie。
         */
        httpCookie?: pulumi.Input<inputs.apig.UpstreamLoadBalancerSettingsConsistentHashLbHttpCookie>;
        /**
         * Parameter. Supports printable ASCII characters, length: 1–256 characters
         */
        httpHeaderName?: pulumi.Input<string>;
        /**
         * Parameter. Supports printable ASCII characters, length: 1–256 characters
         */
        httpQueryParameterName?: pulumi.Input<string>;
        /**
         * Source IP address
         */
        useSourceIp?: pulumi.Input<string>;
    }
    interface UpstreamLoadBalancerSettingsConsistentHashLbHttpCookie {
        /**
         * Name. Supports printable ASCII characters. Length: 0~256 characters
         */
        name?: pulumi.Input<string>;
        /**
         * Path. Supports printable ASCII characters. Length: 1~256 characters
         */
        path?: pulumi.Input<string>;
        /**
         * Validity period, in seconds
         */
        ttl?: pulumi.Input<number>;
    }
    interface UpstreamSourceIngressSettings {
        /**
         * Whether to enable all Ingress classes
         */
        enableAllIngressClasses?: pulumi.Input<boolean>;
        /**
         * Whether all namespaces
         */
        enableAllNamespaces?: pulumi.Input<boolean>;
        /**
         * Whether enabled
         */
        enableIngress?: pulumi.Input<boolean>;
        /**
         * Whether to monitor resources with empty IngressClass
         */
        enableIngressWithoutIngressClass?: pulumi.Input<boolean>;
        /**
         * Specify IngressClass
         */
        ingressClasses?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Traffic entry switch. When enabled, the IP address in the Status of the current cluster's Ingress will be updated to the current gateway's IP address
         */
        updateStatus?: pulumi.Input<boolean>;
        /**
         * Specify namespace
         */
        watchNamespaces?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface UpstreamSourceSourceSpec {
        /**
         * Container cluster source
         */
        k8SSource?: pulumi.Input<inputs.apig.UpstreamSourceSourceSpecK8SSource>;
        /**
         * Registry source
         */
        nacosSource?: pulumi.Input<inputs.apig.UpstreamSourceSourceSpecNacosSource>;
    }
    interface UpstreamSourceSourceSpecK8SSource {
        /**
         * Cluster ID
         */
        clusterId?: pulumi.Input<string>;
        /**
         * Cluster type
         */
        clusterType?: pulumi.Input<string>;
    }
    interface UpstreamSourceSourceSpecNacosSource {
        /**
         * Authentication configuration
         */
        authConfig?: pulumi.Input<inputs.apig.UpstreamSourceSourceSpecNacosSourceAuthConfig>;
        /**
         * Nacos ID。
         */
        nacosId?: pulumi.Input<string>;
        /**
         * Nacos name
         */
        nacosName?: pulumi.Input<string>;
    }
    interface UpstreamSourceSourceSpecNacosSourceAuthConfig {
        /**
         * Basic authentication
         */
        basic?: pulumi.Input<inputs.apig.UpstreamSourceSourceSpecNacosSourceAuthConfigBasic>;
    }
    interface UpstreamSourceSourceSpecNacosSourceAuthConfigBasic {
        /**
         * Password
         */
        password?: pulumi.Input<string>;
        /**
         * Username
         */
        username?: pulumi.Input<string>;
    }
    interface UpstreamTlsSettings {
        /**
         * SNI. If left blank, the domain name accessed by the gateway will be passed through to the upstream
         */
        sni?: pulumi.Input<string>;
        /**
         * TLS mode. Options: DISABLE: disable TLS. SIMPLE: one-way TLS
         */
        tlsMode?: pulumi.Input<string>;
    }
    interface UpstreamUpstreamSpec {
        /**
         * AI model proxy
         */
        aiProvider?: pulumi.Input<inputs.apig.UpstreamUpstreamSpecAiProvider>;
        /**
         * Fixed domain name
         */
        domain?: pulumi.Input<inputs.apig.UpstreamUpstreamSpecDomain>;
        ecsInstances?: pulumi.Input<pulumi.Input<inputs.apig.UpstreamUpstreamSpecEcsInstance>[]>;
        /**
         * Container Service
         */
        k8SService?: pulumi.Input<inputs.apig.UpstreamUpstreamSpecK8SService>;
        /**
         * Registry Center
         */
        nacosService?: pulumi.Input<inputs.apig.UpstreamUpstreamSpecNacosService>;
        /**
         * Function service
         */
        veFaas?: pulumi.Input<inputs.apig.UpstreamUpstreamSpecVeFaas>;
    }
    interface UpstreamUpstreamSpecAiProvider {
        /**
         * Model address
         */
        baseUrl?: pulumi.Input<string>;
        /**
         * Volcano Engine self-hosted model service
         */
        customModelService?: pulumi.Input<inputs.apig.UpstreamUpstreamSpecAiProviderCustomModelService>;
        /**
         * Model Service Provider Name
         */
        name?: pulumi.Input<string>;
        /**
         * Model API key
         */
        token?: pulumi.Input<string>;
    }
    interface UpstreamUpstreamSpecAiProviderCustomModelService {
        /**
         * Model Service Name
         */
        name?: pulumi.Input<string>;
        /**
         * Namespace
         */
        namespace?: pulumi.Input<string>;
        /**
         * Port
         */
        port?: pulumi.Input<number>;
    }
    interface UpstreamUpstreamSpecDomain {
        domainLists?: pulumi.Input<pulumi.Input<inputs.apig.UpstreamUpstreamSpecDomainDomainList>[]>;
    }
    interface UpstreamUpstreamSpecDomainDomainList {
        /**
         * Domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * Port. Default: 80 for HTTP, 443 for HTTPS
         */
        port?: pulumi.Input<number>;
    }
    interface UpstreamUpstreamSpecEcsInstance {
        /**
         * Cloud server ID
         */
        ecsId?: pulumi.Input<string>;
        /**
         * IP address
         */
        ip?: pulumi.Input<string>;
        /**
         * Port
         */
        port?: pulumi.Input<number>;
    }
    interface UpstreamUpstreamSpecK8SService {
        /**
         * Container Service Name. Length: 2–63 characters
         */
        name?: pulumi.Input<string>;
        /**
         * Namespace. Length: 2~63 characters
         */
        namespace?: pulumi.Input<string>;
        /**
         * Port
         */
        port?: pulumi.Input<number>;
    }
    interface UpstreamUpstreamSpecNacosService {
        /**
         * Group
         */
        group?: pulumi.Input<string>;
        /**
         * Namespace
         */
        namespace?: pulumi.Input<string>;
        /**
         * Namespace ID
         */
        namespaceId?: pulumi.Input<string>;
        /**
         * Service
         */
        service?: pulumi.Input<string>;
        /**
         * Upstream source ID
         */
        upstreamSourceId?: pulumi.Input<string>;
    }
    interface UpstreamUpstreamSpecVeFaas {
        /**
         * Function ID
         */
        functionId?: pulumi.Input<string>;
    }
    interface UpstreamVersionDetail {
        labels?: pulumi.Input<pulumi.Input<inputs.apig.UpstreamVersionDetailLabel>[]>;
        /**
         * Version name. Supports uppercase and lowercase letters, numbers, and hyphens (-). Length: 2~63 characters. Cannot start with a hyphen (-)
         */
        name?: pulumi.Input<string>;
        /**
         * Update time
         */
        updateTime?: pulumi.Input<string>;
    }
    interface UpstreamVersionDetailLabel {
        /**
         * Key
         */
        key?: pulumi.Input<string>;
        /**
         * Value
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace ark {
    interface EndpointCertificate {
        /**
         * X509 private certificate expiration time, represented as a timestamp in seconds
         */
        notAfter?: pulumi.Input<number>;
        /**
         * X509 private certificate activation time, represented as a timestamp in seconds
         */
        notBefore?: pulumi.Input<number>;
        /**
         * Certificate subject
         */
        pcaHost?: pulumi.Input<string>;
        /**
         * PEM format leaf certificate
         */
        pcaInstanceCertificate?: pulumi.Input<string>;
        /**
         * Certificate name
         */
        pcaName?: pulumi.Input<string>;
        /**
         * PEM format root certificate
         */
        pcaRootCaCertificate?: pulumi.Input<string>;
        /**
         * Intermediate certificate and root certificate in PEM format
         */
        pcaSubCaCertificate?: pulumi.Input<string>;
    }
    interface EndpointModelReference {
        /**
         * Custom model ID
         */
        customModelId?: pulumi.Input<string>;
        /**
         * Base model
         */
        foundationModel?: pulumi.Input<inputs.ark.EndpointModelReferenceFoundationModel>;
    }
    interface EndpointModelReferenceFoundationModel {
        /**
         * Base model version
         */
        modelVersion?: pulumi.Input<string>;
        /**
         * Base model name. Note: Model names are lowercase. The model name format for doubao 1.5 generation models is "doubao-1-5-**".
         */
        name?: pulumi.Input<string>;
    }
    interface EndpointModeration {
        /**
         * Content safety guardrail scheme. Values: Default: default scheme. Lower latency, broadly covers general content safety requirements; Basic: basic scheme (public beta). Supports providing triggered risk categories in interface responses, currently only includes two risk types: severe violations and aggressive behavior. Note: If using streaming interface calls, this scheme is not recommended, as it will increase the length of each output fragment and raise latency
         */
        strategy?: pulumi.Input<string>;
    }
    interface EndpointRateLimit {
        /**
         * Requests Per Minute, number of requests per minute
         */
        rpm?: pulumi.Input<number>;
        /**
         * Tokens Per Minute, number of tokens requested per minute
         */
        tpm?: pulumi.Input<number>;
    }
    interface EndpointTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace autoscaling {
    interface ScalingConfigurationEip {
        /**
         * Peak bandwidth for the public IP. Default is 1, unit: Mbps. Value: When Eip.BillingType is set to PostPaidByBandwidth, the value is 1–500. When Eip.BillingType is set to PostPaidByTraffic, the value is 1–200.
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * ID of the shared bandwidth package, indicating that the public IP will be added to the shared bandwidth package. You can call the DescribeBandwidthPackages API to query the shared bandwidth package ID. The public IP can be added to the shared bandwidth package only if the following conditions are met: Both have the same security protection type. Both have the same line type. The shared bandwidth package is IPv4 type.
         */
        bandwidthPackageId?: pulumi.Input<string>;
        /**
         * Billing type for public IP. Options: PostPaidByBandwidth (default): Pay-as-you-go, billed by bandwidth cap. PostPaidByTraffic: Pay-as-you-go, billed by actual traffic.
         */
        billingType?: pulumi.Input<string>;
        /**
         * Line type. Values: BGP (default): BGP line. If your account has applied for static single line, ISP can also be set to ChinaMobile (China Mobile), ChinaTelecom (China Telecom), or ChinaUnicom (China Unicom).
         */
        isp?: pulumi.Input<string>;
        /**
         * Whether the public IP is deleted along with the instance. This applies only to pay-as-you-go public IPs and takes effect when deleting the instance in the ECS console. For retention details after deleting an instance in a scaling group, see the detailed instructions in instance management. Values: true: The public IP is deleted with the instance. false: The public IP is not deleted with the instance
         */
        releaseWithInstance?: pulumi.Input<boolean>;
    }
    interface ScalingConfigurationInstanceTypeOverride {
        /**
         * Specify the specifications for preemptible instances. Parameter   - N: Indicates the sequence number of the instance specification, value range 1–10. Value   - InstanceType: Specifies the specification for the preemptible instance. Use & to separate multiple specifications.
         */
        instanceType?: pulumi.Input<string>;
        /**
         * Specify the maximum hourly price for preemptible instance types. Parameter   - N: Indicates the instance type sequence number. Value: 1–10. PriceLimit: Specifies the maximum hourly price for the preemptible instance type. Value: Greater than 0, up to three decimal places. Use & to separate multiple prices.
         */
        priceLimit?: pulumi.Input<number>;
    }
    interface ScalingConfigurationTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface ScalingConfigurationVolume {
        /**
         * Whether the cloud disk is released with the instance: true (default): The cloud disk is released with the instance. false: The cloud disk is not released with the instance. When set to false, this does not apply to system disks. System disks are always released with the instance and cannot be retained.
         */
        deleteWithInstance?: pulumi.Input<boolean>;
        /**
         * You can use this parameter to configure the extra performance package IOPS size for cloud disks. Only ESSD FlexPL is supported. Parameter   - N: Indicates the disk sequence number. '1' represents the system disk; '2' or greater represents a data disk. Only data disks support extra performance packages. Value: 2–16. ExtraPerformanceIOPS specifies the extra performance package IOPS size for the Nth disk: IOPS: 1–50000. Balance: 1–50000.
         */
        extraPerformanceIops?: pulumi.Input<number>;
        /**
         * You can use this parameter to configure the extra performance package throughput size for cloud disks, in MB/s. Only ESSD FlexPL is supported. Parameter   - N: Indicates the disk sequence number. '1' represents the system disk; '2' or greater represents a data disk. Only data disks support extra performance packages. Value: 2–16. ExtraPerformanceThroughputMB specifies the extra performance package throughput size for the Nth disk: Throughput: 1–650.
         */
        extraPerformanceThroughputMb?: pulumi.Input<number>;
        /**
         * This parameter allows you to purchase extra performance for cloud disks. Only ESSD FlexPL is supported. Parameter   - N: Indicates the disk sequence number. "1" is the system disk; "2" or greater indicates a data disk. Only data disks support extra performance packages. Value: 2–16. ExtraPerformanceTypeId specifies the extra performance package type for the Nth disk: IOPS: IOPS type, use the ExtraPerformanceIOPS parameter. Balance: Balanced type, use the ExtraPerformanceIOPS parameter. Throughput: Throughput type, use the ExtraPerformanceThroughputMB parameter.
         */
        extraPerformanceTypeId?: pulumi.Input<string>;
        /**
         * Cloud disk capacity, in GiB. System disk range: 10–500. Data disk range: 10–8192. If using ESSD_FlexPL with additional performance, size must be >= 500 GB
         */
        size?: pulumi.Input<number>;
        /**
         * Cloud disk types: ESSD*FlexPL: Extreme SSD FlexPL. ESSD*PL0: Extreme SSD PL0.
         */
        volumeType?: pulumi.Input<string>;
    }
    interface ScalingGroupInstance {
        /**
         * Time when the instance joined the scaling group
         */
        createdTime?: pulumi.Input<string>;
        /**
         * How the instance joined the scaling group (Attached / AutoCreated)
         */
        creationType?: pulumi.Input<string>;
        /**
         * Whether to enable managed mode for the instance when AttachInstances is performed
         */
        entrusted?: pulumi.Input<boolean>;
        /**
         * ECS instance ID, unique identifier of the subresource
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Launch template ID used by the instance
         */
        launchTemplateId?: pulumi.Input<string>;
        /**
         * Launch template version used by the instance
         */
        launchTemplateVersion?: pulumi.Input<string>;
        /**
         * Whether to trigger lifecycle hooks when the instance is attached, detached, or removed
         */
        lifecycleHook?: pulumi.Input<boolean>;
        /**
         * Scaling configuration ID associated with the instance
         */
        scalingConfigurationId?: pulumi.Input<string>;
        /**
         * Scaling policy ID associated with the instance
         */
        scalingPolicyId?: pulumi.Input<string>;
        /**
         * Current status of the instance in the scaling group
         */
        status?: pulumi.Input<string>;
        /**
         * Availability zone of the instance
         */
        zoneId?: pulumi.Input<string>;
    }
    interface ScalingGroupInstanceRemovePolicy {
        /**
         * Whether to decrease the desired instance count synchronously when DetachInstances or RemoveInstances is performed
         */
        decreaseDesiredCapacity?: pulumi.Input<boolean>;
        /**
         * Instance removal policy for DetachInstances
         */
        detachOption?: pulumi.Input<string>;
        /**
         * Whether to force delete the instance when RemoveInstances is performed
         */
        forceDelete?: pulumi.Input<boolean>;
        /**
         * ECS instance ID, unique identifier of the subresource
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Whether to trigger lifecycle hooks when the instance is attached, detached, or removed
         */
        lifecycleHook?: pulumi.Input<boolean>;
        /**
         * Mode: How to handle an instance when it is removed from the scaling group: Detach means only remove from the scaling group, Remove means remove and delete the instance
         */
        mode?: pulumi.Input<string>;
        /**
         * Removal mode for RemoveInstances
         */
        removeMode?: pulumi.Input<string>;
    }
    interface ScalingGroupInstancesDistribution {
        /**
         * Whether pay-as-you-go instances are allowed to supplement spot capacity if spot instances cannot be created due to price or inventory constraints. true: allowed. false (default): not allowed.
         */
        compensateWithOnDemand?: pulumi.Input<boolean>;
        /**
         * Minimum number of pay-as-you-go instances in the scaling group. Value range: 0~2000. If the number of pay-as-you-go instances in the group is less than this value, pay-as-you-go instances will be prioritized for creation.
         */
        onDemandBaseCapacity?: pulumi.Input<number>;
        /**
         * After the scaling group meets the minimum number of pay-as-you-go instances, the proportion of pay-as-you-go instances among the excess instances. Value range: 0–100.
         */
        onDemandPercentageAboveBaseCapacity?: pulumi.Input<number>;
        /**
         * Whether to allow preemptible instance replacement upon expiration. If enabled, the scaling group will proactively create a new preemptible instance to replace the current one about 5 minutes before the preemptible instance is reclaimed. true: allowed. false (default): not allowed.
         */
        spotInstanceRemedy?: pulumi.Input<boolean>;
    }
    interface ScalingGroupLaunchTemplateOverride {
        /**
         * Specify the instance type. This parameter is valid only when the LaunchTemplateId parameter is set.
         */
        instanceType?: pulumi.Input<string>;
        /**
         * Specify the maximum hourly price for spot instance types. This parameter is valid only when the LaunchTemplateId parameter is set and the launch template's billing mode is SpotWithPriceLimit.
         */
        priceLimit?: pulumi.Input<number>;
    }
    interface ScalingGroupServerGroupAttribute {
        /**
         * Port number of the server in the backend server group for load balancing. Range: 1–65535.
         */
        port?: pulumi.Input<number>;
        /**
         * Backend server group ID for load balancing.
         */
        serverGroupId?: pulumi.Input<string>;
        /**
         * Load balancing server group type. A single CLB/ALB supports up to 20 backend server groups, and the total number of backend servers supported by all CLB/ALB is 100. ALB: Application Load Balancer. CLB: Classic Load Balancer (default).
         */
        type?: pulumi.Input<string>;
        /**
         * Weight of servers in the backend server group of the load balancer
         */
        weight?: pulumi.Input<number>;
    }
    interface ScalingGroupTag {
        /**
         * User label tag key
         */
        key?: pulumi.Input<string>;
        /**
         * The value of the user tag.
         */
        value?: pulumi.Input<string>;
    }
    interface ScalingLifecycleHookLifecycleCommand {
        /**
         * Cloud Assistant command ID, indicates that after the lifecycle hook is triggered, the Cloud Assistant command is executed on the instance. If the command executes successfully, the post-suspend policy is executed according to CONTINUE. If the command fails, times out, or the lifecycle hook times out, the post-suspend policy is executed according to the LifecycleHookPolicy parameter configuration.
         */
        commandId?: pulumi.Input<string>;
        /**
         * Parameters and values in the Cloud Assistant command. The number of parameters ranges from 0 to 60. Note: Parameters cannot be empty strings and can have up to 64 characters. Values can be empty strings. After Base64 encoding, the combined length of parameters and the original command content must not exceed 16 KB. The set of parameter names must be a subset of the parameter set defined when creating the command. Default values are used for parameters not provided.
         */
        parameters?: pulumi.Input<string>;
    }
    interface ScalingPolicyAlarmPolicy {
        /**
         * Detailed monitoring metric information for single-metric monitoring. Valid only when ScalingPolicyType is set to Alarm.
         */
        condition?: pulumi.Input<inputs.autoscaling.ScalingPolicyAlarmPolicyCondition>;
        /**
         * Determination conditions for multi-metric alarms. &&: Alarm is triggered only when all metrics meet the conditions. || (default): Alarm is triggered when any metric meets the condition.
         */
        conditionOperator?: pulumi.Input<string>;
        conditions?: pulumi.Input<pulumi.Input<inputs.autoscaling.ScalingPolicyAlarmPolicyCondition>[]>;
        /**
         * The effective period for the alarm task.
         */
        effective?: pulumi.Input<string>;
        /**
         * Scaling actions are triggered when monitoring metric data reaches the threshold for several consecutive times. Valid only when ScalingPolicyType is set to Alarm and required.
         */
        evaluationCount?: pulumi.Input<number>;
        /**
         * Type of alarm task. Options: Static: static monitoring collected by agent. Valid only when ScalingPolicyType is set to Alarm and required.
         */
        ruleType?: pulumi.Input<string>;
    }
    interface ScalingPolicyAlarmPolicyCondition {
        /**
         * Rule expression object for metric alarms. >: Greater than. <: Less than. =: Equal to.
         */
        comparisonOperator?: pulumi.Input<string>;
        /**
         * Monitoring metric names for metric alarms. CpuTotal*Max: Maximum in-band CPU usage. CpuTotal*Min: Minimum in-band CPU usage. CpuTotal*Avg: Average in-band CPU usage. MemoryUsedUtilization*Max: Maximum in-band memory usage. MemoryUsedUtilization*Min: Minimum in-band memory usage. MemoryUsedUtilization*Avg: Average in-band memory usage. Instance*CpuBusy*Max: Maximum out-of-band CPU utilization. Instance*CpuBusy*Min: Minimum out-of-band CPU utilization. Instance*CpuBusy*Avg: Average out-of-band CPU utilization. Instance*NetTxBits*Avg: Average out-of-band network outbound rate. Instance*NetRxBits*Avg: Average out-of-band network inbound rate. Instance*NetTxPackets*Avg: Average out-of-band network packet send rate. Instance*NetRxPackets*Avg: Average out-of-band network packet receive rate. SystemDiskReadBytes*Avg: Average in-band system disk read bandwidth. SystemDiskWriteBytes*Avg: Average in-band system disk write bandwidth. SystemDiskReadIOPS*Avg: Average in-band system disk read IOPS. SystemDiskWriteIOPS*Avg: Average in-band system disk write IOPS. NetTcpConnection_Avg: Average in-band TCP connection count.
         */
        metricName?: pulumi.Input<string>;
        /**
         * The unit for the monitoring metric threshold when an alarm is triggered. When the AlarmPolicy.Conditions.MetricName parameter is set to CPU/memory usage: Percent. When the AlarmPolicy.Conditions.MetricName parameter is set to system disk read/write bandwidth: Bytes/Second(IEC). When the AlarmPolicy.Conditions.MetricName parameter is set to system disk read/write IOPS: Count/Second. When the AlarmPolicy.Conditions.MetricName parameter is set to TCP connections: Count. When the AlarmPolicy.Condition.MetricName parameter is set to network inbound/outbound rate: Bits/Second(IEC). When the AlarmPolicy.Condition.MetricName parameter is set to network packet transmission rate: Packet/Second.
         */
        metricUnit?: pulumi.Input<string>;
        /**
         * The threshold value for the monitoring metric when an alarm is triggered. When AlarmPolicy.Conditions.MetricUnit is set to Percent: 1–100. When AlarmPolicy.Conditions.MetricUnit is set to Bytes/Second(IEC): an integer greater than 0. When AlarmPolicy.Conditions.MetricUnit is set to Count/Second: an integer greater than 0. When AlarmPolicy.Conditions.MetricUnit is set to Count: an integer greater than 0. When AlarmPolicy.Condition.MetricUnit is set to Bits/Second(IEC): an integer greater than 0. When AlarmPolicy.Condition.MetricUnit is set to Packet/Second: an integer greater than 0.
         */
        threshold?: pulumi.Input<string>;
    }
    interface ScalingPolicyScheduledPolicy {
        /**
         * Indicates the trigger time for the task. The default is the current time. When ScalingPolicyType is set to Scheduled, this specifies the trigger time for the scheduled task. When ScalingPolicyType is set to Recurrence: If ScheduledPolicy.RecurrenceType is empty, the task is executed only once at the specified date and time. If ScheduledPolicy.RecurrenceType is not empty, this specifies the start time for the recurring task.
         */
        launchTime?: pulumi.Input<string>;
        /**
         * Indicates the task trigger time. This is a read-only field; use LaunchTime to modify or create.
         */
        launchTimeRead?: pulumi.Input<string>;
        /**
         * Indicates the end time for the recurring task. Only supports selecting a time within 365 days from the creation date. If not configured, defaults to one day/week/month after the current time based on the recurrence cycle (ScheduledPolicy.RecurrenceType). If set to empty, the task never stops. Valid only when ScalingPolicyType is set to Recurrence and required.
         */
        recurrenceEndTime?: pulumi.Input<string>;
        /**
         * Indicates the end time for the recurring task. Read-only field; use RecurrenceEndTime for modification or creation.
         */
        recurrenceEndTimeRead?: pulumi.Input<string>;
        /**
         * Indicates the start time for the recurring task. Valid only when ScalingPolicyType is set to Recurrence.
         */
        recurrenceStartTime?: pulumi.Input<string>;
        /**
         * Indicates the recurrence cycle for scheduled tasks. Values: Daily: Executes once every XX days. Weekly: Select specific days of the week, executes once per day. Monthly: Select XX to XX days of the month, executes once per day. Cron: Executes according to the specified Cron expression. Required and valid only when ScalingPolicyType is set to Recurrence.
         */
        recurrenceType?: pulumi.Input<string>;
        /**
         * Specifies the value for recurring tasks. When the ScheduledPolicy.RecurrenceType parameter is set to Daily, only one value can be entered: 1–31. When the ScheduledPolicy.RecurrenceType parameter is set to Weekly, multiple values can be entered, separated by commas (,). Values for Monday to Sunday are: 1 (Monday), 2 (Tuesday), 3 (Wednesday), 4 (Thursday), 5 (Friday), 6 (Saturday), 7 (Sunday). When the ScheduledPolicy.RecurrenceType parameter is set to Monthly, the format is A-B. Both A and B range from 1–31, and B must be greater than or equal to A. When the ScheduledPolicy.RecurrenceType parameter is set to Cron, it uses UTC+8 time and supports a five-field expression for minute, hour, day, month, and week. Wildcards supported include comma (,), question mark (?), hyphen (-), asterisk (*), hash (#), slash (/), L, and W. This field is valid and required when ScalingPolicyType is set to Recurrence.
         */
        recurrenceValue?: pulumi.Input<string>;
    }
}
export declare namespace bmq {
    interface GroupResetInfo {
        /**
         * If the reset mode is OFFSET, this parameter is required. Specify the reference consumption position for resuming consumption. Options: EARLIEST: Reference position is the earliest offset. CURRENT: Reference position is the current offset. LATEST: Reference position is the latest offset.
         */
        offsetType?: pulumi.Input<string>;
        /**
         * Partition number
         */
        partitionId?: pulumi.Input<number>;
        /**
         * Reset mode. Options: TIMESTAMP: Reset the consumption offset based on a timestamp. Specify a past or future time to jump directly to the offset at that time and start consuming. OFFSET: Reset the consumption offset based on a specified offset, starting consumption from that offset. You can specify the offset using the offsetType parameter.
         */
        resetBy?: pulumi.Input<string>;
        /**
         * Reset value. If TIMESTAMP is selected, this value is the timestamp for resuming consumption, e.g., 1722224612000. If OFFSET is selected, this value is the relative offset from the reference offset in OffsetType, e.g., 100.
         */
        resetValue?: pulumi.Input<number>;
        /**
         * Topic ID。
         */
        topicId?: pulumi.Input<string>;
    }
    interface GroupTopicInfo {
        /**
         * Topic creation time
         */
        createTime?: pulumi.Input<string>;
        /**
         * Topic description
         */
        description?: pulumi.Input<string>;
        /**
         * Number of unconsumed messages in the Topic
         */
        lag?: pulumi.Input<number>;
        partitionInfos?: pulumi.Input<pulumi.Input<inputs.bmq.GroupTopicInfoPartitionInfo>[]>;
        /**
         * Number of Topic partitions
         */
        partitions?: pulumi.Input<number>;
        /**
         * Retention period of data in the Topic, in hours
         */
        retention?: pulumi.Input<number>;
        /**
         * Topic status
         */
        status?: pulumi.Input<string>;
        /**
         * Topic ID。
         */
        topicId?: pulumi.Input<string>;
        /**
         * Topic name
         */
        topicName?: pulumi.Input<string>;
    }
    interface GroupTopicInfoPartitionInfo {
        /**
         * Current consumption offset
         */
        currentOffset?: pulumi.Input<number>;
        /**
         * Consumer Group name
         */
        groupName?: pulumi.Input<string>;
        /**
         * Number of unconsumed messages in the partition
         */
        lag?: pulumi.Input<number>;
        /**
         * Latest consumption offset
         */
        latestOffset?: pulumi.Input<number>;
        /**
         * Partition number
         */
        partitionId?: pulumi.Input<number>;
        /**
         * Name of the Topic subscribed by the Consumer Group
         */
        topicName?: pulumi.Input<string>;
    }
    interface InstanceEndpoints {
        /**
         * Instance private network access endpoint response data
         */
        overlay?: pulumi.Input<inputs.bmq.InstanceEndpointsOverlay>;
        /**
         * Instance public access endpoint response data
         */
        public?: pulumi.Input<inputs.bmq.InstanceEndpointsPublic>;
    }
    interface InstanceEndpointsOverlay {
        /**
         * Domain mapping address
         */
        address?: pulumi.Input<string>;
        /**
         * ID of the EIP bound to the instance
         */
        eipId?: pulumi.Input<string>;
        /**
         * Private network Plain access point
         */
        plain?: pulumi.Input<string>;
        /**
         * Standard endpoint port
         */
        plainPort?: pulumi.Input<number>;
        /**
         * Private network SASL authentication access point
         */
        sasl?: pulumi.Input<string>;
        /**
         * Authentication endpoint port
         */
        saslPort?: pulumi.Input<number>;
        /**
         * Encrypted endpoint
         */
        ssl?: pulumi.Input<string>;
        /**
         * Encrypted endpoint port
         */
        sslPort?: pulumi.Input<number>;
        /**
         * Endpoint status
         */
        status?: pulumi.Input<string>;
        /**
         * List of VPC IDs associated with the sales zone network
         */
        vpcIds?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface InstanceEndpointsPublic {
        /**
         * Domain mapping address
         */
        address?: pulumi.Input<string>;
        /**
         * ID of the EIP bound to the instance
         */
        eipId?: pulumi.Input<string>;
        /**
         * Private network Plain access point
         */
        plain?: pulumi.Input<string>;
        /**
         * Standard endpoint port
         */
        plainPort?: pulumi.Input<number>;
        /**
         * Private network SASL authentication access point
         */
        sasl?: pulumi.Input<string>;
        /**
         * Authentication endpoint port
         */
        saslPort?: pulumi.Input<number>;
        /**
         * Encrypted endpoint
         */
        ssl?: pulumi.Input<string>;
        /**
         * Encrypted endpoint port
         */
        sslPort?: pulumi.Input<number>;
        /**
         * Endpoint status
         */
        status?: pulumi.Input<string>;
        /**
         * List of VPC IDs associated with the sales zone network
         */
        vpcIds?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface InstanceResourceTag {
        tagKvs?: pulumi.Input<pulumi.Input<inputs.bmq.InstanceResourceTagTagKv>[]>;
        /**
         * Tag type. Options: CUSTOM—custom tag; SYSTEM—system tag
         */
        type?: pulumi.Input<string>;
    }
    interface InstanceResourceTagTagKv {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Type of instance tag. Options: CUSTOM—custom tag; SYSTEM—system tag
         */
        type?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface InstanceResources {
        /**
         * Resource statistics response data
         */
        storage?: pulumi.Input<inputs.bmq.InstanceResourcesStorage>;
    }
    interface InstanceResourcesStorage {
        /**
         * Resource size
         */
        size?: pulumi.Input<number>;
        /**
         * Resource unit
         */
        unit?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Type of instance tag. Options: CUSTOM—custom tag; SYSTEM—system tag
         */
        type?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace cbr {
    interface BackupPlanPolicy {
        /**
         * Account ID that created this policy
         */
        accountId?: pulumi.Input<string>;
        /**
         * Backup type. Options: FULL: Full backup. INCREMENTAL: Incremental backup
         */
        backupType?: pulumi.Input<string>;
        /**
         * Creation Time
         */
        createdTime?: pulumi.Input<string>;
        /**
         * Specifies the backup schedule. Supports standard crontab expressions
         */
        crontab?: pulumi.Input<string>;
        /**
         * Whether the policy is enabled. Options: true: Enable policy. false: Disable policy
         */
        enablePolicy?: pulumi.Input<boolean>;
        /**
         * Policy Name
         */
        name?: pulumi.Input<string>;
        /**
         * Number of backup plans associated with this policy
         */
        planNumber?: pulumi.Input<number>;
        /**
         * Backup Policy ID
         */
        policyId?: pulumi.Input<string>;
        /**
         * Retention time for recovery points. -1 means retain indefinitely
         */
        retentionDay?: pulumi.Input<number>;
        /**
         * Update Time
         */
        updatedTime?: pulumi.Input<string>;
    }
    interface BackupPlanResourceList {
        /**
         * Resource meta information, used to store additional configuration when creating a backup plan
         */
        metaInformation: pulumi.Input<inputs.cbr.BackupPlanResourceListMetaInformation>;
        /**
         * Backup Source ID
         */
        resourceId: pulumi.Input<string>;
        /**
         * Backup source type. Options: ECS: ECS full machine backup. vePFS: vePFS file system backup
         */
        resourceType: pulumi.Input<string>;
    }
    interface BackupPlanResourceListMetaInformation {
        /**
         * ECS metadata, which is a JSON string
         */
        ecsMeta?: pulumi.Input<string>;
        /**
         * vePFS backup source metadata, which is a JSON string
         */
        vepfsMeta?: pulumi.Input<string>;
    }
    interface BackupResourceMetaInformation {
        /**
         * ECS metadata, as a JSON string. For format, see the EcsBackupConfiguration structure in the data structure.
         */
        ecsMeta?: pulumi.Input<string>;
        /**
         * vePFS backup source metadata, as a JSON string. For format, see the VePFSBackupConfiguration structure in the data structure.
         */
        vepfsMeta?: pulumi.Input<string>;
    }
    interface BackupResourcePlan {
        /**
         * Backup Plan ID
         */
        planId?: pulumi.Input<string>;
        /**
         * Backup Plan Name
         */
        planName?: pulumi.Input<string>;
    }
    interface VaultTag {
        /**
         * Tag Key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag Value
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace cdn {
    interface DomainAreaAccessRule {
        /**
         * Indicates a list of countries to which an allowlist or denylist is applied. When Switch is true, this parameter is required. Country names are represented in abbreviated form. Multiple country names are separated by commas (,).
         */
        areas?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Indicates the rule type for the 'region access control' feature. This parameter has the following values: deny: indicates Denylist. allow: indicates Allowlist.
         */
        ruleType?: pulumi.Input<string>;
        /**
         * Indicates whether to enable this feature. This parameter has the following values: true: Enables this feature. false: Disables this feature.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainBrowserCach {
        /**
         * Indicates the relevant configuration for cache behavior.
         */
        cacheAction?: pulumi.Input<inputs.cdn.DomainBrowserCachCacheAction>;
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainBrowserCachCondition>;
    }
    interface DomainBrowserCachCacheAction {
        /**
         * Indicates caching behavior. Currently, you can only specify cache. cache means the behavior is caching.
         */
        action?: pulumi.Input<string>;
        /**
         * This parameter is shared by multiple CDN features.
         */
        defaultPolicy?: pulumi.Input<string>;
        /**
         * Indicates whether Value is case sensitive. The parameter has the following values: true: not case sensitive. false: case sensitive. The default value is false.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Indicates the cache duration in seconds. The valid range is 0–315,360,000. 315,360,000 represents 10 years. If you do not want the content delivery network to cache the specified content, set this parameter to 0.
         */
        ttl?: pulumi.Input<number>;
    }
    interface DomainBrowserCachCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainBrowserCachConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainBrowserCachConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainCach {
        /**
         * Indicates the relevant configuration for cache behavior.
         */
        cacheAction?: pulumi.Input<inputs.cdn.DomainCachCacheAction>;
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainCachCondition>;
    }
    interface DomainCachCacheAction {
        /**
         * Indicates caching behavior. Currently, you can only specify cache. cache means the behavior is caching.
         */
        action?: pulumi.Input<string>;
        /**
         * This parameter is shared by multiple CDN features.
         */
        defaultPolicy?: pulumi.Input<string>;
        /**
         * Indicates whether Value is case sensitive. The parameter has the following values: true: not case sensitive. false: case sensitive. The default value is false.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Indicates the cache duration in seconds. The valid range is 0–315,360,000. 315,360,000 represents 10 years. If you do not want the content delivery network to cache the specified content, set this parameter to 0.
         */
        ttl?: pulumi.Input<number>;
    }
    interface DomainCachCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCachConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainCachConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainCacheHost {
        cacheHostRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCacheHostCacheHostRule>[]>;
        /**
         * Indicates whether to enable this feature. This parameter has the following values: true: enables the feature; false: disables the feature. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainCacheHostCacheHostRule {
        /**
         * Indicates the target domain. The target domain must be an accelerated domain under your account. This parameter specifies that the Domain shares the cache of CacheHost.
         */
        cacheHostAction?: pulumi.Input<inputs.cdn.DomainCacheHostCacheHostRuleCacheHostAction>;
        /**
         * Represents the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainCacheHostCacheHostRuleCondition>;
    }
    interface DomainCacheHostCacheHostRuleCacheHostAction {
        /**
         * Specifies the target domain name. The target domain name must be an acceleration domain under your account. This parameter indicates that Domain shares the cache of CacheHost.
         */
        cacheHost?: pulumi.Input<string>;
    }
    interface DomainCacheHostCacheHostRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCacheHostCacheHostRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainCacheHostCacheHostRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainCacheKey {
        /**
         * Indicates the action performed by the content delivery network under the Condition scenario.
         */
        cacheKeyAction?: pulumi.Input<inputs.cdn.DomainCacheKeyCacheKeyAction>;
        /**
         * Represents the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainCacheKeyCondition>;
    }
    interface DomainCacheKeyCacheKeyAction {
        cacheKeyComponents?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCacheKeyCacheKeyActionCacheKeyComponent>[]>;
    }
    interface DomainCacheKeyCacheKeyActionCacheKeyComponent {
        /**
         * Specifies the action to perform; required when modifying. This parameter has the following values: exclude: The cache key does not include any query parameters, which means parameters are removed from the cache. include: The cache key includes all query parameters, which means parameters are retained in the cache. includePart: The cache key includes query parameters in Subobject, which means some parameters are retained in the cache. excludePart: The cache key does not include query parameters in Subobject, which means some parameters are removed from the cache.
         */
        action?: pulumi.Input<string>;
        /**
         * Indicates whether the content delivery network ignores case when matching Value. The parameter values are: true: ignore case. false: do not ignore case. The default value is false.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Indicates the object to be set. Currently, you can only specify queryString. queryString refers to the query parameters in the request URL.
         */
        object?: pulumi.Input<string>;
        /**
         * Specify one or more objects of the Object type. Parameter details: If Action is include or exclude, Subobject must be *. * means all query parameters. If Action is includePart or excludePart, you can specify one or more query parameters. The query parameters you specify cannot be *, and cannot contain consecutive slashes (//), percent signs (%), or spaces. Use a semicolon (;) to separate multiple query parameter names. The default value for Subobject is *.
         */
        subobject?: pulumi.Input<string>;
    }
    interface DomainCacheKeyCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCacheKeyConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainCacheKeyConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainCompression {
        compressionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCompressionCompressionRule>[]>;
        /**
         * Smart compression configuration switch. This parameter has the following values: true: enables smart compression. false: disables smart compression.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainCompressionCompressionRule {
        /**
         * Represents the configuration for compression operations.
         */
        compressionAction?: pulumi.Input<inputs.cdn.DomainCompressionCompressionRuleCompressionAction>;
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainCompressionCompressionRuleCondition>;
    }
    interface DomainCompressionCompressionRuleCompressionAction {
        /**
         * If the matching condition is based on the Content-Type header (when Condition is null or not specified), this parameter specifies the matching criteria for Content-Type. The values are as follows: default: matches file types included in the default Content-Type list. customize: matches custom file types in the Content-Type header. If Condition is not null, the matching criteria are defined in ConditionRule. In this case, this parameter must be set to all.
         */
        compressionFormat?: pulumi.Input<string>;
        /**
         * Specifies the file types to compress. The parameter is described as follows: If CompressionFormat is default, this parameter must be set to *, indicating the default Content-Type list. The list includes the following file types: text/html, text/xml, text/plain, text/css, application/javascript, application/x-javascript, application/rss+xml, text/javascript, image/tiff, image/svg+xml, application/json, application/xml, text/plain; charset=utf-8. If CompressionFormat is customize, you need to specify one or more file types. Multiple file types are separated by commas (,). If CompressionFormat is all, this parameter must be set to *.
         */
        compressionTarget?: pulumi.Input<string>;
        /**
         * Compression algorithm: gzip and br specify the compression type. default: compresses all files by default, with the target count as *. customize: compresses custom file types. Choices: [default, customize]
         */
        compressionTypes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Indicates the minimum value for the file size range. CDN only compresses files within the range specified by MinFileSizeKB and MaxFileSizeKB. The parameter value range is 0   - 2,147,483,647, the unit is KB, and the base is 1,024. The default value is 0.
         */
        maxFileSizeKb?: pulumi.Input<number>;
        /**
         * Indicates the maximum value for the file size range. The value range is 0   - 2,147,483,647, in KB, using a base of 1,024. If this parameter is not specified, there is no upper limit for file size.
         */
        minFileSizeKb?: pulumi.Input<number>;
    }
    interface DomainCompressionCompressionRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCompressionCompressionRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainCompressionCompressionRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainConditionalOrigin {
        /**
         * Indicates a list of rules. Each rule in the list defines a filter and the action the content delivery network performs on requests that meet the filter criteria.
         */
        originRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainConditionalOriginOriginRule>[]>;
        /**
         * Indicates whether this feature is enabled. The parameter has the following values: true: enables the feature. false: disables the feature. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainConditionalOriginOriginRule {
        /**
         * Indicates the operation configuration for a rule in the list.
         */
        actions?: pulumi.Input<inputs.cdn.DomainConditionalOriginOriginRuleActions>;
        /**
         * Represents the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainConditionalOriginOriginRuleCondition>;
    }
    interface DomainConditionalOriginOriginRuleActions {
        originLines?: pulumi.Input<pulumi.Input<inputs.cdn.DomainConditionalOriginOriginRuleActionsOriginLine>[]>;
    }
    interface DomainConditionalOriginOriginRuleActionsOriginLine {
        /**
         * Represents the address of an origin server. When InstanceType is ip, Address specifies an IPv4 or IPv6 address. When InstanceType is domain, Address specifies a domain name. The domain name cannot be a wildcard domain. If you specify OriginLines, Address is required.
         */
        address?: pulumi.Input<string>;
        /**
         * Indicates the port used by the content delivery network to access the origin server via the HTTP protocol. The valid range is 1–65535, with a default value of 80. If the origin server does not have this port open, you do not need to specify this parameter.
         */
        httpPort?: pulumi.Input<string>;
        /**
         * Specifies the port used by the content delivery network to access the origin server via HTTPS. The value range is 1–65535, and the default is 443. If the origin server does not open this port, you do not need to specify this parameter.
         */
        httpsPort?: pulumi.Input<string>;
        /**
         * Indicates the type of origin. The parameter has the following values: ip: indicates an IP address. domain: indicates a domain name. InstanceType is required if OriginLines is specified.
         */
        instanceType?: pulumi.Input<string>;
        /**
         * If there are multiple sites on the origin server, this parameter specifies the domain name accessed by the origin request. This parameter takes precedence over the global OriginHost parameter. The value of this parameter cannot exceed 1,024 characters. The default value is the same as the global OriginHost.
         */
        originHost?: pulumi.Input<string>;
    }
    interface DomainConditionalOriginOriginRuleCondition {
        conditionGroups?: pulumi.Input<pulumi.Input<inputs.cdn.DomainConditionalOriginOriginRuleConditionConditionGroup>[]>;
        /**
         * Specifies the relationship between these condition groups. This parameter has the following values: or: Indicates an 'or' relationship. In this case, if any condition group is met, the user request matches the rule. and: Indicates an 'and' relationship. In this case, all condition groups must be met for the user request to match the rule. The default value is or.
         */
        connective?: pulumi.Input<string>;
        /**
         * Indicates whether each filter condition is a condition group. The value of this parameter is always true, meaning each filter condition is a condition group. Currently, each condition group can only contain one filter condition.
         */
        isGroup?: pulumi.Input<boolean>;
    }
    interface DomainConditionalOriginOriginRuleConditionConditionGroup {
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainConditionalOriginOriginRuleConditionConditionGroupCondition>;
    }
    interface DomainConditionalOriginOriginRuleConditionConditionGroupCondition {
        /**
         * Indicates a filter type. This parameter has the following values: path: The full path in the request URL. directory: Any directory in the path. For example, if the path is /a/b/c/d/file, then /a/, /b/c/, and /d/ are directories. filetype: The extension at the end of the path. full*querystring: The query string in the request URL. client*ip: The client's IP address or the location associated with the IP address. If you specify Condition, Object is required.
         */
        object?: pulumi.Input<string>;
        /**
         * Specifies a comparison type. Different Objects correspond to different values. When Object is path, directory, or filetype, the parameter values are equal and not*equal. When Object is path, additional values are regex*match and regex*not*match. When Object is full*querystring, the values are regex*match and regex*not*match. When Object is client*ip, the values are equal, not*equal, belong, and not*belong. The comparison types are explained as follows: equal: If Object matches any filter value in Value, the request meets this filter condition. not*equal: If Object does not match any filter value in Value, the request meets this filter condition. regex*match: If any regular expression in Value matches any part of Object, the request meets this filter condition. regex*not*match: If none of the regular expressions in Value match any part of Object, the request meets this filter condition. belong: If the client IP address belongs to any country or region listed in Value, the request meets this filter condition. not*belong: If the client IP address does not belong to any country or region listed in Value, the request meets this filter condition. If you specify Condition, Operator is required.
         */
        operator?: pulumi.Input<string>;
        /**
         * Represents one or more filter values. Filter values are separated by semicolons (;). The input requirements for this parameter are as follows: When Object is path, directory, or filetype, the total length of all filter values must not exceed 1,024 characters and must not contain the following characters: consecutive slashes (//), spaces, dollar sign ($), question mark (?), or Delete (ASCII code 127). When Object is path, this parameter has the following additional requirements: each filter value must start with a slash (/) but must not end with a slash (/). You can use one or more asterisks (*) in the filter value, where each asterisk represents one or more characters. For example: /www/img/my*image.png. When Object is directory, this parameter has the following additional requirements: each filter value must start and end with a slash (/). For example: /www/img/. When Object is filetype, this parameter has the following additional requirements: each filter value does not need to start with a period (.). For example: png;txt. When Object is full*querystring, the input requirements for this parameter are as follows: the total length of all filter values must not exceed 256 characters. Filter values can include numbers, letters, percent sign (%), underscore (*), and hyphen (-). When Object is client*ip, if Operator is equal or not*equal, the input requirements for this parameter are as follows: the number of IP addresses must not exceed 5. IP addresses must be IPv4 addresses. If you specify Condition, Value is required.
         */
        values?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface DomainCustomErrorPage {
        errorPageRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCustomErrorPageErrorPageRule>[]>;
        /**
         * Indicates whether this feature is enabled. The parameter values are: true: Enabled. false: Disabled. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainCustomErrorPageErrorPageRule {
        /**
         * Indicates the relevant configuration for the rule.
         */
        errorPageAction?: pulumi.Input<inputs.cdn.DomainCustomErrorPageErrorPageRuleErrorPageAction>;
    }
    interface DomainCustomErrorPageErrorPageRuleErrorPageAction {
        /**
         * Indicates the actual operation. Currently, you can only set this parameter to redirect. This means the client request will be redirected.
         */
        action?: pulumi.Input<string>;
        /**
         * Indicates the response status code for redirection. You can select an appropriate status code as needed. The available values are 301, 302, 303, 307, and 308. Note: For 301 and 302, if the original request method is not GET, the client may use GET when sending the new request to the new URL. For 303, the new request method is GET. For 307 and 308, the new request method remains the same as the original request and will not be changed.
         */
        redirectCode?: pulumi.Input<string>;
        /**
         * Indicates the target address for redirection. The length must not exceed 1,024 characters. The address must include the protocol, domain name, and path, and comply with URL specifications.
         */
        redirectUrl?: pulumi.Input<string>;
        /**
         * Indicates a status code, with a value range of 400–599. You can enter 4xx or 5xx. 4xx covers all status codes from 400 to 499. 5xx covers all status codes from 500 to 599.
         */
        statusCode?: pulumi.Input<string>;
    }
    interface DomainCustomizeAccessRule {
        customizeInstances?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCustomizeAccessRuleCustomizeInstance>[]>;
        /**
         * Indicates whether this feature is enabled. This parameter has the following options: true: Enable this feature. false: Disable this feature. The default value for this parameter is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainCustomizeAccessRuleCustomizeInstance {
        /**
         * Describes the configuration for a rule in the list.
         */
        customizeRule?: pulumi.Input<inputs.cdn.DomainCustomizeAccessRuleCustomizeInstanceCustomizeRule>;
    }
    interface DomainCustomizeAccessRuleCustomizeInstanceCustomizeRule {
        /**
         * Indicates the configuration of the denylist or allowlist in this rule.
         */
        accessAction?: pulumi.Input<inputs.cdn.DomainCustomizeAccessRuleCustomizeInstanceCustomizeRuleAccessAction>;
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainCustomizeAccessRuleCustomizeInstanceCustomizeRuleCondition>;
    }
    interface DomainCustomizeAccessRuleCustomizeInstanceCustomizeRuleAccessAction {
        /**
         * Indicates whether the CDN accepts user requests where the RequestHeader value is empty. An empty header value refers to either of the following situations: The user request does not include RequestHeader. The user request includes RequestHeader, but the header value is empty ("").
         */
        allowEmpty?: pulumi.Input<boolean>;
        /**
         * Indicates a list of regular expressions used to match the value of the request header. The list can contain up to 20 regular expressions, and the total length of all expressions cannot exceed 1,024 characters. The relationship between the regular expressions is OR. That is, if the value of RequestHeader in a user request matches any regular expression, the rule applies to the request.
         */
        listRules?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Indicates a specified request header. Header names are case-insensitive and must meet the following requirements: The name must not exceed 1,024 characters. The name cannot be Referer, User-Agent, or Origin. The name can contain letters, digits, underscores (_), and hyphens (-). The name cannot start with a digit.
         */
        requestHeader?: pulumi.Input<string>;
        /**
         * Indicates the type of list. This parameter has the following values: allow: defines an allowlist in this rule. If a user request does not match the allowlist, the CDN rejects the request and returns a 403 status code. deny: defines a denylist in this rule. If a user request matches the denylist, the CDN rejects the request and returns a 403 status code.
         */
        ruleType?: pulumi.Input<string>;
    }
    interface DomainCustomizeAccessRuleCustomizeInstanceCustomizeRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainCustomizeAccessRuleCustomizeInstanceCustomizeRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainCustomizeAccessRuleCustomizeInstanceCustomizeRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainDomainLock {
        /**
         * Indicates the reason why the acceleration domain is locked. If Status is on, this parameter provides a description of the reason. If Status is off, this parameter is empty ("")
         */
        remark?: pulumi.Input<string>;
        /**
         * Indicates the lock status of the acceleration domain name. The parameter has the following values: on: the acceleration domain name is locked. off: the acceleration domain name is not locked.
         */
        status?: pulumi.Input<string>;
    }
    interface DomainDownloadSpeedLimit {
        downloadSpeedLimitRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainDownloadSpeedLimitDownloadSpeedLimitRule>[]>;
        /**
         * Indicates whether this feature is enabled. The parameter has the following values: true: enables the feature. false: disables the feature. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainDownloadSpeedLimitDownloadSpeedLimitRule {
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainDownloadSpeedLimitDownloadSpeedLimitRuleCondition>;
        /**
         * Indicates the rate limiting configuration.
         */
        downloadSpeedLimitAction?: pulumi.Input<inputs.cdn.DomainDownloadSpeedLimitDownloadSpeedLimitRuleDownloadSpeedLimitAction>;
    }
    interface DomainDownloadSpeedLimitDownloadSpeedLimitRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainDownloadSpeedLimitDownloadSpeedLimitRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainDownloadSpeedLimitDownloadSpeedLimitRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainDownloadSpeedLimitDownloadSpeedLimitRuleDownloadSpeedLimitAction {
        /**
         * Indicates the maximum download speed for a single request, measured in B/S. The parameter range is 1–1,073,741,824,000,000, using a base conversion of 1,024.
         */
        speedLimitRate?: pulumi.Input<number>;
        /**
         * Represents a data volume. Download throttling is enabled for a request only when the amount of data downloaded in a single request reaches this value. Unit: Byte. The parameter range is 0–1,073,741,824,000,000, using a base of 1,024 for conversion.
         */
        speedLimitRateAfter?: pulumi.Input<number>;
        /**
         * Indicates the date and time period when rate limiting occurs.
         */
        speedLimitTime?: pulumi.Input<inputs.cdn.DomainDownloadSpeedLimitDownloadSpeedLimitRuleDownloadSpeedLimitActionSpeedLimitTime>;
    }
    interface DomainDownloadSpeedLimitDownloadSpeedLimitRuleDownloadSpeedLimitActionSpeedLimitTime {
        /**
         * Indicates the start time for rate limiting. The time format is mm:ss. If the DayWeek parameter value is unlimited, the default values for BeginTime and EndTime will be set to 00:00 and 23:59, respectively.
         */
        beginTime?: pulumi.Input<string>;
        /**
         * Specifies the date when rate limiting occurs. This parameter has the following values: monday, tuesday, wednesday, thursday, friday, saturday, sunday, unlimited. unlimited means every day. You can specify one or more values. Separate multiple values with a semicolon (;).
         */
        dayWeek?: pulumi.Input<string>;
        /**
         * Indicates the end time for rate limiting. The time format is mm:ss. If the DayWeek parameter is set to unlimited, the default values for BeginTime and EndTime are 00:00 and 23:59, respectively.
         */
        endTime?: pulumi.Input<string>;
    }
    interface DomainHttpForcedRedirect {
        /**
         * Indicates whether this feature is enabled. The parameter values are: true: enables the feature. When enabled, the content delivery network redirects incoming HTTPS requests to HTTP requests. false: disables the feature. The content delivery network does not redirect HTTPS requests to HTTP requests. To enable this feature, your acceleration domain must have HTTPS enabled.
         */
        enableForcedRedirect?: pulumi.Input<boolean>;
        /**
         * Indicates the redirect status code returned by the content delivery network when it receives an HTTPS request. This parameter has the following values: 301: indicates the 301 response status code. 302: indicates the 302 response status code. The default value for this parameter is 301.
         */
        statusCode?: pulumi.Input<string>;
    }
    interface DomainHttps {
        /**
         * Indicates the configuration module for the 'mutual authentication' feature. To configure 'mutual authentication'.
         */
        certCheck?: pulumi.Input<inputs.cdn.DomainHttpsCertCheck>;
        /**
         * Indicates the single certificate to be associated with the acceleration domain name.
         */
        certInfo?: pulumi.Input<inputs.cdn.DomainHttpsCertInfo>;
        certInfoLists?: pulumi.Input<pulumi.Input<inputs.cdn.DomainHttpsCertInfoList>[]>;
        /**
         * Indicates whether to allow requests where the URL scheme is HTTP. The parameter values are: true: allows requests with HTTP scheme. false: does not allow requests with HTTP scheme. The default value is false.
         */
        disableHttp?: pulumi.Input<boolean>;
        /**
         * Indicates the configuration module for the 'HTTP Forced Redirect to HTTPS' feature. This feature is disabled by default.
         */
        forcedRedirect?: pulumi.Input<inputs.cdn.DomainHttpsForcedRedirect>;
        /**
         * Indicates the configuration module for the HSTS feature. This feature is disabled by default.
         */
        hsts?: pulumi.Input<inputs.cdn.DomainHttpsHsts>;
        /**
         * HTTP/2 configuration switch. This parameter has the following values: true: enables HTTP/2. false: disables HTTP/2. To enable HTTP/2, you must first enable HTTPS. This feature is disabled by default. However, HTTP/2 is enabled by default in the following scenarios: The business type of the accelerated domain is web (ServiceType is web). The accelerated domain has already enabled HTTPS.
         */
        http2?: pulumi.Input<boolean>;
        /**
         * Specify whether to enable OCSP stapling. This parameter has the following values: true: enables OCSP stapling. false: disables OCSP stapling. To enable OCSP stapling, you must first enable HTTPS. The default value is false.
         */
        ocsp?: pulumi.Input<boolean>;
        /**
         * Indicates whether to enable the HTTPS feature. This parameter has the following values: true: enables the feature; false: disables the feature. If Switch is true, you must specify a certificate. If you specify a single certificate, you need to provide CertInfo. If you specify dual certificates, you need to provide CertInfoList. The certificate you specify can be hosted in the certificate center or on the content delivery network.
         */
        switch?: pulumi.Input<boolean>;
        /**
         * Indicates the configuration module for the "TLS Version" feature. This parameter specifies the TLS versions that user requests can use, with the following options: tlsv1.0: TLS 1.0 tlsv1.1: TLS 1.1 tlsv1.2: TLS 1.2 tlsv1.3: TLS 1.3 The default value for this parameter is ["tlsv1.1", "tlsv1.2", "tlsv1.3"]
         */
        tlsVersions?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface DomainHttpsCertCheck {
        certInfoLists?: pulumi.Input<pulumi.Input<inputs.cdn.DomainHttpsCertCheckCertInfoList>[]>;
        /**
         * Indicates whether to enable this feature. This parameter has the following values: true: enables the feature; false: disables the feature. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainHttpsCertCheckCertInfoList {
        /**
         * Indicates the ID of a CA certificate hosted on the content delivery network. The ID starts with cert_hosting-.
         */
        certId?: pulumi.Input<string>;
        /**
         * Represents the content of the Common Name (CN) field in the CA certificate.
         */
        certName?: pulumi.Input<string>;
        /**
         * Indicates a CA certificate to be uploaded. The uploaded certificate is hosted on the content delivery network.
         */
        certificate?: pulumi.Input<inputs.cdn.DomainHttpsCertCheckCertInfoListCertificate>;
        /**
         * Indicates the issuance time of the certificate, in Unix timestamp.
         */
        effectiveTime?: pulumi.Input<number>;
        /**
         * Indicates the encryption algorithm used by the certificate. The parameter has the following values: inter*cert: RSA or ECC encryption algorithm. sm*cert: SM2 encryption algorithm.
         */
        encryType?: pulumi.Input<string>;
        /**
         * Indicates the expiration time of the certificate, as a Unix timestamp.
         */
        expireTime?: pulumi.Input<number>;
        /**
         * Specifies the certificate hosting location. The parameter values are: volc*cert*center: certificate center; cdn*cert*hosting: content delivery network.
         */
        source?: pulumi.Input<string>;
    }
    interface DomainHttpsCertCheckCertInfoListCertificate {
        /**
         * Indicates the content of the certificate file. Line breaks in the content must be replaced with \r\n. The certificate file extension is .crt or .pem, and the certificate file must include the complete certificate chain.
         */
        certificate?: pulumi.Input<string>;
        /**
         * Specifies the content of the certificate file for the SM certificate Line breaks in the content must be replaced with \r\n The public key contained in this file is used to encrypt the session key The file extension must be .crt or .pem, and the certificate file must include the complete certificate chain If the certificate to be uploaded is not an SM certificate, this parameter is invalid
         */
        encryptionCert?: pulumi.Input<string>;
        /**
         * Indicates the content of the private key file for the SM certificate. Line breaks in the content must be replaced with \r\n. This file is used for decryption and has an extension of .key or .pem. The file name is similar to <domain>_encrypt.key.
         */
        encryptionKey?: pulumi.Input<string>;
        /**
         * Indicates the content of the private key file. Line breaks in the content must be replaced with \r\n. The private key file extension is .key or .pem. If the certificate uses the RSA or ECC encryption algorithm, this file is the private key file for the server certificate you want to upload. The file name is similar to <domain>.key. The private key contained in this file is used to verify the server's signature and encrypt session keys. If the certificate uses the SM2 encryption algorithm, this file is the private key file for the national cryptography certificate you want to upload. The file name is similar to <domain>_sign.key. The private key contained in this file is used to verify the server's signature. For certificates to be uploaded, this parameter is required.
         */
        privateKey?: pulumi.Input<string>;
    }
    interface DomainHttpsCertInfo {
        /**
         * Represents the ID of a CA certificate hosted on the content delivery network. The ID starts with cert_hosting-.
         */
        certId?: pulumi.Input<string>;
        /**
         * Indicates the content of the Common Name (CN) field in the CA certificate.
         */
        certName?: pulumi.Input<string>;
        /**
         * Indicates a CA certificate to be uploaded. The uploaded certificate is hosted on the CDN.
         */
        certificate?: pulumi.Input<inputs.cdn.DomainHttpsCertInfoCertificate>;
        /**
         * Indicates the issuance time of the certificate, in Unix timestamp.
         */
        effectiveTime?: pulumi.Input<number>;
        /**
         * Indicates the encryption algorithm used by the certificate. The parameter has the following values: inter*cert: RSA or ECC encryption algorithm. sm*cert: SM2 encryption algorithm.
         */
        encryType?: pulumi.Input<string>;
        /**
         * Indicates the expiration time of the certificate, in Unix timestamp.
         */
        expireTime?: pulumi.Input<number>;
        /**
         * Indicates the location where the certificate is hosted. This parameter has the following values: volc*cert*center: Certificate Center. cdn*cert*hosting: Content Delivery Network.
         */
        source?: pulumi.Input<string>;
    }
    interface DomainHttpsCertInfoCertificate {
        /**
         * Indicates the content of the certificate file. Line breaks in the content must be replaced with \r\n. The certificate file extension is .crt or .pem, and the certificate file must include the complete certificate chain.
         */
        certificate?: pulumi.Input<string>;
        /**
         * Specifies the content of the certificate file for the SM certificate Line breaks in the content must be replaced with \r\n The public key contained in this file is used to encrypt the session key The file extension must be .crt or .pem, and the certificate file must include the complete certificate chain If the certificate to be uploaded is not an SM certificate, this parameter is invalid
         */
        encryptionCert?: pulumi.Input<string>;
        /**
         * Indicates the content of the private key file for the SM certificate. Line breaks in the content must be replaced with \r\n. This file is used for decryption and has an extension of .key or .pem. The file name is similar to <domain>_encrypt.key.
         */
        encryptionKey?: pulumi.Input<string>;
        /**
         * Indicates the content of the private key file. Line breaks in the content must be replaced with \r\n. The private key file extension is .key or .pem. If the certificate uses the RSA or ECC encryption algorithm, this file is the private key file for the server certificate you want to upload. The file name is similar to <domain>.key. The private key contained in this file is used to verify the server's signature and encrypt session keys. If the certificate uses the SM2 encryption algorithm, this file is the private key file for the national cryptography certificate you want to upload. The file name is similar to <domain>_sign.key. The private key contained in this file is used to verify the server's signature. For certificates to be uploaded, this parameter is required.
         */
        privateKey?: pulumi.Input<string>;
    }
    interface DomainHttpsCertInfoList {
        /**
         * Indicates the ID of a CA certificate hosted on the content delivery network. The ID starts with cert_hosting-.
         */
        certId?: pulumi.Input<string>;
        /**
         * Represents the content of the Common Name (CN) field in the CA certificate.
         */
        certName?: pulumi.Input<string>;
        /**
         * Indicates a CA certificate to be uploaded. The uploaded certificate is hosted on the content delivery network.
         */
        certificate?: pulumi.Input<inputs.cdn.DomainHttpsCertInfoListCertificate>;
        /**
         * Indicates the issuance time of the certificate, in Unix timestamp.
         */
        effectiveTime?: pulumi.Input<number>;
        /**
         * Indicates the encryption algorithm used by the certificate. The parameter has the following values: inter*cert: RSA or ECC encryption algorithm. sm*cert: SM2 encryption algorithm.
         */
        encryType?: pulumi.Input<string>;
        /**
         * Indicates the expiration time of the certificate, as a Unix timestamp.
         */
        expireTime?: pulumi.Input<number>;
        /**
         * Specifies the certificate hosting location. The parameter values are: volc*cert*center: certificate center; cdn*cert*hosting: content delivery network.
         */
        source?: pulumi.Input<string>;
    }
    interface DomainHttpsCertInfoListCertificate {
        /**
         * Indicates the content of the certificate file. Line breaks in the content must be replaced with \r\n. The certificate file extension is .crt or .pem, and the certificate file must include the complete certificate chain.
         */
        certificate?: pulumi.Input<string>;
        /**
         * Specifies the content of the certificate file for the SM certificate Line breaks in the content must be replaced with \r\n The public key contained in this file is used to encrypt the session key The file extension must be .crt or .pem, and the certificate file must include the complete certificate chain If the certificate to be uploaded is not an SM certificate, this parameter is invalid
         */
        encryptionCert?: pulumi.Input<string>;
        /**
         * Indicates the content of the private key file for the SM certificate. Line breaks in the content must be replaced with \r\n. This file is used for decryption and has an extension of .key or .pem. The file name is similar to <domain>_encrypt.key.
         */
        encryptionKey?: pulumi.Input<string>;
        /**
         * Indicates the content of the private key file. Line breaks in the content must be replaced with \r\n. The private key file extension is .key or .pem. If the certificate uses the RSA or ECC encryption algorithm, this file is the private key file for the server certificate you want to upload. The file name is similar to <domain>.key. The private key contained in this file is used to verify the server's signature and encrypt session keys. If the certificate uses the SM2 encryption algorithm, this file is the private key file for the national cryptography certificate you want to upload. The file name is similar to <domain>_sign.key. The private key contained in this file is used to verify the server's signature. For certificates to be uploaded, this parameter is required.
         */
        privateKey?: pulumi.Input<string>;
    }
    interface DomainHttpsForcedRedirect {
        /**
         * Indicates whether to enable this feature. This parameter has the following values: true: enables the feature. When enabled, the content delivery network redirects HTTP requests to HTTPS requests. false: disables the feature. When disabled, the content delivery network does not redirect HTTP requests to HTTPS requests. To enable this feature, your acceleration domain must have HTTPS enabled.
         */
        enableForcedRedirect?: pulumi.Input<boolean>;
        /**
         * Indicates the redirect response status code for the CDN when receiving HTTPS requests. The parameter values are: 301: returns status code 301. 302: returns status code 302. The default value is 301.
         */
        statusCode?: pulumi.Input<string>;
    }
    interface DomainHttpsHsts {
        /**
         * Indicates whether the HSTS configuration also applies to subdomains of the accelerated domain. The parameter has the following values: include: applies HSTS configuration to subdomain sites. exclude: does not apply HSTS configuration to subdomain sites. The default value is exclude.
         */
        subdomain?: pulumi.Input<string>;
        /**
         * Indicates whether to enable this feature. This parameter has the following values: true: enables the feature; false: disables the feature. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
        /**
         * Indicates the cache expiration time for the Strict-Transport-Security response header in the browser, in seconds. If Switch is true, this parameter is required. The value range is 0–31,536,000. 31,536,000 seconds equals 365 days. If the value is 0, it is equivalent to disabling the HSTS setting.
         */
        ttl?: pulumi.Input<number>;
    }
    interface DomainIPv6 {
        /**
         * Specifies whether to enable IPv6 configuration. This parameter has the following values: true: Enables IPv6. false: Disables IPv6.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainIpAccessRule {
        /**
         * Specifies IP addresses in the denylist or allowlist. This parameter is required when Switch is true. You can specify one or more IP addresses and IP address ranges. IP addresses and ranges can be in IPv4 or IPv6 format. You can enter up to 1,000 addresses. If you specify SharedConfig, you cannot specify this parameter.
         */
        ips?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Indicates the type of IP list. This parameter is required when Switch is true. Valid values are: allow: indicates Allowlist. deny: indicates Denylist. If you specify SharedConfig, you cannot specify this parameter.
         */
        ruleType?: pulumi.Input<string>;
        /**
         * Represents a global configuration. If you specify this parameter, you cannot specify RuleType and Ip.
         */
        sharedConfig?: pulumi.Input<inputs.cdn.DomainIpAccessRuleSharedConfig>;
        /**
         * Indicates whether this feature is enabled. This parameter has the following values: true: enables the feature. false: disables the feature.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainIpAccessRuleSharedConfig {
        /**
         * Indicates the name of a global configuration.
         */
        configName?: pulumi.Input<string>;
    }
    interface DomainMethodDeniedRule {
        /**
         * Indicates one or more HTTP request methods that are disabled. When Switch is true, this parameter is required. Use commas (,) to separate multiple methods. The parameter values are: get: disables the GET request method. post: disables the POST request method. delete: disables the DELETE request method. put: disables the PUT request method. head: disables the HEAD request method. patch: disables the PATCH request method. connect: disables the CONNECT request method. options: disables the OPTIONS request method.
         */
        methods?: pulumi.Input<string>;
        /**
         * Configuration switch for disabling methods. Use commas to separate multiple methods. Required when enabled. choices: [get, post, head, delete, put]
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainMultiRange {
        /**
         * Indicates whether the feature is enabled. This parameter has the following values: true: enables the feature. When enabled, CDN allows Range requests with multiple ranges. false: disables the feature. If a Range request with multiple ranges is received, CDN rejects the request and returns a 416 response status code. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainNegativeCach {
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainNegativeCachCondition>;
        /**
         * Represents a list. Each element in the list is a status code cache rule.
         */
        negativeCacheRule?: pulumi.Input<inputs.cdn.DomainNegativeCachNegativeCacheRule>;
    }
    interface DomainNegativeCachCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainNegativeCachConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainNegativeCachConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainNegativeCachNegativeCacheRule {
        /**
         * Represents the cache behavior. Currently, you can only specify cache. cache means the behavior is caching.
         */
        action?: pulumi.Input<string>;
        /**
         * Indicates whether the CDN ignores case when matching files in a request with ConditionRule. The parameter has the following options: true: ignore case. false: do not ignore case. The default value is false.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Specify a status code to cache. The status code range is 400–599. You can also specify 4xx or 5xx. 4xx refers to all status codes from 400 to 499. 5xx refers to all status codes from 500 to 599.
         */
        statusCode?: pulumi.Input<string>;
        /**
         * Indicates the cache duration for status codes, in seconds. The range is 1–315,360,000. 315,360,000 means 10 years.
         */
        ttl?: pulumi.Input<number>;
    }
    interface DomainOfflineCache {
        /**
         * Indicates the trigger conditions for this feature. The parameter has the following values: request*error: indicates an origin request exception. When an origin request exception occurs, the CDN cannot retrieve files from the origin and does not receive any response status code from the origin. error*code: indicates the CDN cannot retrieve files from the origin, and the origin's response status code is 5xx. request*error,error*code: indicates both conditions are included.
         */
        object?: pulumi.Input<string>;
        /**
         * Specifies the specific 5xx response status codes, ranging from 500 to 599. Separate multiple status codes with a semicolon (;). You can also enter 5xx to indicate any status code starting with the digit 5. This parameter is valid only when Object is error*code or request*error,error_code.
         */
        statusCode?: pulumi.Input<string>;
        /**
         * Indicates whether this feature is enabled. This parameter has the following values: true: enables the feature. false: disables the feature.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainOrigin {
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainOriginCondition>;
        /**
         * Indicates origin configuration.
         */
        originAction: pulumi.Input<inputs.cdn.DomainOriginOriginAction>;
    }
    interface DomainOriginAccessRule {
        /**
         * Specifies whether requests are allowed when the Origin header in the user request is empty (""). The parameter values are: true: allow; false: do not allow. The default value is false.
         */
        allowEmpty?: pulumi.Input<boolean>;
        /**
         * Indicates whether Origin is case sensitive. This parameter has the following values: true: Origin is case insensitive; false: Origin is case sensitive. The default value is true.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * The address list corresponding to RuleType. When Switch is true, this parameter is required. You can specify one or more IP addresses, CIDR blocks, domain names, and wildcard domain names. Domain names can be second-level domains. IP addresses can be in IPv4 or IPv6 format. You can enter up to 100 addresses. When entering domain names, you do not need to include http:// or https://. The value length cannot exceed 3,000 characters.
         */
        origins?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Origin list configuration type. When Switch is true, this parameter is required. The parameter has the following values: allow: indicates allowlist. deny: indicates denylist.
         */
        ruleType?: pulumi.Input<string>;
        /**
         * Indicates whether this feature is enabled. This parameter has the following values: true: enables the feature. false: disables the feature.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainOriginArg {
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainOriginArgCondition>;
        /**
         * Represents the action performed when the Condition is met.
         */
        originArgAction?: pulumi.Input<inputs.cdn.DomainOriginArgOriginArgAction>;
    }
    interface DomainOriginArgCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainOriginArgConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainOriginArgConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainOriginArgOriginArgAction {
        originArgComponents?: pulumi.Input<pulumi.Input<inputs.cdn.DomainOriginArgOriginArgActionOriginArgComponent>[]>;
    }
    interface DomainOriginArgOriginArgActionOriginArgComponent {
        /**
         * include: Indicates that the origin request URL includes all query parameters from the user request URL. exclude: Indicates that the origin request URL does not include any query parameters from the user request URL. addPart: Indicates that the origin request URL includes all query parameters from the user request URL, plus the query parameters specified in the Subobject. includePart: Indicates that if the user request URL contains the query parameters specified in the Subobject, the origin request URL will include these specified query parameters. excludePart: Indicates that the origin request URL includes all query parameters from the user request URL except those specified in the Subobject. set: Indicates that the origin request URL includes all query parameters from the user request URL. For the query parameters and values you specify in the Subobject, CDN will perform the following actions: If these query parameters exist in the user request URL, CDN will set their values in the origin request URL to the values you specify. If the user request URL does not contain these query parameters, CDN will add them to the origin request URL.
         */
        action?: pulumi.Input<string>;
        /**
         * Indicates which object the CDN performs the Action on. Currently, this parameter can only be set to queryString, which refers to the query string in the request URL.
         */
        object?: pulumi.Input<string>;
        /**
         * Represents one or more query parameters. Use semicolons (;) to separate multiple query parameters. The total length must not exceed 1,024 characters. Subobject can only contain letters, numbers, underscores (_), commas (,), hyphens (-), periods (.), and exclamation marks (!). When matching query parameters in the request URL, parameters in Subobject are case-sensitive. Additional notes for Subobject: When Action is include or exclude, Subobject must be *, which represents all query parameters in the request URL. When Action is includePart or excludePart, Subobject represents one or more query parameters, for example, param1;param2. When Action is addPart or set, Subobject represents one or more query parameters and their values in the format key=value, for example, param1=val1;param2=val2;param3=val3.
         */
        subobject?: pulumi.Input<string>;
    }
    interface DomainOriginCertCheck {
        /**
         * Switch
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainOriginCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainOriginConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainOriginConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainOriginOriginAction {
        originLines: pulumi.Input<pulumi.Input<inputs.cdn.DomainOriginOriginActionOriginLine>[]>;
    }
    interface DomainOriginOriginActionOriginLine {
        /**
         * Indicates the origin address. The parameter has the following instructions: If InstanceType is ip, you can set an IP address. The IP address can be either IPv4 or IPv6. If InstanceType is domain, you can set a domain name. The domain name cannot be a wildcard domain. If InstanceType is tos, you can set the domain name of an object storage bucket. The bucket can be from Alibaba Cloud, Tencent Cloud, or AWS. If you specify multiple origin configurations in this API request: All primary origin configurations must have the same InstanceType. All backup origin configurations must also have the same InstanceType. If the InstanceType in the primary origin configuration is ip or domain, the InstanceType in the backup origin configuration must also be ip or domain. The total number of primary and backup origin addresses cannot exceed 50.
         */
        address: pulumi.Input<string>;
        /**
         * Indicates the port used by the content delivery network to access the origin server via the HTTP protocol. The value range is 1–65535, and the default value is 80. If the origin server does not support access on this port, you can specify the default value. This parameter is only valid when InstanceType is ip or domain.
         */
        httpPort?: pulumi.Input<string>;
        /**
         * Indicates the port used by the content delivery network to access the origin server via HTTPS. The value range is 1-65535, and the default value is 443. If the origin server does not support access on this port, you can specify the default value. This parameter is only valid when InstanceType is ip or domain.
         */
        httpsPort?: pulumi.Input<string>;
        /**
         * Indicates the type of origin server. This parameter has the following values: ip: The origin server is accessed via IP address. domain: The origin server is accessed via domain name. tos: The origin server is an object storage bucket.
         */
        instanceType: pulumi.Input<string>;
        /**
         * If there are multiple sites on the origin server, this parameter specifies the domain name accessed by the origin request. This parameter applies to all origin configurations, but has lower priority than the OriginHost parameter in the origin configuration. The default value of this parameter is the same as Domain. If the origin is an object storage bucket, you do not need to specify this parameter. Its default value is the same as the Address in the origin configuration.
         */
        originHost?: pulumi.Input<string>;
        /**
         * Indicates the type of origin server. This parameter has the following values:   - primary: Primary origin server.   - backup: Backup origin server. At least one primary origin server configuration must be included in this API request. Backup origin server configuration is optional.
         */
        originType: pulumi.Input<string>;
        /**
         * Indicates whether private read permissions are enabled for the object storage bucket. This parameter is only valid when InstanceType is tos. The parameter values are: true: Enabled. false: Not enabled. The default value is false.
         */
        privateBucketAccess?: pulumi.Input<boolean>;
        /**
         * Represents the authentication information for the object storage bucket of a third-party cloud provider.
         */
        privateBucketAuth?: pulumi.Input<inputs.cdn.DomainOriginOriginActionOriginLinePrivateBucketAuth>;
        /**
         * This parameter is not currently available externally. Do not use this parameter.
         */
        region?: pulumi.Input<string>;
        /**
         * Specifies the weight of the origin. Value range is 1–100, default is 1. The higher the weight, the more likely this origin is selected when the content delivery network sends a request to the origin. This parameter is only valid when InstanceType is ip or domain.
         */
        weight?: pulumi.Input<string>;
    }
    interface DomainOriginOriginActionOriginLinePrivateBucketAuth {
        /**
         * Indicates the third-party cloud provider where the object storage bucket is located. The parameter values are: cos: Tencent Cloud. oss: Alibaba Cloud. aws: Amazon AWS.
         */
        authType?: pulumi.Input<string>;
        /**
         * Indicates whether the object storage bucket is from a third-party cloud provider. This parameter has the following values: true: the object storage bucket is from a third-party cloud provider. The default value is false
         */
        switch?: pulumi.Input<boolean>;
        /**
         * Specifies the access key for the third-party cloud provider. This parameter is only valid when Switch is true.
         */
        tosAuthInformation?: pulumi.Input<inputs.cdn.DomainOriginOriginActionOriginLinePrivateBucketAuthTosAuthInformation>;
    }
    interface DomainOriginOriginActionOriginLinePrivateBucketAuthTosAuthInformation {
        /**
         * Specifies the AccessKey ID for your Alibaba Cloud account, SecretId for your Tencent Cloud account, or access key ID for your AWS account.
         */
        accessKeyId?: pulumi.Input<string>;
        /**
         * Indicates the AccessKey Secret for your Alibaba Cloud account, the SecretKey for your Tencent Cloud account, or the secret access key for your AWS account.
         */
        accessKeySecret?: pulumi.Input<string>;
    }
    interface DomainOriginRetry {
        /**
         * Indicates one or more status codes in the range 400–599. Separate multiple status codes with a semicolon (;). You can enter 4xx or 5xx to represent all status codes starting with the digit 4 or 5.
         */
        statusCode?: pulumi.Input<string>;
        /**
         * Indicates whether this feature is enabled. The parameter values are: true: Enabled. false: Disabled. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainOriginRewrite {
        originRewriteRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainOriginRewriteOriginRewriteRule>[]>;
        /**
         * Indicates whether to enable this module. The parameter has the following values: true: enables the module. false: disables the module. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainOriginRewriteOriginRewriteRule {
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainOriginRewriteOriginRewriteRuleCondition>;
        /**
         * Indicates a rule configuration for origin path rewrite.
         */
        originRewriteAction?: pulumi.Input<inputs.cdn.DomainOriginRewriteOriginRewriteRuleOriginRewriteAction>;
    }
    interface DomainOriginRewriteOriginRewriteRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainOriginRewriteOriginRewriteRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainOriginRewriteOriginRewriteRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainOriginRewriteOriginRewriteRuleOriginRewriteAction {
        /**
         * Indicates the rewrite type. This parameter supports the following values: rewrite*path: rewrites the path in the request URL. rewrite*url: rewrites both the path and query string in the request URL. The default value is rewrite_path.
         */
        rewriteType?: pulumi.Input<string>;
        /**
         * Indicates a regular expression, with a maximum length of 1,024 characters, used to match objects in the user's request URL. For a user request, if the regular expression matches any part of the object, this rule applies to the request. When RewriteType is rewrite*path, the object refers to the path in the request URL. When RewriteType is rewrite*url, the object refers to both the path and query string in the request URL.
         */
        sourcePath?: pulumi.Input<string>;
        /**
         * Indicates the object in the origin request URL after rewriting. When RewriteType is rewrite*path, this object is the path in the origin request URL. When RewriteType is rewrite*url, this object is the path and query string in the origin request URL. You can use $1, $2, $3, etc. in TargetPath to represent groups defined in the regular expression of SourcePath.
         */
        targetPath?: pulumi.Input<string>;
    }
    interface DomainOriginSni {
        /**
         * Specifies the domain name for origin SNI. When Switch is true, this parameter is required. The value cannot exceed 1,024 characters.
         */
        sniDomain?: pulumi.Input<string>;
        /**
         * Indicates whether this feature is enabled. This parameter has the following options: true: Enable this feature. false: Disable this feature. The default value for this parameter is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainPageOptimization {
        /**
         * Specifies the optimization target. This parameter has the following values: html: HTML page. js: JavaScript code. css: CSS code. The default value is html. If you specify js or css, html must also be specified.
         */
        optimizationTypes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Indicates whether this feature is enabled. The parameter values are: true: The feature is enabled. false: The feature is disabled.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainQuic {
        /**
         * QUIC configuration switch. The parameter values are as follows: true: enables QUIC. false: disables QUIC. To enable QUIC, you must first enable HTTPS.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainRedirectionRewrite {
        redirectionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRedirectionRewriteRedirectionRule>[]>;
        /**
         * Indicates whether this configuration is enabled. This parameter has the following values: true: enables URL redirect rewrite. false: disables URL redirect rewrite.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainRedirectionRewriteRedirectionRule {
        /**
         * Indicates a URL redirect rewrite rule
         */
        redirectionAction?: pulumi.Input<inputs.cdn.DomainRedirectionRewriteRedirectionRuleRedirectionAction>;
    }
    interface DomainRedirectionRewriteRedirectionRuleRedirectionAction {
        /**
         * Indicates the response status code for URL redirection. Valid values are 301, 302, 303, 307, and 308. Note: For 301 and 302, if the original request method is not GET, the client may use GET when sending the new request to the new URL. For 303, the new request method is GET. For 307 and 308, the new request method remains the same as the original and is not changed.
         */
        redirectCode?: pulumi.Input<string>;
        /**
         * Specifies the original file path, which is the path included in the request. The path must start with a slash (/) and cannot contain consecutive slashes (//), percent signs (%), or spaces. The value of this parameter cannot exceed 1,024 characters.
         */
        sourcePath?: pulumi.Input<string>;
        /**
         * Indicates the domain name or IP address of the site to which the target path belongs. The IP address must be IPv4. The parameter value cannot exceed 1,024 characters. The default value is your acceleration domain name.
         */
        targetHost?: pulumi.Input<string>;
        /**
         * Indicates the target path after redirection. The path must start with a slash (/) and cannot contain consecutive slashes (//), percent signs (%), or spaces. The value cannot exceed 1,024 characters.
         */
        targetPath?: pulumi.Input<string>;
        /**
         * Specifies the protocol used for the new request after URL redirection. The parameter values are: followclient: use the protocol of the original request; http: force the new request to use HTTP; https: force the new request to use HTTPS.
         */
        targetProtocol?: pulumi.Input<string>;
        /**
         * Indicates how the query parameters in the original request URL are handled.
         */
        targetQueryComponents?: pulumi.Input<inputs.cdn.DomainRedirectionRewriteRedirectionRuleRedirectionActionTargetQueryComponents>;
    }
    interface DomainRedirectionRewriteRedirectionRuleRedirectionActionTargetQueryComponents {
        /**
         * Indicates how to handle query parameters in the original request URL. This parameter has the following values: include: includes all query parameters from the original request URL in the redirected URL. exclude: excludes all query parameters from the original request URL in the redirected URL. includePart: includes specific query parameters from the original request URL in the redirected URL. excludePart: excludes specific query parameters from the original request URL in the redirected URL.
         */
        action?: pulumi.Input<string>;
        /**
         * Indicates the query parameters to retain or remove. Multiple query parameters are separated by a semicolon (;). The specified query parameters cannot contain consecutive slashes (//), percent signs ("), or spaces. The default value of Value is *, which means all query parameters. If Action is include or exclude, Value must be *. If Action is includePart or excludePart, you can specify one or more query parameters. In this case, the specified query parameters cannot be *.
         */
        value?: pulumi.Input<string>;
    }
    interface DomainRefererAccessRule {
        /**
         * Specifies whether the content delivery network accepts a request when the Referer header in the user's request is empty (""). This parameter has the following values: true: accepts the request; false: rejects the request. The default value is false.
         */
        allowEmpty?: pulumi.Input<boolean>;
        /**
         * Indicates a list of Referers. The input requirements for this parameter are consistent with those for Referers under the CommonType of ReferersType. We recommend using ReferersType to specify the Referer list. If you specify SharedConfig, you cannot specify this parameter.
         */
        referers?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Indicates a ReferersType object. It contains a CommonType object and a RegularType object, representing a standard Referer list and a Referer regular expression list, respectively. If you specify SharedConfig, you cannot specify this parameter.
         */
        referersType?: pulumi.Input<inputs.cdn.DomainRefererAccessRuleReferersType>;
        /**
         * Indicates the type of Referer list. This parameter is required when Switch is true. This parameter has the following values: allow: indicates Allowlist. deny: indicates Denylist.
         */
        ruleType?: pulumi.Input<string>;
        /**
         * Represents a global configuration. If you specify this parameter, you cannot specify Referers or ReferersType.
         */
        sharedConfig?: pulumi.Input<inputs.cdn.DomainRefererAccessRuleSharedConfig>;
        /**
         * Indicates whether this feature is enabled. This parameter has the following values: true: enables the feature. false: disables the feature.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainRefererAccessRuleReferersType {
        /**
         * Indicates a CommonType object that contains a list of standard Referers.
         */
        commonType?: pulumi.Input<inputs.cdn.DomainRefererAccessRuleReferersTypeCommonType>;
        /**
         * Specifies a RegularType object, which contains a list of regular expressions used to match the Referer header value in requests This parameter provides the allowlist feature To use this parameter, submit a ticket Note that if the Referer header value in a request matches the Referers list under CommonType or the Referers list under RegularType, the content delivery network considers it a match
         */
        regularType?: pulumi.Input<inputs.cdn.DomainRefererAccessRuleReferersTypeRegularType>;
    }
    interface DomainRefererAccessRuleReferersTypeCommonType {
        /**
         * Specifies whether the Referers list under CommonType is case sensitive during matching. The parameter supports the following values: true: not case sensitive. false: case sensitive. The default value is true.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Indicates whether the Referer header value in this Referers list under CommonType must start with HTTP or HTTPS. This parameter has the following values: true: Referer header values that do not start with HTTP or HTTPS are valid. In this case, the content delivery network will attempt to match them with the Referers list. false: Referer header values that do not start with HTTP or HTTPS are invalid. In this case, the content delivery network determines that they do not match the Referers list under CommonType. The default value is false.
         */
        ignoreScheme?: pulumi.Input<boolean>;
        /**
         * Represents a standard Referer list. In this list, you can specify one or more IP addresses, CIDR blocks, domain names, and wildcard domains. Domain names can include second-level domains. IP addresses can be in IPv4 or IPv6 format. You can enter up to 1,000 IP addresses. The domain names entered must not include http:// or https://. During matching, the content delivery network compares the domain name in the Referer header of the request with the Referer list. The value of this parameter must not exceed 30,000 characters.
         */
        referers?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface DomainRefererAccessRuleReferersTypeRegularType {
        /**
         * Indicates a list of Referer regular expressions. The value of this parameter cannot exceed 30,000 characters.
         */
        referers?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface DomainRefererAccessRuleSharedConfig {
        /**
         * Indicates the name of a global configuration.
         */
        configName?: pulumi.Input<string>;
    }
    interface DomainRemoteAuth {
        remoteAuthRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRule>[]>;
        /**
         * Indicates whether this feature is enabled. The parameter values are as follows: true: enables the feature. false: disables the feature.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainRemoteAuthRemoteAuthRule {
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleCondition>;
        /**
         * Indicates the specific authentication configuration.
         */
        remoteAuthRuleAction?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleAction>;
    }
    interface DomainRemoteAuthRemoteAuthRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleAction {
        /**
         * Indicates the configuration of the authentication server.
         */
        authModeConfig?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthModeConfig>;
        /**
         * The content delivery network needs to handle the authentication status codes returned by the authentication server. This parameter specifies the relevant configuration.
         */
        authResponseConfig?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfig>;
        /**
         * Represents the parameter settings for authentication requests.
         */
        queryStringRules?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionQueryStringRules>;
        /**
         * Indicates the rule for the authentication request body. You can leave this parameter unspecified or set its value to default. default means the request body is empty ("").
         */
        requestBodyRules?: pulumi.Input<string>;
        /**
         * Indicates the settings for authentication request headers. You can set up to 50 request headers.
         */
        requestHeaderRules?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionRequestHeaderRules>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthModeConfig {
        /**
         * Indicates the backup address of the authentication server. The address format and requirements are the same as the primary address.
         */
        backupRemoteAddr?: pulumi.Input<string>;
        /**
         * Indicates the primary address of the authentication server. The length must not exceed 100 characters. The primary address format is \n\n://\n\n:\n\n or \n\n://\n\n:\n\n, where: \n\n is http or https. \n\n cannot be localhost. \n\n cannot be 127.0.0.1. \n\n is optional.
         */
        masterRemoteAddr?: pulumi.Input<string>;
        /**
         * Indicates the path for the authentication request. The authentication address and request path together form the complete authentication URL. The content delivery network forwards the user's request to this authentication URL. The parameter accepts the following values: constant: The path in the authentication request is the same as the path in the user's request. variable: You need to specify a path for the authentication request in the pathValue parameter.
         */
        pathType?: pulumi.Input<string>;
        /**
         * Represents the path for an authentication request. The path cannot exceed 100 characters. It must start with a slash (/), and can include any printable ASCII characters except the following: consecutive slashes (//), percent sign (%), dollar sign ($), space, question mark (?), and Delete (ASCII code 127).
         */
        pathValue?: pulumi.Input<string>;
        /**
         * Indicates the request method used by the content delivery network when sending authentication requests. The parameter has the following values: default: uses the same method as the user's request. get: uses the GET method. post: uses the POST method. head: uses the HEAD method.
         */
        requestMethod?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfig {
        /**
         * The content delivery network can cache authentication status codes. This parameter indicates the related configuration.
         */
        cacheAction?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfigCacheAction>;
        /**
         * Indicates how the content delivery network responds to users when authentication fails.
         */
        responseAction?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfigResponseAction>;
        /**
         * Specifies how the content delivery network handles authentication status codes.
         */
        statusCodeAction?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfigStatusCodeAction>;
        /**
         * Specifies how the content delivery network handles authentication requests after authentication timeout.
         */
        timeOutAction?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfigTimeOutAction>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfigCacheAction {
        /**
         * Indicates whether the CDN caches authentication status codes. The parameter values are: nocache: CDN does not cache authentication status codes. cache: CDN caches authentication status codes.
         */
        action?: pulumi.Input<string>;
        /**
         * The cache key specifies the query parameters used to distinguish different request URIs. Each parameter must start with $.
         */
        cacheKeys?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Indicates the cache duration for authentication status codes, measured in seconds. The range is 1–86400. 86400 seconds equals 24 hours.
         */
        ttl?: pulumi.Input<number>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfigResponseAction {
        /**
         * Indicates the status code returned by the content delivery network to the user when authentication fails. You can specify any status code in the range 400–499. The default value is 403.
         */
        statusCode?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfigStatusCodeAction {
        /**
         * Specifies how the content delivery network handles authentication requests when the authentication status code is neither FailCode nor SuccessCode. This parameter has the following values: reject: the content delivery network considers authentication failed; pass: the content delivery network considers authentication successful.
         */
        defaultAction?: pulumi.Input<string>;
        /**
         * Indicates the authentication status code returned when authentication fails. You can specify one or more status codes in the range 400–499. Separate multiple status codes with a semicolon (;). You can also specify 4xx to indicate any status code between 400 and 499. The default value for this parameter is 401.
         */
        failCode?: pulumi.Input<string>;
        /**
         * Indicates the authentication status code for successful authentication. You can specify one or more status codes in the range 200–299. Separate multiple status codes with a semicolon (;). You can also specify 2xx to represent any status code from 200–299. The default value is 200.
         */
        successCode?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionAuthResponseConfigTimeOutAction {
        /**
         * Indicates the strategy for handling authentication requests after a timeout in the content delivery network. This parameter supports the following values: reject: The content delivery network considers authentication failed. pass: The content delivery network considers authentication successful.
         */
        action?: pulumi.Input<string>;
        /**
         * Specifies the authentication timeout in milliseconds. The default value is 200. The valid range is 200–3600.
         */
        time?: pulumi.Input<number>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionQueryStringRules {
        /**
         * Indicates the strategy for setting authentication request parameters.
         */
        queryStringComponents?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionQueryStringRulesQueryStringComponents>;
        queryStringInstances?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionQueryStringRulesQueryStringInstance>[]>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionQueryStringRulesQueryStringComponents {
        /**
         * Indicates whether the authentication request includes query parameters from the user's request URL. The parameter accepts the following values: exclude: The authentication request does not include any query parameters. include: The authentication request includes all query parameters. includePart: The authentication request includes specified query parameters.
         */
        action?: pulumi.Input<string>;
        /**
         * Indicates the parameter value corresponding to the Action parameter. The length cannot exceed 1,024 characters. The parameter accepts the following values: If Action is exclude or include, Value must be *. If Action is includePart, you need to specify one or more query parameters from the user's request URL in the Value parameter, separated by semicolons (;). You cannot specify *. Query parameters are case-sensitive and can include printable ASCII characters except for the following: double quotes (") , spaces, and Delete (ASCII code 127). The default value for this parameter is *.
         */
        value?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionQueryStringRulesQueryStringInstance {
        /**
         * Describes how to set authentication request parameters. Currently, you can only set Action to set. set means to configure parameters. You need to specify the authentication request parameter to set in Key. If the specified authentication request parameter does not exist, the content delivery network adds the parameter to the authentication request. If the specified authentication request parameter already exists, the content delivery network uses the value of Value as the parameter's value.
         */
        action?: pulumi.Input<string>;
        /**
         * Indicates the authentication request parameter you need to set. The length must not exceed 1,024 characters. The authentication request parameter can contain printable ASCII characters except for the following: double quotes ("), space, and Delete (ASCII code 127)
         */
        key?: pulumi.Input<string>;
        /**
         * Indicates the value of the authentication request parameter. The length cannot exceed 1,024 characters and is case-sensitive. Value has the following options: When ValueType is constant, the authentication request parameter value is a constant. You need to specify this constant value. The constant value cannot start with a dollar sign ($) and can include any printable ASCII character except the following: double quotes (") and Delete (ASCII code 127). When ValueType is variable, the authentication request parameter value comes from a variable. You can specify a variable from the variable list. When ValueType is customize, the authentication request parameter value is a string formed by concatenating variables from the list with fixed strings. In the concatenated string, variables are represented as ${variable*name}. Example value: bind${request*uri}to${local_ip}done
         */
        value?: pulumi.Input<string>;
        /**
         * Indicates the type of authentication request parameter set in Key. ValueType has the following options: constant: The authentication request parameter is a constant. In this case, you need to specify the constant value in Value. variable: The authentication request parameter value comes from a variable. See the description for Value. customize: The authentication request parameter value is a string formed by concatenating a variable and a fixed string.
         */
        valueType?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionRequestHeaderRules {
        /**
         * Indicates the configuration policy for authentication request headers.
         */
        requestHeaderComponents?: pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionRequestHeaderRulesRequestHeaderComponents>;
        requestHeaderInstances?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionRequestHeaderRulesRequestHeaderInstance>[]>;
        /**
         * Indicates the value of the HOST header in authentication requests. The default value for this parameter is default, meaning the HOST header matches your acceleration domain name.
         */
        requestHost?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionRequestHeaderRulesRequestHeaderComponents {
        /**
         * Indicates whether the authentication request header includes user request headers. The parameter values are: exclude: the authentication request header does not include any user request headers. include: the authentication request header includes all user request headers. includePart: the authentication request header includes specified user request headers.
         */
        action?: pulumi.Input<string>;
        /**
         * Indicates the parameter value corresponding to the Action parameter. The length must not exceed 1,024 characters. The parameter has the following notes: If Action is exclude or include, Value must be *. If Action is includePart, the Value parameter can be one or more headers from the user's request. Multiple headers are separated by a semicolon (;). The value cannot be only *, and can include printable ASCII characters except for the following: underscore (_), space, double quotes ("), Delete (ASCII code 127). The default value for this parameter is *.
         */
        value?: pulumi.Input<string>;
    }
    interface DomainRemoteAuthRemoteAuthRuleRemoteAuthRuleActionRequestHeaderRulesRequestHeaderInstance {
        /**
         * Indicates how to set the authentication request header. Currently, you can only set this parameter to set. set means to configure the request header. You need to specify the request header in Key. If the request header does not exist, the content delivery network adds it to the authentication request. If the request header already exists, the content delivery network uses the value specified in Value as the header value.
         */
        action?: pulumi.Input<string>;
        /**
         * Specifies the name of a header. The name cannot exceed 1,024 characters and is case insensitive. It can contain any printable ASCII character except: underscore (_), space, double quotes ("), and Delete (ASCII code 127).
         */
        key?: pulumi.Input<string>;
        /**
         * Indicates the value of the Key. This parameter is only valid when Action equals "set". If Action does not equal "set", this parameter is invalid. When ValueType is constant, you must specify a fixed string as the header value. The header value cannot exceed 1,024 characters and can contain any printable ASCII character except the following: dollar sign ($), Delete (ASCII code 127)
         */
        value?: pulumi.Input<string>;
        /**
         * Specifies the value type for the Key. This parameter is only valid when Action is set to 'set'. If Action is not 'set', this parameter is invalid. The parameter has the following values: constant: the Key value is a fixed string. variable: the Key value comes from a variable. customize: the Key value is a string formed by concatenating a variable and a fixed string.
         */
        valueType?: pulumi.Input<string>;
    }
    interface DomainRequestBlockRule {
        blockRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRequestBlockRuleBlockRule>[]>;
        /**
         * Indicates the configuration switch for this module. This parameter has the following values: true: enables the module. false: disables the module. The default value is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainRequestBlockRuleBlockRule {
        /**
         * Indicates the interception configuration for a rule in the list.
         */
        blockAction?: pulumi.Input<inputs.cdn.DomainRequestBlockRuleBlockRuleBlockAction>;
        /**
         * Represents the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainRequestBlockRuleBlockRuleCondition>;
        /**
         * Indicates the name of the rule, which must not exceed 20 characters and can include letters, numbers, underscores (_), hyphens (-), and Chinese characters. One Chinese character counts as 3 characters.
         */
        ruleName?: pulumi.Input<string>;
    }
    interface DomainRequestBlockRuleBlockRuleBlockAction {
        /**
         * Specifies how the content delivery network intercepts matching requests. This parameter has the following values: refuse: The content delivery network rejects the request and returns a 4xx error code. The error code is specified in StatusCode. redirect: The content delivery network redirects the request to the URL specified in RedirectUrl.
         */
        action?: pulumi.Input<string>;
        /**
         * When Action is refuse, this parameter is optional, as explained below: If specified, this parameter indicates the name of a custom response page under global configuration. When the content delivery network refuses a request, it returns this custom page. Note that 'global configuration' is an Allowlist feature. To use this feature, submit a ticket. If this parameter is not specified, the content delivery network uses the standard response body for the error code specified in StatusCode. When Action is redirect, this parameter is invalid and can be omitted.
         */
        errorPage?: pulumi.Input<string>;
        /**
         * When Action is redirect, this parameter is required and specifies the redirect URL. The URL must start with http:// or https:// and cannot exceed 1,024 characters. When Action is refuse, this parameter is invalid and can be omitted.
         */
        redirectUrl?: pulumi.Input<string>;
        /**
         * Represents the response status code from the content delivery network for intercepted requests. When Action is refuse, this parameter specifies an error code in the range 400–499. When Action is redirect, this parameter can be: 301: The response status code is 301. 302: The response status code is 302.
         */
        statusCode?: pulumi.Input<string>;
    }
    interface DomainRequestBlockRuleBlockRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRequestBlockRuleBlockRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainRequestBlockRuleBlockRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainRequestHeader {
        /**
         * Represents the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainRequestHeaderCondition>;
        /**
         * Represents a list of configuration rules for request headers. Each rule includes settings for header operations. You can add up to 50 rules.
         */
        requestHeaderAction?: pulumi.Input<inputs.cdn.DomainRequestHeaderRequestHeaderAction>;
    }
    interface DomainRequestHeaderCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRequestHeaderConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainRequestHeaderConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainRequestHeaderRequestHeaderAction {
        requestHeaderInstances?: pulumi.Input<pulumi.Input<inputs.cdn.DomainRequestHeaderRequestHeaderActionRequestHeaderInstance>[]>;
    }
    interface DomainRequestHeaderRequestHeaderActionRequestHeaderInstance {
        /**
         * Indicates how to set the authentication request header. Currently, you can only set this parameter to set. set means to configure the request header. You need to specify the request header in Key. If the request header does not exist, the content delivery network adds it to the authentication request. If the request header already exists, the content delivery network uses the value specified in Value as the header value.
         */
        action?: pulumi.Input<string>;
        /**
         * Specifies the name of a header. The name cannot exceed 1,024 characters and is case insensitive. It can contain any printable ASCII character except: underscore (_), space, double quotes ("), and Delete (ASCII code 127).
         */
        key?: pulumi.Input<string>;
        /**
         * Indicates the value of the Key. This parameter is only valid when Action equals "set". If Action does not equal "set", this parameter is invalid. When ValueType is constant, you must specify a fixed string as the header value. The header value cannot exceed 1,024 characters and can contain any printable ASCII character except the following: dollar sign ($), Delete (ASCII code 127)
         */
        value?: pulumi.Input<string>;
        /**
         * Specifies the value type for the Key. This parameter is only valid when Action is set to 'set'. If Action is not 'set', this parameter is invalid. The parameter has the following values: constant: the Key value is a fixed string. variable: the Key value comes from a variable. customize: the Key value is a string formed by concatenating a variable and a fixed string.
         */
        valueType?: pulumi.Input<string>;
    }
    interface DomainResponseHeader {
        /**
         * Indicates the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainResponseHeaderCondition>;
        /**
         * Indicates operations on the response header performed by the Content Delivery Network when responding to user requests.
         */
        responseHeaderAction?: pulumi.Input<inputs.cdn.DomainResponseHeaderResponseHeaderAction>;
    }
    interface DomainResponseHeaderCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainResponseHeaderConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainResponseHeaderConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainResponseHeaderResponseHeaderAction {
        responseHeaderInstances?: pulumi.Input<pulumi.Input<inputs.cdn.DomainResponseHeaderResponseHeaderActionResponseHeaderInstance>[]>;
    }
    interface DomainResponseHeaderResponseHeaderActionResponseHeaderInstance {
        /**
         * Indicates whether the Origin field in the request header is validated when the content delivery network responds to user requests. Valid values are: true: The content delivery network validates the Origin field. If validation succeeds, the response header includes the Access-Control-Allow-Origin field, with the value matching the Origin field. If validation fails, the response header does not include the Access-Control-Allow-Origin field. false: The content delivery network does not validate the Origin field. The response header includes the Access-Control-Allow-Origin field, with the value set to your configured Access-Control-Allow-Origin content. The default value is false. This parameter is only effective when all the following conditions are met: Action is set. Key is Access-Control-Allow-Origin. ValueType is constant.
         */
        accessOriginControl?: pulumi.Input<boolean>;
        /**
         * Specifies the operation on the response header. This parameter has the following values: set: sets a header. The set operation includes adding and modifying. If the header already exists in the origin response, its value will be overwritten. If the header does not exist in the origin response, it will be added. delete: deletes a header
         */
        action?: pulumi.Input<string>;
        /**
         * Specifies the name of a header. The name cannot exceed 1,024 characters, is case-insensitive, and can include any printable ASCII character except the following: underscore (_), space, double quotes ("), and Delete (ASCII code 127)
         */
        key?: pulumi.Input<string>;
        /**
         * Indicates the value of the Key. This parameter is valid only when Action is set. If Action is not set, this parameter is invalid. When ValueType is constant, you must specify a fixed string as the header value. The header value cannot exceed 1,024 characters and can include printable ASCII characters except for the following: dollar sign ($), Delete (ASCII code 127).
         */
        value?: pulumi.Input<string>;
        /**
         * Specifies the value type for Key. This parameter is only valid when Action is set. If Action is not set, this parameter is invalid. The parameter supports the following values: constant: Key is a fixed string. variable: Key is sourced from a variable. customize: Key is a string formed by concatenating a variable and a fixed string.
         */
        valueType?: pulumi.Input<string>;
    }
    interface DomainRewriteHls {
        /**
         * Indicates the name of the signature parameter, which cannot exceed 100 characters. Parameter names are case-sensitive and can include letters, numbers, underscores (_), hyphens (-), commas (,), periods (.), and exclamation marks (!). The default value is DrmAuthToken.
         */
        signName?: pulumi.Input<string>;
        /**
         * Indicates whether this feature is enabled. This parameter has the following options: true: Enable this feature. false: Disable this feature. The default value for this parameter is false.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainSignedUrlAuth {
        signedUrlAuthRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainSignedUrlAuthSignedUrlAuthRule>[]>;
        /**
         * Indicates whether to enable this feature. This parameter has the following values: true: Enables this feature. false: Disables this feature.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainSignedUrlAuthSignedUrlAuthRule {
        /**
         * Represents the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainSignedUrlAuthSignedUrlAuthRuleCondition>;
        /**
         * Indicates the configuration for signature calculation.
         */
        signedUrlAuthAction?: pulumi.Input<inputs.cdn.DomainSignedUrlAuthSignedUrlAuthRuleSignedUrlAuthAction>;
    }
    interface DomainSignedUrlAuthSignedUrlAuthRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainSignedUrlAuthSignedUrlAuthRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainSignedUrlAuthSignedUrlAuthRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainSignedUrlAuthSignedUrlAuthRuleSignedUrlAuthAction {
        /**
         * Indicates the algorithm used for signature calculation. This configuration has the following values: md5: MD5 algorithm. sha256: SHA-256 algorithm. The default value for this parameter is md5.
         */
        authAlgorithm?: pulumi.Input<string>;
        /**
         * Indicates the backup secret key. The backup secret key must be 6–40 characters long and can contain any printable ASCII character except Delete (ASCII code 127).
         */
        backupSecretKey?: pulumi.Input<string>;
        /**
         * Indicates custom signature calculation variables.
         */
        customVariableRules?: pulumi.Input<inputs.cdn.DomainSignedUrlAuthSignedUrlAuthRuleSignedUrlAuthActionCustomVariableRules>;
        /**
         * The validity period of the signature, in seconds. This parameter is used with the timestamp included in the request to calculate the expiration time of the signature. The value range for this parameter is 0–315,360,000. Signature expiration time = timestamp + Duration. When the content delivery network receives a request, if the signature expiration time is less than the current time, the content delivery network determines that the signature has expired.
         */
        duration?: pulumi.Input<number>;
        /**
         * This parameter is not currently available to external users. Do not use this parameter.
         */
        keepOriginArg?: pulumi.Input<boolean>;
        /**
         * Indicates the primary key, with a length of 6–40 characters. It can include printable ASCII characters except Delete (ASCII code 127)
         */
        masterSecretKey?: pulumi.Input<string>;
        /**
         * Indicates whether the content delivery network adds signature parameters to the URL of each segment file in a .m3u8 file when responding to a .m3u8 file request. The signature for each segment URL is calculated based on the rewritten segment URL using the signature rules. The parameter values are as follows: true: enabled. false: disabled.
         */
        rewriteM3U8?: pulumi.Input<boolean>;
        /**
         * Specifies the configuration for the 'M3U8 Rewrite' feature. This configuration is valid only when both of the following conditions are met: RewriteM3u8 is true; URLAuthType is not typee.
         */
        rewriteM3U8Rule?: pulumi.Input<inputs.cdn.DomainSignedUrlAuthSignedUrlAuthRuleSignedUrlAuthActionRewriteM3U8Rule>;
        /**
         * Indicates the name of the signature parameter. The length cannot exceed 100 characters. Parameter names are case-sensitive and can include letters, numbers, underscores (_), hyphens (-), commas (,), periods (.), and exclamation marks (!).
         */
        signName?: pulumi.Input<string>;
        /**
         * When URLAuthType is set to typee, this parameter is required and specifies the fields to be included in the signature calculation. The following fields must be included in the signature calculation: key: the secret key, which is the parameter value for MasterSecretKey or BackupSecretKey. uri: the URI of the resource requested by the user. If the URI contains Chinese characters, you need to encode the URI. TimeName: the parameter value for the timestamp. The following fields can optionally be included in the signature calculation: domain: the acceleration domain name. referer: the referer value carried in the user's request. ua: the User-Agent value carried in the user's request. ip: the client IP of the user's request. origin: the Origin value carried in the user's request. Custom variables: the variable names you define in CustomVariableInstances. The order in which the fields are listed determines the order of values in MD5() during signature calculation.
         */
        signatureRules?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Numeral system configuration. This parameter has the following values: decimal: decimal system; hexadecimal: hexadecimal system. When URLAuthType is typed or typee, this parameter is required. When URLAuthType is typec, regardless of your setting, this parameter is forcibly set to hexadecimal. For other URLAuthType values, this parameter is not effective.
         */
        timeFormat?: pulumi.Input<string>;
        /**
         * Indicates the name of the timestamp parameter. The value of TimeName can include English letters, numbers, underscores (_), hyphens (-), periods (.), commas (,), and exclamation marks (!), with a length of 1–100 characters. TimeName cannot be the same as SignName. When URLAuthType is typed or typee, this parameter is required. For other types, this parameter does not apply.
         */
        timeName?: pulumi.Input<string>;
        /**
         * Signature type
         */
        urlAuthType?: pulumi.Input<string>;
    }
    interface DomainSignedUrlAuthSignedUrlAuthRuleSignedUrlAuthActionCustomVariableRules {
        customVariableInstances?: pulumi.Input<pulumi.Input<inputs.cdn.DomainSignedUrlAuthSignedUrlAuthRuleSignedUrlAuthActionCustomVariableRulesCustomVariableInstance>[]>;
    }
    interface DomainSignedUrlAuthSignedUrlAuthRuleSignedUrlAuthActionCustomVariableRulesCustomVariableInstance {
        /**
         * Indicates the matching method for the variable. The value of this parameter can only be match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Indicates the variable type. This parameter has the following values: queryString: indicates the variable is a query parameter in the request. requestHeader: indicates the variable is a header field in the request.
         */
        type?: pulumi.Input<string>;
        /**
         * Specifies the variable name, with a maximum length of 100 characters. Variable name requirements are as follows: If Type is queryString, the variable name can include letters, numbers, hyphens (-), commas (,), periods (.), and exclamation marks (!). If Type is requestHeader, the variable name can include any printable ASCII character except: underscore (_), space, double quotes ("), colon (:), and Delete (ASCII code 127).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainSignedUrlAuthSignedUrlAuthRuleSignedUrlAuthActionRewriteM3U8Rule {
        /**
         * Indicates whether to retain the original parameters in the URL when rewriting the shard URL. This parameter has the following values: true: removes the original parameters. false: retains the original parameters.
         */
        deleteParam?: pulumi.Input<boolean>;
        /**
         * Indicates whether to add unsigned query parameters from the M3U8 file request to the segment URL. The parameter has the following options: true: add query parameters to the segment URL. false: do not add query parameters.
         */
        keepM3U8Param?: pulumi.Input<boolean>;
    }
    interface DomainTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface DomainTimeout {
        /**
         * Specify whether to enable origin timeout configuration. This parameter has the following values: true: enables origin timeout configuration. false: disables origin timeout configuration. In this case, the system default timeout values are used for TCP and HTTP requests, which are 2 seconds and 60 seconds respectively.
         */
        switch?: pulumi.Input<boolean>;
        timeoutRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainTimeoutTimeoutRule>[]>;
    }
    interface DomainTimeoutTimeoutRule {
        /**
         * Represents the conditions under which this configuration module takes effect, consisting of a set of rules.
         */
        condition?: pulumi.Input<inputs.cdn.DomainTimeoutTimeoutRuleCondition>;
        /**
         * Indicates the timeout configuration.
         */
        timeoutAction?: pulumi.Input<inputs.cdn.DomainTimeoutTimeoutRuleTimeoutAction>;
    }
    interface DomainTimeoutTimeoutRuleCondition {
        conditionRules?: pulumi.Input<pulumi.Input<inputs.cdn.DomainTimeoutTimeoutRuleConditionConditionRule>[]>;
        /**
         * Represents the logical relationship between multiple ConditionRule entries. This parameter has the following values: AND: indicates the logical relationship is 'AND'. OR: indicates the logical relationship is 'OR'. The default value is OR.
         */
        connective?: pulumi.Input<string>;
    }
    interface DomainTimeoutTimeoutRuleConditionConditionRule {
        /**
         * When Object is query*name or customize, this parameter is valid. If Object is query*name, this parameter indicates the name of a query parameter. If Object is customize, this parameter indicates the name of a custom header. The length of Name cannot exceed 256 characters and can include digits, letters, percent sign (%), underscore (_), and hyphen (-).
         */
        name?: pulumi.Input<string>;
        /**
         * Specifies the type of matching object. The content delivery network applies matching rules to objects of the specified type in the target. This parameter supports the following values: path: matches the path in the target. directory: matches the directory in the target. filetype: matches the file extension in the target.
         */
        object?: pulumi.Input<string>;
        /**
         * Indicates the matching method. This parameter has the following value: match: If any value in Value exists, it is considered a match.
         */
        operator?: pulumi.Input<string>;
        /**
         * Specifies the target type. The value of this parameter is url, indicating the target is a URL.
         */
        type?: pulumi.Input<string>;
        /**
         * Represents a set of values separated by semicolons (;). The total length must not exceed 1,024 characters. Printable ASCII characters are allowed, except for the following: consecutive slashes (//), spaces, dollar sign ($), question mark (?), and Delete (ASCII code 127). If any value in the set matches the request, it is considered a match. When Object is path, this parameter specifies one or more paths. Paths must start with a slash (/). You can use one or more asterisks (*) in the path, where each asterisk represents one or more characters. When Object is directory, this parameter specifies one or more directories. Directories must start and end with a slash (/). You can use one or more asterisks (*) in the directory, where each asterisk represents one or more characters. When Object is filetype, this parameter specifies one or more file extensions. Extensions do not need to start with a period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface DomainTimeoutTimeoutRuleTimeoutAction {
        /**
         * Indicates the timeout period for HTTP requests. The value range for this parameter is 5–60.
         */
        httpTimeout?: pulumi.Input<number>;
        /**
         * Indicates the timeout for TCP requests. The valid range for this parameter is 2–60.
         */
        tcpTimeout?: pulumi.Input<number>;
    }
    interface DomainUaAccessRule {
        /**
         * Indicates whether requests with an empty UA ("") or without a UA field are allowed to access the acceleration domain. The parameter has the following values: true: allowed. false: not allowed. The default value is false.
         */
        allowEmpty?: pulumi.Input<boolean>;
        /**
         * Indicates whether the UA string is case-sensitive. The parameter has the following options: true: The UA string is case-insensitive. false: The UA string is case-sensitive. The default value for this parameter is false.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Specifies whether a denylist or allowlist is used. When Switch is true, this parameter is required. The parameter values are as follows: deny: specifies a denylist. allow: specifies an allowlist.
         */
        ruleType?: pulumi.Input<string>;
        /**
         * Indicates whether the UA allowlist and blocklist feature is enabled. This parameter has the following values: true: enabled. false: disabled.
         */
        switch?: pulumi.Input<boolean>;
        /**
         * Represents a list of UAs. When Switch is true, this parameter is required. The list can contain up to 1,000 UAs. The parameter details are as follows: The value length cannot exceed 30,000 characters. If RuleType is allow, only requests containing UAs in the list are permitted to access the acceleration domain. If RuleType is deny, requests containing UAs in the list are not permitted to access the acceleration domain. UA character restrictions are as follows: You can use * in a UA to represent one or more characters. * can only appear at the beginning or end of the UA. A UA cannot consist only of * or spaces. A UA can contain printable ASCII characters except Delete (ASCII code 127). If a UA contains symbols, the symbols must be HTML encoded.
         */
        userAgents?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface DomainUrlNormalize {
        /**
         * This specifies the list of URL normalization options you need to enable. When Switch is true, this parameter is required. The list can include the following options: dot*segments: replaces the following in the request URL: /./: replaced with a single slash (/). /../: if there is a directory level before /../, removes /../ and that directory. If there is no directory before /../, the original URL is retained. back*slashes: replaces backslashes () in the request URL with a single slash (/). successive_slashes: replaces consecutive slashes (//) in the request URL with a single slash (/).
         */
        normalizeObjects?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * This specifies the list of URL normalization options you need to enable. When Switch is true, this parameter is required. The list can include the following options: dot*segments: replaces the following in the request URL: /./: replaced with a single slash (/). /../: if there is a directory level before /../, removes /../ and that directory. If there is no directory before /../, the original URL is retained. back*slashes: replaces backslashes () in the request URL with a single slash (/). successive_slashes: replaces consecutive slashes (//) in the request URL with a single slash (/).
         */
        switch?: pulumi.Input<boolean>;
    }
    interface DomainVideoDrag {
        /**
         * Smart compression configuration switch. The parameter has the following options: true: enable video seeking. false: disable video seeking.
         */
        switch?: pulumi.Input<boolean>;
    }
    interface ShareConfigAllowIpAccessRule {
        /**
         * Specifies a list of entries. Each entry in the list is an IP address or CIDR block. IP addresses and blocks can be in IPv4 or IPv6 format. List limits: For AddSharedConfig, the number of entries in the list cannot exceed 30,000.
         */
        rules?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ShareConfigAllowRefererAccessRule {
        /**
         * Indicates whether requests with an empty Referer header or without a Referer header are not allowed. This parameter has the following values: true: Not allowed. If the Referer header is empty or missing, the content delivery network rejects the request. false: Allowed. The default value is false.
         */
        allowEmpty?: pulumi.Input<boolean>;
        /**
         * Specifies the contents of the common list.
         */
        commonType?: pulumi.Input<inputs.cdn.ShareConfigAllowRefererAccessRuleCommonType>;
    }
    interface ShareConfigAllowRefererAccessRuleCommonType {
        /**
         * Indicates whether entries in Rules are case-sensitive. This parameter has the following values: true: Not case-sensitive. false: Case-sensitive. The default value is true.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Indicates an entry list, where each entry is a string. List quotas are as follows: The list can contain up to 4,000 entries. The total length of all entries cannot exceed 200,000 characters. When the CDN creates this global configuration, duplicate entries in the list are removed. Duplicate entries do not count toward the quota.
         */
        rules?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ShareConfigCommonMatchList {
        /**
         * Specifies the contents of the common list.
         */
        commonType?: pulumi.Input<inputs.cdn.ShareConfigCommonMatchListCommonType>;
    }
    interface ShareConfigCommonMatchListCommonType {
        /**
         * Indicates whether entries in Rules are case-sensitive. This parameter has the following values: true: Not case-sensitive. false: Case-sensitive. The default value is true.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Indicates an entry list, where each entry is a string. List quotas are as follows: The list can contain up to 4,000 entries. The total length of all entries cannot exceed 200,000 characters. When the CDN creates this global configuration, duplicate entries in the list are removed. Duplicate entries do not count toward the quota.
         */
        rules?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ShareConfigDenyIpAccessRule {
        /**
         * Specifies the configuration for an IP denylist, where ConfigType is deny*ip*access_rule.
         */
        rules?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ShareConfigDenyRefererAccessRule {
        /**
         * Indicates whether requests with an empty Referer header or without a Referer header are allowed. This parameter has the following values: true: Allowed. false: Not allowed. If the Referer header is empty or missing, the content delivery network rejects the request. The default value is true.
         */
        allowEmpty?: pulumi.Input<boolean>;
        /**
         * Specifies the contents of the common list.
         */
        commonType?: pulumi.Input<inputs.cdn.ShareConfigDenyRefererAccessRuleCommonType>;
    }
    interface ShareConfigDenyRefererAccessRuleCommonType {
        /**
         * Indicates whether entries in Rules are case-sensitive. This parameter has the following values: true: Not case-sensitive. false: Case-sensitive. The default value is true.
         */
        ignoreCase?: pulumi.Input<boolean>;
        /**
         * Indicates an entry list, where each entry is a string. List quotas are as follows: The list can contain up to 4,000 entries. The total length of all entries cannot exceed 200,000 characters. When the CDN creates this global configuration, duplicate entries in the list are removed. Duplicate entries do not count toward the quota.
         */
        rules?: pulumi.Input<pulumi.Input<string>[]>;
    }
}
export declare namespace cen {
    interface BandwidthPackageTag {
        /**
         * Tag key for user tags. Parameter   - N: indicates the tag key index, value range: 1–20. Use & to separate multiple tag keys. Cannot start with sys:, in any case. Length range: 1–128 characters. Supports all languages, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals (=), plus (+), hyphens (-), and @ (@). If a tag key starts or ends with a space, the system automatically removes it.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for user tags. Parameter   - N indicates the tag value index, range: 1–20. Use & to separate multiple tag values. Length range: 0–256 characters. If not specified, defaults to empty. Supports all languages, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). Case-sensitive. If the tag value starts or ends with a space, the system automatically removes it.
         */
        value?: pulumi.Input<string>;
    }
    interface CenInstance {
        /**
         * Network instance ID
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Account ID for the network instance
         */
        instanceOwnerId?: pulumi.Input<string>;
        /**
         * Region where the network instance is located
         */
        instanceRegionId?: pulumi.Input<string>;
        /**
         * Type of the network instance
         */
        instanceType?: pulumi.Input<string>;
    }
    interface CenTag {
        /**
         * Tag key for user labels. Length limit: 1–128 characters. Case sensitive. Cannot start or end with a space. Allowed characters: letters, numbers, spaces, underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @. Duplicate tag keys are not allowed for the same resource
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for user labels. Length limit: 0–256 characters. Case sensitive. Cannot start or end with a space. Allowed characters: letters, numbers, spaces, underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @
         */
        value?: pulumi.Input<string>;
    }
    interface ServiceRouteEntryPublishToInstance {
        /**
         * Network instance ID for published cloud service access route.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Region for published cloud service access route.
         */
        instanceRegionId?: pulumi.Input<string>;
        /**
         * Network instance type for published cloud service access route.
         */
        instanceType?: pulumi.Input<string>;
    }
}
export declare namespace clb {
    interface AclAclEntry {
        /**
         * Description of the IP entry. Default value is an empty string. Must start with a letter, number, or Chinese character. Can include letters, numbers, Chinese characters, and the following special characters: English comma (,), period (.), underscore (_), space ( ), equals sign (=), hyphen (-), Chinese comma (，), and Chinese period (。). Length must be between 0 and 255 characters.
         */
        description?: pulumi.Input<string>;
        /**
         * Address range of the IP entry. Only CIDR addresses are supported. Both IPv4 and IPv6 entries can be provided.
         */
        entry?: pulumi.Input<string>;
    }
    interface AclListener {
        /**
         * Listener control mode for this access control policy group. white: allowlist. When the listener monitors CLB traffic, CLB only forwards requests from IP addresses associated with the allowlist access control policy group. black: denylist. When the listener monitors CLB traffic, CLB rejects requests from IP addresses associated with the denylist access control policy group.
         */
        aclType?: pulumi.Input<string>;
        /**
         * Listener ID
         */
        listenerId?: pulumi.Input<string>;
        /**
         * Listener name
         */
        listenerName?: pulumi.Input<string>;
        /**
         * Listener port
         */
        port?: pulumi.Input<number>;
        /**
         * Listener protocol. Includes TCP, UDP, HTTP, HTTPS.
         */
        protocol?: pulumi.Input<string>;
    }
    interface AclTag {
        /**
         * User tag key. Length must be 1–128 characters. Supports input of characters in any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). If the tag key starts or ends with a space, the system automatically removes it.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value. Supports input of characters in any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). Case sensitive. If the tag value starts or ends with a space, the system automatically removes it.
         */
        value?: pulumi.Input<string>;
    }
    interface CertificateTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface ClbAccessLog {
        /**
         * Name of the object storage bucket for storing Layer 7 access logs
         */
        bucketName?: pulumi.Input<string>;
        /**
         * Enable access log TOS feature?
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Enable access log TLS feature?
         */
        tlsEnabled?: pulumi.Input<boolean>;
        /**
         * Log project
         */
        tlsProjectId?: pulumi.Input<string>;
        /**
         * Log topic
         */
        tlsTopicId?: pulumi.Input<string>;
    }
    interface ClbEip {
        /**
         * Peak bandwidth
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Shared bandwidth package ID
         */
        bandwidthPackageId?: pulumi.Input<string>;
        /**
         * Billing method
         */
        eipBillingType?: pulumi.Input<number>;
        /**
         * Line type
         */
        isp?: pulumi.Input<string>;
        /**
         * Protection package ID
         */
        securityProtectionInstanceId?: pulumi.Input<number>;
        /**
         * Security protection type
         */
        securityProtectionTypes?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ClbEni {
        /**
         * Private IP address of the load balancer instance
         */
        eniAddress?: pulumi.Input<string>;
        /**
         * Network interface ID occupied by the load balancer instance
         */
        eniId?: pulumi.Input<string>;
    }
    interface ClbEnis {
        /**
         * Private IP address of the load balancer instance
         */
        eniAddress?: pulumi.Input<string>;
        /**
         * Network interface ID occupied by the load balancer instance
         */
        eniId?: pulumi.Input<string>;
    }
    interface ClbIpv6AddressBandwidth {
        /**
         * Peak bandwidth of IPv6 public bandwidth, in Mbps
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Shared bandwidth package ID associated with IPv6 public bandwidth
         */
        bandwidthPackageId?: pulumi.Input<string>;
        /**
         * Billing type for IPv6 public bandwidth
         */
        billingType?: pulumi.Input<number>;
        /**
         * Line type of IPv6 public bandwidth
         */
        isp?: pulumi.Input<string>;
        /**
         * Network type of the load balancer instance's IPv6 address
         */
        networkType?: pulumi.Input<string>;
    }
    interface ClbListener {
        /**
         * Listener ID
         */
        listenerId?: pulumi.Input<string>;
        /**
         * Listener name
         */
        listenerName?: pulumi.Input<string>;
    }
    interface ClbServerGroup {
        /**
         * ID of the backend server group in the load balancer instance
         */
        serverGroupId?: pulumi.Input<string>;
        /**
         * Name of the backend server group in the load balancer instance
         */
        serverGroupName?: pulumi.Input<string>;
    }
    interface ClbTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface ListenerDomainExtension {
        /**
         * Certificate ID of the extended domain name.
         */
        certCenterCertificateId?: pulumi.Input<string>;
        /**
         * Certificate source for the extended domain name to be added. Value: cert_center: SSL certificate from Volcano Engine Certificate Center. This parameter is required when adding an extended domain name.
         */
        certificateSource?: pulumi.Input<string>;
        /**
         * Domain name. Supports both wildcard and exact domain names. Specifications: 1. Must contain at least one '.', and cannot start or end with '.'. 2. Only letters, numbers, '.', '-', and '*' are allowed. 3. Length must be between 1 and 128 characters. 4. Wildcard domain: Use '*' to replace one or more characters. 5. Exact domain: A domain name that strictly follows domain name specifications.
         */
        domain?: pulumi.Input<string>;
    }
    interface ListenerHealthCheck {
        /**
         * Domain name for health check. Must be set to the actual address provided by the backend server. This parameter takes effect when Protocol is set to HTTP or HTTPS and HealthCheck.Enabled is on. Must contain at least one period (.), and cannot start or end with a period (.). Each string can include letters, numbers, hyphens (-), and periods (.), with hyphens (-) not allowed at the beginning or end of the string. Length limit: 1 to 128 characters. If this parameter is not provided or no value is specified, the default is empty, meaning CLB uses the private IP address of each backend server for health checks.
         */
        domain?: pulumi.Input<string>;
        /**
         * Whether health check is enabled for the listener. on (default): enabled. off: disabled.
         */
        enabled?: pulumi.Input<string>;
        /**
         * Health threshold, i.e., the number of consecutive successful health checks. Range: 2–10, default is 3, unit: times.
         */
        healthyThreshold?: pulumi.Input<number>;
        /**
         * HTTP status codes for healthy checks. This parameter is effective when Protocol is HTTP or HTTPS and HealthCheck.Enabled is on. Values: http*2xx (default), http*3xx, http*4xx, http*5xx. Separate multiple status codes with a comma (,).
         */
        httpCode?: pulumi.Input<string>;
        /**
         * Interval for performing health checks. Range: 1–300, default is 2, in seconds.
         */
        interval?: pulumi.Input<number>;
        /**
         * Listener health check method. GET: server must support the GET method. HEAD: server returns only HEAD header information, which reduces backend overhead, but requires server support for the HEAD method.
         */
        method?: pulumi.Input<string>;
        /**
         * Health check port. Value range: 1–65535.
         */
        port?: pulumi.Input<number>;
        /**
         * Health check response timeout. If the backend server does not respond correctly within the specified time, the health check is considered 'abnormal'. Value range: 1 to 60. Default: 2. Unit: seconds.
         */
        timeout?: pulumi.Input<number>;
        /**
         * Expected response string for health check. Only letters and numbers are allowed, with a maximum length of 64 characters. This parameter takes effect when Protocol is set to UDP and HealthCheck.Enabled is set to on. HealthCheck.UdpRequest and HealthCheck.UdpExpect must either both be empty or both be non-empty.
         */
        udpExpect?: pulumi.Input<string>;
        /**
         * Request string for performing health checks. Only letters and numbers are allowed, with a maximum length of 64 characters. This parameter takes effect when Protocol is set to UDP and HealthCheck.Enabled is set to on. The values of HealthCheck.UdpRequest and HealthCheck.UdpExpect must either both be empty or both be non-empty.
         */
        udpRequest?: pulumi.Input<string>;
        /**
         * Unhealthy threshold, which is the number of consecutive health check failures. Value range: 2–10. Default: 3. Unit: occurrences.
         */
        unhealthyThreshold?: pulumi.Input<number>;
        /**
         * Health check path. Must be configured as the actual address provided by the backend server. This parameter takes effect when Protocol is set to HTTP or HTTPS and HealthCheck.Enabled is on. Must start with '/'. Only letters, digits, hyphens (-), underscores (_), slashes (/), periods (.), percent signs (%), question marks (?), #, &, and equals signs (=) are allowed. Length: 1–128 characters. If not specified or no value is provided, the default is '/'.
         */
        uri?: pulumi.Input<string>;
    }
    interface ListenerTag {
        /**
         * Tag key for user tags. Length range: 1–128 characters. Supports input of characters from all languages, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). If the tag key starts or ends with a space, the system automatically removes it.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for user tags. Supports input of characters from any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). Case sensitive. If the tag value starts or ends with a space, the system will automatically remove it.
         */
        value?: pulumi.Input<string>;
    }
    interface NlbAccessLog {
        /**
         * Enable access logs. true: yes. false: no.
         */
        accessLogEnabled?: pulumi.Input<boolean>;
        /**
         * Log project ID.
         */
        projectId?: pulumi.Input<string>;
        /**
         * Log topic ID.
         */
        topicId?: pulumi.Input<string>;
    }
    interface NlbListenerHealth {
        /**
         * Backend server instance ID or IP address
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Backend server IP address
         */
        ip?: pulumi.Input<string>;
        /**
         * Port on which the backend server provides services
         */
        port?: pulumi.Input<number>;
        /**
         * Backend server ID
         */
        serverId?: pulumi.Input<string>;
        /**
         * Backend server type: ecs (cloud server instance, i.e., primary network interface); eni (secondary network interface); ip (IP address)
         */
        serverType?: pulumi.Input<string>;
        /**
         * Backend server health status: Up (normal); Down (abnormal); Unused (not in use—NLB instance has disabled cross-zone forwarding and there is no traffic from this backend server's zone)
         */
        status?: pulumi.Input<string>;
        /**
         * Last update time of health status
         */
        updatedTime?: pulumi.Input<string>;
        /**
         * Zone ID where the backend server receives traffic
         */
        zoneId?: pulumi.Input<string>;
    }
    interface NlbListenerTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface NlbSecurityPolicyTag {
        /**
         * User tag key
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value
         */
        value?: pulumi.Input<string>;
    }
    interface NlbServerGroupHealthCheck {
        /**
         * Health check domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * Enable health check
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Health check healthy threshold. Range: 2–10 times, default: 3 times. If the backend server passes the specified number of consecutive health checks with 'normal' results, it is considered health check 'normal'
         */
        healthyThreshold?: pulumi.Input<number>;
        /**
         * HTTP status codes indicating a healthy health check.
         */
        httpCode?: pulumi.Input<string>;
        /**
         * Health check interval, range: 1–300 seconds, default: 10 seconds.
         */
        interval?: pulumi.Input<number>;
        /**
         * Health check request method
         */
        method?: pulumi.Input<string>;
        /**
         * Health check port. Range: 1–65535. If full port forwarding is not enabled for the server group, this parameter defaults to 0, meaning the backend server's port is used for health checks. If full port forwarding is enabled, this parameter must be specified
         */
        port?: pulumi.Input<number>;
        /**
         * Health check response timeout. Range: 1–60 seconds, default: 3 seconds. If the backend server does not respond correctly within the specified time, it is considered health check 'abnormal'
         */
        timeout?: pulumi.Input<number>;
        /**
         * Health check protocol type. Options: TCP (default), HTTP, UDP
         */
        type?: pulumi.Input<string>;
        /**
         * UDP health check request string. Only letters and numbers are allowed, with a maximum length of 64 characters.
         */
        udpExpect?: pulumi.Input<string>;
        /**
         * Expected response string for UDP health check
         */
        udpRequest?: pulumi.Input<string>;
        /**
         * Health check unhealthy threshold. Range: 2–10 times, default: 3 times. If the backend server fails the specified number of consecutive health checks with 'abnormal' results, it is considered health check abnormal
         */
        unhealthyThreshold?: pulumi.Input<number>;
        /**
         * Health check path
         */
        uri?: pulumi.Input<string>;
    }
    interface NlbServerGroupServer {
        /**
         * Description of the backend server, default is an empty string.
         */
        description?: pulumi.Input<string>;
        /**
         * Server instance ID or IP address. If the server type is 'ecs', enter the cloud server instance ID. You can call the DescribeInstances API to obtain the cloud server instance ID. If the server type is 'eni', enter the network interface card ID bound to the cloud server instance. You can call the DescribeNetworkInterfaces API to obtain the network interface card ID. If the server type is 'ip', enter the backend server's IP address.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Private IP address of the backend server. You can call the DescribeInstances API to obtain the private IP address of an 'ecs' type backend server. You can call the DescribeNetworkInterfaces API to obtain the private IP address of an 'eni' type backend server.
         */
        ip?: pulumi.Input<string>;
        /**
         * Port number on which the backend server receives requests, range: 1–65535. If AnyPortEnabled is 'false' (all-port forwarding is disabled), this parameter is required. If AnyPortEnabled is 'true' (all-port forwarding is enabled), the default value is 0.
         */
        port?: pulumi.Input<number>;
        /**
         * Backend server ID
         */
        serverId?: pulumi.Input<string>;
        /**
         * Backend server type. Available values: ecs: cloud server instance (primary network interface). eni: auxiliary network interface. ip: IP address.
         */
        type?: pulumi.Input<string>;
        /**
         * Backend server weight, range: 0–100. Weight of 0 means requests will not be forwarded to this server. If not specified, the default is 0.
         */
        weight?: pulumi.Input<number>;
        /**
         * Specify the availability zone of the NLB instance associated with the backend server. This parameter is required when Servers.N.Type is ip. If the NLB instance enables cross-zone forwarding, the backend server can receive traffic from all availability zones of the NLB instance. If cross-zone forwarding is disabled, the backend server only receives traffic from the specified availability zone
         */
        zoneId?: pulumi.Input<string>;
    }
    interface NlbServerGroupTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface NlbTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface NlbZoneMapping {
        /**
         * Network interface card ID.
         */
        eniId?: pulumi.Input<string>;
        /**
         * Private IPv4 VIP address of the NLB instance. If this parameter is not provided, the system automatically assigns an available IPv4 address from the subnet.
         */
        ipv4Address?: pulumi.Input<string>;
        /**
         * Public IPv4 EIP address of the NLB instance.
         */
        ipv4EipAddress?: pulumi.Input<string>;
        /**
         * Public IPv4 EIP ID of the NLB instance.
         */
        ipv4EipId?: pulumi.Input<string>;
        /**
         * Health status of the NLB instance's private IPv4 address. Healthy: healthy. Unhealthy: abnormal.
         */
        ipv4HcStatus?: pulumi.Input<string>;
        /**
         * Private IPv4 LIP address of the NLB instance.
         */
        ipv4LocalAddresses?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Private IPv6 VIP address of the NLB instance.
         */
        ipv6Address?: pulumi.Input<string>;
        /**
         * ID of the IPv6 public bandwidth associated with the NLB instance.
         */
        ipv6EipId?: pulumi.Input<string>;
        /**
         * Health status of the NLB instance's private IPv6 address. Healthy: healthy. Unhealthy: abnormal.
         */
        ipv6HcStatus?: pulumi.Input<string>;
        /**
         * Private IPv6 LIP address of the NLB instance.
         */
        ipv6LocalAddresses?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Subnet ID to which the NLB instance belongs.
         */
        subnetId?: pulumi.Input<string>;
        /**
         * Availability zone ID to which the NLB instance belongs.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface RuleRedirectConfig {
        /**
         * The domain name for forwarding rule redirection currently supports only exact domain names. Specifications: Must contain at least one '.', and cannot start or end with '.'. Only letters, numbers, '.', and '-' are allowed. Length must be between 1 and 128 characters. Example of a valid exact domain name: www.test.com.
         */
        host?: pulumi.Input<string>;
        /**
         * Path for forwarding rule redirection. Specifications: Must start with a forward slash '/'. Consecutive '/' characters are not allowed. Only letters, numbers, '-', '_', '/', '.', '%', '?', '#', '&', '=', and other specified characters are allowed. Length must be between 1 and 128 characters.
         */
        path?: pulumi.Input<string>;
        /**
         * Port for forwarding rule redirection. Value range: 1~65535.
         */
        port?: pulumi.Input<string>;
        /**
         * Protocol for forwarding rule redirection. Options: HTTP. HTTPS (default).
         */
        protocol?: pulumi.Input<string>;
        /**
         * Status code for forwarding rule redirection. Options: 301 (default): Indicates the requested resource has been permanently moved to a new URL. The client should use the new URL for subsequent requests. 302: Indicates the requested resource has been temporarily moved to a new URL and may change again in the future. The client should use the new URL for subsequent requests. 307: Similar to 302, but requires the client to keep the request method unchanged during redirection. For example, if the original request is GET, the redirected request remains GET. 308: Similar to 301, but requires the client to keep the request method unchanged during redirection.
         */
        statusCode?: pulumi.Input<string>;
    }
    interface RuleTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface ServerGroupListener {
        /**
         * Listener ID.
         */
        listenerId?: pulumi.Input<string>;
    }
    interface ServerGroupServer {
        /**
         * Backend server description. Must start with a letter, number, or Chinese character. Can include letters, numbers, Chinese characters, and the following special characters: comma (,), period (.), underscore (_), space ( ), equals sign (=), hyphen (-), Chinese comma (，), Chinese period (。). Length limit: 0–255 characters. If not specified, defaults to an empty string.
         */
        description?: pulumi.Input<string>;
        /**
         * Backend server. Value options: When Type is ecs, provide the cloud server instance ID. When Type is eni, provide the ID of the auxiliary network card attached to the cloud server. When Type is ip, provide the IP address as the backend server.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Private IP address of the backend server. Use '&' to separate multiple backend server IP addresses.
         */
        ip?: pulumi.Input<string>;
        /**
         * Port number on which the backend server receives requests. Value range: 1–65535. If the AnyPortEnabled parameter is 'off' and you need to add backend servers at the same time, this parameter must be provided. If AnyPortEnabled is 'on', this parameter defaults to 0.
         */
        port?: pulumi.Input<number>;
        /**
         * Backend server instance type. When the Type parameter is instance, value options are: ecs: cloud server instance. eni: auxiliary network card. When the Type parameter is ip, this parameter value is ip.
         */
        type?: pulumi.Input<string>;
        /**
         * Backend server weight, range: 0–100. If not specified, defaults to 0. 0 means requests will not be forwarded to this backend server.
         */
        weight?: pulumi.Input<number>;
    }
    interface ServerGroupTag {
        /**
         * Information about bound tag keys.
         */
        key?: pulumi.Input<string>;
        /**
         * Bound tag value information.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace cloudidentity {
    interface GroupMember {
        /**
         * User ID
         */
        userId?: pulumi.Input<string>;
    }
    interface PermissionSetPermissionPolicy {
        /**
         * Policy syntax content. Refer to policy syntax documentation
         */
        permissionPolicyDocument?: pulumi.Input<string>;
        /**
         * Policy Name
         */
        permissionPolicyName?: pulumi.Input<string>;
        /**
         * Policy Type: System or Inline
         */
        permissionPolicyType?: pulumi.Input<string>;
    }
}
export declare namespace cloudmonitor {
    interface ContactGroupContact {
        /**
         * Contact ID
         */
        contactId?: pulumi.Input<string>;
    }
    interface RuleCondition {
        /**
         * Comparison operators. Supports standard threshold alerting: >, >=, <, <=, !=, =, as well as the following period-over-period alerting: last*period*increase*pct: Increased compared to last period. last*period*decrease*pct: Decreased compared to last period. last*period*abs*pct: Increased or decreased compared to last period. last*day*increase*pct: Increased compared to the same period yesterday. last*day*decrease*pct: Decreased compared to the same period yesterday. last*day*abs*pct: Increased or decreased compared to the same period yesterday. last*week*increase*pct: Increased compared to the same period last week. last*week*decrease*pct: Decreased compared to the same period last week. last*week*abs_pct: Increased or decreased compared to the same period last week.
         */
        comparisonOperator?: pulumi.Input<string>;
        /**
         * Monitoring metric name. For details, see MetricName for each product in Cloud Monitoring Metric Query.
         */
        metricName?: pulumi.Input<string>;
        /**
         * Unit of the monitoring metric. For details, see MetricUnit for each product in Cloud Monitoring Metric Query. For period-over-period alerting, MetricUnit must be set to "Percent." Whether IEC is included in MetricUnit indicates different base values: With IEC: base is 1024; Without IEC: base is 1000.
         */
        metricUnit?: pulumi.Input<string>;
        /**
         * Statistical period for monitoring metrics. For details, see Period for each product in Cloud Monitoring Metric Query.
         */
        period?: pulumi.Input<string>;
        /**
         * Statistical method. Options: avg: average, max: maximum, min: minimum. The statistical method is applied to data within the detection time period. For example, the default detection time span is 1 minute. If the statistical method is avg, the average value of data within 1 minute is used.
         */
        statistics?: pulumi.Input<string>;
        /**
         * Metric threshold. Supports positive numbers or 0. Up to three decimal places allowed.
         */
        threshold?: pulumi.Input<string>;
    }
    interface RuleDimensionConditions {
        /**
         * Condition for selecting alert objects based on resource name. Required when Type is meta.
         */
        metaCondition?: pulumi.Input<inputs.cloudmonitor.RuleDimensionConditionsMetaCondition>;
        /**
         * Condition for selecting alert targets by project. Required when Type is project.
         */
        projectCondition?: pulumi.Input<inputs.cloudmonitor.RuleDimensionConditionsProjectCondition>;
        /**
         * Condition for selecting alert objects by tag. Required when Type is tag.
         */
        tagCondition?: pulumi.Input<inputs.cloudmonitor.RuleDimensionConditionsTagCondition>;
        /**
         * Dimensions type. Values: project: Select alert targets by project. tag: Select alert targets by tag. meta: Select alert targets by resource name.
         */
        type?: pulumi.Input<string>;
    }
    interface RuleDimensionConditionsMetaCondition {
        /**
         * Whether all resources are included. true: All resources. false: Partial resources.
         */
        allDimensions?: pulumi.Input<boolean>;
        /**
         * Condition. and: All conditions met. or: Any condition met.
         */
        condition?: pulumi.Input<string>;
        metas?: pulumi.Input<pulumi.Input<inputs.cloudmonitor.RuleDimensionConditionsMetaConditionMeta>[]>;
    }
    interface RuleDimensionConditionsMetaConditionMeta {
        /**
         * Tag match operator. contain: Contains not*contain: Does not contain prefix*match: Prefix match suffix*match: Suffix match equal: Equals not*equal: Does not equal exist: Exists.
         */
        comparator?: pulumi.Input<string>;
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value (Value). When Comparator is exist, includes all Values corresponding to the Key and does not support input. When Comparator is equal or not*equal, supports multiple Value inputs. When Comparator is contain, not*contain, prefix*match, or suffix*match, only one Value can be entered.
         */
        values?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface RuleDimensionConditionsProjectCondition {
        /**
         * Project name list, in array format. Separate multiple values with commas.
         */
        projects?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface RuleDimensionConditionsTagCondition {
        /**
         * Condition. and: All conditions met. or: Any condition met.
         */
        condition?: pulumi.Input<string>;
        tags?: pulumi.Input<pulumi.Input<inputs.cloudmonitor.RuleDimensionConditionsTagConditionTag>[]>;
    }
    interface RuleDimensionConditionsTagConditionTag {
        /**
         * Tag match operator. contain: Contains not*contain: Does not contain prefix*match: Prefix match suffix*match: Suffix match equal: Equals not*equal: Does not equal exist: Exists.
         */
        comparator?: pulumi.Input<string>;
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value (Value). When Comparator is exist, includes all Values corresponding to the Key and does not support input. When Comparator is equal or not*equal, supports multiple Value inputs. When Comparator is contain, not*contain, prefix*match, or suffix*match, only one Value can be entered.
         */
        values?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface RuleLevelCondition {
        conditions?: pulumi.Input<pulumi.Input<inputs.cloudmonitor.RuleLevelConditionCondition>[]>;
        /**
         * Alert notification level. Options: notice: notification, warning: warning, critical: critical, recovery: recovery.
         */
        level?: pulumi.Input<string>;
    }
    interface RuleLevelConditionCondition {
        /**
         * Comparison operators. Supports standard threshold alerting: >, >=, <, <=, !=, =, as well as the following period-over-period alerting: last*period*increase*pct: Increased compared to last period. last*period*decrease*pct: Decreased compared to last period. last*period*abs*pct: Increased or decreased compared to last period. last*day*increase*pct: Increased compared to the same period yesterday. last*day*decrease*pct: Decreased compared to the same period yesterday. last*day*abs*pct: Increased or decreased compared to the same period yesterday. last*week*increase*pct: Increased compared to the same period last week. last*week*decrease*pct: Decreased compared to the same period last week. last*week*abs_pct: Increased or decreased compared to the same period last week.
         */
        comparisonOperator?: pulumi.Input<string>;
        /**
         * Metric display name.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Monitoring metric name. For details, see MetricName for each product in Cloud Monitoring Metric Query.
         */
        metricName?: pulumi.Input<string>;
        /**
         * Unit of the monitoring metric. For details, see MetricUnit for each product in Cloud Monitoring Metric Query. For period-over-period alerting, MetricUnit must be set to "Percent." Whether IEC is included in MetricUnit indicates different base values: With IEC: base is 1024; Without IEC: base is 1000.
         */
        metricUnit?: pulumi.Input<string>;
        /**
         * Statistical period for monitoring metrics. For details, see Period for each product in Cloud Monitoring Metric Query.
         */
        period?: pulumi.Input<string>;
        /**
         * Statistical method. Options: avg: average, max: maximum, min: minimum. The statistical method is applied to data within the detection time period. For example, the default detection time span is 1 minute. If the statistical method is avg, the average value of data within 1 minute is used.
         */
        statistics?: pulumi.Input<string>;
        /**
         * Metric threshold. Supports positive numbers or 0. Up to three decimal places allowed.
         */
        threshold?: pulumi.Input<string>;
    }
    interface RuleNoData {
        /**
         * Enable no data alert. Values: true: enable no data alert. false (default): disable no data alert.
         */
        enable?: pulumi.Input<boolean>;
        /**
         * No data alert trigger threshold. If no data is reported within the configured threshold period, a no data alert will be triggered. When Enable is set to true, this field is required. Integer format; value range is 3–20.
         */
        evaluationCount?: pulumi.Input<number>;
    }
    interface RuleNotifyTemplate {
        /**
         * Notification channel. Options: email: Email sms: SMS phone: Phone feishu: Feishu dingtalk: DingTalk wecom: WeCom slack: Slack api: Callback URL.
         */
        channel?: pulumi.Input<string>;
        /**
         * Notification template ID. Note: Each notification channel supports only one notification template ID.
         */
        notifyTemplateId?: pulumi.Input<string>;
    }
    interface RuleOriginalDimensions {
        /**
         * Metric Dimension name, such as ResourceID, NodeName, etc. Dimension names vary by cloud product. For details, see Cloud Monitoring Metric Query. ResourceID is required, and its capitalization must match Cloud Monitoring Metric Query. Supports multiple Dimension names and grouping by multiple Dimension names. For example: If you only enter ResourceID, the system groups alerts by ResourceID. If you enter both ResourceID and NodeName, the system first groups alerts by ResourceID, then groups within each ResourceID group by NodeName.
         */
        key?: pulumi.Input<string>;
        /**
         * Metric Dimension values, in array format. Separate multiple values with commas. Wildcard * can be used to select all instance values. For example: ["*"] .
         */
        values?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface RuleRecoveryNotify {
        /**
         * Enable alert recovery notification. Options: true: (default) enable alert recovery notification, false: disable alert recovery notification.
         */
        enable?: pulumi.Input<boolean>;
    }
    interface RuleTag {
        /**
         * Tag key. Supports Chinese, uppercase and lowercase English letters, numbers, and spaces. The following special characters are supported: _ . : / = +   - @. Cannot start or end with a space. volc: and /sys: are system-reserved tag keys. When adding a tag, the tag key cannot start with any case form of volc: or /sys:. Tag key length must be 1–128 characters.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value. Supports Chinese, uppercase and lowercase English letters, numbers, and spaces. The following special characters are supported: _ . : / = +   - @. Cannot start or end with a space. Tag key length must be 0–255 characters.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace config {
}
export declare namespace cr {
    interface RegistryEndpoint {
        aclPolicies?: pulumi.Input<pulumi.Input<inputs.cr.RegistryEndpointAclPolicy>[]>;
        /**
         * Whether to enable the public endpoint. Options: false: not enabled; true: enabled. Default is false
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Current status of the public endpoint. Parameter values: Enabling: enabling; Enabled: enabled; Disabling: disabling; Updating: updating; Failed: failed; Disabled: disabled
         */
        status?: pulumi.Input<string>;
    }
    interface RegistryEndpointAclPolicy {
        /**
         * IP entry address
         */
        description?: pulumi.Input<string>;
        /**
         * IP entry description
         */
        entry?: pulumi.Input<string>;
    }
    interface RegistryProxyCache {
        /**
         * Instance types supported by ProxyCache. Parameter value description: DockerHub: DockerHub image repository.
         */
        type?: pulumi.Input<string>;
    }
    interface RegistryStatus {
        /**
         * Creating, [ Progressing ]: Creating. Running, [ Ok ]: Running. Running, [ Degraded ]: Running. Stopped, [ Balance ]: Suspended due to overdue payment. Stopped, [ Released ]: Pending recycle. Stopped, [ Released, Balance ]: Suspended due to overdue payment. Starting, [ Progressing ]: Starting. Deleting, [ Progressing ]: Deleting. Failed, [ Unknown ]: Error.
         */
        conditions?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Creating, [ Progressing ]: Creating. Running, [ Ok ]: Running. Running, [ Degraded ]: Running. Stopped, [ Balance ]: Suspended due to overdue payment. Stopped, [ Released ]: Pending recycle. Stopped, [ Released, Balance ]: Suspended due to overdue payment. Starting, [ Progressing ]: Starting. Deleting, [ Progressing ]: Deleting. Failed, [ Unknown ]: Error.
         */
        phase?: pulumi.Input<string>;
    }
    interface RegistryTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * List of tag values
         */
        value?: pulumi.Input<string>;
    }
    interface VpcEndpointVpc {
        /**
         * Primary account ID for the VPC
         */
        accountId?: pulumi.Input<number>;
        /**
         * Subnet ID
         */
        subnetId?: pulumi.Input<string>;
        /**
         * VPC ID。
         */
        vpcId?: pulumi.Input<string>;
    }
}
export declare namespace directconnect {
    interface DirectConnectGatewayAssociateCen {
        /**
         * ID of CEN.
         */
        cenId?: pulumi.Input<string>;
        /**
         * User ID of CEN.
         */
        cenOwnerId?: pulumi.Input<string>;
        /**
         * Status of the instance in CEN. Attaching: attaching. Attached: attached.
         */
        cenStatus?: pulumi.Input<string>;
    }
    interface DirectConnectGatewayAssociateEic {
        /**
         * ID of EIC.
         */
        eicId?: pulumi.Input<string>;
        /**
         * User ID of EIC.
         */
        eicOwnerId?: pulumi.Input<string>;
        /**
         * Status of the instance in EIC.
         */
        eicStatus?: pulumi.Input<string>;
    }
    interface DirectConnectGatewayTag {
        /**
         * User label tag key. Length must be between 1 and 128 characters.
         */
        key?: pulumi.Input<string>;
        /**
         * User label tag value. Length must be between 0 and 256 characters.
         */
        value?: pulumi.Input<string>;
    }
    interface VirtualInterfaceTag {
        /**
         * Tag key (Key) of the virtual interface tag. Parameter   - N   - indicates the sequence number of the tag key (Key), with a range of 1, 2, 3, …, 49, 50. N must be in continuous ascending order. Multiple tag keys (Key) are separated by &. Cannot start with sys: in any case. sys: is reserved for system tags and cannot be created. Length range: 1–128 characters. Supports input in any language, numbers, spaces (), underscores (_), periods (.), colons (:), slashes (/), equal signs (=), plus signs (+), hyphens (-), and at signs (@).
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value (Value) of the virtual interface tag. Parameter   - N   - indicates the sequence number of the tag value (Value), with a range of 1, 2, 3, …, 49, 50. N must be in continuous ascending order. Multiple tag values (Value) are separated by &. Length range: 0–256 characters. If not specified, the default is empty. Supports input in any language, numbers, spaces (), underscores (_), periods (.), colons (:), slashes (/), equal signs (=), plus signs (+), hyphens (-), and at signs (@). Case sensitive. Cannot start or end with a space. Note: If Tags.N.Value is provided, Tags.N.Key must also be provided.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace dns {
    interface ZoneTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace ecs {
    interface CommandParameterDefinition {
        /**
         * Allowed decimal places for custom parameter (number).
         */
        decimalPrecision?: pulumi.Input<number>;
        /**
         * Default value for custom parameter.
         */
        defaultValue?: pulumi.Input<string>;
        /**
         * Maximum length for custom parameter (string).
         */
        maxLength?: pulumi.Input<number>;
        /**
         * Maximum value for custom parameter (number).
         */
        maxValue?: pulumi.Input<string>;
        /**
         * Minimum length for custom parameter (string).
         */
        minLength?: pulumi.Input<number>;
        /**
         * Minimum value for custom parameter (number).
         */
        minValue?: pulumi.Input<string>;
        /**
         * Custom parameter name. Define it in the script using {{Param}}. Each parameter name must not exceed 64 bytes. Follow Shell variable naming rules: combinations of a-z, A-Z, 0-9, -, and _. The first character cannot be a digit. No spaces allowed; underscores can be used instead.
         */
        name?: pulumi.Input<string>;
        /**
         * Whether it is required.
         */
        required?: pulumi.Input<boolean>;
        /**
         * Custom parameter type. Values: String: Indicates the custom parameter type is String (string type). Digit: Indicates the custom parameter type is Digit (numeric type).
         */
        type?: pulumi.Input<string>;
    }
    interface CommandTag {
        /**
         * User tag key. Naming rules: must not start with any case combination of volc: or sys:. Only language characters, digits, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Length must be between 1 and 128 characters.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value. Naming rules: only language characters, digits, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Can be empty. Length must be between 0 and 256 characters.
         */
        value?: pulumi.Input<string>;
    }
    interface DeploymentSetCapacity {
        /**
         * You can also include the number of ECS instances in the current deployment set within this availability zone.
         */
        availableCount?: pulumi.Input<number>;
        /**
         * Number of ECS instances in the deployment set that belong to this availability zone.
         */
        usedCount?: pulumi.Input<number>;
        /**
         * Availability zone ID. Only returns the availability zone ID for ECS instances in the deployment set.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface HpcClusterTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface ImageDetectionResults {
        /**
         * Check status. Options: Finished (completed), Processing (in progress).
         */
        detectionStatus?: pulumi.Input<string>;
        items?: pulumi.Input<pulumi.Input<inputs.ecs.ImageDetectionResultsItem>[]>;
    }
    interface ImageDetectionResultsItem {
        /**
         * Check item name
         */
        name?: pulumi.Input<string>;
        /**
         * Result for this check item.
         */
        result?: pulumi.Input<string>;
        /**
         * Risk description code
         */
        riskCode?: pulumi.Input<string>;
        /**
         * Risk level. If this parameter is empty, it means no risk
         */
        riskLevel?: pulumi.Input<string>;
    }
    interface ImageImportImage {
        /**
         * Data disk files included in the custom image, at the TOS bucket URL.
         */
        importDataVolumes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * System disk files included in the custom image, at the TOS bucket URL.
         */
        url?: pulumi.Input<string>;
    }
    interface ImageSnapshot {
        /**
         * Snapshot size (GiB)
         */
        size?: pulumi.Input<number>;
        /**
         * Snapshot ID
         */
        snapshotId?: pulumi.Input<string>;
        /**
         * Cloud disk type. system: System disk. data: Data disk.
         */
        volumeKind?: pulumi.Input<string>;
    }
    interface ImageTag {
        /**
         * Tag key for the image label.
         */
        key?: pulumi.Input<string>;
        /**
         * Image tag value
         */
        value?: pulumi.Input<string>;
    }
    interface InstanceCpuMemory {
        /**
         * Number of instance cores.
         */
        coreCount?: pulumi.Input<number>;
        /**
         * Number of vCPUs for the instance.
         */
        cpuNumber?: pulumi.Input<number>;
        /**
         * Instance memory size (MB).
         */
        memorySize?: pulumi.Input<number>;
        /**
         * Threads per core for the instance.
         */
        threadsPerCore?: pulumi.Input<number>;
    }
    interface InstanceEipAddress {
        /**
         * Instance allocation ID
         */
        allocationId?: pulumi.Input<string>;
        /**
         * Maximum bandwidth for public IP. Default value is 1, unit: Mbps.
         *     - If `ChargeType` is `PayByBandwidth`: value range is 1–500.
         *     - If `ChargeType` is `PayByTraffic`: value range is 1–200.
         */
        bandwidthMbps?: pulumi.Input<number>;
        /**
         * Shared bandwidth package ID, used to add a public IP to the shared bandwidth package.
         *     - You can call the [DescribeBandwidthPackages](https://www.volcengine.com/docs/6623/100685) API to query the shared bandwidth package ID.
         *     - To add a public IP to a shared bandwidth package, all of the following conditions must be met:
         *       - Both must have the same security protection type.
         *       - Both must be in the same region.
         *       - The public IP must use pay-as-you-go billing.
         *       - The shared bandwidth package must be IPv4 type.
         */
        bandwidthPackageId?: pulumi.Input<string>;
        /**
         * Public IP billing method. Values:
         *     - PayByBandwidth (default): Pay-as-you-go—billed by bandwidth cap.
         *     - PayByTraffic: Pay-as-you-go—billed by actual traffic.
         *     - PrePaid: Subscription.
         *
         *   **Note:**
         *   When `InstanceChargeType` is set to `PostPaid`, this parameter cannot be set to `PrePaid`.
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Instance IP address.
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Line type for the public IP. Default is BGP. Values:
         *     - BGP: BGP (multi-line)
         *     - If your account has applied for and enabled static single-line permissions, you can use the following values:
         *       - ChinaMobile: China Mobile static single-line
         *       - ChinaTelecom: China Telecom static single-line
         *       - ChinaUnicom: China Unicom static single-line
         *     - If your account has applied for and enabled BGP single-line permissions, you can use SingleLine_BGP.
         *     - If your account has applied for and enabled static BGP permissions, you can use Static_BGP
         */
        isp?: pulumi.Input<string>;
        /**
         * Whether this resource is released when the instance is released.
         */
        releaseWithInstance?: pulumi.Input<boolean>;
        /**
         * DDoS Native Protection (Enterprise Edition) ID.
         */
        securityProtectionInstanceId?: pulumi.Input<number>;
        /**
         * Public IP security protection type.
         */
        securityProtectionTypes?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface InstanceImage {
        /**
         * Instance image ID.
         */
        imageId: pulumi.Input<string>;
        /**
         * The image release version of the instance.
         */
        imageReleaseVersion?: pulumi.Input<string>;
        /**
         * Whether the instance retains image credentials
         */
        keepImageCredential?: pulumi.Input<boolean>;
        /**
         * Instance security enhancement policy. Active: Enable security hardening, applies only to public images. InActive: Disable security hardening, applies to all images
         */
        securityEnhancementStrategy?: pulumi.Input<string>;
    }
    interface InstanceKeyPair {
        /**
         * Instance public key
         */
        keyPairId?: pulumi.Input<string>;
        /**
         * Instance key pair name
         */
        keyPairName?: pulumi.Input<string>;
    }
    interface InstanceLocalVolume {
        /**
         * The number of local disks attached to the instance.
         */
        count?: pulumi.Input<number>;
        /**
         * Capacity of each local disk mounted to the instance (GiB).
         */
        size?: pulumi.Input<number>;
        /**
         * Local disk type. Values: LOCAL_SSD: SSD local disk. LOCAL_HDD: HDD local disk.
         */
        volumeType?: pulumi.Input<string>;
    }
    interface InstanceOperationSystem {
        /**
         * Instance operating system name.
         */
        name?: pulumi.Input<string>;
        /**
         * Operating system type of the instance. Linux: Linux system. Windows: Windows system.
         */
        type?: pulumi.Input<string>;
    }
    interface InstancePlacement {
        /**
         * For ECS instances in economy stop mode, some resources are released after stopping. This parameter indicates whether the ECS instance will remain deployed on the original host when restarted. Values: Host: When restarting an instance in economy stop mode, it will remain on the original host. Default: When restarting an instance in economy stop mode, it will preferentially migrate to a host that supports automatic deployment; if resources are insufficient, it will start on the original host.
         */
        affinity?: pulumi.Input<string>;
        /**
         * Instance dedicated host cluster ID.
         */
        dedicatedHostClusterId?: pulumi.Input<string>;
        /**
         * Dedicated host ID for the instance.
         */
        dedicatedHostId?: pulumi.Input<string>;
        /**
         * Whether to create the instance on a dedicated host. Values: Default: Create a regular cloud server instance. Host: Create a dedicated host instance. If you do not specify DedicatedHostId, the system automatically selects a dedicated host to place the instance.
         */
        tenancy?: pulumi.Input<string>;
    }
    interface InstancePrimaryNetworkInterface {
        /**
         * The number of IPv6 addresses for the instance.
         */
        ipv6AddressCount?: pulumi.Input<number>;
        /**
         * IPv6 address of the instance.
         */
        ipv6Addresses?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance MAC address.
         */
        macAddress?: pulumi.Input<string>;
        /**
         * The network interface ID of the instance.
         */
        networkInterfaceId?: pulumi.Input<string>;
        /**
         * Instance primary IP address
         */
        primaryIpAddress?: pulumi.Input<string>;
        /**
         * Instance private IP address.
         */
        privateIpAddresses?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance security group ID
         */
        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance subnet ID.
         */
        subnetId?: pulumi.Input<string>;
        /**
         * VPC ID of the instance.
         */
        vpcId?: pulumi.Input<string>;
    }
    interface InstanceRdmaNetworkInterfaceDetail {
        /**
         * Gateway address.
         */
        gateway?: pulumi.Input<string>;
        /**
         * IP address
         */
        ip?: pulumi.Input<string>;
        /**
         * Subnet mask.
         */
        mask?: pulumi.Input<string>;
        /**
         * Switch name.
         */
        switchName?: pulumi.Input<string>;
        /**
         * Switch port.
         */
        switchPort?: pulumi.Input<string>;
    }
    interface InstanceRenewInfo {
        /**
         * Number of months for renewal. Valid values: 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 24, 36.
         */
        period?: pulumi.Input<number>;
        /**
         * Time unit for renewal duration, i.e., the unit for the Period parameter. Value: Month (default)
         */
        periodUnit?: pulumi.Input<string>;
    }
    interface InstanceSecondaryNetworkInterface {
        /**
         * The number of IPv6 addresses for the instance.
         */
        ipv6AddressCount?: pulumi.Input<number>;
        /**
         * IPv6 address of the instance.
         */
        ipv6Addresses?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance MAC address.
         */
        macAddress?: pulumi.Input<string>;
        /**
         * The network interface ID of the instance.
         */
        networkInterfaceId?: pulumi.Input<string>;
        /**
         * Instance primary IP address
         */
        primaryIpAddress?: pulumi.Input<string>;
        /**
         * Instance private IP address.
         */
        privateIpAddresses?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance security group ID
         */
        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance subnet ID.
         */
        subnetId?: pulumi.Input<string>;
        /**
         * VPC ID of the instance.
         */
        vpcId?: pulumi.Input<string>;
    }
    interface InstanceSystemVolume {
        /**
         * Whether the attached resources are deleted along with the instance.
         */
        deleteWithInstance?: pulumi.Input<boolean>;
        /**
         * Additional performance IOPS for the instance
         */
        extraPerformanceIops?: pulumi.Input<number>;
        /**
         * The additional performance throughput of the instance, in MB.
         */
        extraPerformanceThroughputMb?: pulumi.Input<number>;
        /**
         * Type of additional performance. Values:
         *   Balance: Balanced additional performance
         *   IOPS: IOPS additional performance
         *   Throughput: Throughput additional performance
         */
        extraPerformanceTypeId?: pulumi.Input<string>;
        /**
         * Instance size, in GiB
         */
        size?: pulumi.Input<number>;
        /**
         * Instance snapshot ID
         */
        snapshotId?: pulumi.Input<string>;
        /**
         * Instance volume ID.
         */
        volumeId?: pulumi.Input<string>;
        /**
         * Cloud disk type. Values:
         *   PTSSD: Performance SSD.
         *   ESSD_PL0: Ultra SSD disk, PL0 specification.
         *   ESSD_FlexPL: Ultra SSD disk, FlexPL specification.
         *   TSSD_TL0: Throughput SSD disk.
         */
        volumeType?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * Instance key.
         */
        key?: pulumi.Input<string>;
        /**
         * Instance value.
         */
        value?: pulumi.Input<string>;
    }
    interface InvocationInvocationResult {
        /**
         * Command ID.
         */
        commandId?: pulumi.Input<string>;
        /**
         * Command execution completion time.
         */
        endTime?: pulumi.Input<string>;
        /**
         * Error codes for command execution failure. TaskDeliveryTimeout: Indicates command delivery timeout. TaskExecutionTimeout: Indicates command execution timeout. TaskExecutionFailed: Indicates command execution failure.
         */
        errorCode?: pulumi.Input<string>;
        /**
         * Error message for command execution failure.
         */
        errorMessage?: pulumi.Input<string>;
        /**
         * Exit status code after script execution.
         */
        exitCode?: pulumi.Input<number>;
        /**
         * Instance ID.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Task execution ID.
         */
        invocationId?: pulumi.Input<string>;
        /**
         * Task execution result ID.
         */
        invocationResultId?: pulumi.Input<string>;
        /**
         * Command progress status for a single instance.
         */
        invocationResultStatus?: pulumi.Input<string>;
        /**
         * Output information after command execution, encoded in Base64.
         */
        output?: pulumi.Input<string>;
        /**
         * Time when the command starts executing in the instance.
         */
        startTime?: pulumi.Input<string>;
        /**
         * User name for executing the command in the instance.
         */
        username?: pulumi.Input<string>;
    }
    interface InvocationParameterDefinition {
        /**
         * Allowed number of decimal places for custom parameter values (numeric).
         */
        decimalPrecision?: pulumi.Input<number>;
        /**
         * Default value for custom parameter.
         */
        defaultValue?: pulumi.Input<string>;
        /**
         * Maximum length for custom parameter value (string).
         */
        maxLength?: pulumi.Input<number>;
        /**
         * Maximum value for custom parameter (numeric).
         */
        maxValue?: pulumi.Input<string>;
        /**
         * Minimum length for custom parameter values (string).
         */
        minLength?: pulumi.Input<number>;
        /**
         * Minimum value for custom parameter (numeric).
         */
        minValue?: pulumi.Input<string>;
        /**
         * Custom parameter name. Must be defined in the script using {{Param}}.
         */
        name?: pulumi.Input<string>;
        /**
         * Required. true: Required. false: Optional.
         */
        required?: pulumi.Input<boolean>;
        /**
         * Custom parameter type. String: Indicates custom parameter type is string. Digit: Indicates custom parameter type is numeric.
         */
        type?: pulumi.Input<string>;
    }
    interface InvocationTag {
        /**
         * Tag key for user tags. Naming rules: Cannot start with any combination of 'volc:' or 'sys:' in any case. Can only contain letters, numbers, spaces, and English symbols '_', '.', ':', '/', '=', '+', '-', '@'. Length must be between 1 and 128 characters.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value. Naming rules: Only letters, numbers, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Can be empty; length must be between 0 and 256 characters.
         */
        value?: pulumi.Input<string>;
    }
    interface KeypairTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface LaunchTemplateLaunchTemplateTag {
        /**
         * Tag key for user tags added to the resource.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value added to the resource
         */
        value?: pulumi.Input<string>;
    }
    interface LaunchTemplateLaunchTemplateVersion {
        /**
         * When the ECS instance needs to join or adjust the deployment set strategy to the deployment set group high availability strategy (AvailabilityGroup), you can use this parameter to specify the group number of the instance in the deployment set.
         */
        deploymentSetGroupNumber?: pulumi.Input<number>;
        /**
         * Deployment set ID the instance needs to join.
         */
        deploymentSetId?: pulumi.Input<string>;
        /**
         * Instance description
         */
        description?: pulumi.Input<string>;
        /**
         * Public IP information bound to the instance
         */
        eip?: pulumi.Input<inputs.ecs.LaunchTemplateLaunchTemplateVersionEip>;
        /**
         * Instance hostname. For Linux, the hostname length must be 2–59 characters. For Windows, the hostname length must be 2–10 characters.
         */
        hostName?: pulumi.Input<string>;
        /**
         * When creating a high-performance computing GPU instance, please specify the high-performance computing cluster ID.
         */
        hpcClusterId?: pulumi.Input<string>;
        /**
         * Image ID.
         */
        imageId?: pulumi.Input<string>;
        /**
         * Image name.
         */
        imageName?: pulumi.Input<string>;
        /**
         * Billing type for the instance and cloud disk. Options: PostPaid: Pay-as-you-go. PrePaid: Yearly/monthly subscription. Esi: Elastic reservation instance. Segmented: Time-based elastic reservation instance.
         */
        instanceChargeType?: pulumi.Input<string>;
        /**
         * Instance name.
         */
        instanceName?: pulumi.Input<string>;
        /**
         * Instance specification
         */
        instanceTypeId?: pulumi.Input<string>;
        /**
         * Whether to retain image settings. Values: true: Retain image settings. If retained, the instance will use the preset password or key pair from the image for login. false (default): Do not retain image settings.
         */
        keepImageCredential?: pulumi.Input<boolean>;
        /**
         * Key pair bound to the instance.
         */
        keyPairName?: pulumi.Input<string>;
        networkInterfaces?: pulumi.Input<pulumi.Input<inputs.ecs.LaunchTemplateLaunchTemplateVersionNetworkInterface>[]>;
        /**
         * Project associated with the instance.
         */
        projectName?: pulumi.Input<string>;
        /**
         * Elastic reservation order information
         */
        scheduledInstance?: pulumi.Input<inputs.ecs.LaunchTemplateLaunchTemplateVersionScheduledInstance>;
        /**
         * Enable security hardening. Active: Enable security hardening, applies only to public images. InActive: Disable security hardening, applies to all images.
         */
        securityEnhancementStrategy?: pulumi.Input<string>;
        /**
         * Maximum hourly price for preemptible instances
         */
        spotPriceLimit?: pulumi.Input<number>;
        /**
         * Preemptible strategy for pay-as-you-go billing. Options: NoSpot: Create a regular pay-as-you-go instance. SpotAsPriceGo: System automatically bids, follows the current market price for preemptible instances. SpotWithPriceLimit: Preemptible instance with a bid limit.
         */
        spotStrategy?: pulumi.Input<string>;
        /**
         * Starting number for the sequential suffix
         */
        suffixIndex?: pulumi.Input<number>;
        tags?: pulumi.Input<pulumi.Input<inputs.ecs.LaunchTemplateLaunchTemplateVersionTag>[]>;
        /**
         * Indicates whether to automatically add sequential suffixes to Hostname and InstanceName when creating multiple instances
         */
        uniqueSuffix?: pulumi.Input<boolean>;
        /**
         * Custom data for the instance.
         */
        userData?: pulumi.Input<string>;
        /**
         * Template version description.
         */
        versionDescription?: pulumi.Input<string>;
        volumes?: pulumi.Input<pulumi.Input<inputs.ecs.LaunchTemplateLaunchTemplateVersionVolume>[]>;
        /**
         * Private network ID.
         */
        vpcId?: pulumi.Input<string>;
        /**
         * Instance availability zone ID
         */
        zoneId?: pulumi.Input<string>;
    }
    interface LaunchTemplateLaunchTemplateVersionEip {
        /**
         * Public IP bandwidth cap, unit: Mbps. Value range: 1–200. Default: 1.
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Shared bandwidth package ID, indicates adding the public IP to the shared bandwidth package.
         */
        bandwidthPackageId?: pulumi.Input<string>;
        /**
         * Billing method for public IP. Values: 2: Pay-as-you-go—by bandwidth cap. 3: Pay-as-you-go—by actual traffic.
         */
        billingType?: pulumi.Input<number>;
        /**
         * Line type for the public IP. Options: BGP: BGP (multi-line). ChinaMobile: China Mobile static single line. ChinaTelecom: China Telecom static single line. ChinaUnicom: China Unicom static single line.
         */
        isp?: pulumi.Input<string>;
        /**
         * Whether the public IP is released with the instance; only applies to pay-as-you-go public IPs
         */
        releaseWithInstance?: pulumi.Input<boolean>;
        /**
         * Security protection package ID
         */
        securityProtectionInstanceId?: pulumi.Input<number>;
        /**
         * Security protection type for public IP. Value: AntiDDoS_Enhanced: Apply for a public IP with enhanced protection, which can be added to a DDoS Native Protection (Enterprise Edition) instance.
         */
        securityProtectionTypes?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface LaunchTemplateLaunchTemplateVersionNetworkInterface {
        /**
         * Security group ID associated with the network interface.
         */
        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance VPC subnet ID
         */
        subnetId?: pulumi.Input<string>;
    }
    interface LaunchTemplateLaunchTemplateVersionScheduledInstance {
        /**
         * Description of the elastic reservation order
         */
        scheduledInstanceDescription?: pulumi.Input<string>;
        /**
         * Name of the elastic reservation order
         */
        scheduledInstanceName?: pulumi.Input<string>;
    }
    interface LaunchTemplateLaunchTemplateVersionTag {
        /**
         * Tag key for user tags added to the resource.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value added to the resource
         */
        value?: pulumi.Input<string>;
    }
    interface LaunchTemplateLaunchTemplateVersionVolume {
        /**
         * Whether the cloud disk is released with the instance
         */
        deleteWithInstance?: pulumi.Input<boolean>;
        /**
         * Cloud disk extra IOPS performance size, supported only by ESSD FlexPL data disks, unit: operations/second. This parameter must be set when ExtraPerformanceTypeId is Balance or IOPS. The value ranges for each extra performance type are as follows: IOPS type: 1–50000. Balance type: 1–50000.
         */
        extraPerformanceIops?: pulumi.Input<number>;
        /**
         * Extra throughput performance size for the cloud disk, in MB/s. Only supported by ESSD FlexPL data disks. This parameter must be set when ExtraPerformanceTypeId is Throughput. Value range: 1–650.
         */
        extraPerformanceThroughputMb?: pulumi.Input<number>;
        /**
         * Type of cloud disk extra performance, supported only by ESSD FlexPL data disks. For more information about extra performance, see Cloud Disk Extra Performance. Values: Balance: Balanced extra performance. IOPS: IOPS extra performance. Throughput: Throughput extra performance.
         */
        extraPerformanceTypeId?: pulumi.Input<string>;
        /**
         * Cloud disk size, unit: GB. System disk: ESSD*PL0: 20–2048, PTSSD: 10–500. Data disk: ESSD*PL0: 10–32768, PTSSD: 20–8192
         */
        size?: pulumi.Input<number>;
        /**
         * Create a cloud disk using a snapshot, only supports creating data disks. You can call the DescribeSnapshots API to query the snapshot ID.
         */
        snapshotId?: pulumi.Input<string>;
        /**
         * Cloud disk type. ESSD_PL0: Ultra-fast SSD PL0. PTSSD: Performance SSD.
         */
        volumeType?: pulumi.Input<string>;
    }
    interface LaunchTemplateVersionEip {
        /**
         * Maximum bandwidth for the public IP, measured in Mbps. Value range: 1–200. Default: 1
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Shared bandwidth package ID, indicating that the public IP is added to the shared bandwidth package
         */
        bandwidthPackageId?: pulumi.Input<string>;
        /**
         * Billing method for the public IP. Values: 2: Pay-as-you-go by bandwidth cap. 3: Pay-as-you-go by actual traffic
         */
        billingType?: pulumi.Input<number>;
        /**
         * Line type of the public IP. Values: BGP: BGP (multi-line). ChinaMobile: China Mobile static single line. ChinaTelecom: China Telecom static single line. ChinaUnicom: China Unicom static single line
         */
        isp?: pulumi.Input<string>;
        /**
         * Whether the public IP is released with the instance. Only applies to pay-as-you-go public IPs.
         */
        releaseWithInstance?: pulumi.Input<boolean>;
        /**
         * Security protection package ID.
         */
        securityProtectionInstanceId?: pulumi.Input<number>;
        /**
         * Security protection type for public IP. Value: AntiDDoS_Enhanced: Apply for a public IP with enhanced protection, which can be added to a DDoS native protection (Enterprise Edition) instance.
         */
        securityProtectionTypes?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface LaunchTemplateVersionNetworkInterface {
        /**
         * Security group ID associated with the network interface.
         */
        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Private network subnet ID of the instance.
         */
        subnetId?: pulumi.Input<string>;
    }
    interface LaunchTemplateVersionScheduledInstance {
        /**
         * Description of the elastic reservation order
         */
        scheduledInstanceDescription?: pulumi.Input<string>;
        /**
         * Name of the elastic reservation order
         */
        scheduledInstanceName?: pulumi.Input<string>;
    }
    interface LaunchTemplateVersionTag {
        /**
         * Tag key for user tags added to the resource.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for user tags added to the resource
         */
        value?: pulumi.Input<string>;
    }
    interface LaunchTemplateVersionVolume {
        /**
         * Whether the disk is released with the instance
         */
        deleteWithInstance?: pulumi.Input<boolean>;
        /**
         * Extra IOPS performance size for the disk, supported only by ESSD FlexPL data disks, measured in operations per second. This parameter must be set when ExtraPerformanceTypeId is Balance or IOPS. Value ranges for each type: IOPS: 1–50000. Balance: 1–50000
         */
        extraPerformanceIops?: pulumi.Input<number>;
        /**
         * Additional disk throughput performance in MB/s. Supported only by ESSD FlexPL data disks. Set this parameter when ExtraPerformanceTypeId is Throughput. Value range: 1–650.
         */
        extraPerformanceThroughputMb?: pulumi.Input<number>;
        /**
         * Type of extra disk performance, supported only by ESSD FlexPL data disks. For more information about extra performance, see Extra Disk Performance. Values: Balance: Balanced extra performance. IOPS: IOPS extra performance. Throughput: Throughput extra performance
         */
        extraPerformanceTypeId?: pulumi.Input<string>;
        /**
         * Disk size, measured in GB. System disk: ESSD*PL0: 20–2048, PTSSD: 10–500. Data disk: ESSD*PL0: 10–32768, PTSSD: 20–8192
         */
        size?: pulumi.Input<number>;
        /**
         * Create a cloud disk from a snapshot. Only data disks are supported. You can call the DescribeSnapshots API to query the snapshot ID.
         */
        snapshotId?: pulumi.Input<string>;
        /**
         * Cloud disk type. ESSD_PL0: Ultra-fast SSD PL0. PTSSD: Performance SSD.
         */
        volumeType?: pulumi.Input<string>;
    }
}
export declare namespace efs {
    interface FileSystemChargeConfig {
        /**
         * Billing status. Value description: WaitingPaid: Waiting for payment, Pending: Creating, Modifying: Reconfiguring, Failed: Failed, Normal: Normal, Expired: Expired, Overdue: Overdue, Reclaimed: Reclaimed, Terminated: Unsubscribed.
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Billing type. Only supports PayAsYouGo, which means pay-as-you-go billing.
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Expiration time.
         */
        expireTime?: pulumi.Input<string>;
        /**
         * Recycle time.
         */
        reclaimTime?: pulumi.Input<string>;
        /**
         * Shutdown time.
         */
        stopTime?: pulumi.Input<string>;
    }
    interface FileSystemPerformance {
        /**
         * Bandwidth mode. Value description: Baseline: Baseline bandwidth mode, Provisioned: Provisioned bandwidth mode.
         */
        bandwidthMode: pulumi.Input<string>;
        /**
         * Baseline bandwidth.
         */
        baselineBandwidth?: pulumi.Input<number>;
        /**
         * Baseline IOPS.
         */
        baselineIops?: pulumi.Input<number>;
        /**
         * Burst bandwidth.
         */
        burstBandwidth?: pulumi.Input<number>;
        /**
         * Burst IOPS.
         */
        burstIops?: pulumi.Input<number>;
        /**
         * Provisioned bandwidth.
         */
        provisionedBandwidth?: pulumi.Input<number>;
        /**
         * Provisioned IOPS.
         */
        provisionedIops?: pulumi.Input<number>;
    }
    interface FileSystemStorage {
        /**
         * Capacity limit, in MiB.
         */
        capacityLimit?: pulumi.Input<number>;
        /**
         * Used capacity, in MiB.
         */
        capacityUsed?: pulumi.Input<number>;
        /**
         * File count limit.
         */
        inodeLimit?: pulumi.Input<number>;
        /**
         * Used file count.
         */
        inodeUsed?: pulumi.Input<number>;
    }
    interface FileSystemTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag type. Value description: System: System tag, Custom: Custom tag.
         */
        type?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace emr {
    interface ClusterApplication {
        /**
         * Application configuration path.
         */
        applicationConfigHome?: pulumi.Input<string>;
        /**
         * Application installation path.
         */
        applicationHome?: pulumi.Input<string>;
        /**
         * Application name.
         */
        applicationName?: pulumi.Input<string>;
        /**
         * Service status. NORMAL: normal; WARNING: alert; STOPPED: stopped; INIT: initializing; INSTALLING: installing; INSTALLED: installed; STARTING: starting; STARTED: started; STOPPING: stopping; UNINSTALLING: uninstalling; UNINSTALLED: uninstalled; EXCEPTION: exception.
         */
        applicationState?: pulumi.Input<string>;
        /**
         * Application version.
         */
        applicationVersion?: pulumi.Input<string>;
        /**
         * Application user group.
         */
        group?: pulumi.Input<string>;
        /**
         * Whether client is supported.
         */
        supportClient?: pulumi.Input<boolean>;
        /**
         * Application user.
         */
        user?: pulumi.Input<string>;
    }
    interface ClusterApplicationExtra {
        applicationComponentLayouts?: pulumi.Input<pulumi.Input<inputs.emr.ClusterApplicationExtraApplicationComponentLayout>[]>;
        applicationConfigs?: pulumi.Input<pulumi.Input<inputs.emr.ClusterApplicationExtraApplicationConfig>[]>;
        /**
         * Application name.
         */
        applicationName?: pulumi.Input<string>;
        /**
         * Metadata connection ID.
         */
        connectionId?: pulumi.Input<string>;
        /**
         * Metadata connection type. BUILT*IN*MYSQL: built-in database. EXTERNAL*MYSQL: external database. HIVE*METASTORE: HMS.
         */
        connectionType?: pulumi.Input<string>;
    }
    interface ClusterApplicationExtraApplicationComponentLayout {
        /**
         * Component name.
         */
        componentName?: pulumi.Input<string>;
        /**
         * Component layout scope.
         */
        effectiveScope?: pulumi.Input<inputs.emr.ClusterApplicationExtraApplicationComponentLayoutEffectiveScope>;
    }
    interface ClusterApplicationExtraApplicationComponentLayoutEffectiveScope {
        /**
         * Component name list. Required when EffectiveType=COMPONENT_NAME.
         */
        componentNames?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Effective type. CLUSTER, NODE*GROUP*NAME, NODE*GROUP*ID, NODE*GROUP*TYPE, NODE*NAME, NODE*ID, COMPONENT_NAME.
         */
        effectiveType?: pulumi.Input<string>;
        /**
         * Node group ID list. Required when EffectiveType=NODE*GROUP*ID.
         */
        nodeGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node group name list. Required when EffectiveType=NODE*GROUP*NAME.
         */
        nodeGroupNames?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node group type list. Required when EffectiveType=NODE*GROUP*TYPE. Currently includes MASTER, CORE, TASK.
         */
        nodeGroupTypes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node ID list. Required when EffectiveType=NODE_ID.
         */
        nodeIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node name list. Required when EffectiveType=NODE_NAME.
         */
        nodeNames?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ClusterApplicationExtraApplicationConfig {
        /**
         * Component instance name.
         */
        componentInstanceName?: pulumi.Input<string>;
        /**
         * Component name.
         */
        componentName?: pulumi.Input<string>;
        /**
         * Configuration file name.
         */
        configFileName?: pulumi.Input<string>;
        /**
         * Configuration item name.
         */
        configItemKey?: pulumi.Input<string>;
        /**
         * Configuration item value.
         */
        configItemValue?: pulumi.Input<string>;
        /**
         * Whether to delete.
         */
        deleted?: pulumi.Input<boolean>;
        /**
         * Affected component.
         */
        effectiveScope?: pulumi.Input<inputs.emr.ClusterApplicationExtraApplicationConfigEffectiveScope>;
    }
    interface ClusterApplicationExtraApplicationConfigEffectiveScope {
        /**
         * Component name list. Required when EffectiveType=COMPONENT_NAME.
         */
        componentNames?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Effective type. CLUSTER, NODE*GROUP*NAME, NODE*GROUP*ID, NODE*GROUP*TYPE, NODE*NAME, NODE*ID, COMPONENT_NAME.
         */
        effectiveType?: pulumi.Input<string>;
        /**
         * Node group ID list. Required when EffectiveType=NODE*GROUP*ID.
         */
        nodeGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node group name list. Required when EffectiveType=NODE*GROUP*NAME.
         */
        nodeGroupNames?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node group type list. Required when EffectiveType=NODE*GROUP*TYPE. Currently includes MASTER, CORE, TASK.
         */
        nodeGroupTypes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node ID list. Required when EffectiveType=NODE_ID.
         */
        nodeIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node name list. Required when EffectiveType=NODE_NAME.
         */
        nodeNames?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ClusterBootstrapScript {
        /**
         * Script execution scope.
         */
        effectiveScope?: pulumi.Input<inputs.emr.ClusterBootstrapScriptEffectiveScope>;
        /**
         * Execution failure policy. Range: FAILED*CONTINUE: Continue with other tasks after failure. FAILED*BLOCK: Stop and do not execute subsequent tasks after failure. If the script is BOOTSTRAP, this will interrupt and fail cluster creation or node group expansion. Default: FAILED_BLOCK.
         */
        executionFailStrategy?: pulumi.Input<string>;
        /**
         * Script execution timing. Only effective when scriptType=BOOTSTRAP. BEFORE*APPLICATION*INSTALL: before application installation. AFTER*APPLICATION*STARTED: after application startup. Default: BEFORE*APP*INSTALL.
         */
        executionMoment?: pulumi.Input<string>;
        /**
         * Script execution priority. Range: 1~1000. Default: 1.
         */
        priority?: pulumi.Input<string>;
        /**
         * Script parameters.
         */
        scriptArgs?: pulumi.Input<string>;
        /**
         * Script name (required). Length: 1–128 characters. Must start with an uppercase or lowercase letter or Chinese character. Cannot start with http: or https:. Can include Chinese, English, numbers, underscores (_), or hyphens (-).
         */
        scriptName?: pulumi.Input<string>;
        /**
         * Script TOS path. Required. Must start with 'tos:'.
         */
        scriptPath?: pulumi.Input<string>;
        /**
         * Script type. NORMAL: normal script. BOOTSTRAP: bootstrap script.
         */
        scriptType?: pulumi.Input<string>;
    }
    interface ClusterBootstrapScriptEffectiveScope {
        /**
         * Component name list. Required when EffectiveType=COMPONENT_NAME.
         */
        componentNames?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Effective type. CLUSTER, NODE*GROUP*NAME, NODE*GROUP*ID, NODE*GROUP*TYPE, NODE*NAME, NODE*ID, COMPONENT_NAME.
         */
        effectiveType?: pulumi.Input<string>;
        /**
         * Node group ID list. Required when EffectiveType=NODE*GROUP*ID.
         */
        nodeGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node group name list. Required when EffectiveType=NODE*GROUP*NAME.
         */
        nodeGroupNames?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node group type list. Required when EffectiveType=NODE*GROUP*TYPE. Currently includes MASTER, CORE, TASK.
         */
        nodeGroupTypes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node ID list. Required when EffectiveType=NODE_ID.
         */
        nodeIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node name list. Required when EffectiveType=NODE_NAME.
         */
        nodeNames?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ClusterChargePreConfig {
        /**
         * Enable auto-renewal. Options: true (enabled), false (disabled).
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Renewal duration when auto-renewal is triggered. When AutoRenew=true, the default value is 1.
         */
        autoRenewPeriod?: pulumi.Input<number>;
        /**
         * Renewal duration unit when auto-renewal is triggered. When AutoRenew=true, default is Month. Options: Month, Year.
         */
        autoRenewPeriodUnit?: pulumi.Input<string>;
        /**
         * When chargeType=PRE, default value=1. Unit for monthly subscription duration.
         */
        chargePeriod?: pulumi.Input<number>;
        /**
         * When chargeType=PRE, default value=Month. Unit for monthly subscription duration. Range: Month: month. Year: year.
         */
        chargePeriodUnit?: pulumi.Input<string>;
        /**
         * Payment type. Options: PRE, POST.
         */
        chargeType?: pulumi.Input<string>;
    }
    interface ClusterNodeAttribute {
        /**
         * ECS instance role.
         */
        ecsIamRole?: pulumi.Input<string>;
        /**
         * Zone ID.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface ClusterNodeGroupAttribute {
        /**
         * Public bandwidth. Default is 8M. If the user changes it later, EMR needs to synchronize this information.
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Node group billing type. If empty, reuses the cluster's chargeType. Master and Core groups must reuse the cluster-level billing type. When the cluster's chargeType is PRE, the task node group's chargeType can be set to POST. When the cluster's chargeType is POST, the node group's chargeType defaults to POST, and this parameter setting on the node group is invalid.
         */
        chargeType?: pulumi.Input<string>;
        dataDisks?: pulumi.Input<pulumi.Input<inputs.emr.ClusterNodeGroupAttributeDataDisk>[]>;
        /**
         * Node group's ECS instance type list. Only one instance type can be set. The list length is limited to 1.
         */
        ecsInstanceTypes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * ECS key pair name.
         */
        ecsKeyPairName?: pulumi.Input<string>;
        /**
         * Password for ECS root account.
         */
        ecsPassword?: pulumi.Input<string>;
        /**
         * Current expected number of nodes to purchase for the node group.
         */
        nodeCount?: pulumi.Input<number>;
        /**
         * Length: 1–128 characters. Cannot start with http: or https:. Can include Chinese, English, numbers, underscores (_), or hyphens (-).
         */
        nodeGroupName?: pulumi.Input<string>;
        /**
         * Node group type.
         */
        nodeGroupType?: pulumi.Input<string>;
        /**
         * Subnet ID list. Currently, only one parameter can be passed, and all node groups must use the same subnet ID.
         */
        subnetIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * System disk configuration.
         */
        systemDisk?: pulumi.Input<inputs.emr.ClusterNodeGroupAttributeSystemDisk>;
        /**
         * Whether to attach public IP.
         */
        withPublicIp?: pulumi.Input<boolean>;
        /**
         * Availability zone ID.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface ClusterNodeGroupAttributeDataDisk {
        /**
         * Number of disk blocks. Default is 4, maximum is 15, minimum is 1.
         */
        count?: pulumi.Input<number>;
        /**
         * Disk size. Default is 80GB, minimum is 60GB, maximum is 2048GB, unit: GB.
         */
        size?: pulumi.Input<number>;
        /**
         * Disk type. ESSD*PL0: Ultra SSD*PL0. ESSD*PL1: Ultra SSD*PL1. ESSD*PL2: Ultra SSD*PL2. ESSD*PL3: Ultra SSD*PL3. ESSD*FLEXPL: Ultra SSD*FlexPL. ULTRA*DISK: Efficient cloud disk. PTSSD: Performance SSD. SSD: General SSD. EHDD: Efficient cloud disk. ZENYA*SSD: Zenya. LOCAL*HDD: Big data HDD. LOCAL*SSD: Local SSD. LOCAL*SSD*SRIOV: Local SSD SRIOV.
         */
        volumeType?: pulumi.Input<string>;
    }
    interface ClusterNodeGroupAttributeSystemDisk {
        /**
         * Disk size.
         */
        size?: pulumi.Input<number>;
        /**
         * Disk type.
         */
        volumeType?: pulumi.Input<string>;
    }
    interface ClusterStateChangeReason {
        /**
         * Status update code.
         */
        code?: pulumi.Input<string>;
        /**
         * Status update reason.
         */
        reason?: pulumi.Input<string>;
    }
    interface ClusterTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface NodeGroupApplicationLayout {
        /**
         * Application name.
         */
        applicationName?: pulumi.Input<string>;
        /**
         * Custom configuration parameter list for the component.
         */
        layoutComponentNames?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface NodeGroupChargePreConfig {
        /**
         * Whether to enable auto-renewal.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Renewal duration when auto-renewal is triggered. When autoRenew=true, the default value is 1.
         */
        autoRenewPeriod?: pulumi.Input<number>;
        /**
         * Renewal duration unit when auto-renewal is triggered. When autoRenew=true, the default value is Month. Value range: Month: month. Year: year.
         */
        autoRenewPeriodUnit?: pulumi.Input<string>;
        /**
         * When chargeType=PRE, the default value is 1. The unit for the purchase duration when chargeType=PRE is monthly subscription.
         */
        chargePeriod?: pulumi.Input<number>;
        /**
         * When chargeType=PRE, the default value is Month. The unit for the purchase duration when chargeType=PRE is monthly subscription. Value range: Month (month), Year (year).
         */
        chargePeriodUnit?: pulumi.Input<string>;
        /**
         * Payment type. Enum values: POST, PRE.
         */
        chargeType?: pulumi.Input<string>;
    }
    interface NodeGroupDataDisk {
        /**
         * Number of disk blocks. Default value: 4. Maximum: 15. Minimum: 1.
         */
        count?: pulumi.Input<number>;
        /**
         * Disk size. Default value: 80GB. Minimum: 60GB. Maximum: 2048GB. Unit: GB.
         */
        size?: pulumi.Input<number>;
        /**
         * Disk type. ESSD*PL0: Ultra-fast SSD*PL0. ESSD*PL1: Ultra-fast SSD*PL1. ESSD*PL2: Ultra-fast SSD*PL2. ESSD*PL3: Ultra-fast SSD*PL3. ESSD*FLEXPL: Ultra-fast SSD*FlexPL. ULTRA*DISK: Efficient cloud disk. PTSSD: Performance SSD. SSD: General SSD. EHDD: Efficient cloud disk. ZENYA*SSD: Zenya. LOCAL*HDD: Big data HDD. LOCAL*SSD: Local SSD. LOCAL*SSD*SRIOV: Local SSD SRIOV.
         */
        volumeType?: pulumi.Input<string>;
    }
    interface NodeGroupNode {
        /**
         * Node creation time.
         */
        createdTime?: pulumi.Input<number>;
        /**
         * ecs instance specification.
         */
        ecsInstanceType?: pulumi.Input<string>;
        /**
         * Node FQDN.
         */
        nodeFqdn?: pulumi.Input<string>;
        /**
         * Node ID.
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node name.
         */
        nodeName?: pulumi.Input<string>;
        /**
         * Node status. UNKNOWN: Unknown. CREATING: Creating. RUNNING: Running. STOPPING: Stopping. STOPPED: Stopped. REBOOTING: Rebooting. DELETED: Deleted.
         */
        nodeState?: pulumi.Input<string>;
        /**
         * Private IP.
         */
        privateIp?: pulumi.Input<string>;
        /**
         * Public IP.
         */
        publicIp?: pulumi.Input<string>;
        /**
         * Ready time.
         */
        readyTime?: pulumi.Input<number>;
        /**
         * Cluster termination time.
         */
        terminateTime?: pulumi.Input<number>;
    }
    interface NodeGroupSystemDisk {
        /**
         * System disk size. Default value: 80GB. Minimum: 60GB. Maximum: 2048GB. Unit: GB.
         */
        size?: pulumi.Input<number>;
        /**
         * Disk type. ESSD*PL0: Ultra-fast SSD*PL0. ESSD*PL1: Ultra-fast SSD*PL1. ESSD*PL2: Ultra-fast SSD*PL2. ESSD*PL3: Ultra-fast SSD*PL3. ESSD*FLEXPL: Ultra-fast SSD*FlexPL. ULTRA*DISK: Efficient cloud disk. PTSSD: Performance SSD. SSD: General SSD. EHDD: Efficient cloud disk. ZENYA*SSD: Zenya. LOCAL*HDD: Big data HDD. LOCAL*SSD: Local SSD. LOCAL*SSD*SRIOV: Local SSD SRIOV.
         */
        volumeType?: pulumi.Input<string>;
    }
}
export declare namespace escloud {
    interface InstanceInstanceConfiguration {
        /**
         * Administrator password.
         */
        adminPassword?: pulumi.Input<string>;
        /**
         * Administrator username.
         */
        adminUserName?: pulumi.Input<string>;
        /**
         * Whether the subscription instance is set to auto-renewal. true: Auto-renewal; the system will automatically renew the instance before each expiration. false: Auto-renewal is not enabled; manual renewal is required before the instance expires. For more information, see Instance renewal.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Instance billing type. PostPaid: Pay-as-you-go. PrePaid: Subscription
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Number of cold nodes.
         */
        coldNodeNumber?: pulumi.Input<number>;
        /**
         * Node specification details for cold nodes
         */
        coldNodeResourceSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationColdNodeResourceSpec>;
        /**
         * Details of cold node storage specification configuration
         */
        coldNodeStorageSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationColdNodeStorageSpec>;
        /**
         * Billing configuration code, obtainable via the DescribeNodeAvailableSpecs API.
         */
        configurationCode?: pulumi.Input<string>;
        /**
         * Coordinator node count
         */
        coordinatorNodeNumber?: pulumi.Input<number>;
        /**
         * Node specification configuration details for coordinator node.
         */
        coordinatorNodeResourceSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationCoordinatorNodeResourceSpec>;
        /**
         * Storage specification configuration details for coordinator node.
         */
        coordinatorNodeStorageSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationCoordinatorNodeStorageSpec>;
        /**
         * Enable instance deletion protection. Values: true: Enable instance deletion protection. false: Disable instance deletion protection. Note: After enabling deletion protection, you cannot delete the instance via console or API
         */
        deletionProtection?: pulumi.Input<boolean>;
        /**
         * Enable HTTPS access protocol. true: Enable HTTPS access. false: Disable HTTPS, use HTTP access. Note: If you choose HTTP access, you can access without security authentication and transmit data in plain HTTP. Ensure the security of your access environment and do not expose the API to the public network. After the instance is created, you can modify the transmission protocol as needed. For related documentation, see Switch Instance Transmission Protocol
         */
        enableHttps?: pulumi.Input<boolean>;
        /**
         * Whether the master node is dedicated. true: Master node is dedicated. false: Master node is combined with data node, that is, uses Hot node.
         */
        enablePureMaster?: pulumi.Input<boolean>;
        /**
         * Number of data nodes
         */
        hotNodeNumber?: pulumi.Input<number>;
        /**
         * Node specification configuration details for data node.
         */
        hotNodeResourceSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationHotNodeResourceSpec>;
        /**
         * Data node storage specification configuration details
         */
        hotNodeStorageSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationHotNodeStorageSpec>;
        /**
         * Set a custom instance name. Only Chinese characters, letters, numbers, hyphens (-), and underscores (_) are allowed. The name cannot start or end with a number or hyphen (-). Length must be between 1 and 128 characters.
         */
        instanceName?: pulumi.Input<string>;
        /**
         * Number of Kibana nodes
         */
        kibanaNodeNumber?: pulumi.Input<number>;
        /**
         * Kibana node specification configuration details
         */
        kibanaNodeResourceSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationKibanaNodeResourceSpec>;
        /**
         * Number of master nodes.
         */
        masterNodeNumber?: pulumi.Input<number>;
        /**
         * Master node specification configuration details
         */
        masterNodeResourceSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationMasterNodeResourceSpec>;
        /**
         * Storage specification details for master node
         */
        masterNodeStorageSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationMasterNodeStorageSpec>;
        networkSpecs?: pulumi.Input<pulumi.Input<inputs.escloud.InstanceInstanceConfigurationNetworkSpec>[]>;
        nodeSpecsAssigns?: pulumi.Input<pulumi.Input<inputs.escloud.InstanceInstanceConfigurationNodeSpecsAssign>[]>;
        /**
         * Subscription instance purchase duration, in months.
         */
        period?: pulumi.Input<number>;
        /**
         * Set the project for your cloud search instance as needed to facilitate grouping and management of cloud resources. Projects provide a resource management method that helps maintain resource independence and data security. You can also view resource consumption bills by project, making it easier to calculate cloud resource usage costs. For more information, see Project Overview
         */
        projectName?: pulumi.Input<string>;
        /**
         * Instance region
         */
        regionId?: pulumi.Input<string>;
        /**
         * Set subnet information for the instance. Note: The subnet must be in the primary zone.
         */
        subnet?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationSubnet>;
        tags?: pulumi.Input<pulumi.Input<inputs.escloud.InstanceInstanceConfigurationTag>[]>;
        /**
         * API version. Value: 2023-01-01.
         */
        version?: pulumi.Input<string>;
        /**
         * Set VPC information for the instance
         */
        vpc?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationVpc>;
        /**
         * Warm node count.
         */
        warmNodeNumber?: pulumi.Input<number>;
        /**
         * Warm node specification configuration details.
         */
        warmNodeResourceSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationWarmNodeResourceSpec>;
        /**
         * Storage specification details for warm nodes
         */
        warmNodeStorageSpec?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationWarmNodeStorageSpec>;
        /**
         * Zone where the instance is located. Note: For multi-zone deployment, enter multiple ZoneIds separated by commas, e.g., cn-beijing-a,cn-beijing-c. The leftmost ZoneId is the primary zone, others are backup zones.
         */
        zoneId?: pulumi.Input<string>;
        /**
         * Number of instance availability zones.
         */
        zoneNumber?: pulumi.Input<number>;
    }
    interface InstanceInstanceConfigurationColdNodeResourceSpec {
        /**
         * CPU resources for node specification, measured in cores.
         */
        cpu?: pulumi.Input<number>;
        /**
         * Description of node specifications
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of node specification.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Memory capacity for node specification, measured in GiB
         */
        memory?: pulumi.Input<number>;
        /**
         * Node specification. For details on node specification types and details.
         */
        name?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationColdNodeStorageSpec {
        /**
         * Description of storage specification
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of storage specification
         */
        displayName?: pulumi.Input<string>;
        /**
         * Maximum storage specification, measured in GiB
         */
        maxSize?: pulumi.Input<number>;
        /**
         * Minimum storage specification, measured in GiB
         */
        minSize?: pulumi.Input<number>;
        /**
         * Storage specification. Current specification: es.volume.essd.pl0: Standard Edition   - High Performance Cloud Disk   - pl0
         */
        name?: pulumi.Input<string>;
        /**
         * Current storage specification value, in GiB.
         */
        size?: pulumi.Input<number>;
    }
    interface InstanceInstanceConfigurationCoordinatorNodeResourceSpec {
        /**
         * CPU resources of node specification, unit: cores.
         */
        cpu?: pulumi.Input<number>;
        /**
         * Description of node specifications
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of node specification.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Memory capacity of node specification, unit: GiB.
         */
        memory?: pulumi.Input<number>;
        /**
         * Node specification. For details on node specification types and details.
         */
        name?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationCoordinatorNodeStorageSpec {
        /**
         * Description of storage specification.
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of storage specification
         */
        displayName?: pulumi.Input<string>;
        /**
         * Maximum storage specification, in GiB
         */
        maxSize?: pulumi.Input<number>;
        /**
         * Minimum value for storage specification, unit: GiB.
         */
        minSize?: pulumi.Input<number>;
        /**
         * Storage specification. Current specification: es.volume.essd.pl0: Standard Edition   - High Performance Cloud Disk   - pl0
         */
        name?: pulumi.Input<string>;
        /**
         * Current storage specification value, in GiB.
         */
        size?: pulumi.Input<number>;
    }
    interface InstanceInstanceConfigurationHotNodeResourceSpec {
        /**
         * CPU resources of node specification, measured in cores
         */
        cpu?: pulumi.Input<number>;
        /**
         * Description of node specification.
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of node specification.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Memory capacity for node specification, measured in GiB.
         */
        memory?: pulumi.Input<number>;
        /**
         * Node specification. For details on node specification types and details, see Product Specifications.
         */
        name?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationHotNodeStorageSpec {
        /**
         * Description of storage specification
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of storage specification.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Maximum storage specification, in GiB
         */
        maxSize?: pulumi.Input<number>;
        /**
         * Minimum storage specification, measured in GiB.
         */
        minSize?: pulumi.Input<number>;
        /**
         * Storage specification. Current specification: es.volume.essd.pl0: Standard Edition   - High Performance Cloud Disk   - pl0
         */
        name?: pulumi.Input<string>;
        /**
         * Configured available disk space size
         */
        size?: pulumi.Input<number>;
    }
    interface InstanceInstanceConfigurationKibanaNodeResourceSpec {
        /**
         * CPU resources for node specification, measured in cores.
         */
        cpu?: pulumi.Input<number>;
        /**
         * Description of node specifications
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of node specification.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Memory capacity for node specification, measured in GiB
         */
        memory?: pulumi.Input<number>;
        /**
         * Node specification. For information about node specification types and details, please refer to the documentation.
         */
        name?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationMasterNodeResourceSpec {
        /**
         * CPU resources of node specification, unit: cores.
         */
        cpu?: pulumi.Input<number>;
        /**
         * Description of node specifications
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of node specification
         */
        displayName?: pulumi.Input<string>;
        /**
         * Memory capacity of node specification, unit: GiB.
         */
        memory?: pulumi.Input<number>;
        /**
         * Node specification. For information about node specification types and details, please refer to the documentation.
         */
        name?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationMasterNodeStorageSpec {
        /**
         * Description of storage specification.
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of storage specification.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Maximum storage specification, measured in GiB
         */
        maxSize?: pulumi.Input<number>;
        /**
         * Minimum value for storage specification, unit: GiB.
         */
        minSize?: pulumi.Input<number>;
        /**
         * Storage specification. Current specification: es.volume.essd.pl0: Standard Edition   - High Performance Cloud Disk   - pl0
         */
        name?: pulumi.Input<string>;
        /**
         * Current storage specification value, in GiB.
         */
        size?: pulumi.Input<number>;
    }
    interface InstanceInstanceConfigurationNetworkSpec {
        /**
         * Public IP bandwidth limit. Default is '1', unit: Mbps.
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Enable/Disable
         */
        isOpen?: pulumi.Input<boolean>;
        /**
         * Instance public resource specification name
         */
        specName?: pulumi.Input<string>;
        /**
         * Public network application types: Elasticsearch—for ES instance usage. Kibana—for Dashboard usage
         */
        type?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationNodeSpecsAssign {
        /**
         * Disk extra performance package configuration.
         */
        extraPerformance?: pulumi.Input<inputs.escloud.InstanceInstanceConfigurationNodeSpecsAssignExtraPerformance>;
        /**
         * Node count. When configuring the number of data nodes, note the following based on deployment mode: Single availability zone deployment: For production environments, configure at least 3 data nodes. Configuring 2 nodes poses a split-brain risk. If dedicated master nodes are enabled, 2 data nodes will not result in split-brain. Dual availability zone deployment, dedicated master nodes enabled by default: For production environments, configure at least 4 data nodes—2 per availability zone. Triple availability zone deployment, dedicated master nodes enabled by default: For production environments, configure at least 6 data nodes—2 per availability zone. You can set the number of data nodes from 1 to 100. If you need more, apply to increase the quota to 200. Master node configuration: If dedicated master nodes are not enabled, master node configuration matches data nodes; otherwise, master node configuration is independent. Dedicated master node configuration: If you need to enable dedicated master nodes, the default number is 3. Kibana node configuration: The number is fixed at 1. Coordinator node configuration: If enabled, configure at least 2 coordinator nodes for production environments. The configurable range is 2–50. Warm data nodes: If enabled, configure at least 3 warm data nodes for production environments, up to 100. Cold data nodes: If enabled, configure at least 2 cold data nodes for production environments, up to 100.
         */
        number?: pulumi.Input<number>;
        /**
         * Compute resource specification name. You can call the DescribeNodeAvailableSpecs API to get the list of available node specifications. For details, see V2 instance specifications.
         */
        resourceSpecName?: pulumi.Input<string>;
        /**
         * Storage capacity, measured in GiB. Default value is 100 GiB, adjustment step is 10 GiB. Note: StorageSize for Kibana nodes is set to 0, i.e., "StorageSize": 0. StorageSize for dedicated master and coordinator nodes defaults to 20
         */
        storageSize?: pulumi.Input<number>;
        /**
         * Storage specification name. Currently supported specifications: es.volume.essd.pl0: Standard Edition   - High Performance Cloud Disk   - pl0. es.volume.essd.flexpl-standard: Standard Edition   - High Performance Cloud Disk   - flexpl. Note: StorageSpecName for Kibana nodes is set to empty, i.e., "StorageSpecName": ""
         */
        storageSpecName?: pulumi.Input<string>;
        /**
         * Node type. Please understand the function of each node type first, then determine whether to create based on your business needs. For details, see node types. Master: Master node. Hot: Data node. Cold: Cold data node. Warm: Warm data node. Kibana: Kibana node. Coordinator: Coordinator node
         */
        type?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationNodeSpecsAssignExtraPerformance {
        /**
         * When your data node uses the FlexPL storage type and the storage specification is 500 GiB or above, you can purchase a bandwidth package to increase disk bandwidth. Unit: MiB; adjustment step: 10 MiB. Supported storage specifications and corresponding maximum throughput for additional performance packages are as follows: es.volume.essd.flexpl-standard: 650.
         */
        throughput?: pulumi.Input<number>;
    }
    interface InstanceInstanceConfigurationSubnet {
        /**
         * Subnet ID。
         */
        subnetId?: pulumi.Input<string>;
        /**
         * Subnet name
         */
        subnetName?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationTag {
        /**
         * Tag key for user labels. Length limit: 1–128 characters. Case-sensitive. Cannot start or end with a space. Letters, numbers, spaces (), underscores (_), periods (.), colons (:), slashes (/), equals (=), plus (+), minus (-), and @ are allowed. Duplicate tag keys are not allowed for the same resource
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for user tag. Length limit: 0–256 characters. Case-sensitive, cannot start or end with a space. Allowed characters: letters, numbers, spaces ( ), underscore (_), period (.), colon (:), slash (/), equals (=), plus (+), minus (-), and @
         */
        value?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationVpc {
        /**
         * VPC ID。
         */
        vpcId?: pulumi.Input<string>;
        /**
         * VPC name
         */
        vpcName?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationWarmNodeResourceSpec {
        /**
         * CPU resources for node specification, measured in cores.
         */
        cpu?: pulumi.Input<number>;
        /**
         * Description of node specification
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of node specification.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Memory capacity for node specification, measured in GiB
         */
        memory?: pulumi.Input<number>;
        /**
         * Node specification. For details on node specification types and details.
         */
        name?: pulumi.Input<string>;
    }
    interface InstanceInstanceConfigurationWarmNodeStorageSpec {
        /**
         * Description of storage specification.
         */
        description?: pulumi.Input<string>;
        /**
         * Display name of storage specification.
         */
        displayName?: pulumi.Input<string>;
        /**
         * Maximum storage specification, measured in GiB
         */
        maxSize?: pulumi.Input<number>;
        /**
         * Minimum value for storage specification, unit: GiB.
         */
        minSize?: pulumi.Input<number>;
        /**
         * Storage specification. Current specification: es.volume.essd.pl0: Standard Edition   - High Performance Cloud Disk   - pl0
         */
        name?: pulumi.Input<string>;
        /**
         * Current storage specification value, in GiB.
         */
        size?: pulumi.Input<number>;
    }
    interface InstanceKibanaConfig {
        /**
         * API request timeout duration. Default is 30000 milliseconds. If the backend response exceeds 30 seconds, a 503 Request timed out error will occur. To receive responses normally and reduce 503 errors, you can increase the request timeout duration
         */
        requestTimeout?: pulumi.Input<number>;
        /**
         * Whether to proactively extend session validity. true: Default value, session validity is extended with each page request. false: Session validity is not proactively extended. With this setting, session timeout can occur; when login duration reaches the session validity period, you will be automatically logged out.
         */
        sessionKeepAlive?: pulumi.Input<boolean>;
        /**
         * Session validity duration. Default is 3600000 milliseconds (1 hour). If you set Session activity retention to No, you will be automatically logged out when the login duration reaches the session validity duration
         */
        sessionTtl?: pulumi.Input<number>;
    }
    interface InstanceSubInstance {
        /**
         * Enterprise-level SQL analysis instance ID.
         */
        subInstanceId?: pulumi.Input<string>;
        /**
         * Instance status
         */
        subInstanceStatus?: pulumi.Input<string>;
        /**
         * Instance type
         */
        subInstanceType?: pulumi.Input<string>;
    }
    interface InstanceTransferInfo {
        /**
         * ForbidStop
         */
        forbidStop?: pulumi.Input<boolean>;
        /**
         * Resource information
         */
        reduceSpecConfig?: pulumi.Input<inputs.escloud.InstanceTransferInfoReduceSpecConfig>;
        /**
         * Data migration task progress, percentage
         */
        transferProgress?: pulumi.Input<number>;
        /**
         * Data migration task status
         */
        transferStatus?: pulumi.Input<string>;
        /**
         * Data migration task ID
         */
        transferTaskId?: pulumi.Input<string>;
    }
    interface InstanceTransferInfoReduceSpecConfig {
        /**
         * Number of cold nodes.
         */
        coldNodeNum?: pulumi.Input<number>;
        /**
         * Number of data nodes
         */
        dataNodeNum?: pulumi.Input<number>;
        /**
         * Whether the master node is independent. true: Master node is independent. false: Master node overlaps with data node, declared as Hot
         */
        enablePureMaster?: pulumi.Input<boolean>;
        /**
         * Number of master nodes.
         */
        masterNodeNum?: pulumi.Input<number>;
        /**
         * Number of warm nodes
         */
        warmNodeNum?: pulumi.Input<number>;
    }
}
export declare namespace filenas {
    interface InstanceCachePerformance {
        /**
         * Provisioned bandwidth, used to increase file system bandwidth
         */
        cacheBandwidth?: pulumi.Input<number>;
    }
    interface InstanceCapacity {
        /**
         * Total available file system capacity, in GiB
         */
        total?: pulumi.Input<number>;
        /**
         * Used file system capacity, in MiB
         */
        used?: pulumi.Input<number>;
    }
    interface InstanceTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag type
         */
        type?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface MountPointClient {
        /**
         * Client's private network IP address.
         */
        ip?: pulumi.Input<string>;
        /**
         * Mount protocol version. Value: NFSv3.
         */
        protocolVersion?: pulumi.Input<string>;
        /**
         * Private network name.
         */
        vpcName?: pulumi.Input<string>;
    }
    interface MountPointPermissionGroup {
        /**
         * Permission group creation time.
         */
        createTime?: pulumi.Input<string>;
        /**
         * Permission group description information.
         */
        description?: pulumi.Input<string>;
        /**
         * Number of file systems associated with this permission group.
         */
        fileSystemCount?: pulumi.Input<number>;
        /**
         * File system type. Value explanation: Extreme: NAS extreme type. Capacity: NAS capacity type. Cache: NAS cache type.
         */
        fileSystemType?: pulumi.Input<string>;
        mountPoints?: pulumi.Input<pulumi.Input<inputs.filenas.MountPointPermissionGroupMountPoint>[]>;
        /**
         * Permission group name.
         */
        permissionGroupName?: pulumi.Input<string>;
        /**
         * Number of permission rules.
         */
        permissionRuleCount?: pulumi.Input<number>;
    }
    interface MountPointPermissionGroupMountPoint {
        /**
         * File system ID.
         */
        fileSystemId?: pulumi.Input<string>;
        /**
         * Mount point ID.
         */
        mountPointId?: pulumi.Input<string>;
        /**
         * Mount point name.
         */
        mountPointName?: pulumi.Input<string>;
    }
}
export declare namespace fwcenter {
    interface DnsControlPolicyDomainListV1 {
        /**
         * Specific address information.
         */
        address?: pulumi.Input<string>;
        /**
         * Description information.
         */
        description?: pulumi.Input<string>;
        /**
         * Address type. Supported values are as follows. ip: IPv4 address; ipv6: IPv6 address; domain: domain name; port: port number.
         */
        type?: pulumi.Input<string>;
    }
    interface DnsControlPolicySource {
        /**
         * VPC region information.
         */
        region?: pulumi.Input<string>;
        /**
         * VPC ID。
         */
        vpcId?: pulumi.Input<string>;
    }
}
export declare namespace gtm {
    interface PolicyStatistics {
        /**
         * Number of available addresses
         */
        activeAddr?: pulumi.Input<number>;
        /**
         * Number of unavailable addresses
         */
        inactiveAddr?: pulumi.Input<number>;
    }
    interface PolicyTarget {
        /**
         * Address pool ID.
         */
        poolId?: pulumi.Input<string>;
    }
    interface PoolAddress {
        /**
         * Address capacity
         */
        capacity?: pulumi.Input<number>;
        /**
         * Address availability mode
         */
        mode?: pulumi.Input<string>;
        /**
         * List of geographic route codes to be corrected
         */
        rectifiedGeos?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Target address value
         */
        value: pulumi.Input<string>;
        /**
         * Address weight
         */
        weight?: pulumi.Input<number>;
    }
    interface RulePoolSet {
        /**
         * Minimum number of available addresses required for the address pool collection to be considered available.
         */
        activeAddrThr?: pulumi.Input<number>;
        /**
         * Address pool name.
         */
        name?: pulumi.Input<string>;
        pools?: pulumi.Input<pulumi.Input<inputs.gtm.RulePoolSetPool>[]>;
    }
    interface RulePoolSetPool {
        addresses?: pulumi.Input<pulumi.Input<inputs.gtm.RulePoolSetPoolAddress>[]>;
        /**
         * The number of unavailable addresses in the address pool.
         */
        inactiveAddrCount?: pulumi.Input<number>;
        /**
         * Address pool name.
         */
        name?: pulumi.Input<string>;
        /**
         * Address pool ID.
         */
        poolId?: pulumi.Input<string>;
        /**
         * Address pool weight.
         */
        weight?: pulumi.Input<number>;
    }
    interface RulePoolSetPoolAddress {
        /**
         * Whether the address is available. true: The address is available. false: The address is unavailable.
         */
        active?: pulumi.Input<boolean>;
        /**
         * The capacity of the address. For addresses without a set capacity value, this parameter returns the default capacity value of 1000.
         */
        capacity?: pulumi.Input<number>;
        /**
         * This parameter has no practical significance. You can ignore this parameter.
         */
        geo?: pulumi.Input<string>;
        /**
         * Latency (ms) for health check probe accessing the target address.
         */
        latency?: pulumi.Input<number>;
        /**
         * The mechanism for determining whether an address is available. auto: automatic mode. Cloud Scheduling GTM determines address availability based on health check results. always*on: address is always available. always*off: address is always unavailable.
         */
        mode?: pulumi.Input<string>;
        /**
         * The assigned region for the target address. See line codes for the mapping between line codes and specific regions (i.e., lines).
         */
        rectifiedGeos?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Address.
         */
        value?: pulumi.Input<string>;
        /**
         * Address weight. For addresses without a specified weight, this parameter returns the default weight value of 1.
         */
        weight?: pulumi.Input<number>;
    }
    interface RuleProbe {
        /**
         * Recommended number of health check probe points.
         */
        advisedNodeCount?: pulumi.Input<number>;
        /**
         * Whether health checks are disabled. true: disabled. false: not disabled.
         */
        disable?: pulumi.Input<boolean>;
        /**
         * The threshold for the number of health check failures before a single target address is considered faulty. For example, if you set this parameter to 3, a target address is marked as faulty after 3 consecutive health check failures. The default value is 3.
         */
        failedCount?: pulumi.Input<number>;
        /**
         * Domain name of the health check target address. This parameter is only valid when the health check protocol is set to HTTP or HTTPS.
         */
        host?: pulumi.Input<string>;
        /**
         * HTTP request method. This parameter is only valid when the health check protocol is set to HTTP or HTTPS.
         */
        httpMethod?: pulumi.Input<string>;
        httpUsabilityCodes?: pulumi.Input<pulumi.Input<inputs.gtm.RuleProbeHttpUsabilityCode>[]>;
        /**
         * The interval between each health check, in seconds.
         */
        interval?: pulumi.Input<number>;
        /**
         * Whether to manually configure the health check probe. true: Manually configure the health check probe. false: Use recommended health check probe.
         */
        isManualNodes?: pulumi.Input<boolean>;
        /**
         * Health check probe point.
         */
        nodes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Packet count. If you set this parameter to 10, each ping check sends 10 packets simultaneously. This parameter is only valid when the health check protocol is set to ping.
         */
        pingCount?: pulumi.Input<number>;
        /**
         * Packet loss rate, expressed as a percentage. If the packet loss rate exceeds this parameter, the result is considered abnormal. For example, if this parameter is set to 10 and the packet loss rate during the health check is 11%, the result is considered abnormal. This parameter is only valid when the health check protocol is set to ping.
         */
        pingLossPercent?: pulumi.Input<number>;
        /**
         * Port of the health check target address. This parameter is only valid when the health check protocol is set to HTTP or HTTPS.
         */
        port?: pulumi.Input<number>;
        /**
         * Protocol used for health checks. ping: ICMP protocol. tcp: TCP protocol. http: HTTP protocol. https: HTTPS protocol.
         */
        protocol?: pulumi.Input<string>;
        /**
         * The timeout period for the health check task, in seconds. ping: If the latency exceeds the value of Timeout, it is considered packet loss. http/https: If the latency exceeds the value of Timeout, it is considered an abnormal result.
         */
        timeout?: pulumi.Input<number>;
        /**
         * Path part of the health check target address, starting with /. This parameter is only valid when the health check protocol is set to HTTP or HTTPS.
         */
        url?: pulumi.Input<string>;
    }
    interface RuleProbeHttpUsabilityCode {
        /**
         * HTTP status code list.
         */
        codes?: pulumi.Input<pulumi.Input<number>[]>;
        /**
         * Operator. interval: Matches values within the range. include: Matches specified values. exclude: Matches values other than the specified values.
         */
        operator?: pulumi.Input<string>;
    }
}
export declare namespace hbase {
    interface InstanceEndpoint {
        /**
         * Connection address type. For more information about connection addresses, see Connection Address Types. The value range is as follows: Zk: ZK address. Thrift: Thrift2 address. HBaseReUsedEipId: When public access is enabled for the ZK or Thrift2 connection address, this parameter is returned, indicating the EIP ID information shared and used by other components in the instance (such as RS nodes, Master nodes, etc.)
         */
        addressType?: pulumi.Input<string>;
        /**
         * When the ZK connection address or Thrift2 connection address enables public access, this parameter is returned, indicating the EIP ID.
         */
        eipId?: pulumi.Input<string>;
        /**
         * Connection address ID. By default, only the ZK private network connection address is returned. If you apply for a Thrift2 connection address or enable public access for the ZK or Thrift2 connection address, the corresponding connection address ID will also be returned. When the connection address type is HBaseReUsedEipId, the connection address ID is fixed as HBaseReUsedEipId
         */
        endpointId?: pulumi.Input<string>;
        /**
         * Connection string for the connection address. By default, only the ZK private network connection address is returned. If you have requested a Thrift2 connection address, or enabled public access for ZK or Thrift2 connection addresses, the corresponding connection string will also be provided. When the connection address type is HBaseReUsedEipId, the connection string is always set to HBaseReUsedEipId.
         */
        endpointStr?: pulumi.Input<string>;
        /**
         * Connection address network type. Value range: Public: public access address. Private: private access address.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Whether public DNS resolution is enabled for the private network domain name.
         */
        privateDnsVisibility?: pulumi.Input<boolean>;
    }
    interface InstanceTag {
        /**
         * Tag key of the tags bound to the instance
         */
        key?: pulumi.Input<string>;
        /**
         * Tag values bound to the instance.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace iam {
    interface AllowedIpAddressIpList {
        /**
         * Description
         */
        description: pulumi.Input<string>;
        /**
         * IP address
         */
        ip: pulumi.Input<string>;
    }
    interface GroupAttachedPolicy {
        /**
         * Policy name.
         */
        policyName?: pulumi.Input<string>;
        policyScopes?: pulumi.Input<pulumi.Input<inputs.iam.GroupAttachedPolicyPolicyScope>[]>;
        /**
         * Policy type. System indicates a system predefined policy; Custom indicates a custom policy.
         */
        policyType?: pulumi.Input<string>;
    }
    interface GroupAttachedPolicyPolicyScope {
        /**
         * Project authorization time.
         */
        attachTime?: pulumi.Input<string>;
        /**
         * Authorization type. Global indicates global authorization (not limited by project); Project indicates project-based authorization.
         */
        policyScopeType?: pulumi.Input<string>;
        /**
         * Project display name for project-based authorization.
         */
        projectDisplayName?: pulumi.Input<string>;
        /**
         * Project name for project-based authorization.
         */
        projectName?: pulumi.Input<string>;
    }
    interface GroupUser {
        /**
         * Username.
         */
        userName?: pulumi.Input<string>;
    }
    interface PolicyPolicyRole {
        /**
         * Name of the corresponding user, role, or user group.
         */
        name?: pulumi.Input<string>;
        policyScopes?: pulumi.Input<pulumi.Input<inputs.iam.PolicyPolicyRolePolicyScope>[]>;
    }
    interface PolicyPolicyRolePolicyScope {
        /**
         * Project name.
         */
        projectName?: pulumi.Input<string>;
    }
    interface PolicyPolicyUser {
        /**
         * Name of the corresponding user, role, or user group.
         */
        name?: pulumi.Input<string>;
        policyScopes?: pulumi.Input<pulumi.Input<inputs.iam.PolicyPolicyUserPolicyScope>[]>;
    }
    interface PolicyPolicyUserGroup {
        /**
         * Name of the corresponding user, role, or user group.
         */
        name?: pulumi.Input<string>;
        policyScopes?: pulumi.Input<pulumi.Input<inputs.iam.PolicyPolicyUserGroupPolicyScope>[]>;
    }
    interface PolicyPolicyUserGroupPolicyScope {
        /**
         * Project name.
         */
        projectName?: pulumi.Input<string>;
    }
    interface PolicyPolicyUserPolicyScope {
        /**
         * Project name.
         */
        projectName?: pulumi.Input<string>;
    }
    interface RolePolicy {
        /**
         * Policy name
         */
        policyName?: pulumi.Input<string>;
        /**
         * Policy type. Policy type. System indicates a system preset policy; Custom indicates a custom policy.
         */
        policyType?: pulumi.Input<string>;
    }
    interface RoleTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface SamlProviderCertificate {
        /**
         * Certificate ID
         */
        certificateId?: pulumi.Input<string>;
        /**
         * Certificate Upload Time
         */
        createDate?: pulumi.Input<string>;
        /**
         * Certificate Authority
         */
        issuer?: pulumi.Input<string>;
        /**
         * Certificate Expiration Time
         */
        notAfter?: pulumi.Input<string>;
        /**
         * Certificate Validity Period
         */
        notBefore?: pulumi.Input<string>;
        /**
         * Certificate Serial Number
         */
        serialNumber?: pulumi.Input<string>;
        /**
         * Certificate Signature Algorithm
         */
        signatureAlgorithm?: pulumi.Input<string>;
        /**
         * Certificate Subject
         */
        subject?: pulumi.Input<string>;
        /**
         * Certificate Update Time
         */
        updateDate?: pulumi.Input<string>;
        /**
         * Certificate Version
         */
        version?: pulumi.Input<string>;
    }
    interface UserAccessKey {
        /**
         * Access key ID.
         */
        accessKeyId?: pulumi.Input<string>;
        /**
         * Access key creation time.
         */
        createDate?: pulumi.Input<string>;
        /**
         * Most recently used service region.
         */
        region?: pulumi.Input<string>;
        /**
         * Last used time of the access key.
         */
        requestTime?: pulumi.Input<string>;
        /**
         * Name of the most recently used service.
         */
        service?: pulumi.Input<string>;
        /**
         * Access key status. 'Active' means enabled, 'Inactive' means disabled.
         */
        status?: pulumi.Input<string>;
        /**
         * Access key update time.
         */
        updateDate?: pulumi.Input<string>;
        /**
         * Access key Secret.
         */
        userName?: pulumi.Input<string>;
    }
    interface UserLoginProfile {
        /**
         * Login configuration creation time.
         */
        createDate?: pulumi.Input<string>;
        /**
         * Last login time.
         */
        lastLoginDate?: pulumi.Input<string>;
        /**
         * Last login IP.
         */
        lastLoginIp?: pulumi.Input<string>;
        /**
         * Last password reset time. Last password reset time. 0 means no password has been set; a non-zero value means the timestamp when the password expires.
         */
        lastResetPasswordTime?: pulumi.Input<number>;
        /**
         * Whether login is allowed. 'true' means allowed, 'false' means not allowed. Default is 'false'.
         */
        loginAllowed?: pulumi.Input<boolean>;
        /**
         * Whether login is locked. 'true' means locked, 'false' means not locked. After the administrator sets a limit for incorrect password retry attempts, login will be locked if the user exceeds the limit.
         */
        loginLocked?: pulumi.Input<boolean>;
        /**
         * Login password.
         */
        password?: pulumi.Input<string>;
        /**
         * Password expiration time. '0' means never expires; non-zero means the expiration timestamp.
         */
        passwordExpireAt?: pulumi.Input<number>;
        /**
         * Whether password reset is required on next login. Whether password reset is required on next login. 'true' means password reset is required, 'false' means not required. Default is 'false'.
         */
        passwordResetRequired?: pulumi.Input<boolean>;
        /**
         * Login protection exemption duration. Supports setting 1 to 7 (days), 1 to 168 (hours), or 5 to 1440 (minutes). For unit settings, refer to the SafeAuthExemptUnit parameter.
         */
        safeAuthExemptDuration?: pulumi.Input<number>;
        /**
         * Whether login protection exemption is enabled. Whether login protection exemption is enabled. 0 means disabled, 1 means enabled. When login protection exemption is enabled, after verification is completed, login will not require verification again within a certain period.
         */
        safeAuthExemptRequired?: pulumi.Input<number>;
        /**
         * Login protection exemption time unit. Login protection exemption time unit. 0 represents minutes, 1 represents hours, 2 represents days.
         */
        safeAuthExemptUnit?: pulumi.Input<number>;
        /**
         * Whether login protection is enabled. 'true' means enabled, 'false' means disabled. Default is 'false'.
         */
        safeAuthFlag?: pulumi.Input<boolean>;
        /**
         * Login protection type. Login protection type. 'phone' represents mobile verification, 'email' represents email verification, 'vmfa' represents MFA device verification. Multiple login protection types can be set, separated by commas. Options: vmfa, phone, email, separated by commas.
         */
        safeAuthType?: pulumi.Input<string>;
        /**
         * Login configuration update time.
         */
        updateDate?: pulumi.Input<string>;
    }
    interface UserPolicy {
        /**
         * Permission policy name. Length: 1–64 characters. Supports English letters, numbers, and +=,.@-_ symbols.
         */
        policyName?: pulumi.Input<string>;
        /**
         * Permission policy type. 'System' indicates system preset policy, 'Custom' indicates custom policy.
         */
        policyType?: pulumi.Input<string>;
    }
    interface UserSecurityConfig {
        /**
         * Whether operation protection is enabled. 0 means enabled, 1 means disabled.
         */
        safeAuthClose?: pulumi.Input<number>;
        /**
         * Operation protection exemption time. After verification is completed, no further verification is required within the exemption period. Supports values from 5 to 30; the default value is 10. Unit: minutes.
         */
        safeAuthExemptDuration?: pulumi.Input<number>;
        /**
         * Operation protection type. 'phone' indicates phone verification, 'email' indicates email verification, 'vmfa' indicates MFA device verification. Multiple operation protection types can be set, separated by commas.
         */
        safeAuthType?: pulumi.Input<string>;
    }
    interface UserTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace id {
    interface ServiceBackend {
        /**
         * Backend service domain name, for example api.example.com
         */
        backendDomain: pulumi.Input<string>;
        /**
         * Backend service port, default is 443
         */
        backendPort?: pulumi.Input<number>;
        /**
         * Whether to enable TLS
         */
        enableTls: pulumi.Input<boolean>;
        /**
         * Communication protocol, for example HTTP or HTTPS
         */
        protocol?: pulumi.Input<string>;
        /**
         * Request timeout in seconds, default is 30 seconds
         */
        timeoutSeconds?: pulumi.Input<number>;
    }
    interface ServiceRoute {
        /**
         * API specification configuration
         */
        apiSpec?: pulumi.Input<inputs.id.ServiceRouteApiSpec>;
        /**
         * Authentication resource type
         */
        authResourceType?: pulumi.Input<string>;
        /**
         * Route description
         */
        description?: pulumi.Input<string>;
        /**
         * HTTP methods, separated by commas
         */
        method?: pulumi.Input<string>;
        /**
         * Request path, 1–256 characters
         */
        path?: pulumi.Input<string>;
        /**
         * Path match type, for example Exact, Prefix
         */
        pathMatchType?: pulumi.Input<string>;
        /**
         * Permission pool name
         */
        permissionPool?: pulumi.Input<string>;
        /**
         * Route priority, lower values indicate higher priority
         */
        priority?: pulumi.Input<number>;
        /**
         * Resource type, for example Collection
         */
        resourceType?: pulumi.Input<string>;
        /**
         * Route name, 1–64 characters
         */
        routeName?: pulumi.Input<string>;
    }
    interface ServiceRouteApiSpec {
        /**
         * Operation type, for example READ
         */
        actionType?: pulumi.Input<string>;
        /**
         * Operation value, for example search
         */
        actionValue?: pulumi.Input<string>;
        extractors?: pulumi.Input<pulumi.Input<inputs.id.ServiceRouteApiSpecExtractor>[]>;
        /**
         * Resource identifier type
         */
        identifierType?: pulumi.Input<number>;
        /**
         * Resource identifier value, for example JSON Pointer
         */
        identifierValue?: pulumi.Input<string>;
        responseFilters?: pulumi.Input<pulumi.Input<inputs.id.ServiceRouteApiSpecResponseFilter>[]>;
    }
    interface ServiceRouteApiSpecExtractor {
        /**
         * Whether used for authentication
         */
        isAuth?: pulumi.Input<boolean>;
        /**
         * JSON Pointer expression
         */
        path?: pulumi.Input<string>;
        /**
         * Extracted resource type
         */
        resourceType?: pulumi.Input<string>;
        /**
         * Extraction source enumeration value
         */
        source?: pulumi.Input<number>;
    }
    interface ServiceRouteApiSpecResponseFilter {
        attributes?: pulumi.Input<pulumi.Input<inputs.id.ServiceRouteApiSpecResponseFilterAttribute>[]>;
        /**
         * Array path JSON Pointer
         */
        filterPath?: pulumi.Input<string>;
        /**
         * ID field name
         */
        idField?: pulumi.Input<string>;
        /**
         * Whether used for authentication
         */
        isAuth?: pulumi.Input<boolean>;
        /**
         * Filter mode enumeration value
         */
        mode?: pulumi.Input<number>;
        /**
         * Resource path JSON Pointer
         */
        resourcePath?: pulumi.Input<string>;
        /**
         * Filtered resource type
         */
        resourceType?: pulumi.Input<string>;
    }
    interface ServiceRouteApiSpecResponseFilterAttribute {
        /**
         * Source field path JSON Pointer
         */
        field?: pulumi.Input<string>;
        /**
         * Target attribute name
         */
        target?: pulumi.Input<string>;
    }
    interface ServiceTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace kafka {
    interface AllowListAssociatedInstance {
        /**
         * ID of the instance bound to the allowlist
         */
        instanceId?: pulumi.Input<string>;
    }
    interface GroupTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface InstanceChargeInfo {
        /**
         * Whether to automatically renew the subscription instance after expiration. true   - auto renewal; false (default)   - no auto renewal, instance will be stopped upon expiration.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Expiration time for the subscription instance.
         */
        chargeExpireTime?: pulumi.Input<string>;
        /**
         * Instance billing start time.
         */
        chargeStartTime?: pulumi.Input<string>;
        /**
         * Billing status of the instance. Supported types: Normal   - normal, Overdue   - pay-as-you-go overdue, Expired   - subscription expired
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Billing type for the instance. Supported types: PostPaid   - pay-as-you-go, PrePaid   - subscription.
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Estimated release time after the instance is stopped due to overdue payment.
         */
        overdueReclaimTime?: pulumi.Input<string>;
        /**
         * Instance suspension time due to overdue payment.
         */
        overdueTime?: pulumi.Input<string>;
        /**
         * Purchase duration for subscription-based instances.
         */
        period?: pulumi.Input<number>;
        /**
         * The lifecycle unit for subscription-based instances, specifying purchase by month (Month/Monthly) or by year (Year/Yearly).
         */
        periodUnit?: pulumi.Input<string>;
    }
    interface InstanceConnectionInfo {
        /**
         * Instance endpoint type. PLAINTEXT: default endpoint. SASL*PLAINTEXT: SASL endpoint (private network). SASL*SSL: SASL endpoint (public network). If public access is not enabled, this endpoint is not provided.
         */
        endpointType?: pulumi.Input<string>;
        /**
         * Instance private network access domain name.
         */
        internalEndpoint?: pulumi.Input<string>;
        /**
         * Network type for the access point. Unified as PrivateNetwork.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Public access domain name for the instance.
         */
        publicEndpoint?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface TopicAccessPolicy {
        /**
         * SASL user access permissions for the current Topic. PubSub: publish and subscribe permissions. Pub: publish permission. Sub: subscribe permission.
         */
        accessPolicy?: pulumi.Input<string>;
        /**
         * SASL username.
         */
        userName?: pulumi.Input<string>;
    }
    interface TopicTag {
        /**
         * Label key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace kms {
    interface KeyAsymmetricCiphertext {
        /**
         * Encryption algorithm. Optional values: RSAES*OAEP*SHA_256, SM2PKE.
         */
        algorithm?: pulumi.Input<string>;
        /**
         * Ciphertext of encryption result, Base64-encoded.
         */
        ciphertextBlob?: pulumi.Input<string>;
        /**
         * Plaintext to be encrypted, Base64-encoded.
         */
        plaintext?: pulumi.Input<string>;
    }
    interface KeyAsymmetricSignature {
        /**
         * Signature algorithm, for example: RSA*PSS*SHA*256, RSA*PKCS1*SHA*256, ECDSA*SHA*256, SM2_DSA.
         */
        algorithm?: pulumi.Input<string>;
        /**
         * Message to be signed, Base64-encoded.
         */
        message?: pulumi.Input<string>;
        /**
         * Message type. Optional values: RAW, DIGEST.
         */
        messageType?: pulumi.Input<string>;
        /**
         * Signature result, Base64-encoded.
         */
        signature?: pulumi.Input<string>;
    }
    interface KeyCiphertext {
        /**
         * Ciphertext of encryption result, Base64-encoded.
         */
        ciphertextBlob?: pulumi.Input<string>;
        /**
         * Encryption context JSON string.
         */
        encryptionContext?: pulumi.Input<string>;
        /**
         * Plaintext to be encrypted, Base64-encoded.
         */
        plaintext?: pulumi.Input<string>;
    }
    interface KeyMultiRegionConfiguration {
        /**
         * Multi-region key type.
         */
        multiRegionKeyType?: pulumi.Input<string>;
        /**
         * Primary multi-region key transaction identifier and region ID.
         */
        primaryKey?: pulumi.Input<inputs.kms.KeyMultiRegionConfigurationPrimaryKey>;
        replicaKeys?: pulumi.Input<pulumi.Input<inputs.kms.KeyMultiRegionConfigurationReplicaKey>[]>;
    }
    interface KeyMultiRegionConfigurationPrimaryKey {
        /**
         * Multi-region key region ID.
         */
        region?: pulumi.Input<string>;
        /**
         * Multi-region key TRN.
         */
        trn?: pulumi.Input<string>;
    }
    interface KeyMultiRegionConfigurationReplicaKey {
        /**
         * Multi-region key region ID.
         */
        region?: pulumi.Input<string>;
        /**
         * Multi-region key conversion.
         */
        trn?: pulumi.Input<string>;
    }
    interface KeyReEncrypt {
        /**
         * Re-encrypted ciphertext, Base64-encoded.
         */
        ciphertextBlob?: pulumi.Input<string>;
        /**
         * New encryption context JSON string.
         */
        newEncryptionContext?: pulumi.Input<string>;
        /**
         * Target key ID. If not specified, you must provide NewKeyringName and NewKeyName.
         */
        newKeyId?: pulumi.Input<string>;
        /**
         * Target key name.
         */
        newKeyName?: pulumi.Input<string>;
        /**
         * Name of the keyring to which the target key belongs.
         */
        newKeyringName?: pulumi.Input<string>;
        /**
         * Old encryption context JSON string.
         */
        oldEncryptionContext?: pulumi.Input<string>;
        /**
         * Source ciphertext to be re-encrypted, Base64-encoded.
         */
        sourceCiphertextBlob?: pulumi.Input<string>;
    }
    interface KeyReplicateKey {
        /**
         * Replica key description.
         */
        description?: pulumi.Input<string>;
        /**
         * Replica key ID.
         */
        replicaKeyId?: pulumi.Input<string>;
        /**
         * Target region of the replica key.
         */
        replicaRegion?: pulumi.Input<string>;
        tags?: pulumi.Input<pulumi.Input<inputs.kms.KeyReplicateKeyTag>[]>;
    }
    interface KeyReplicateKeyTag {
        /**
         * KMS key label key.
         */
        key?: pulumi.Input<string>;
        /**
         * KMS key label value.
         */
        value?: pulumi.Input<string>;
    }
    interface KeyTag {
        /**
         * KMS key label key.
         */
        key?: pulumi.Input<string>;
        /**
         * KMS key label value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace mongodb {
    interface AccountAccountPrivilege {
        /**
         * Databases for which the account has permissions.
         */
        dbName?: pulumi.Input<string>;
        /**
         * Permissions the account has in the current database.
         */
        roleName?: pulumi.Input<string>;
    }
    interface AllowListAssociatedInstance {
        /**
         * Instance ID bound to the current allowlist.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Instance name bound to the current allowlist.
         */
        instanceName?: pulumi.Input<string>;
        /**
         * Project name of the instance.
         */
        projectName?: pulumi.Input<string>;
        /**
         * Private network ID of the instance.
         */
        vpc?: pulumi.Input<string>;
    }
    interface EndpointDbAddress {
        /**
         * Domain name of the connection address
         */
        addressDomain?: pulumi.Input<string>;
        /**
         * IP corresponding to the connection address
         */
        addressIp?: pulumi.Input<string>;
        /**
         * Port number of the connection address
         */
        addressPort?: pulumi.Input<string>;
        /**
         * Connection address type of the node. Possible values:
         *
         *   Primary: Primary node connection address
         *   Secondary: Secondary node connection address
         *   Hidden: Hidden node connection address
         *   ReadOnly: Read-only node connection address
         *
         *
         *   **Note:**
         *   Hidden node connection address information is returned only when the connection address type is a private connection address (that is, when `NetworkType` is set to `Private`).
         */
        addressType?: pulumi.Input<string>;
        /**
         * EIP ID bound to the instance's public address
         *
         *
         *   **Note:**
         *   This parameter is returned only when the connection address type is a public connection address (that is, when `NetworkType` is set to `Public`).
         */
        eipId?: pulumi.Input<string>;
        /**
         * Node ID associated with the connection address
         */
        nodeId?: pulumi.Input<string>;
        /**
         * AZ of the node; all nodes are consistent for single-AZ instances, while nodes differ for multi-AZ instances
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceConfigServer {
        /**
         * ConfigServer node ID
         */
        configServerNodeId?: pulumi.Input<string>;
        /**
         * Node role. Options: Primary: primary node. Secondary: secondary node. Hidden: hidden node.
         */
        nodeRole?: pulumi.Input<string>;
        /**
         * Node status.
         */
        nodeStatus?: pulumi.Input<string>;
        /**
         * Total memory. Unit: GiB.
         */
        totalMemoryGb?: pulumi.Input<number>;
        /**
         * Total cores.
         */
        totalvCpu?: pulumi.Input<number>;
        /**
         * Used memory. Unit: GiB.
         */
        usedMemoryGb?: pulumi.Input<number>;
        /**
         * Used cores.
         */
        usedvCpu?: pulumi.Input<number>;
        /**
         * Availability zone ID of the current node.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceInstanceParameter {
        /**
         * Parameter name
         */
        parameterName?: pulumi.Input<string>;
        /**
         * Parameter role. Optional values: Node, Shard, ConfigServer, Mongos
         */
        parameterRole?: pulumi.Input<string>;
        /**
         * Parameter value
         */
        parameterValue?: pulumi.Input<string>;
    }
    interface InstanceMongo {
        /**
         * Mongos node ID
         */
        mongosNodeId?: pulumi.Input<string>;
        /**
         * Node specification.
         */
        nodeSpec?: pulumi.Input<string>;
        /**
         * Node status.
         */
        nodeStatus?: pulumi.Input<string>;
        /**
         * Total memory. Unit: GiB.
         */
        totalMemoryGb?: pulumi.Input<number>;
        /**
         * Total cores.
         */
        totalvCpu?: pulumi.Input<number>;
        /**
         * Used memory. Unit: GiB.
         */
        usedMemoryGb?: pulumi.Input<number>;
        /**
         * Used cores.
         */
        usedvCpu?: pulumi.Input<number>;
        /**
         * Availability zone ID of the current node.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceNode {
        /**
         * Node latency. Unit: seconds.
         */
        nodeDelayTime?: pulumi.Input<number>;
        /**
         * Node ID.
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node role. Options: Primary: primary node. Secondary: secondary node. Hidden: hidden node. ReadOnly: read-only node.
         */
        nodeRole?: pulumi.Input<string>;
        /**
         * Node specification.
         */
        nodeSpec?: pulumi.Input<string>;
        /**
         * Node status.
         */
        nodeStatus?: pulumi.Input<string>;
        /**
         * Total memory. Unit: GiB.
         */
        totalMemoryGb?: pulumi.Input<number>;
        /**
         * Total storage space for this node. Unit: GiB.
         */
        totalStorageGb?: pulumi.Input<number>;
        /**
         * Total cores.
         */
        totalvCpu?: pulumi.Input<number>;
        /**
         * Used memory. Unit: GiB.
         */
        usedMemoryGb?: pulumi.Input<number>;
        /**
         * Storage space used by this node. Unit: GiB.
         */
        usedStorageGb?: pulumi.Input<number>;
        /**
         * Used cores.
         */
        usedvCpu?: pulumi.Input<number>;
        /**
         * Availability zone ID of the current node.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceNodeAvailabilityZone {
        /**
         * Number of read-only nodes to add in the current availability zone. Currently, only replica set instances and Shard nodes in sharded cluster instances support adding read-only nodes. When the instance type is ReplicaSet (InstanceType is ReplicaSet), this value indicates the total number of read-only nodes in a single replica set instance. Each replica set instance supports up to 5 read-only nodes. When the instance type is ShardedCluster (InstanceType is ShardedCluster), this value indicates the number of read-only nodes per Shard node. Each Shard node supports up to 5 read-only nodes.
         */
        nodeNumber?: pulumi.Input<number>;
        /**
         * Availability zone of the read-only node.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceShard {
        nodes?: pulumi.Input<pulumi.Input<inputs.mongodb.InstanceShardNode>[]>;
        /**
         * Shard node ID.
         */
        shardId?: pulumi.Input<string>;
    }
    interface InstanceShardNode {
        /**
         * Node latency. Unit: seconds.
         */
        nodeDelayTime?: pulumi.Input<number>;
        /**
         * Node ID.
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node role. Options: Primary: primary node. Secondary: secondary node. Hidden: hidden node. ReadOnly: read-only node.
         */
        nodeRole?: pulumi.Input<string>;
        /**
         * Node specification.
         */
        nodeSpec?: pulumi.Input<string>;
        /**
         * Node status.
         */
        nodeStatus?: pulumi.Input<string>;
        /**
         * Total memory. Unit: GiB.
         */
        totalMemoryGb?: pulumi.Input<number>;
        /**
         * Total storage space for this node. Unit: GiB.
         */
        totalStorageGb?: pulumi.Input<number>;
        /**
         * Total cores.
         */
        totalvCpu?: pulumi.Input<number>;
        /**
         * Used memory. Unit: GiB.
         */
        usedMemoryGb?: pulumi.Input<number>;
        /**
         * Storage space used by this node. Unit: GiB.
         */
        usedStorageGb?: pulumi.Input<number>;
        /**
         * Used cores.
         */
        usedvCpu?: pulumi.Input<number>;
        /**
         * Availability zone ID of the current node.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace natgateway {
    interface NgwEipAddress {
        /**
         * Public IP ID
         */
        allocationId?: pulumi.Input<string>;
        /**
         * Public IP address
         */
        eipAddress?: pulumi.Input<string>;
        /**
         * Usage status of the public IP. Idle: Not used. UsedBySnat: Used by SNAT rule. UsedByDnat: Used by DNAT rule. UsedByNat: Used by both SNAT and DNAT rules.
         */
        usingStatus?: pulumi.Input<string>;
    }
    interface NgwNatIpAddress {
        /**
         * Transit IP address
         */
        natIpAddress?: pulumi.Input<string>;
        /**
         * Transit IP ID
         */
        natIpId?: pulumi.Input<string>;
    }
    interface NgwTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace organization {
    interface AccountSecureContactInfo {
        /**
         * Security email
         */
        email?: pulumi.Input<string>;
        /**
         * Security email verification status: 1. Not verified, 2. Verified
         */
        emailVerified?: pulumi.Input<number>;
        /**
         * New email being changed
         */
        newEmail?: pulumi.Input<string>;
        /**
         * New mobile number being changed
         */
        newPhone?: pulumi.Input<string>;
        /**
         * Security mobile number
         */
        phone?: pulumi.Input<string>;
        /**
         * Security mobile number verification status: 1. Not verified, 2. Verified
         */
        phoneVerified?: pulumi.Input<number>;
    }
    interface AccountTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface OrganizationOrganization {
        /**
         * Creation Time
         */
        createdTime?: pulumi.Input<string>;
        /**
         * Description
         */
        description?: pulumi.Input<string>;
        /**
         * Organization Name
         */
        name?: pulumi.Input<string>;
        /**
         * Administrator ID
         */
        owner?: pulumi.Input<string>;
        /**
         * Status
         */
        status?: pulumi.Input<number>;
        /**
         * Organization type, enterprise organization is always 1
         */
        type?: pulumi.Input<number>;
        /**
         * Last Updated
         */
        updatedTime?: pulumi.Input<string>;
    }
    interface OrganizationOwner {
        /**
         * Account ID
         */
        accountId?: pulumi.Input<number>;
        /**
         * Account Name
         */
        accountName?: pulumi.Input<string>;
        /**
         * Entity Name
         */
        mainName?: pulumi.Input<string>;
    }
    interface ServiceControlPolicyTarget {
        /**
         * Target ID.
         */
        targetId?: pulumi.Input<string>;
        /**
         * Target type: 1. OU 2. Account.
         */
        targetType?: pulumi.Input<string>;
    }
}
export declare namespace privatelink {
    interface EndpointServicePrivateDnsNameConfiguration {
        /**
         * Domain verification name.
         */
        name?: pulumi.Input<string>;
        /**
         * Domain verification status. PendingVerification: Pending verification, Verifying: In progress, Verified: Verified, Failed: Verification failed
         */
        status?: pulumi.Input<string>;
        /**
         * Domain verification type. TXT: TXT record.
         */
        type?: pulumi.Input<string>;
        /**
         * Domain verification value.
         */
        value?: pulumi.Input<string>;
    }
    interface EndpointServiceResource {
        /**
         * Service resource ID to be added to the endpoint service.
         */
        resourceId?: pulumi.Input<string>;
        /**
         * Availability zone where the load balancer provides service.
         */
        zoneIds?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface EndpointServiceTag {
        /**
         * Tag keys for endpoint service tags.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value of the endpoint service tag.
         */
        value?: pulumi.Input<string>;
    }
    interface GatewayEndpointTag {
        /**
         * Tag key of the endpoint tag
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value of the endpoint tag
         */
        value?: pulumi.Input<string>;
    }
    interface VpcEndpointConnectionResourcesAllocate {
        /**
         * Specify the service resource for the endpoint connection
         */
        resourceId?: pulumi.Input<string>;
        /**
         * Availability zone ID of the service resource to be specified
         */
        zoneId?: pulumi.Input<string>;
    }
    interface VpcEndpointConnectionZone {
        /**
         * Endpoint network interface ID. If a seamless service resource replacement is in progress, this indicates the endpoint network interface ID connected to the replaced service resource
         */
        networkInterfaceId?: pulumi.Input<string>;
        /**
         * The private IPv4 address of the terminal node NIC. If a smooth service resource replacement is in progress, this refers to the IPv4 address of the terminal node NIC connected to the service resource being replaced.
         */
        networkInterfaceIp?: pulumi.Input<string>;
        /**
         * Private IPv6 address of the endpoint network interface. If a seamless service resource replacement is in progress, this indicates the IPv6 address of the endpoint network interface connected to the replaced service resource. If the endpoint only supports IPv4, this parameter is not returned
         */
        networkInterfaceIpv6?: pulumi.Input<string>;
        /**
         * Service resource ID
         */
        resourceId?: pulumi.Input<string>;
        /**
         * Status of the service resource
         */
        serviceStatus?: pulumi.Input<string>;
        /**
         * ID of the subnet to which the endpoint network interface belongs
         */
        subnetId?: pulumi.Input<string>;
        /**
         * The domain name of the terminal node availability zone.
         */
        zoneDomain?: pulumi.Input<string>;
        /**
         * Endpoint zone ID
         */
        zoneId?: pulumi.Input<string>;
        /**
         * Status of the endpoint zone. PendingAcceptance: waiting for connection. Connecting: connecting. Connected: connected. Disconnecting: disconnecting. Rejected: connection rejected. Failed: connection failed
         */
        zoneStatus?: pulumi.Input<string>;
    }
    interface VpcEndpointTag {
        /**
         * Tag key of the endpoint user tag. Length limit: 1–128 characters. Case sensitive. Cannot start with 'or' or 'sys:' in any case combination. Cannot start or end with a space. Allowed characters: letters, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equal signs (=), plus signs (+), hyphens (-), and @.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value of the endpoint user tag. Length limit: 0–256 characters. Case sensitive. Cannot start or end with a space. Allowed characters: letters, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equal signs (=), plus signs (+), hyphens (-), and @
         */
        value?: pulumi.Input<string>;
    }
    interface VpcEndpointZone {
        /**
         * The private IPv4 address of the endpoint node's network interface must belong to the subnet's IPv4 CIDR block. You can call the DescribeSubnets API to obtain the subnet's CIDR block. Parameter -N: indicates the sequence number of the private IPv4 address, with a value range of 1–10. Use & to separate multiple private IPv4 addresses.
         */
        privateIpAddress?: pulumi.Input<string>;
        /**
         * The private IPv6 address of the endpoint node's network interface must belong to the subnet's IPv6 CIDR block. You can call the DescribeSubnets API to obtain the subnet's CIDR block. Parameter -N: indicates the sequence number of the private IPv6 address, with a value range of 1–10. Use & to separate multiple private IPv6 addresses. If not specified, an IPv6 address will be randomly assigned within the subnet's IPv6 CIDR block by default.
         */
        privateIpv6Address?: pulumi.Input<string>;
        /**
         * ID of the subnet to which the NIC of the endpoint to be created belongs. You can call the DescribeSubnets API to obtain the subnet ID. Parameter -N: Indicates the sequence number of the subnet ID, value range: 1–10. Separate multiple subnet IDs with &.
         */
        subnetId?: pulumi.Input<string>;
        /**
         * ID of the availability zone to which the NIC of the endpoint to be created belongs. For more information about availability zones, see Regions and Availability Zones. Parameter -N: Indicates the sequence number of the availability zone, value range: 1–10. Separate multiple availability zone IDs with &.
         */
        zoneId?: pulumi.Input<string>;
    }
}
export declare namespace privatezone {
    interface PrivateZoneTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface PrivateZoneVpc {
        /**
         * Region where the VPC is located
         */
        region?: pulumi.Input<string>;
        /**
         * VPC ID
         */
        vpcId?: pulumi.Input<string>;
    }
    interface RecordRecordSet {
        /**
         * Full domain name
         */
        fqdn?: pulumi.Input<string>;
        /**
         * Subdomain prefix
         */
        host?: pulumi.Input<string>;
        /**
         * Record set ID
         */
        id?: pulumi.Input<string>;
        /**
         * Resolution line
         */
        line?: pulumi.Input<string>;
        /**
         * Record type
         */
        type?: pulumi.Input<string>;
        /**
         * Load balancing enabled
         */
        weightEnabled?: pulumi.Input<boolean>;
    }
    interface ResolverEndpointIpConfig {
        /**
         * Availability zone for the endpoint IP address. To ensure high availability, it is recommended to add at least 2 availability zones
         */
        azId?: pulumi.Input<string>;
        /**
         * IPv4 address of the endpoint. If you do not set this parameter, the system automatically assigns an IP address. You can add up to 6 IP addresses
         */
        ip?: pulumi.Input<string>;
        /**
         * IPv6 address of the endpoint. If you do not set this parameter, the system automatically assigns an IP address. You can add up to 6 IP addresses
         */
        ipv6?: pulumi.Input<string>;
        /**
         * Subnet ID for the endpoint IP address
         */
        subnetId?: pulumi.Input<string>;
    }
    interface ResolverEndpointTag {
        /**
         * User tag key
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value
         */
        value?: pulumi.Input<string>;
    }
    interface ResolverRuleForwardIP {
        /**
         * IP address of the external DNS server for the VPC
         */
        ip?: pulumi.Input<string>;
        /**
         * Port of the external DNS server for the VPC
         */
        port?: pulumi.Input<number>;
    }
    interface ResolverRuleTag {
        /**
         * Tag key for the user tag
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for the user tag
         */
        value?: pulumi.Input<string>;
    }
    interface ResolverRuleVpC {
        /**
         * Region of the VPC
         */
        region?: pulumi.Input<string>;
        /**
         * VPC ID
         */
        vpcId?: pulumi.Input<string>;
    }
}
export declare namespace rabbitmq {
    interface AllowListAssociatedInstance {
        /**
         * Instance ID
         */
        instanceId?: pulumi.Input<string>;
    }
    interface InstanceChargeDetail {
        /**
         * Whether to automatically renew the subscription instance after expiration.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Instance billing end time. The time format is YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        chargeEndTime?: pulumi.Input<string>;
        /**
         * Expiration time of the subscription instance. The time format is YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        chargeExpireTime?: pulumi.Input<string>;
        /**
         * Instance billing start time. The time format is YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        chargeStartTime?: pulumi.Input<string>;
        /**
         * Instance billing status. Includes: Normal: normal, Overdue: pay-as-you-go overdue, Expired: subscription expired.
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Instance billing type. Supported types include: PostPaid: pay-as-you-go, PrePaid: subscription.
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Estimated release time after the instance is suspended due to overdue payment. Time format: YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        overdueReclaimTime?: pulumi.Input<string>;
        /**
         * Instance suspension time due to overdue payment. Time format: YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        overdueTime?: pulumi.Input<string>;
        /**
         * Subscription instance purchase duration. When PeriodUnit is set to Month, the value range is 1–9. When PeriodUnit is set to Year, the value range is 1–3.
         */
        period?: pulumi.Input<number>;
        /**
         * Unit for purchase duration. Values: MONTHLY: monthly purchase, YEARLY: annual purchase.
         */
        periodUnit?: pulumi.Input<string>;
    }
    interface InstanceEndpoint {
        /**
         * Type of instance endpoint. RabbitMQ instances provide the following endpoint types: WEB: Web UI endpoint, AMQP0*9*1: AMQP endpoint, MQTT: MQTT endpoint, WEB_MQTT: WEB and MQTT endpoints, STOMP: STOMP endpoint.
         */
        endpointType?: pulumi.Input<string>;
        /**
         * Private network access domain name of the instance.
         */
        internalEndpoint?: pulumi.Input<string>;
        /**
         * Public service zone IP endpoint.
         */
        internalIpEndpoint?: pulumi.Input<string>;
        /**
         * Network type of the endpoint. PrivateNetwork indicates a private network (VPC).
         */
        networkType?: pulumi.Input<string>;
        /**
         * Instance public access domain name. Displayed only after public access is enabled.
         */
        publicEndpoint?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface PublicAddressChargeDetail {
        /**
         * Whether subscription instances are automatically renewed after expiration.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Instance billing end time. Time format: YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        chargeEndTime?: pulumi.Input<string>;
        /**
         * Expiration time for subscription instances. Time format: YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        chargeExpireTime?: pulumi.Input<string>;
        /**
         * Instance billing start time. Time format: YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        chargeStartTime?: pulumi.Input<string>;
        /**
         * Instance billing status. Includes: Normal: normal, Overdue: pay-as-you-go overdue, Expired: subscription expired.
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Instance billing type. Supported types: PostPaid: pay-as-you-go, PrePaid: subscription.
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Estimated release time after instance is stopped due to overdue payment. Time format: YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        overdueReclaimTime?: pulumi.Input<string>;
        /**
         * Instance overdue shutdown time. Time format: YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        overdueTime?: pulumi.Input<string>;
    }
    interface PublicAddressEndpoint {
        /**
         * Access point type of the instance. RabbitMQ instance provides the following access point types: WEB: Web UI access point, AMQP0*9*1: AMQP access point, MQTT: MQTT access point, WEB_MQTT: WEB and MQTT access point, STOMP: STOMP access point.
         */
        endpointType?: pulumi.Input<string>;
        /**
         * Instance private network access domain name.
         */
        internalEndpoint?: pulumi.Input<string>;
        /**
         * Public service zone IP access point.
         */
        internalIpEndpoint?: pulumi.Input<string>;
        /**
         * Network type of the access point. PrivateNetwork indicates private VPC network.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Instance public access domain name. Displayed only after public access is enabled.
         */
        publicEndpoint?: pulumi.Input<string>;
    }
    interface PublicAddressTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace rdsmssql {
    interface AllowListAssociatedInstance {
        /**
         * Instance ID
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Instance name
         */
        instanceName?: pulumi.Input<string>;
        /**
         * Instance status
         */
        instanceStatus?: pulumi.Input<string>;
        /**
         * Sync latest allowlist IP
         */
        isLatest?: pulumi.Input<boolean>;
        /**
         * Project name of the instance
         */
        projectName?: pulumi.Input<string>;
        /**
         * VPC ID of the instance
         */
        vpc?: pulumi.Input<string>;
    }
    interface BackupBackupDatabaseDetail {
        /**
         * External network backup download link.
         */
        backupDownloadLinkEip?: pulumi.Input<string>;
        /**
         * Internal network backup download link.
         */
        backupDownloadLinkInner?: pulumi.Input<string>;
        /**
         * Backup end time. Format: yyyy-MM-ddTHH:mm:ss.sZ (UTC time).
         */
        backupEndTime?: pulumi.Input<string>;
        /**
         * Backup file name.
         */
        backupFileName?: pulumi.Input<string>;
        /**
         * Backup file size (Bytes).
         */
        backupFileSize?: pulumi.Input<number>;
        /**
         * Backup start time. Format: yyyy-MM-ddTHH:mm:ss.sZ (UTC time).
         */
        backupStartTime?: pulumi.Input<string>;
        /**
         * Backup type. Values: Full (full backup), Diff (differential backup).
         */
        backupType?: pulumi.Input<string>;
        /**
         * Database name.
         */
        databaseName?: pulumi.Input<string>;
        /**
         * Backup file preparation progress (%).
         */
        downloadProgress?: pulumi.Input<number>;
        /**
         * Backup file preparation status. Values: Success (preparation completed), Failed (preparation failed), Running (preparing), NotDownload (not downloaded).
         */
        downloadStatus?: pulumi.Input<string>;
        /**
         * Download link expiration time. Format: yyyy-MM-ddTHH:mm:sssZ (UTC time).
         */
        linkExpiredTime?: pulumi.Input<string>;
    }
    interface BackupBackupMeta {
        /**
         * Backup database name.
         */
        dbName?: pulumi.Input<string>;
    }
    interface InstanceChargeInfo {
        /**
         * Auto-renewal for prepaid scenarios. true: auto-renew (default). false: do not auto-renew.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Billing expiration time, in the format yyyy-MM-ddTHH:mm:ssZ (UTC time).
         */
        chargeEndTime?: pulumi.Input<string>;
        /**
         * Billing start time, in the format yyyy-MM-ddTHH:mm:ssZ (UTC time).
         */
        chargeStartTime?: pulumi.Input<string>;
        /**
         * Payment status. Possible values: Normal: instance is normal. Overdue: instance is overdue. Unpaid: instance is awaiting payment.
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Billing type. Values: PostPaid: pay-as-you-go. PrePaid: annual/monthly subscription.
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Estimated release time when service is suspended due to overdue payment. Format: yyyy-MM-ddTHH:mm:ssZ (UTC time).
         */
        overdueReclaimTime?: pulumi.Input<string>;
        /**
         * Shutdown time due to overdue payment, in the format yyyy-MM-ddTHH:mm:ssZ (UTC time).
         */
        overdueTime?: pulumi.Input<string>;
        /**
         * Purchase duration for prepaid scenarios. Default: 1 month.
         */
        period?: pulumi.Input<number>;
        /**
         * Purchase cycle for prepaid scenarios. Month: monthly subscription (default). Year: annual subscription.
         */
        periodUnit?: pulumi.Input<string>;
    }
    interface InstanceConnectionInfo {
        addresses?: pulumi.Input<pulumi.Input<inputs.rdsmssql.InstanceConnectionInfoAddress>[]>;
        /**
         * Description.
         */
        description?: pulumi.Input<string>;
        /**
         * Terminal ID.
         */
        endpointId?: pulumi.Input<string>;
        /**
         * Terminal name.
         */
        endpointName?: pulumi.Input<string>;
        /**
         * Terminal type. Possible values: Primary: primary node terminal. ROCluster: read-only cluster terminal. RO: read-only node terminal.
         */
        endpointType?: pulumi.Input<string>;
    }
    interface InstanceConnectionInfoAddress {
        /**
         * Indicates whether private network to public network resolution is enabled. Available values: true: enabled. false: disabled.
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Domain name.
         */
        domain?: pulumi.Input<string>;
        /**
         * EIP ID, valid only for public addresses.
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP address.
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network address type. Possible values: Private: private network type. Public: public network type.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Port.
         */
        port?: pulumi.Input<string>;
        /**
         * Subnet ID, valid only for private network addresses.
         */
        subnetId?: pulumi.Input<string>;
    }
    interface InstanceNodeDetailInfo {
        /**
         * Node creation time.
         */
        createTime?: pulumi.Input<string>;
        /**
         * Node hostname.
         */
        hostName?: pulumi.Input<string>;
        /**
         * Instance ID.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Memory size, in GiB.
         */
        memory?: pulumi.Input<number>;
        /**
         * Node ID.
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node IP.
         */
        nodeIp?: pulumi.Input<string>;
        /**
         * Node specification.
         */
        nodeSpec?: pulumi.Input<string>;
        /**
         * Node status. Possible values: Running: running. Creating: creating. Deleting: deleting. Restarting: restarting. Updating: updating. MasterChanging: master/standby switching. Error: error.
         */
        nodeStatus?: pulumi.Input<string>;
        /**
         * Node type. Possible values: Primary: primary node terminal. ReadOnly: read-only node terminal. Secondary: standby node terminal.
         */
        nodeType?: pulumi.Input<string>;
        /**
         * Region ID.
         */
        regionId?: pulumi.Input<string>;
        /**
         * Update time.
         */
        updateTime?: pulumi.Input<string>;
        /**
         * vCPU count.
         */
        vcpu?: pulumi.Input<number>;
        /**
         * Availability zone ID.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * Tag key for user tags.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace rdsmysql {
    interface AllowListAssociatedInstance {
        /**
         * Instance ID bound to the current allowlist.
         */
        instanceId?: pulumi.Input<string>;
    }
    interface AllowListSecurityGroupBindInfo {
        /**
         * Mode for associating security groups. Values: IngressDirectionIp: Inbound IP. AssociateEcsIp: Associate ECS IP. Note: In the CreateAllowList API, the BindMode and SecurityGroupId fields of SecurityGroupBindInfoObject are required.
         */
        bindMode?: pulumi.Input<string>;
        /**
         * Security group ID.
         */
        securityGroupId?: pulumi.Input<string>;
        /**
         * Security group name.
         */
        securityGroupName?: pulumi.Input<string>;
    }
    interface BackupBackupMeta {
        /**
         * Database name
         */
        database?: pulumi.Input<string>;
        /**
         * Table name list
         */
        tables?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface BackupDbTableInfo {
        /**
         * Database name
         */
        database?: pulumi.Input<string>;
        /**
         * Table name list
         */
        tables?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface DatabaseDatabasePrivilege {
        /**
         * Database account name.
         */
        accountName?: pulumi.Input<string>;
        /**
         * Granted account privilege type. Values: ReadWrite (read and write privileges), ReadOnly (read-only privileges), DDLOnly (DDL privileges only), DMLOnly (DML privileges only), Custom (custom privileges).
         */
        accountPrivilege?: pulumi.Input<string>;
        /**
         * The specified database account can access the database from the IP address. Default value: %. If Host is set to %, the account can access the database from any IP address. If Host is set to 192.10.10.%, the account can access the database from IP addresses between 192.10.10.0 and 192.10.10.255. The specified Host must be added to the instance's allowlist.
         */
        host?: pulumi.Input<string>;
    }
    interface DbAccountAccountPrivilege {
        /**
         * Type of database permission. Value options: ReadWrite: read and write permission. ReadOnly: read-only permission. DDLOnly: DDL permission only. DMLOnly: DML permission only. Custom: custom permission. Global: global permission. None: clear account permission. Note: When used as a request parameter, pay attention to the following: Only Global and None are allowed as values when used as request parameters. Permission type is single-select; passing multiple values will result in an error. Only the GrantDBAccountPrivilege API supports None as a value for AccountPrivilege. When AccountPrivilege is set to None and DBName is an empty string, all global permissions for the account are cleared. If DBName is set to a specific database, all permissions for the account in that database are cleared.
         */
        accountPrivilege?: pulumi.Input<string>;
        /**
         * Account privilege information. When AccountPrivilege is set to Custom, the valid values for this field are: SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, REFERENCES, INDEX, ALTER, CREATE TEMPORARY TABLES, LOCK TABLES, EXECUTE, CREATE VIEW, SHOW VIEW, EVENT, TRIGGER, CREATE ROUTINE, ALTER ROUTINE. When AccountPrivilege is set to Global, the valid values for this field are: PROCESS, REPLICATION SLAVE, REPLICATION CLIENT, SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, RELOAD, REFERENCES, INDEX, ALTER, LOCK TABLES, EXECUTE, CREATE VIEW, SHOW VIEW, CREATE ROUTINE, ALTER ROUTINE, CREATE USER, EVENT, TRIGGER, SHOW DATABASES, CREATE TEMPORARY TABLES. Note: When used as a request parameter, this field is required if AccountPrivilege is set to Custom. In the CreateDBAccount API, REPLICATION SLAVE, PROCESS, and REPLICATION CLIENT global privileges are automatically granted to the account. Multiple values can be specified, separated by commas (,). The write mode is overwrite.
         */
        accountPrivilegeDetails?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * The name of the database for which account authorization needs to be modified or for which the account already has privileges. Note: When used as a request parameter in the CreateDBAccount and GrantDBAccountPrivilege APIs, ensure that the database corresponding to DBName already exists. For global privilege modifications, set DBName to an empty string.
         */
        dbName?: pulumi.Input<string>;
    }
    interface DbAccountTableColumnPrivilege {
        columnPrivileges?: pulumi.Input<pulumi.Input<inputs.rdsmysql.DbAccountTableColumnPrivilegeColumnPrivilege>[]>;
        /**
         * Name of the database to which the table belongs for setting permissions for the account.
         */
        dbName?: pulumi.Input<string>;
        tablePrivileges?: pulumi.Input<pulumi.Input<inputs.rdsmysql.DbAccountTableColumnPrivilegeTablePrivilege>[]>;
    }
    interface DbAccountTableColumnPrivilegeColumnPrivilege {
        /**
         * Permission information for setting column permissions for the account. Values (multiple selections allowed): INSERT, REFERENCES, SELECT, UPDATE. Note: Use commas (,) to separate multiple permissions.
         */
        accountPrivilegeDetails?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Name of the column for setting column permissions for the account.
         */
        columnName?: pulumi.Input<string>;
        /**
         * Name of the database to which the table belongs for setting column permissions for the account.
         */
        tableName?: pulumi.Input<string>;
    }
    interface DbAccountTableColumnPrivilegeTablePrivilege {
        /**
         * Account table permissions. Value options (multiple selections allowed): ALTER, CREATE, DELETE, DROP, INDEX, INSERT, SELECT, SHOW, VIEW, TRIGGER, UPDATE, CREATE VIEW, REFERENCES. Note: Use commas (,) to separate multiple permissions.
         */
        accountPrivilegeDetails?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Name of the table for setting permissions for the account.
         */
        tableName?: pulumi.Input<string>;
    }
    interface EndpointAddress {
        /**
         * false: Volcano Engine private network resolution (default). true: Volcano Engine private network and public network resolution.
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Connection address prefix. The prefix must meet the following rules: start with a lowercase letter and end with a lowercase letter or digit; contain at least two of the following: lowercase letters, digits, or hyphens (-); be at least 8 characters long; and the total connection address length (prefix + suffix) must not exceed 63 characters.
         */
        domainPrefix?: pulumi.Input<string>;
        /**
         * Port.
         */
        port?: pulumi.Input<string>;
    }
    interface EndpointCustomRouteStrategy {
        keywordRouteStrategies?: pulumi.Input<pulumi.Input<inputs.rdsmysql.EndpointCustomRouteStrategyKeywordRouteStrategy>[]>;
    }
    interface EndpointCustomRouteStrategyKeywordRouteStrategy {
        /**
         * SQL forwarding rule target. Options: Primary: primary node. Secondary: secondary node. ReadOnly: read-only node. Note: For dual-node instances, you can select the primary node or read-only node. For multi-node instances, you can select the primary node or secondary node.
         */
        nodeType?: pulumi.Input<string>;
        /**
         * Forwarding rule keywords. SQL keyword rules: Each rule can contain up to 20 keywords, with a maximum length of 64 characters. Allowed characters: English letters, digits, underscore (_), @, #, :=, and Chinese characters.
         */
        sqlKeyword?: pulumi.Input<string>;
    }
    interface EndpointReadOnlyNodeWeight {
        /**
         * NodeId is required for read-only nodes; not required for primary nodes.
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node type. Primary: primary node. ReadOnly: read-only node.
         */
        nodeType?: pulumi.Input<string>;
        /**
         * Node read weight increases in increments of 100, up to a maximum of 10,000. Note: Not all weights can be set to 0.
         */
        weight?: pulumi.Input<number>;
    }
    interface InstanceAddressObject {
        /**
         * false: private network resolution (default). true: private and public network resolution.
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Connection domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * EIP ID, valid only for Public addresses.
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP protocol version. Value: IPv4.
         */
        internetProtocol?: pulumi.Input<string>;
        /**
         * IP address.
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network address type. Values: Private: private address. Public: public address
         */
        networkType?: pulumi.Input<string>;
        /**
         * Port
         */
        port?: pulumi.Input<string>;
        /**
         * Subnet ID, valid only for Private addresses
         */
        subnetId?: pulumi.Input<string>;
    }
    interface InstanceAutoStorageScalingConfig {
        /**
         * Whether to enable automatic scaling for the instance. Values: true: Yes. false: No.
         */
        enableStorageAutoScale?: pulumi.Input<boolean>;
        /**
         * Percentage of available storage space that triggers automatic scaling. Value range: 10–50, default: 10, unit: %
         */
        storageThreshold?: pulumi.Input<number>;
        /**
         * Maximum storage space for automatic expansion. The minimum value is instance storage space + 20 GB; the maximum value is the upper limit of the storage space range for the primary node specification, in GB. See details about selectable storage space ranges for different specifications.
         */
        storageUpperBound?: pulumi.Input<number>;
    }
    interface InstanceChargeDetail {
        /**
         * Enable auto-renewal for prepaid scenarios. Values: true: auto-renewal. false: do not auto-renew
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Billing end time for subscription instance (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
         */
        chargeEndTime?: pulumi.Input<string>;
        /**
         * Billing start time for the instance (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ
         */
        chargeStartTime?: pulumi.Input<string>;
        /**
         * Instance billing status. Values: Normal: normal. Overdue: overdue. Unpaid: pending payment.
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Billing type. Options: PrePaid: subscription. PostPaid: pay-as-you-go
         */
        chargeType: pulumi.Input<string>;
        /**
         * Number of instances to purchase. Value range: 1–50. Default: 1
         */
        number?: pulumi.Input<number>;
        /**
         * Estimated release time after the instance is stopped due to overdue payment (pay-as-you-go) or expiration (subscription), in UTC. Format: yyyy-MM-ddTHH:mm:ss.sssZ
         */
        overdueReclaimTime?: pulumi.Input<string>;
        /**
         * Time when the instance is stopped due to overdue payment (pay-as-you-go) or expiration (subscription) (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
         */
        overdueTime?: pulumi.Input<string>;
        /**
         * Purchase duration in prepaid scenarios.
         */
        period?: pulumi.Input<number>;
        /**
         * Purchase cycle in prepaid scenarios. Month: monthly purchase cycle (default). Year: yearly purchase cycle.
         */
        periodUnit?: pulumi.Input<string>;
        /**
         * Restore time for temporary scaling (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
         */
        tempModifyEndTime?: pulumi.Input<string>;
        /**
         * Start time for temporary scaling (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ
         */
        tempModifyStartTime?: pulumi.Input<string>;
    }
    interface InstanceDisasterRecoveryInstance {
        /**
         * ID of synchronization tasks between primary and disaster recovery instances.
         */
        dtsTaskId?: pulumi.Input<string>;
        /**
         * Name of the synchronization task between the primary instance and the disaster recovery instance
         */
        dtsTaskName?: pulumi.Input<string>;
        /**
         * Status of synchronization tasks between the primary instance and the disaster recovery instance
         */
        dtsTaskStatus?: pulumi.Input<string>;
        /**
         * Disaster recovery instance ID.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Name of disaster recovery instance.
         */
        instanceName?: pulumi.Input<string>;
        /**
         * Latency between the disaster recovery instance and the primary instance.
         */
        secondsBehindMaster?: pulumi.Input<number>;
    }
    interface InstanceEndpoint {
        /**
         * When the endpoint type is read/write or read-only, you can set whether new nodes join automatically. Values: Enable: auto join. Disable: do not auto join (default)
         */
        autoAddNewNodes?: pulumi.Input<string>;
        /**
         * Connection endpoint tag.
         */
        connectionInfoTags?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Connection endpoint type. Values: Proxy: proxy endpoint. Direct: direct endpoint
         */
        connectionMode?: pulumi.Input<string>;
        /**
         * Connection pool type for proxy terminal. Values: Transaction: Transaction-level connection pool. Default value. Direct: Direct mode.
         */
        connectionPoolType?: pulumi.Input<string>;
        /**
         * Description of the connection endpoint
         */
        description?: pulumi.Input<string>;
        /**
         * Enable connection keep-alive. Options: true: yes. false: no
         */
        enableConnectionPersistent?: pulumi.Input<boolean>;
        /**
         * Is global read-only enabled? Values: Enable: enabled. Disable: not enabled.
         */
        enableReadOnly?: pulumi.Input<string>;
        /**
         * Whether to enable read/write separation. Values: Enable: Enabled. Disable: Not enabled.
         */
        enableReadWriteSplitting?: pulumi.Input<string>;
        /**
         * Instance connection endpoint ID.
         */
        endpointId?: pulumi.Input<string>;
        /**
         * Instance connection endpoint name.
         */
        endpointName?: pulumi.Input<string>;
        /**
         * Endpoint type. Value: Custom, custom endpoint.
         */
        endpointType?: pulumi.Input<string>;
        /**
         * Whether the idle connection recycling feature is enabled. true: Enabled. false: Not enabled.
         */
        idleConnectionReclaim?: pulumi.Input<boolean>;
        /**
         * Whether to enable transaction separation. Values: true: Yes. false: No.
         */
        implicitTransSplit?: pulumi.Input<boolean>;
        /**
         * Whether to enable primary node routing. Values: true: Yes. false: No.
         */
        masterNodeRouting?: pulumi.Input<boolean>;
        /**
         * Overload protection timeout. Value range: integer between 60 and 7200, in seconds.
         */
        masterProtectorTimeout?: pulumi.Input<number>;
        /**
         * Multi-Statements mode for proxy endpoints. Values: Strict: strict mode (default). Loose: loose mode
         */
        multiStatementsMode?: pulumi.Input<string>;
        /**
         * Overload protection enabled. Values: true: yes. false: no
         */
        overloadProtection?: pulumi.Input<boolean>;
        /**
         * Read weight allocation mode. This parameter is required when read/write splitting is enabled (set to true). For request parameters in the CreateDBEndpoint and ModifyDBEndpoint APIs, valid values are: LoadSchedule: load scheduling. RoundRobinCustom: custom weighted round-robin scheduling. RoundRobinAuto: automatic weighted round-robin scheduling. For response parameters in the DescribeDBInstanceDetail API, valid values are: Default: automatic allocation based on specification weights. Custom: custom weight allocation. RoundRobin: round-robin scheduling. LoadSchedule: load scheduling. RoundRobinCustom: custom weighted round-robin scheduling. RoundRobinAuto: automatic weighted round-robin scheduling.
         */
        readOnlyNodeDistributionType?: pulumi.Input<string>;
        /**
         * Read-only node latency threshold. Value range: 1~3600, default is 30, unit: seconds.
         */
        readOnlyNodeMaxDelayTime?: pulumi.Input<number>;
        readOnlyNodeWeights?: pulumi.Input<pulumi.Input<inputs.rdsmysql.InstanceEndpointReadOnlyNodeWeight>[]>;
        /**
         * Read/write mode: ReadWrite: read/write. ReadOnly: read-only
         */
        readWriteMode?: pulumi.Input<string>;
    }
    interface InstanceEndpointReadOnlyNodeWeight {
        /**
         * Read-only nodes require NodeId. Primary nodes do not require it
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node type. Primary: primary node. ReadOnly: read-only node
         */
        nodeType?: pulumi.Input<string>;
        /**
         * Node read weight, increments of 100, maximum value is 10000.
         */
        weight?: pulumi.Input<number>;
    }
    interface InstanceMaintenanceWindow {
        /**
         * Maintenance cycle granularity. Value: Week.
         */
        dayKind?: pulumi.Input<string>;
        /**
         * Specify the days of the week when the maintenance window is active. Multiple selections allowed. Monday: Monday. Tuesday: Tuesday. Wednesday: Wednesday. Thursday: Thursday. Friday: Friday. Saturday: Saturday. Sunday: Sunday.
         */
        dayOfWeeks?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance maintenance window. Format: HH:mmZ-HH:mmZ (UTC). Note: Specifies the time period during which maintenance can be performed.
         */
        maintenanceTime?: pulumi.Input<string>;
    }
    interface InstanceNode {
        /**
         * Node specification.
         */
        nodeSpec: pulumi.Input<string>;
        /**
         * Node type. Values: Primary: primary node. Secondary: secondary node. ReadOnly: read-only node.
         */
        nodeType: pulumi.Input<string>;
        /**
         * Availability zone ID
         */
        zoneId: pulumi.Input<string>;
    }
    interface InstanceProxyDetail {
        /**
         * Status of the instance database proxy feature. Values: Creating: proxy enabling. Running: proxy running. Shutdown: proxy disabled. Deleting: proxy disabling
         */
        dbProxyStatus?: pulumi.Input<string>;
        /**
         * Resource information for the instance's database proxy service
         */
        proxyResourceInfo?: pulumi.Input<inputs.rdsmysql.InstanceProxyDetailProxyResourceInfo>;
    }
    interface InstanceProxyDetailProxyResourceInfo {
        /**
         * Current number of cores for the instance database proxy service
         */
        currentProxyCpuNum?: pulumi.Input<number>;
        /**
         * Maximum number of cores configurable for database proxy service.
         */
        maxProxyCpuNum?: pulumi.Input<number>;
        /**
         * Minimum number of CPU cores configurable for the database proxy service
         */
        minProxyCpuNum?: pulumi.Input<number>;
    }
    interface InstanceTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface ParameterTemplateTemplateParam {
        /**
         * Instance parameter name
         */
        name: pulumi.Input<string>;
        /**
         * Parameter runtime value
         */
        runningValue: pulumi.Input<string>;
    }
}
export declare namespace rdspostgresql {
    interface AllowListAssociatedInstance {
        /**
         * Instance ID.
         */
        instanceId?: pulumi.Input<string>;
    }
    interface AllowListSecurityGroupBindInfo {
        /**
         * Mode for associating security groups. Values: IngressDirectionIp: inbound IP. AssociateEcsIp: associate ECS IP.
         */
        bindMode?: pulumi.Input<string>;
        /**
         * IP address list in the security group.
         */
        ipLists?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Security group ID.
         */
        securityGroupId?: pulumi.Input<string>;
        /**
         * Security group name.
         */
        securityGroupName?: pulumi.Input<string>;
    }
    interface BackupBackupMeta {
        /**
         * Database name.
         */
        dbName?: pulumi.Input<string>;
    }
    interface BackupBackupPolicy {
        /**
         * Backup retention days.
         */
        backupRetentionPeriod?: pulumi.Input<number>;
        /**
         * Data incremental backup schedule.
         */
        dataIncrBackupPeriods?: pulumi.Input<string>;
        /**
         * Full backup schedule, such as Monday,Tuesday.
         */
        fullBackupPeriod?: pulumi.Input<string>;
        /**
         * Full backup time window, such as 00:00Z-01:00Z.
         */
        fullBackupTime?: pulumi.Input<string>;
        /**
         * Enable hourly incremental backup.
         */
        hourlyIncrBackupEnable?: pulumi.Input<boolean>;
        /**
         * Incremental backup frequency (hours).
         */
        incrementBackupFrequency?: pulumi.Input<number>;
        /**
         * Enable WAL log space limit.
         */
        walLogSpaceLimitEnable?: pulumi.Input<boolean>;
    }
    interface DbEndpointInnerAddresses {
        /**
         * Private network address accessible across regions. Note: If this address is unavailable, this field will not be returned.
         */
        crossRegionDomain?: pulumi.Input<string>;
        /**
         * Whether public network resolution is enabled. Values: false: Default, private network resolution. true: Both private and public network resolution.
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Connection domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * New access address prefix. The access address prefix must meet the following rules: consists of lowercase letters, numbers, and hyphens (-). Must contain at least 8 characters. The total length (including suffix) must not exceed 63 characters. Must start with a lowercase letter and end with a lowercase letter or number.
         */
        domainPrefix?: pulumi.Input<string>;
        /**
         * Type of private network address. Values: LocalDomain: Local region domain name. CrossRegionDomain: Domain name accessible across regions.
         */
        domainVisibilitySetting?: pulumi.Input<string>;
        /**
         * EIP ID, valid only for Public addresses.
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP address
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network address type. Values: Private: private network connection address. Public: public network connection address. Inner: public service zone address.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Port number.
         */
        port?: pulumi.Input<string>;
        /**
         * Subnet ID
         */
        subnetId?: pulumi.Input<string>;
    }
    interface DbEndpointPrivateAddresses {
        /**
         * Private network address accessible across regions. Note: If this address is unavailable, this field will not be returned.
         */
        crossRegionDomain?: pulumi.Input<string>;
        /**
         * Whether public network resolution is enabled. Values: false: Default, private network resolution. true: Both private and public network resolution.
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Connection domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * New access address prefix. The access address prefix must meet the following rules: consists of lowercase letters, numbers, and hyphens (-). Must contain at least 8 characters. The total length (including suffix) must not exceed 63 characters. Must start with a lowercase letter and end with a lowercase letter or number.
         */
        domainPrefix?: pulumi.Input<string>;
        /**
         * Type of private network address. Values: LocalDomain: Local region domain name. CrossRegionDomain: Domain name accessible across regions.
         */
        domainVisibilitySetting?: pulumi.Input<string>;
        /**
         * EIP ID, valid only for Public addresses.
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP address
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network address type. Values: Private: private network connection address. Public: public network connection address. Inner: public service zone address.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Port number.
         */
        port?: pulumi.Input<string>;
        /**
         * Subnet ID
         */
        subnetId?: pulumi.Input<string>;
    }
    interface DbEndpointPublicAddresses {
        /**
         * Private network address accessible across regions. Note: If this address is unavailable, this field will not be returned.
         */
        crossRegionDomain?: pulumi.Input<string>;
        /**
         * Whether public network resolution is enabled. Values: false: Default, private network resolution. true: Both private and public network resolution.
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Connection domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * New access address prefix. The access address prefix must meet the following rules: consists of lowercase letters, numbers, and hyphens (-). Must contain at least 8 characters. The total length (including suffix) must not exceed 63 characters. Must start with a lowercase letter and end with a lowercase letter or number.
         */
        domainPrefix?: pulumi.Input<string>;
        /**
         * Type of private network address. Values: LocalDomain: Local region domain name. CrossRegionDomain: Domain name accessible across regions.
         */
        domainVisibilitySetting?: pulumi.Input<string>;
        /**
         * EIP ID, valid only for Public addresses.
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP address
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network address type. Values: Private: private network connection address. Public: public network connection address. Inner: public service zone address.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Port number.
         */
        port?: pulumi.Input<string>;
        /**
         * Subnet ID
         */
        subnetId?: pulumi.Input<string>;
    }
    interface DbEndpointReadOnlyNodeWeight {
        /**
         * Read-only nodes require the NodeId to be provided.
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node type. Values: Primary: primary node. ReadOnly: read-only node.
         */
        nodeType?: pulumi.Input<string>;
        /**
         * Read weight of the node, increases in increments of 100, maximum value is 40000. Note: Weights cannot all be set to 0.
         */
        weight?: pulumi.Input<number>;
    }
    interface InstanceChargeDetail {
        /**
         * Enable auto-renewal for prepaid scenarios
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Billing expiration time for yearly/monthly instances
         */
        chargeEndTime?: pulumi.Input<string>;
        /**
         * Instance billing start time
         */
        chargeStartTime?: pulumi.Input<string>;
        /**
         * Payment status. Value:   - `Normal`: Normal   - `Overdue`: Overdue and suspended   - `Unpaid`: Unpaid
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Payment type. Value:   - `PostPaid`: Postpaid   - `PrePaid`: Prepaid
         */
        chargeType: pulumi.Input<string>;
        /**
         * Estimated release time after instance suspension due to overdue payment
         */
        overdueReclaimTime?: pulumi.Input<string>;
        /**
         * Instance shutdown time due to overdue payment
         */
        overdueTime?: pulumi.Input<string>;
        /**
         * Purchase duration for prepaid scenarios
         */
        period?: pulumi.Input<number>;
        /**
         * Purchase period for prepaid scenarios. Values:   - `Month`: month   - `Year`: year
         */
        periodUnit?: pulumi.Input<string>;
        /**
         * Rollback time for temporary upgrade
         */
        tempModifyEndTime?: pulumi.Input<string>;
        /**
         * Start time of temporary scaling
         */
        tempModifyStartTime?: pulumi.Input<string>;
    }
    interface InstanceEndpoint {
        addresses?: pulumi.Input<pulumi.Input<inputs.rdspostgresql.InstanceEndpointAddress>[]>;
        /**
         * When the terminal type is read-write or read-only, you can set whether new nodes join automatically. Values:   - `Enable`: join automatically   - `Disable`: do not join automatically (default)
         */
        autoAddNewNodes?: pulumi.Input<string>;
        /**
         * Address description.
         */
        description?: pulumi.Input<string>;
        /**
         * Enable global read-only mode.   - `Enable`: enabled   - `Disable`: not enabled
         */
        enableReadOnly?: pulumi.Input<string>;
        /**
         * Enable read-write separation. Values:   - `Enable`: enabled   - `Disable`: not enabled
         */
        enableReadWriteSplitting?: pulumi.Input<string>;
        /**
         * Instance connection terminal ID
         */
        endpointId?: pulumi.Input<string>;
        /**
         * Instance connection terminal name
         */
        endpointName?: pulumi.Input<string>;
        /**
         * Endpoint type:   - `Cluster`: Default endpoint (created by default)   - `Custom`: Custom endpoint
         */
        endpointType?: pulumi.Input<string>;
        /**
         * Read-only weight allocation mode. Options:   - `Default`: Standard weight allocation (default).   - `Custom`: Custom weight allocation
         */
        readOnlyNodeDistributionType?: pulumi.Input<string>;
        /**
         * Maximum latency threshold for read-only nodes. If a read-only node's latency exceeds this value, read traffic will not be sent to that node. Unit: seconds. Range: 0~3600. Default: 30.
         * **Note:** This parameter can be set for the default endpoint when read/write splitting is enabled.
         */
        readOnlyNodeMaxDelayTime?: pulumi.Input<number>;
        readOnlyNodeWeights?: pulumi.Input<pulumi.Input<inputs.rdspostgresql.InstanceEndpointReadOnlyNodeWeight>[]>;
        /**
         * Read/write mode:   - `ReadWrite`: Read/write   - `ReadOnly`: Read-only
         */
        readWriteMode?: pulumi.Input<string>;
        /**
         * After read/write splitting is enabled for the terminal, set the number of proxy connections for the terminal.   - The minimum value for proxy connections is 20.   - The maximum value depends on the specification of the instance's primary node. Different specifications support different maximum proxy connections. For details, see [Product Specifications]
         */
        readWriteProxyConnection?: pulumi.Input<number>;
        /**
         * Whether the endpoint sends write requests to the write node (currently, only the primary node is the write node). Value:   - `true`: Yes. (Default)   - `false`: No
         */
        writeNodeHaltWriting?: pulumi.Input<boolean>;
    }
    interface InstanceEndpointAddress {
        /**
         * Private network address accessible across regions
         */
        crossRegionDomain?: pulumi.Input<string>;
        /**
         * Enable public network resolution. Values:   - false: default, private network resolution   - true: private and public network resolution
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Connection domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * Private network address type. Values: LocalDomain: local region domain name CrossRegionDomain: cross-region accessible domain name
         */
        domainVisibilitySetting?: pulumi.Input<string>;
        /**
         * EIP ID, valid only for Public addresses
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP address
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network address type. Value:   - `Private`: Private network address   - `Public`: Public network address   - `Inner`: Public service zone address
         */
        networkType?: pulumi.Input<string>;
        /**
         * Port.
         */
        port?: pulumi.Input<string>;
        /**
         * Subnet ID
         */
        subnetId?: pulumi.Input<string>;
    }
    interface InstanceEndpointReadOnlyNodeWeight {
        /**
         * Read-only nodes require NodeId
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node type
         */
        nodeType?: pulumi.Input<string>;
        /**
         * Node read weight, increases by 100, maximum value is 10000
         */
        weight?: pulumi.Input<number>;
    }
    interface InstanceMaintenanceWindow {
        /**
         * Granularity of the maintenance cycle. Value: Week (week)
         */
        dayKind?: pulumi.Input<string>;
        dayOfWeekMaintenanceTimes?: pulumi.Input<pulumi.Input<inputs.rdspostgresql.InstanceMaintenanceWindowDayOfWeekMaintenanceTime>[]>;
    }
    interface InstanceMaintenanceWindowDayOfWeekMaintenanceTime {
        /**
         * Specify maintenance days for the instance each week. Multiple selections allowed. Monday: Monday. Tuesday: Tuesday. Wednesday: Wednesday. Thursday: Thursday. Friday: Friday. Saturday: Saturday. Sunday: Sunday. Note: If not specified or left blank, all seven days are enabled by default.
         */
        dayOfWeek?: pulumi.Input<string>;
        /**
         * Start time of the maintenance window on the maintenance day. Format: HH:mmZ (UTC time). Currently, only start times between 16:00Z and 20:00Z are supported.
         */
        maintenanceWindowStartTime?: pulumi.Input<string>;
        /**
         * Duration of the maintenance window on the maintenance day. Minimum duration is 2 hours, maximum is 6 hours.
         */
        period?: pulumi.Input<number>;
    }
    interface InstanceNodeInfo {
        /**
         * Node creation time. Format: yyyy-MM-ddTHH:mm:ss.sssZ (UTC time)
         */
        createTime?: pulumi.Input<string>;
        /**
         * Instance ID
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Memory size, unit: GB
         */
        memory?: pulumi.Input<number>;
        /**
         * Node ID
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node specification
         */
        nodeSpec: pulumi.Input<string>;
        /**
         * Node status
         */
        nodeStatus?: pulumi.Input<string>;
        /**
         * Node type
         */
        nodeType: pulumi.Input<string>;
        /**
         * Region ID
         */
        regionId?: pulumi.Input<string>;
        /**
         * Node update time. Format: yyyy-MM-ddTHH:mm:ss.sssZ (UTC time)
         */
        updateTime?: pulumi.Input<string>;
        /**
         * CPU size. For example: 1 means 1U
         */
        vcpu?: pulumi.Input<number>;
        /**
         * Availability zone of the node
         */
        zoneId: pulumi.Input<string>;
    }
    interface InstanceReplicationSlot {
        /**
         * Database associated with the slot
         */
        database?: pulumi.Input<string>;
        /**
         * Connected client IP address
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Plugin used by the slot
         */
        plugin?: pulumi.Input<string>;
        /**
         * Slot name
         */
        slotName?: pulumi.Input<string>;
        /**
         * Slot status
         */
        slotStatus?: pulumi.Input<string>;
        /**
         * Slot type
         */
        slotType?: pulumi.Input<string>;
        /**
         * Whether it is a temporary slot
         */
        temporary?: pulumi.Input<boolean>;
        /**
         * WAL delay size
         */
        walDelay?: pulumi.Input<number>;
    }
    interface InstanceRestoreToExistedInstance {
        /**
         * Backup set ID
         */
        backupId?: pulumi.Input<string>;
        databases?: pulumi.Input<pulumi.Input<inputs.rdspostgresql.InstanceRestoreToExistedInstanceDatabase>[]>;
        /**
         * Source instance ID
         */
        sourceDbInstanceId?: pulumi.Input<string>;
        /**
         * Database account for the target instance
         */
        targetDbInstanceAccount?: pulumi.Input<string>;
    }
    interface InstanceRestoreToExistedInstanceDatabase {
        /**
         * Source database name
         */
        dbName?: pulumi.Input<string>;
        /**
         * Name of the new database after restoration
         */
        newDbName?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface ParameterTemplateTemplateParam {
        /**
         * Parameter name
         */
        name: pulumi.Input<string>;
        /**
         * Parameter value
         */
        value: pulumi.Input<string>;
    }
}
export declare namespace redis {
    interface AllowListAssociatedInstance {
        /**
         * Instance ID bound to the current allowlist
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Instance names bound to the current allowlist
         */
        instanceName?: pulumi.Input<string>;
        /**
         * Project name associated with the instance
         */
        projectName?: pulumi.Input<string>;
        /**
         * Private network ID associated with the instance
         */
        vpc?: pulumi.Input<string>;
    }
    interface AllowListSecurityGroupBindInfo {
        /**
         * Security group association mode. The value range is as follows: IngressDirectionIp: ingress IP, which allows IPs involved in TCP and ALL protocols in the source address of the security group ingress direction to access the database. If the source address is configured as a security group, it will be ignored. AssociateEcsIp: associate ECS IP, which allows cloud servers within the security group to access the database. Currently, only importing IP information of the primary network interface is supported
         */
        bindMode?: pulumi.Input<string>;
        /**
         * Associated security group ID
         */
        securityGroupId?: pulumi.Input<string>;
    }
    interface InstanceBackupRestore {
        /**
         * Backup ID, used to specify which backup to use when restoring from a backup set
         */
        backupPointId?: pulumi.Input<string>;
        /**
         * Recovery method
         */
        backupType?: pulumi.Input<string>;
        /**
         * Used to specify the point in time for point-in-time recovery
         */
        timePoint?: pulumi.Input<string>;
    }
    interface InstanceCapacity {
        /**
         * Total memory capacity of the current instance. Unit: MiB.
         */
        total?: pulumi.Input<number>;
        /**
         * Used capacity of the current instance. Unit: MiB.
         */
        used?: pulumi.Input<number>;
    }
    interface InstanceConfigureNode {
        /**
         * The availability zone each node belongs to.
         */
        az?: pulumi.Input<string>;
    }
    interface InstanceInstanceShard {
        /**
         * Number of nodes in each shard
         */
        nodeNumber?: pulumi.Input<number>;
        serverNodes?: pulumi.Input<pulumi.Input<inputs.redis.InstanceInstanceShardServerNode>[]>;
        /**
         * Shard ID.
         */
        shardId?: pulumi.Input<string>;
    }
    interface InstanceInstanceShardServerNode {
        /**
         * Current role of the node. Valid values: PrimaryNode: primary node; SecondaryNode: secondary node.
         */
        currentRole?: pulumi.Input<string>;
        /**
         * Node ID.
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node status. Valid values: deploy: starting; running: running; loading: loading data; error: error.
         */
        status?: pulumi.Input<string>;
        /**
         * Availability zone where the node is located.
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface InstanceVisitAddr {
        /**
         * Connection address type. Value options: Private: Private network connection address; Public: Public network connection address; DirectLink: Direct connection address.
         */
        addrType?: pulumi.Input<string>;
        /**
         * IP address or domain name.
         */
        address?: pulumi.Input<string>;
        /**
         * EIP ID bound to the instance's public address. This parameter is returned only when the connection address type (AddrType) is Public.
         */
        eipId?: pulumi.Input<string>;
        /**
         * Port number.
         */
        port?: pulumi.Input<string>;
        /**
         * IPv6 address corresponding to the connection address.
         */
        viPv6?: pulumi.Input<string>;
        /**
         * The IPv4 address corresponding to the connection address.
         */
        vip?: pulumi.Input<string>;
    }
    interface ParameterGroupParamValue {
        /**
         * Parameter name
         */
        name: pulumi.Input<string>;
        /**
         * Parameter value
         */
        value: pulumi.Input<string>;
    }
    interface ParameterGroupParameter {
        /**
         * Current parameter value
         */
        currentValue?: pulumi.Input<string>;
        /**
         * Parameter description
         */
        description?: pulumi.Input<string>;
        /**
         * Whether modifying this parameter requires a restart
         */
        needReboot?: pulumi.Input<boolean>;
        /**
         * Parameter name
         */
        paramName?: pulumi.Input<string>;
        /**
         * Parameter value range
         */
        range?: pulumi.Input<string>;
        /**
         * Parameter type
         */
        type?: pulumi.Input<string>;
        /**
         * Parameter unit
         */
        unit?: pulumi.Input<string>;
    }
}
export declare namespace rocketmq {
    interface AccessKeyTopicPermission {
        /**
         * Permission type. AccessKey has permissions for this Topic. ALL: Publish and subscribe permissions. PUB: Publish permission. SUB: Subscribe permission. DENY: No publish or subscribe permissions
         */
        permission?: pulumi.Input<string>;
        /**
         * Topic name
         */
        topicName?: pulumi.Input<string>;
    }
    interface AllowListAssociatedInstance {
        /**
         * Instance ID
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Instance Name
         */
        instanceName?: pulumi.Input<string>;
        /**
         * VPC ID of the instance
         */
        vpc?: pulumi.Input<string>;
    }
    interface GroupConsumedClient {
        /**
         * Address and port of this consumer instance.
         */
        clientAddress?: pulumi.Input<string>;
        /**
         * ID of this consumer instance.
         */
        clientId?: pulumi.Input<string>;
        /**
         * Message backlog.
         */
        diff?: pulumi.Input<number>;
        /**
         * Development language of the consumer application.
         */
        language?: pulumi.Input<string>;
        /**
         * Consumer version.
         */
        version?: pulumi.Input<string>;
    }
    interface GroupConsumedTopic {
        /**
         * Number of queues associated with the Topic. Each Topic contains one or more queues for storing messages.
         */
        queueNum?: pulumi.Input<number>;
        /**
         * Subscription rules.
         */
        subString?: pulumi.Input<string>;
        /**
         * Name of the Topic subscribed by the client.
         */
        topicName?: pulumi.Input<string>;
    }
    interface InstanceChargeDetail {
        /**
         * Whether the subscription instance is automatically renewed upon expiration. true: automatically renewed. false: not automatically renewed. Manual renewal is required after expiration; otherwise, the instance will be shut down.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Expiration time for yearly/monthly subscription instances. The time format is YYYY-MM-DD'T'HH:MM:SS'Z'. For pay-as-you-go instances, this field defaults to 1970-01-01T00:00:00Z.
         */
        chargeExpireTime?: pulumi.Input<string>;
        /**
         * Billing start time for the instance. The time format is YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        chargeStartTime?: pulumi.Input<string>;
        /**
         * Instance billing status. Includes: Normal: normal Overdue: pay-as-you-go overdue Expired: subscription expired
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Billing type for the instance. Supported types include: PostPaid: pay-as-you-go; PrePaid: yearly/monthly subscription
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Estimated release time after the instance is suspended due to overdue payment. The time format is YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        overdueReclaimTime?: pulumi.Input<string>;
        /**
         * Suspension time due to overdue payment for the instance. The time format is YYYY-MM-DD'T'HH:MM:SS'Z'.
         */
        overdueTime?: pulumi.Input<string>;
        /**
         * Purchase duration for subscription instances. When PeriodUnit is set to Monthly, the value range is 1–9. When PeriodUnit is set to Yearly, the value range is 1–3. Only required for subscription instances, that is, when ChargeType is set to PrePaid.
         */
        period?: pulumi.Input<number>;
        /**
         * Lifecycle unit for subscription-based instances, specifying whether to purchase by month or by year. Monthly: (default) monthly subscription Yearly: annual subscription
         */
        periodUnit?: pulumi.Input<string>;
    }
    interface InstanceConnectionInfo {
        /**
         * Instance endpoint IP address.
         */
        endpointAddressIp?: pulumi.Input<string>;
        /**
         * Instance access point type.
         */
        endpointType?: pulumi.Input<string>;
        /**
         * Private network endpoint address for the instance.
         */
        internalEndpoint?: pulumi.Input<string>;
        /**
         * Instance access point type.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Public access point address of the instance.
         */
        publicEndpoint?: pulumi.Input<string>;
    }
    interface InstanceProductInfo {
        /**
         * Edit the read/write throttling ratio. The default read/write ratio is 50% each. For example, if set to 40, the sending TPS ratio is 40% and the subscription ratio is 60%. Note: Only RocketMQ 5.x instances support adjusting the TPS ratio for the instance.
         */
        sendReceiveRatio?: pulumi.Input<number>;
    }
    interface InstanceTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface TopicAccessPolicy {
        /**
         * AccessKey of the RocketMQ key.
         */
        accessKey?: pulumi.Input<string>;
        /**
         * User access permissions for the current Topic. ALL: Publish and subscribe permissions. PUB: Publish permission. SUB: Subscribe permission. DENY: No publish or subscribe permissions.
         */
        authority?: pulumi.Input<string>;
    }
    interface TopicGroupsInfo {
        /**
         * Group ID of the consumer group.
         */
        groupId?: pulumi.Input<string>;
        /**
         * Consumption mode. The values are as follows: Clustering: cluster consumption mode. Broadcasting: broadcast consumption mode.
         */
        messageModel?: pulumi.Input<string>;
        /**
         * Subscription rule. This field contains the exact string specified by the consumer group when subscribing to this Topic, usually * or TAG1 || TAG2.
         */
        subString?: pulumi.Input<string>;
    }
    interface TopicQueuesInfo {
        /**
         * The maximum offset of the current queue, which is the offset of the next message. The position of the latest message is EndOffset   - 1.
         */
        endOffset?: pulumi.Input<number>;
        /**
         * The time of the most recent message written to this queue.
         */
        lastUpdateTimestamp?: pulumi.Input<number>;
        /**
         * The number of messages in the current queue. EndOffset is the offset of the next message, so MessageCount = EndOffset   - StartOffset.
         */
        messageCount?: pulumi.Input<number>;
        /**
         * Queue ID.
         */
        queueId?: pulumi.Input<string>;
        /**
         * The earliest message offset in the current queue.
         */
        startOffset?: pulumi.Input<number>;
    }
    interface TopicReadAccessPolicy {
        /**
         * AccessKey of the RocketMQ key.
         */
        accessKey?: pulumi.Input<string>;
        /**
         * User access permissions for the current Topic. ALL: Publish and subscribe permissions. PUB: Publish permission. SUB: Subscribe permission. DENY: No publish or subscribe permissions.
         */
        authority?: pulumi.Input<string>;
    }
}
export declare namespace storageebs {
    interface SnapshotGroupSnapshot {
        /**
         * Snapshot creation time
         */
        creationTime?: pulumi.Input<string>;
        /**
         * Snapshot description
         */
        description?: pulumi.Input<string>;
        /**
         * Image ID
         */
        imageId?: pulumi.Input<string>;
        /**
         * Whether the snapshot has enabled ultra-fast availability. Values are as follows:   - true: Ultra-fast availability enabled   - false: Ultra-fast availability not enabled
         */
        instantAccess?: pulumi.Input<boolean>;
        /**
         * Dump progress
         */
        progress?: pulumi.Input<number>;
        /**
         * Project of the snapshot
         */
        projectName?: pulumi.Input<string>;
        /**
         * Retention days for automatic snapshots
         */
        retentionDays?: pulumi.Input<number>;
        /**
         * Whether the snapshot is shared with others. Values are as follows:   - true: Snapshot is shared with others   - false: Snapshot is not shared with others
         */
        shared?: pulumi.Input<boolean>;
        /**
         * Snapshot consistency group ID
         */
        snapshotGroupId?: pulumi.Input<string>;
        /**
         * Snapshot ID
         */
        snapshotId?: pulumi.Input<string>;
        /**
         * Snapshot name
         */
        snapshotName?: pulumi.Input<string>;
        /**
         * Snapshot type. Values are as follows:   - user: Manual snapshot   - auto: Automatic snapshot
         */
        snapshotType?: pulumi.Input<string>;
        /**
         * Snapshot status. Values are as follows:   - available: Available   - creating: Creating   - rollbacking: Rolling back   - deleted: Deleted   - failed: Error
         */
        status?: pulumi.Input<string>;
        tags?: pulumi.Input<pulumi.Input<inputs.storageebs.SnapshotGroupSnapshotTag>[]>;
        /**
         * Cloud disk ID
         */
        volumeId?: pulumi.Input<string>;
        /**
         * Cloud disk category. Values are as follows:   - system: System disk   - data: Data disk
         */
        volumeKind?: pulumi.Input<string>;
        /**
         * Cloud disk name
         */
        volumeName?: pulumi.Input<string>;
        /**
         * Cloud disk size (GiB)
         */
        volumeSize?: pulumi.Input<number>;
        /**
         * Cloud disk status. Values are as follows:   - available: Available   - attaching: Attaching   - attached: Attached   - detaching: Detaching   - creating: Creating   - deleting: Deleting   - error: Error   - extending: Expanding
         */
        volumeStatus?: pulumi.Input<string>;
        /**
         * Cloud disk type. Values are as follows:   - ESSD*PL0: Ultra-fast SSD cloud disk, PL0 specification   - ESSD*FlexPL: Ultra-fast SSD cloud disk, FlexPL specification   - TSSD_TL0: Throughput SSD cloud disk
         */
        volumeType?: pulumi.Input<string>;
        /**
         * Zone ID. If ultra-fast availability is enabled for the snapshot, you can create a cloud disk in this zone using the ultra-fast available snapshot
         */
        zoneId?: pulumi.Input<string>;
    }
    interface SnapshotGroupSnapshotTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface SnapshotGroupTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface SnapshotPolicyTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface SnapshotTag {
        /**
         * User tag key added to the resource. Naming rules: Cannot start with volc: or sys: in any case. Keys starting with volc: or sys: are reserved system tag keys and cannot be created. Only language characters, numbers, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Length must be between 1 and 128 characters.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value added to the resource. Naming rules: Only language characters, numbers, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Can be empty. Length must be between 0 and 256 characters.
         */
        value?: pulumi.Input<string>;
    }
    interface VolumeBaselinePerformance {
        /**
         * Total IOPS of the disk, which is the sum of the baseline IOPS and extra IOPS.
         */
        iops?: pulumi.Input<number>;
        /**
         * The total throughput of the cloud disk is the sum of its baseline throughput and additional throughput.
         */
        throughput?: pulumi.Input<number>;
    }
    interface VolumeExtraPerformance {
        /**
         * Type of extra performance. Value description: Balance: Balanced extra performance; IOPS: IOPS extra performance; Throughput: Throughput extra performance.
         */
        extraPerformanceTypeId?: pulumi.Input<string>;
        /**
         * Extra IOPS of the disk.
         */
        iops?: pulumi.Input<number>;
        /**
         * Extra throughput of the disk.
         */
        throughput?: pulumi.Input<number>;
    }
    interface VolumeTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface VolumeTotalPerformance {
        /**
         * Total IOPS of the disk, which is the sum of the baseline IOPS and extra IOPS.
         */
        iops?: pulumi.Input<number>;
        /**
         * The total throughput of the cloud disk is the sum of its baseline throughput and additional throughput.
         */
        throughput?: pulumi.Input<number>;
    }
}
export declare namespace tls {
    interface AlarmAlarmNotifyGroup {
        /**
         * Alert notification group ID.
         */
        alarmNotifyGroupId?: pulumi.Input<string>;
    }
    interface AlarmAlarmPeriodDetail {
        /**
         * Email alert interval, in minutes. Value range: 1–1440
         */
        email?: pulumi.Input<number>;
        /**
         * Custom Webhook alert interval, in minutes. Value range: 1–1440.
         */
        generalWebhook?: pulumi.Input<number>;
        /**
         * Phone alert cycle, in minutes. Value range: 10–1440.
         */
        phone?: pulumi.Input<number>;
        /**
         * SMS alert interval, in minutes. Value range: 10–1440
         */
        sms?: pulumi.Input<number>;
    }
    interface AlarmJoinConfiguration {
        /**
         * Expression used for left join or right join.
         */
        condition?: pulumi.Input<string>;
        /**
         * Set operation type. Optional values: CrossJoin: Cartesian product. LeftJoin: Left join. RightJoin: Right join. InnerJoin: Inner join. FullJoin: Full join.
         */
        setOperationType?: pulumi.Input<string>;
    }
    interface AlarmNotifyGroupNoticeRule {
        /**
         * Whether there is an end node afterwards.
         */
        hasEndNode?: pulumi.Input<boolean>;
        /**
         * Condition for whether to proceed to the next level.
         */
        hasNext?: pulumi.Input<boolean>;
        receiverInfos?: pulumi.Input<pulumi.Input<inputs.tls.AlarmNotifyGroupNoticeRuleReceiverInfo>[]>;
        /**
         * Rule node. JSON format.
         */
        ruleNode?: pulumi.Input<string>;
    }
    interface AlarmNotifyGroupNoticeRuleReceiverInfo {
        /**
         * Alarm content template ID.
         */
        alarmContentTemplateId?: pulumi.Input<string>;
        /**
         * User group name to notify when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
         */
        alarmWebhookAtGroups?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Username to notify when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
         */
        alarmWebhookAtUsers?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Alarm webhook integration configuration ID.
         */
        alarmWebhookIntegrationId?: pulumi.Input<string>;
        /**
         * Name of the alarm Webhook integration configuration.
         */
        alarmWebhookIntegrationName?: pulumi.Input<string>;
        /**
         * Whether to notify everyone when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
         */
        alarmWebhookIsAtAll?: pulumi.Input<boolean>;
        /**
         * End time for receiving alarm notifications. Uses 24-hour format: HH:mm:ss, with a valid range of 00:00:00–23:59:59. StartTime cannot be greater than EndTime.
         */
        endTime?: pulumi.Input<string>;
        /**
         * Custom WebHook request body. It is recommended to set the request body according to the callback interface requirements of the corresponding service.
         */
        generalWebhookBody?: pulumi.Input<string>;
        generalWebhookHeaders?: pulumi.Input<pulumi.Input<inputs.tls.AlarmNotifyGroupNoticeRuleReceiverInfoGeneralWebhookHeader>[]>;
        /**
         * Custom callback method for the interface. Only POST or PUT is supported.
         */
        generalWebhookMethod?: pulumi.Input<string>;
        /**
         * Custom callback URL for the interface.
         */
        generalWebhookUrl?: pulumi.Input<string>;
        /**
         * Notification channels. Supports one or more channels. Options: Email, Sms, Phone, GeneralWebhook, Lark, DingTalk, WeChat.
         */
        receiverChannels?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * IAM user or user group name.
         */
        receiverNames?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Recipient type. Options: User: IAM user; UserGroup: IAM user group.
         */
        receiverType?: pulumi.Input<string>;
        /**
         * Alarm notification start time. Uses 24-hour format (HH:mm:ss), valid range is 00:00:00–23:59:59. StartTime cannot be later than EndTime.
         */
        startTime?: pulumi.Input<string>;
    }
    interface AlarmNotifyGroupNoticeRuleReceiverInfoGeneralWebhookHeader {
        /**
         * Custom request header key.
         */
        key?: pulumi.Input<string>;
        /**
         * Custom request header value.
         */
        value?: pulumi.Input<string>;
    }
    interface AlarmNotifyGroupReceiver {
        /**
         * Alarm content template ID.
         */
        alarmContentTemplateId?: pulumi.Input<string>;
        /**
         * User group name to notify when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
         */
        alarmWebhookAtGroups?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Username to notify when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
         */
        alarmWebhookAtUsers?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Alarm webhook integration configuration ID.
         */
        alarmWebhookIntegrationId?: pulumi.Input<string>;
        /**
         * Name of the alarm Webhook integration configuration.
         */
        alarmWebhookIntegrationName?: pulumi.Input<string>;
        /**
         * Whether to notify everyone when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
         */
        alarmWebhookIsAtAll?: pulumi.Input<boolean>;
        /**
         * End time for receiving alarm notifications. Uses 24-hour format: HH:mm:ss, with a valid range of 00:00:00–23:59:59. StartTime cannot be greater than EndTime.
         */
        endTime?: pulumi.Input<string>;
        /**
         * Custom WebHook request body. It is recommended to set the request body according to the callback interface requirements of the corresponding service.
         */
        generalWebhookBody?: pulumi.Input<string>;
        generalWebhookHeaders?: pulumi.Input<pulumi.Input<inputs.tls.AlarmNotifyGroupReceiverGeneralWebhookHeader>[]>;
        /**
         * Custom callback method for the interface. Only POST or PUT is supported.
         */
        generalWebhookMethod?: pulumi.Input<string>;
        /**
         * Custom callback URL for the interface.
         */
        generalWebhookUrl?: pulumi.Input<string>;
        /**
         * Notification channels. Supports one or more channels. Options: Email, Sms, Phone, GeneralWebhook, Lark, DingTalk, WeChat.
         */
        receiverChannels?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * IAM user or user group name.
         */
        receiverNames?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Recipient type. Options: User: IAM user; UserGroup: IAM user group.
         */
        receiverType?: pulumi.Input<string>;
        /**
         * Alarm notification start time. Uses 24-hour format (HH:mm:ss), valid range is 00:00:00–23:59:59. StartTime cannot be later than EndTime.
         */
        startTime?: pulumi.Input<string>;
    }
    interface AlarmNotifyGroupReceiverGeneralWebhookHeader {
        /**
         * Custom request header key.
         */
        key?: pulumi.Input<string>;
        /**
         * Custom request header value.
         */
        value?: pulumi.Input<string>;
    }
    interface AlarmQueryRequest {
        /**
         * Query end time, relative to the current time, in minutes. Value must be a non-positive integer and greater than StartTimeOffset. Maximum: 0, minimum: -1440
         */
        endTimeOffset?: pulumi.Input<number>;
        /**
         * Unit for the end time range of the query. Default is minutes. Supports second/minute/hour (Second, Minute, Hour).
         */
        endTimeOffsetUnit?: pulumi.Input<string>;
        /**
         * Query analysis statement, with a maximum supported length of 1024 characters.
         */
        query?: pulumi.Input<string>;
        /**
         * Query start time, relative to the current time, in minutes. Value must be a non-positive integer. Maximum: 0, minimum: -1440
         */
        startTimeOffset?: pulumi.Input<number>;
        /**
         * Unit for the query start time range. The default is minutes. Supports seconds/minutes/hours (Second, Minute, Hour).
         */
        startTimeOffsetUnit?: pulumi.Input<string>;
        /**
         * Whether to use on-the-hour time for the query. If left blank, defaults to Relative.
         */
        timeSpanType?: pulumi.Input<string>;
        /**
         * Log topic ID monitored by the alert policy.
         */
        topicId?: pulumi.Input<string>;
        /**
         * Name of the log topic monitored by the alert policy.
         */
        topicName?: pulumi.Input<string>;
        /**
         * Round time values, i.e., round to the nearest minute or hour (Second, Minute, Hour).
         */
        truncatedTime?: pulumi.Input<string>;
    }
    interface AlarmRequestCycle {
        /**
         * Cron expression. Log Service uses a Cron expression to specify the scheduled execution of alert tasks. The minimum granularity is one minute, using a 24-hour format. For example, 0 18 * * * means the alert task runs once daily at 18:00.
         */
        cronTab?: pulumi.Input<string>;
        /**
         * Time zone in which the Cron expression takes effect.
         */
        cronTimeZone?: pulumi.Input<string>;
        /**
         * Scheduling cycle or the specific time point for periodic execution (minutes from 00:00). Value range: 1–1440, in minutes.
         */
        time?: pulumi.Input<number>;
        /**
         * Scheduling interval type. Options: Period: schedule at regular intervals. Fixed: schedule at a fixed time each day. Cron: use a Cron expression.
         */
        type?: pulumi.Input<string>;
    }
    interface AlarmTriggerCondition {
        /**
         * Alert trigger condition expression.
         */
        condition?: pulumi.Input<string>;
        /**
         * Numerical expression for scenarios with data or specific entries, implemented using **count**.
         */
        countCondition?: pulumi.Input<string>;
        /**
         * When enabled, if the result after set operations is an empty set, a separate no-data alert is triggered.
         */
        noData?: pulumi.Input<boolean>;
        /**
         * Alert notification level, indicating the severity of the alert. Supports notice, warning, or critical, with severity increasing in that order. The default is notice.
         */
        severity?: pulumi.Input<string>;
    }
    interface EtlTargetResource {
        /**
         * Name of the custom output target. You must use this name to refer to the output target in the data processing rules
         */
        alias: pulumi.Input<string>;
        /**
         * Region of the log topic for storing processed logs
         */
        region: pulumi.Input<string>;
        /**
         * Cross-account authorization role name
         */
        roleTrn?: pulumi.Input<string>;
        /**
         * Log topic ID for storing processed logs
         */
        topicId: pulumi.Input<string>;
    }
    interface HostGroupRule {
        /**
         * Container collection rules
         */
        containerRule?: pulumi.Input<inputs.tls.HostGroupRuleContainerRule>;
        /**
         * Time when the collection configuration was created.
         */
        createTime?: pulumi.Input<string>;
        excludePaths?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleExcludePath>[]>;
        /**
         * Extraction rules
         */
        extractRule?: pulumi.Input<inputs.tls.HostGroupRuleExtractRule>;
        /**
         * Collection type. 0: Host log file. 1: K8s container standard output. 2: Log file inside K8s container.
         */
        inputType?: pulumi.Input<number>;
        /**
         * Log sample.
         */
        logSample?: pulumi.Input<string>;
        /**
         * Collection modes. minimalist*log: single-line full mode. json*log: JSON mode. delimiter*log: delimiter mode. multiline*log: multi-line full mode. fullregex_log: full regex mode.
         */
        logType?: pulumi.Input<string>;
        /**
         * Time when the collection configuration was modified.
         */
        modifyTime?: pulumi.Input<string>;
        /**
         * Data collection path list
         */
        paths?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Running status of the collection configuration. 0: Running. 1: Paused.
         */
        pause?: pulumi.Input<number>;
        /**
         * Collection configuration ID.
         */
        ruleId?: pulumi.Input<string>;
        /**
         * Name of the collection configuration.
         */
        ruleName?: pulumi.Input<string>;
        /**
         * ID of the log topic to which the collection configuration belongs.
         */
        topicId?: pulumi.Input<string>;
        /**
         * Name of the log topic associated with the collection configuration
         */
        topicName?: pulumi.Input<string>;
        /**
         * User-defined collection rules.
         */
        userDefineRule?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRule>;
    }
    interface HostGroupRuleContainerRule {
        /**
         * Container name to collect. If no container name is specified, all containers in the machine group are collected. Supports regular expressions. For example, setting the container name to ^(container-test)$ collects all containers named container-test.
         */
        containerNameRegex?: pulumi.Input<string>;
        envTags?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleEnvTag>[]>;
        excludeContainerEnvRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleExcludeContainerEnvRegex>[]>;
        excludeContainerLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleExcludeContainerLabelRegex>[]>;
        includeContainerEnvRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleIncludeContainerEnvRegex>[]>;
        includeContainerLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleIncludeContainerLabelRegex>[]>;
        /**
         * Kubernetes container collection rules.
         */
        kubernetesRule?: pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRule>;
        /**
         * Collection information. stdout: Container standard output (stdout). stderr: Container standard error (stderr). all: Both container standard output (stdout) and standard error (stderr).
         */
        stream?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleEnvTag {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleExcludeContainerEnvRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleExcludeContainerLabelRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleIncludeContainerEnvRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleIncludeContainerLabelRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleKubernetesRule {
        annotationTags?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleAnnotationTag>[]>;
        /**
         * Whether to add all Kubernetes Labels as log tags to the raw log data. When enabled, the log service adds fields for all Labels in the Kubernetes Pod to the log. For example, if the Pod has Label source=DC and destination=CS, the log will include fields **tag**source__: DC and **tag**destination__: CS.
         */
        enableAllLabelTag?: pulumi.Input<boolean>;
        excludePodAnnotationRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex>[]>;
        excludePodLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleExcludePodLabelRegex>[]>;
        includePodAnnotationRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex>[]>;
        includePodLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleIncludePodLabelRegex>[]>;
        labelTags?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleLabelTag>[]>;
        /**
         * Name of the Kubernetes Namespace to be collected. If not specified, all containers are collected. Namespace names support regular expression matching. For example, setting the Namespace name to ^(tcp|udp)$ collects all containers under the tcp and udp namespaces.
         */
        namespaceNameRegex?: pulumi.Input<string>;
        /**
         * Pod name is used to specify the Pod(s) to be collected. If the Pod name is not specified, all containers are collected. Pod name supports regex matching. For example, setting the Pod name to ^(http.*)$ collects all containers under Pods whose names start with http.
         */
        podNameRegex?: pulumi.Input<string>;
        /**
         * Specify the container to collect by workload name. If no workload name is specified, all containers are collected. Workload names support regular expressions. For example, setting the workload name to ^(http.*)$ collects all containers under workloads starting with http.
         */
        workloadNameRegex?: pulumi.Input<string>;
        /**
         * Specify containers to collect by workload type. Only one type can be selected. If no type is specified, containers of all types will be collected. Supported workload types are: Deployment: stateless workload StatefulSet: stateful workload DaemonSet: daemon process Job: job CronJob: scheduled job
         */
        workloadType?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleKubernetesRuleAnnotationTag {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleKubernetesRuleExcludePodLabelRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleKubernetesRuleIncludePodLabelRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleContainerRuleKubernetesRuleLabelTag {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleExcludePath {
        /**
         * Collection path type. File: file name. Path: directory.
         */
        type?: pulumi.Input<string>;
        /**
         * Collection path. Must be specified as an absolute path. When Type is Path, Value indicates a directory. When Type is File, Value indicates a file name.
         */
        value?: pulumi.Input<string>;
    }
    interface HostGroupRuleExtractRule {
        /**
         * The regex pattern required to match the first line of the log. This is valid only when LogType is multiline*log or fullregex*log. The pattern must be a valid regular expression.
         */
        beginRegex?: pulumi.Input<string>;
        /**
         * Log delimiter. Valid only when LogType is delimiter_log.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * Enable nanosecond precision time. When enabled, log time parsing will report time with nanosecond precision. true: Enable nanosecond precision time. false: Disable nanosecond precision time.
         */
        enableNanosecond?: pulumi.Input<boolean>;
        filterKeyRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleExtractRuleFilterKeyRegex>[]>;
        /**
         * List of log field names (Keys).
         */
        keys?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * The entire log entry must match the regular expression. This is only valid when the log type is fullregex_log. The regular expression must be valid.
         */
        logRegex?: pulumi.Input<string>;
        /**
         * Automatically extract log fields based on the specified log template.
         */
        logTemplate?: pulumi.Input<inputs.tls.HostGroupRuleExtractRuleLogTemplate>;
        /**
         * Quotation mark. Content enclosed by quotation marks is parsed as a complete field and not separated. Only valid when LogType is delimiter_log.
         */
        quote?: pulumi.Input<string>;
        /**
         * Regular expression for extracting time, used to extract the time value from the TimeKey field and parse it as the collection time.
         */
        timeExtractRegex?: pulumi.Input<string>;
        /**
         * Parsing format for the time field. If a specified time field in the log is used as the log timestamp, you must provide TimeKey and TimeFormat.
         */
        timeFormat?: pulumi.Input<string>;
        /**
         * Field name for the log time field. If a specified time field in the log is used as the log timestamp, you must provide TimeKey and TimeFormat.
         */
        timeKey?: pulumi.Input<string>;
        /**
         * Sample time. Used to verify whether the specified time parsing format is correct.
         */
        timeSample?: pulumi.Input<string>;
        /**
         * Time zone. Supports machine time zone (default) and custom time zone. Custom time zone supports GMT and UTC.
         */
        timeZone?: pulumi.Input<string>;
        /**
         * Key name for logs that failed to parse when uploading
         */
        unMatchLogKey?: pulumi.Input<string>;
        /**
         * Upload logs that failed to parse. UnMatchUpLoadSwitch=true and UnMatchLogKey must be used together. true: Upload logs that failed to parse. false: Do not upload logs that failed to parse.
         */
        unMatchUpLoadSwitch?: pulumi.Input<boolean>;
    }
    interface HostGroupRuleExtractRuleFilterKeyRegex {
        /**
         * Name of the filter field.
         */
        key?: pulumi.Input<string>;
        /**
         * The log content of the filter field must match the specified regular expression.
         */
        regex?: pulumi.Input<string>;
    }
    interface HostGroupRuleExtractRuleLogTemplate {
        /**
         * Log template format
         */
        format?: pulumi.Input<string>;
        /**
         * Log template type. Supported types: Nginx (Nginx log template type).
         */
        type?: pulumi.Input<string>;
    }
    interface HostGroupRuleUserDefineRule {
        /**
         * Advanced parameters are used for extended configuration. After enabling extended configuration, you can customize advanced behaviors of LogCollector, such as when to release file handles. Note: If multiple conditions for releasing handles are specified, the handle will be released and log file monitoring will end as soon as any condition is met.
         */
        advanced?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRuleAdvanced>;
        /**
         * Whether to upload the Label information of the host group to the log service. Disabled by default. true: LogCollector uploads the Label information of the host group to the specified field. You can specify the field name in the HostGroupLabelKey parameter. false (default): LogCollector does not upload the Label information of the host group.
         */
        enableHostGroupLabel?: pulumi.Input<boolean>;
        /**
         * Whether to upload the hostname field. Default is disabled. true: Adds a field to the original log to record the log source's hostname. Specify the hostname field name using HostnameKey. false (default): Does not add the hostname field.
         */
        enableHostname?: pulumi.Input<boolean>;
        /**
         * Whether to upload raw logs. true: Upload raw logs. false (default): Do not upload raw logs.
         */
        enableRawLog?: pulumi.Input<boolean>;
        fields?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleUserDefineRuleField>[]>;
        /**
         * Field name used to store machine group label information.
         */
        hostGroupLabelKey?: pulumi.Input<string>;
        /**
         * hostname field name. Only required when EnableHostname is set to true.
         */
        hostnameKey?: pulumi.Input<string>;
        /**
         * Ignore log files that have not been updated for a specified duration, in hours.
         */
        ignoreOlder?: pulumi.Input<number>;
        /**
         * Allows multiple log file collections. Empty: Uses the log file ID (including file inode, device, and checksum of the first N bytes) to uniquely identify the log file. RuleID: Uses the collection rule ID and log file ID to uniquely identify the log file. TopicIDRuleName: Uses the log topic ID, collection rule Name, and log file ID to uniquely identify the log file.
         */
        multiCollectsType?: pulumi.Input<string>;
        /**
         * Rules for parsing the collection path. After setting the rule, fields in the collection path are extracted using the specified regex and added as metadata to the log data. Note: This parameter is not supported when collecting container standard output.
         */
        parsePathRule?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRuleParsePathRule>;
        /**
         * LogCollector plugin configuration. After enabling plugin configuration, you can add one or more LogCollector processor plugins to parse logs with complex or variable structures.
         */
        plugin?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRulePlugin>;
        /**
         * Original log field name. Only effective when EnableRawLog is set to true. RawLogKey defaults to **raw**, meaning the original log data will be encapsulated in the **raw** field and uploaded to the log service together with the parsed log data
         */
        rawLogKey?: pulumi.Input<string>;
        /**
         * Rules for routing log partitions. If this parameter is not set, logs are written using the default load balancing mode, and packets are written to any available Shard. If set, logs are collected using the HashKey routing Shard mode, and the log service writes data to the Shard containing the specified Key value.
         */
        shardHashKey?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRuleShardHashKey>;
        /**
         * LogCollector collection strategy, specifying whether LogCollector collects incremental logs or full logs. The default is false, which means full log collection. true: incremental collection. When LogCollector collects logs, it only collects newly added content in the file. When a monitored log file receives new log entries, LogCollector is triggered to collect logs. For log files being collected for the first time, LogCollector automatically determines the collection position based on the incremental threshold TailSizeKb you specify. If the new file size does not exceed the incremental threshold, collection starts from the beginning of the new file. If the new file size exceeds the incremental threshold, collection starts from the position at the end of the file minus the incremental threshold, meaning only incremental logs are collected. For log files that are not being collected for the first time, LogCollector determines the collection position based on the Checkpoint and continues collecting. false: (default) full collection. LogCollector collects logs from the beginning of each file, including historical log data.
         */
        tailFiles?: pulumi.Input<boolean>;
        /**
         * Incremental collection backtracking threshold, in KiB. When LogCollector uses incremental collection, for the first collection of a log file: if the new log file size does not exceed the TailSizeKb value, collection starts from the beginning of the file. If the new log file size exceeds the TailSizeKb value, collection starts from the position TailSizeKb from the end of the file.
         */
        tailSizeKb?: pulumi.Input<number>;
    }
    interface HostGroupRuleUserDefineRuleAdvanced {
        /**
         * After reading to the end of the log file, whether to release the file handle. Default is false.
         */
        closeEof?: pulumi.Input<boolean>;
        /**
         * Wait time before releasing log file handles. If no new logs are written to a log file for the specified duration, the handle for that log file is released. Unit: seconds. Range: 1–300 seconds. Default: 60 seconds.
         */
        closeInactive?: pulumi.Input<number>;
        /**
         * Whether to release the handle of the log file after it is removed. Default is false.
         */
        closeRemoved?: pulumi.Input<boolean>;
        /**
         * Whether to release the handle of the log file after it is renamed. Default is false.
         */
        closeRenamed?: pulumi.Input<boolean>;
        /**
         * Maximum duration for LogCollector to monitor log files, in seconds. The default is 0 seconds, meaning LogCollector does not limit the monitoring duration. Timing starts when LogCollector begins monitoring the log file. After the specified duration is exceeded, regardless of whether the log file has been fully read, LogCollector immediately releases the file handle and stops monitoring.
         */
        closeTimeout?: pulumi.Input<number>;
        /**
         * Maximum wait time when LogCollector does not read a line break. Unit: seconds. Default: 5s. LogCollector starts timing when it begins reading log file content. If no line break is read within the specified time, it will send the buffered logs. If the file write interval is large, a complete log entry may be split into two parts and written separately. Adjust this parameter based on your log write interval.
         */
        noLineTerminatorEofMaxTime?: pulumi.Input<number>;
    }
    interface HostGroupRuleUserDefineRuleField {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface HostGroupRuleUserDefineRuleParsePathRule {
        /**
         * List of field names. Log Service parses PathSample into multiple fields using regular expressions (Regex). Keys specify the name of each field. You can configure up to 100 field names. Field names cannot be empty or duplicated.
         */
        keys?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Sample collection path for actual scenarios. The sample path must be an absolute path. Wildcards *, ?, ** are not allowed in the sample path.
         */
        pathSample?: pulumi.Input<string>;
        /**
         * Regular expression used to extract the path field. It must match the example collection path; otherwise, extraction will fail.
         */
        regex?: pulumi.Input<string>;
    }
    interface HostGroupRuleUserDefineRulePlugin {
        /**
         * LogCollector plugins. For supported plugin lists and parameter descriptions, see LogCollector plugin overview.
         */
        processors?: pulumi.Input<string>;
    }
    interface HostGroupRuleUserDefineRuleShardHashKey {
        /**
         * The HashKey of the log group specifies the shard where the current log group will be written. The valid range for this parameter is [00000000000000000000000000000000-ffffffffffffffffffffffffffffffff).
         */
        hashKey?: pulumi.Input<string>;
    }
    interface ImportTaskImportSourceInfo {
        /**
         * Kafka data source information. When sourceType is kafka, the KafkaSourceInfo field is required
         */
        kafkaSourceInfo?: pulumi.Input<inputs.tls.ImportTaskImportSourceInfoKafkaSourceInfo>;
        /**
         * TOS data source information. When sourceType is tos, the TosSourceInfo field is required.
         */
        tosSourceInfo?: pulumi.Input<inputs.tls.ImportTaskImportSourceInfoTosSourceInfo>;
    }
    interface ImportTaskImportSourceInfoKafkaSourceInfo {
        /**
         * Data encoding format. Available options: UTF-8, GBK.
         */
        encode?: pulumi.Input<string>;
        /**
         * Kafka consumer group. If not specified, the system will automatically create a Kafka consumer group.
         */
        group?: pulumi.Input<string>;
        /**
         * The service addresses for different types of Kafka clusters vary. Details are as follows: Message Queue Kafka Edition: Use the access point of the Kafka instance. For more information, see Access Point. If the Kafka instance and the Log Service Project are in the same region, you can use private network access; otherwise, use public network access. Self-hosted Kafka clusters: Use the IP address and port number or the domain name and port number of the Kafka Broker. Only public network access is supported. Separate multiple service addresses with a comma (,).
         */
        host?: pulumi.Input<string>;
        /**
         * Starting position for data import. Options: 0: Earliest time, start importing from the first record in the specified Kafka Topic. 1: Latest time, start importing from the most recently generated record in the specified Kafka Topic.
         */
        initialOffset?: pulumi.Input<number>;
        /**
         * If you are using Message Queue Kafka Edition, set this to the Kafka instance ID.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Whether to enable authentication. If you use a public service address, it is recommended to enable authentication.
         */
        isNeedAuth?: pulumi.Input<boolean>;
        /**
         * Password authentication mechanism. Available options: PLAIN, SCRAM-SHA-256, and SCRAM-SHA-512.
         */
        mechanism?: pulumi.Input<string>;
        /**
         * Kafka SASL user password for authentication.
         */
        password?: pulumi.Input<string>;
        /**
         * Secure transmission protocol. Options include plaintext, sasl*ssl, ssl, and sasl*plaintext
         */
        protocol?: pulumi.Input<string>;
        /**
         * Specify log time. Options: 0: Use Kafka message timestamp. 1: Use current system time.
         */
        timeSourceDefault?: pulumi.Input<number>;
        /**
         * Kafka Topic name. Separate multiple Kafka Topics with commas (,).
         */
        topic?: pulumi.Input<string>;
        /**
         * Kafka SASL username for authentication.
         */
        username?: pulumi.Input<string>;
    }
    interface ImportTaskImportSourceInfoTosSourceInfo {
        /**
         * TOS bucket name
         */
        bucket?: pulumi.Input<string>;
        /**
         * Compression mode for data in the TOS bucket. none: No compression. snappy: Compress using snappy. gzip: Compress using gzip. lz4: Compress using lz4.
         */
        compressType?: pulumi.Input<string>;
        /**
         * Path of the file to be imported in the TOS bucket.
         */
        prefix?: pulumi.Input<string>;
        /**
         * Region where the TOS bucket is located. Cross-region data import is supported
         */
        region?: pulumi.Input<string>;
    }
    interface ImportTaskTargetInfo {
        /**
         * Log extraction rule.
         */
        extractRule?: pulumi.Input<inputs.tls.ImportTaskTargetInfoExtractRule>;
        /**
         * Log sample. When LogType is set to multiline_log, you must configure log samples. It is recommended to provide more than two log entries as examples to ensure the regular expression matches the first line of each log. Use real samples from the production environment.
         */
        logSample?: pulumi.Input<string>;
        /**
         * Specify log parsing type during import. delimiter*log: CSV type. multiline*log: multiline full text type. minimalist*log: single line full text type. json*log: JSON type.
         */
        logType: pulumi.Input<string>;
        /**
         * Region.
         */
        region: pulumi.Input<string>;
    }
    interface ImportTaskTargetInfoExtractRule {
        /**
         * Basic content of log extraction rules.
         */
        extractRule?: pulumi.Input<inputs.tls.ImportTaskTargetInfoExtractRuleExtractRule>;
        /**
         * Number of skipped rows. Only valid when the log type is delimiterLog and the import type is tos.
         */
        skipLineCount?: pulumi.Input<number>;
        /**
         * Time extraction regular expression, used to extract the time value from the TimeKey field and parse it as the collection time
         */
        timeExtractRegex?: pulumi.Input<string>;
        /**
         * Time zone. Supports machine time zone (default) and custom time zone. Custom time zone supports GMT and UTC. GMT format: GMT+08:00. UTC format: Asia/Shanghai.
         */
        timeZone?: pulumi.Input<string>;
    }
    interface ImportTaskTargetInfoExtractRuleExtractRule {
        /**
         * Regular expression for identifying the first line of each log. The matched part is treated as the start of the log. When LogType is set to multiline_log, you must configure a log sample
         */
        beginRegex?: pulumi.Input<string>;
        /**
         * Delimiter. Only valid when LogType is delimiter_log.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * Enable nanoseconds.
         */
        enableNanosecond?: pulumi.Input<boolean>;
        filterKeyRegexes?: pulumi.Input<pulumi.Input<inputs.tls.ImportTaskTargetInfoExtractRuleExtractRuleFilterKeyRegex>[]>;
        /**
         * List of log field names (Key). Valid only when LogType is delimiter_log. Supports up to 100 field names. Duplicate field names are not allowed, and all field names cannot be left blank
         */
        keys?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Log regular expression
         */
        logRegex?: pulumi.Input<string>;
        /**
         * Log template.
         */
        logTemplate?: pulumi.Input<inputs.tls.ImportTaskTargetInfoExtractRuleExtractRuleLogTemplate>;
        /**
         * Quotation mark. Content enclosed by the quotation mark will not be separated and will be parsed as a complete field. Only valid when LogType is delimiter_log.
         */
        quote?: pulumi.Input<string>;
        /**
         * Parsing format for the time field. If you use a specified time field in the log as the log timestamp, you must fill in TimeKey and TimeFormat. TimeKey and TimeFormat must be paired. For configuration details, see time format.
         */
        timeFormat?: pulumi.Input<string>;
        /**
         * Name of the log time field. If you use a specific time field in the log as the log timestamp, you must provide both TimeKey and TimeFormat. TimeKey and TimeFormat must appear in pairs
         */
        timeKey?: pulumi.Input<string>;
        /**
         * Time sample. Used to verify whether the entered time parsing format is correct
         */
        timeSample?: pulumi.Input<string>;
        /**
         * When uploading logs that failed to parse, specify the key name for the failed logs. UnMatchUpLoadSwitch=true and UnMatchLogKey must be used together.
         */
        unMatchLogKey?: pulumi.Input<string>;
        /**
         * Whether to upload logs that failed to parse. UnMatchUpLoadSwitch=true and UnMatchLogKey must be paired. true: Upload logs that failed to parse. false: Do not upload logs that failed to parse.
         */
        unMatchUpLoadSwitch?: pulumi.Input<boolean>;
    }
    interface ImportTaskTargetInfoExtractRuleExtractRuleFilterKeyRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Regular expression.
         */
        regex?: pulumi.Input<string>;
    }
    interface ImportTaskTargetInfoExtractRuleExtractRuleLogTemplate {
        /**
         * Format.
         */
        format?: pulumi.Input<string>;
        /**
         * Type
         */
        type?: pulumi.Input<string>;
    }
    interface ImportTaskTaskStatistics {
        /**
         * Total resource bytes enumerated
         */
        bytesTotal?: pulumi.Input<number>;
        /**
         * Bytes transferred.
         */
        bytesTransferred?: pulumi.Input<number>;
        /**
         * Number of resources failed to import.
         */
        failed?: pulumi.Input<number>;
        /**
         * Number of resources not found.
         */
        notExist?: pulumi.Input<number>;
        /**
         * Number of resources skipped during import
         */
        skipped?: pulumi.Input<number>;
        /**
         * Task status. Status of the import task. Preparing: Preparing for import. Importing: Importing data. Success: Import completed successfully. Failed: Import failed. Stopped: Import paused.
         */
        taskStatus?: pulumi.Input<string>;
        /**
         * Total number of resources enumerated.
         */
        total?: pulumi.Input<number>;
        /**
         * Number of records transferred.
         */
        transferred?: pulumi.Input<number>;
    }
    interface IndexFullText {
        /**
         * Case sensitivity. true: Case sensitive. false: Not case sensitive.
         */
        caseSensitive?: pulumi.Input<boolean>;
        /**
         * Token separators for the full-text index. Each character in the string represents a token separator. Length: 1–256 bytes. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * When searching, specify whether to segment Chinese content in logs according to Chinese grammar. The default is false. true: For Chinese characters in logs, segment the log according to common Chinese grammar rules. Custom segmentation symbols for Chinese content are not supported. For non-Chinese characters in logs, segment the log using the segmentation symbols specified in the parameter. false: Segment the log using the segmentation symbols specified in the parameter.
         */
        includeChinese?: pulumi.Input<boolean>;
    }
    interface IndexKeyValue {
        /**
         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
         */
        key?: pulumi.Input<string>;
        /**
         * Field description information required for configuring key-value indexes.
         */
        value?: pulumi.Input<inputs.tls.IndexKeyValueValue>;
    }
    interface IndexKeyValueValue {
        /**
         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
         */
        autoIndexFlag?: pulumi.Input<boolean>;
        /**
         * Whether to distinguish case. Default is false.
         */
        caseSensitive?: pulumi.Input<boolean>;
        /**
         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
         */
        includeChinese?: pulumi.Input<boolean>;
        /**
         * Create indexes for all fields with text values in the JSON field.
         */
        indexAll?: pulumi.Input<boolean>;
        /**
         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
         */
        indexSqlAll?: pulumi.Input<boolean>;
        jsonKeys?: pulumi.Input<pulumi.Input<inputs.tls.IndexKeyValueValueJsonKey>[]>;
        /**
         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
         */
        sqlFlag?: pulumi.Input<boolean>;
        /**
         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
         */
        valueType?: pulumi.Input<string>;
    }
    interface IndexKeyValueValueJsonKey {
        /**
         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
         */
        key?: pulumi.Input<string>;
        /**
         * Field description information required for configuring key-value indexes.
         */
        value?: pulumi.Input<inputs.tls.IndexKeyValueValueJsonKeyValue>;
    }
    interface IndexKeyValueValueJsonKeyValue {
        /**
         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
         */
        autoIndexFlag?: pulumi.Input<boolean>;
        /**
         * Whether to distinguish case. Default is false.
         */
        caseSensitive?: pulumi.Input<boolean>;
        /**
         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
         */
        includeChinese?: pulumi.Input<boolean>;
        /**
         * Create indexes for all fields with text values in the JSON field.
         */
        indexAll?: pulumi.Input<boolean>;
        /**
         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
         */
        indexSqlAll?: pulumi.Input<boolean>;
        /**
         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
         */
        sqlFlag?: pulumi.Input<boolean>;
        /**
         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
         */
        valueType?: pulumi.Input<string>;
    }
    interface IndexUserInnerKeyValue {
        /**
         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
         */
        key?: pulumi.Input<string>;
        /**
         * Field description information required for configuring key-value indexes.
         */
        value?: pulumi.Input<inputs.tls.IndexUserInnerKeyValueValue>;
    }
    interface IndexUserInnerKeyValueValue {
        /**
         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
         */
        autoIndexFlag?: pulumi.Input<boolean>;
        /**
         * Whether to distinguish case. Default is false.
         */
        caseSensitive?: pulumi.Input<boolean>;
        /**
         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
         */
        includeChinese?: pulumi.Input<boolean>;
        /**
         * Create indexes for all fields with text values in the JSON field.
         */
        indexAll?: pulumi.Input<boolean>;
        /**
         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
         */
        indexSqlAll?: pulumi.Input<boolean>;
        jsonKeys?: pulumi.Input<pulumi.Input<inputs.tls.IndexUserInnerKeyValueValueJsonKey>[]>;
        /**
         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
         */
        sqlFlag?: pulumi.Input<boolean>;
        /**
         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
         */
        valueType?: pulumi.Input<string>;
    }
    interface IndexUserInnerKeyValueValueJsonKey {
        /**
         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
         */
        key?: pulumi.Input<string>;
        /**
         * Field description information required for configuring key-value indexes.
         */
        value?: pulumi.Input<inputs.tls.IndexUserInnerKeyValueValueJsonKeyValue>;
    }
    interface IndexUserInnerKeyValueValueJsonKeyValue {
        /**
         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
         */
        autoIndexFlag?: pulumi.Input<boolean>;
        /**
         * Whether to distinguish case. Default is false.
         */
        caseSensitive?: pulumi.Input<boolean>;
        /**
         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
         */
        includeChinese?: pulumi.Input<boolean>;
        /**
         * Create indexes for all fields with text values in the JSON field.
         */
        indexAll?: pulumi.Input<boolean>;
        /**
         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
         */
        indexSqlAll?: pulumi.Input<boolean>;
        /**
         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
         */
        sqlFlag?: pulumi.Input<boolean>;
        /**
         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
         */
        valueType?: pulumi.Input<string>;
    }
    interface ProjectTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface RuleContainerRule {
        /**
         * Container name to collect. If no container name is specified, all containers in the machine group will be collected. Supports regex matching; for example, setting the container name to ^(container-test)$ will collect all containers named container-test.
         */
        containerNameRegex?: pulumi.Input<string>;
        envTags?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleEnvTag>[]>;
        excludeContainerEnvRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleExcludeContainerEnvRegex>[]>;
        excludeContainerLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleExcludeContainerLabelRegex>[]>;
        includeContainerEnvRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleIncludeContainerEnvRegex>[]>;
        includeContainerLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleIncludeContainerLabelRegex>[]>;
        /**
         * Kubernetes container collection rules.
         */
        kubernetesRule?: pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRule>;
        /**
         * Collection information. stdout: Collects container standard output (stdout). stderr: Collects container standard error (stderr). all: Collects both container standard output (stdout) and standard error (stderr).
         */
        stream?: pulumi.Input<string>;
    }
    interface RuleContainerRuleEnvTag {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleExcludeContainerEnvRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleExcludeContainerLabelRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleIncludeContainerEnvRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleIncludeContainerLabelRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleKubernetesRule {
        annotationTags?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleAnnotationTag>[]>;
        /**
         * Whether to add all Kubernetes Labels as log tags to the original log data. When enabled, the log service adds fields for all Labels in the Kubernetes Pod to the logs. For example, if the Pod contains Label source=DC and destination=CS, the logs will include fields **tag**source__: DC and **tag**destination__: CS.
         */
        enableAllLabelTag?: pulumi.Input<boolean>;
        excludePodAnnotationRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleExcludePodAnnotationRegex>[]>;
        excludePodLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleExcludePodLabelRegex>[]>;
        includePodAnnotationRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleIncludePodAnnotationRegex>[]>;
        includePodLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleIncludePodLabelRegex>[]>;
        labelTags?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleLabelTag>[]>;
        /**
         * Name of the Kubernetes Namespace to collect. If no Namespace name is specified, all containers will be collected. Namespace names support regular expression matching. For example, if you set the Namespace name to ^(tcp|udp)$, it will collect all containers under the tcp and udp namespaces.
         */
        namespaceNameRegex?: pulumi.Input<string>;
        /**
         * Pod name is used to specify the Pod whose containers will be collected. If no Pod name is specified, all containers will be collected. Pod name supports regular expression matching. For example, setting the Pod name to ^(http.*)$ collects all containers under Pods whose names start with http.
         */
        podNameRegex?: pulumi.Input<string>;
        /**
         * Specify the container to collect by workload name. If no workload name is specified, all containers are collected. Workload names support regular expressions. For example, setting the workload name to ^(http.*)$ collects all containers under workloads starting with http.
         */
        workloadNameRegex?: pulumi.Input<string>;
        /**
         * Specify the container to collect by workload type. Only one type can be selected. If no type is specified, containers of all types will be collected. Supported workload types: Deployment: stateless workload StatefulSet: stateful workload DaemonSet: daemon process Job: task CronJob: scheduled task
         */
        workloadType?: pulumi.Input<string>;
    }
    interface RuleContainerRuleKubernetesRuleAnnotationTag {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleKubernetesRuleExcludePodAnnotationRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleKubernetesRuleExcludePodLabelRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleKubernetesRuleIncludePodAnnotationRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleKubernetesRuleIncludePodLabelRegex {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleContainerRuleKubernetesRuleLabelTag {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleExcludePath {
        /**
         * Collection path type. File: File name. Path: Directory.
         */
        type?: pulumi.Input<string>;
        /**
         * Collection path. Must be specified as an absolute path. When Type is Path, Value indicates a directory. When Type is File, Value indicates a file name.
         */
        value?: pulumi.Input<string>;
    }
    interface RuleExtractRule {
        /**
         * Regular expression that the first line of the log must match. Valid only when LogType is multiline*log or fullregex*log. Must be a valid regular expression.
         */
        beginRegex?: pulumi.Input<string>;
        /**
         * Log delimiter. Valid only when LogType is delimiter_log.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * Enable nanosecond precision time. When enabled, log time parsing will include and report nanosecond precision. true: Enable nanosecond precision time. false: Disable nanosecond precision time.
         */
        enableNanosecond?: pulumi.Input<boolean>;
        filterKeyRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleExtractRuleFilterKeyRegex>[]>;
        /**
         * List of log field names (Key). This is only valid when LogType is delimiter*log or fullregex*log. You can configure up to 100 field names. When LogType is delimiter*log, field names must be unique and cannot all be empty. When LogType is fullregex*log, field names must be unique and cannot be empty.
         */
        keys?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * The entire log must match the specified regular expression. This is only valid when the collected log type is fullregex_log. Must be a valid regular expression.
         */
        logRegex?: pulumi.Input<string>;
        /**
         * Automatically extract log fields based on the specified log template
         */
        logTemplate?: pulumi.Input<inputs.tls.RuleExtractRuleLogTemplate>;
        /**
         * Quoting character. Content wrapped by a quoting character will not be split but parsed as a complete field. Only valid when LogType is delimiter_log.
         */
        quote?: pulumi.Input<string>;
        /**
         * Regular expression for extracting time, used to extract the time value from the TimeKey field and parse it as the collection time
         */
        timeExtractRegex?: pulumi.Input<string>;
        /**
         * Parsing format for the time field. If you use a specific time field in the log as the log timestamp, you must provide both TimeKey and TimeFormat. TimeKey and TimeFormat must be used together.
         */
        timeFormat?: pulumi.Input<string>;
        /**
         * Name of the log time field. If you want to use a specific time field in the log as the log timestamp, you need to specify both TimeKey and TimeFormat. TimeKey and TimeFormat must be provided together.
         */
        timeKey?: pulumi.Input<string>;
        /**
         * Time sample. Used to check whether the entered time parsing format is correct.
         */
        timeSample?: pulumi.Input<string>;
        /**
         * Time zone. Supports machine time zone (default) and custom time zone. Custom time zone supports GMT and UTC. GMT format: GMT+08:00. UTC format: Asia/Shanghai.
         */
        timeZone?: pulumi.Input<string>;
        /**
         * Key name for unmatched logs.
         */
        unMatchLogKey?: pulumi.Input<string>;
        /**
         * Switch for uploading unmatched logs.
         */
        unMatchUpLoadSwitch?: pulumi.Input<boolean>;
    }
    interface RuleExtractRuleFilterKeyRegex {
        /**
         * Name of the filter field.
         */
        key?: pulumi.Input<string>;
        /**
         * The log content of the filter field must match the specified regular expression.
         */
        regex?: pulumi.Input<string>;
    }
    interface RuleExtractRuleLogTemplate {
        /**
         * Log template format.
         */
        format?: pulumi.Input<string>;
        /**
         * Log template types. Supported types: Nginx: Nginx log template.
         */
        type?: pulumi.Input<string>;
    }
    interface RuleHostGroupInfo {
        /**
         * Machine group ID
         */
        hostGroupId?: pulumi.Input<string>;
    }
    interface RuleUserDefineRule {
        /**
         * The Advanced parameter is used for extended configuration. After enabling extended configuration, you can customize advanced behaviors of LogCollector, such as when to release file handles. Note: If multiple release conditions are specified, the handle is released and log file monitoring ends as soon as any condition is met.
         */
        advanced?: pulumi.Input<inputs.tls.RuleUserDefineRuleAdvanced>;
        /**
         * Whether to upload the label information of the host group to the log service. The default is off. true: LogCollector uploads the label information of the host group to the specified field. You can specify the field name in the HostGroupLabelKey parameter. false (default): Host group label information is not uploaded.
         */
        enableHostGroupLabel?: pulumi.Input<boolean>;
        /**
         * Upload the hostname field. Default is disabled. true: Add a field to the original log to record the source hostname. Specify the hostname field name using HostnameKey. false: (default) Do not add the hostname field.
         */
        enableHostname?: pulumi.Input<boolean>;
        /**
         * Upload raw logs. true: Upload raw logs. false (default): Do not upload raw logs.
         */
        enableRawLog?: pulumi.Input<boolean>;
        fields?: pulumi.Input<pulumi.Input<inputs.tls.RuleUserDefineRuleField>[]>;
        /**
         * Field name used to store machine group label information
         */
        hostGroupLabelKey?: pulumi.Input<string>;
        /**
         * Hostname field name. Required only when EnableHostname is true.
         */
        hostnameKey?: pulumi.Input<string>;
        /**
         * Ignore log files that have not been updated for a specified period (in hours).
         */
        ignoreOlder?: pulumi.Input<number>;
        /**
         * Allow multiple log file collections. Empty: Use log file ID (including file inode, device, and checksum of the first N bytes) to uniquely identify the log file. RuleID: Use collection rule ID and log file ID to uniquely identify the log file. TopicIDRuleName: Use log topic ID, collection rule name, and log file ID to uniquely identify the log file.
         */
        multiCollectsType?: pulumi.Input<string>;
        /**
         * Rule for parsing the collection path. After setting the rule, fields in the collection path are extracted using the specified regular expression and added as metadata to the log data. Note: This parameter is not supported when collecting container standard output.
         */
        parsePathRule?: pulumi.Input<inputs.tls.RuleUserDefineRuleParsePathRule>;
        /**
         * LogCollector plugin configuration. After enabling plugin configuration, you can add one or more LogCollector processor plugins to parse logs with complex or variable structures.
         */
        plugin?: pulumi.Input<inputs.tls.RuleUserDefineRulePlugin>;
        /**
         * Name of the raw log field. Only effective when EnableRawLog is set to true. RawLogKey defaults to **raw**, meaning the original log data will be encapsulated in the **raw** field and uploaded to the log service along with the parsed log data.
         */
        rawLogKey?: pulumi.Input<string>;
        /**
         * Rules for routing log partitions. If this parameter is not set, logs are written using the default load balancing mode, and packets are written to any available Shard. If this parameter is set, logs are collected using the HashKey routing Shard mode, and the log service writes data to the Shard containing the specified Key value
         */
        shardHashKey?: pulumi.Input<inputs.tls.RuleUserDefineRuleShardHashKey>;
        /**
         * LogCollector collection policy, which specifies whether LogCollector collects incremental logs or full logs. Default is false, meaning full log collection. true: incremental collection. LogCollector only collects newly added content in the file. When new logs are written to monitored log files, LogCollector triggers log collection. For first-time collection, LogCollector automatically determines the collection position based on the incremental threshold TailSizeKb you specify. If the new file size does not exceed the incremental threshold, collection starts from the beginning of the file. If the new file size exceeds the incremental threshold, collection starts from the position at the end of the file minus the incremental threshold, collecting only incremental logs. For subsequent collections, LogCollector determines the collection position based on Checkpoint and continues collecting. false: (default) full collection. LogCollector collects logs from the beginning of each file, including historical log data.
         */
        tailFiles?: pulumi.Input<boolean>;
        /**
         * Backtracking threshold for incremental collection, in KiB. When LogCollector uses incremental collection, for the first collection of a log file: If the new log file size does not exceed the TailSizeKb value, collection starts from the beginning of the file. If the new log file size exceeds the TailSizeKb value, collection starts from the position that is TailSizeKb from the end of the file.
         */
        tailSizeKb?: pulumi.Input<number>;
    }
    interface RuleUserDefineRuleAdvanced {
        /**
         * After reading to the end of the log file, choose whether to release the file handle. Default is false.
         */
        closeEof?: pulumi.Input<boolean>;
        /**
         * Wait time to release log file handle. If no new logs are written to the log file within the specified time, the handle for that log file is released. Unit: seconds. Range: 1–300 seconds. Default: 60 seconds.
         */
        closeInactive?: pulumi.Input<number>;
        /**
         * Release the file handle after the log file is removed. Default is false.
         */
        closeRemoved?: pulumi.Input<boolean>;
        /**
         * Release the file handle after the log file is renamed. Default is false.
         */
        closeRenamed?: pulumi.Input<boolean>;
        /**
         * Maximum monitoring duration for LogCollector log files, in seconds. The default is 0 seconds, meaning LogCollector does not limit the monitoring duration for log files. Timing starts when LogCollector begins monitoring the log file. Once the specified duration is exceeded, LogCollector immediately releases the file handle and stops monitoring, regardless of whether the log file has been fully read.
         */
        closeTimeout?: pulumi.Input<number>;
        /**
         * Maximum wait time when LogCollector does not detect a line break, in seconds. The default is 5s. Timing starts when LogCollector begins reading the log file. If no line break is detected within the specified time, LogCollector sends the logs in the buffer. If the file write interval is long, a complete log entry may be split into two parts and written separately. Adjust this parameter based on your log write interval.
         */
        noLineTerminatorEofMaxTime?: pulumi.Input<number>;
    }
    interface RuleUserDefineRuleField {
        /**
         * Key.
         */
        key?: pulumi.Input<string>;
        /**
         * Value.
         */
        val?: pulumi.Input<string>;
    }
    interface RuleUserDefineRuleParsePathRule {
        /**
         * Field name list. The log service uses a regular expression (Regex) to parse the path sample (PathSample) into multiple fields. Keys specify the name of each field. You can configure up to 100 field names. Field names cannot be empty or duplicated.
         */
        keys?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Sample collection path for actual scenarios. The sample collection path must be an absolute path. Wildcards *, ?, ** are not allowed in the path sample.
         */
        pathSample?: pulumi.Input<string>;
        /**
         * Regular expression used to extract the path field. Must match the sample collection path, otherwise extraction will fail
         */
        regex?: pulumi.Input<string>;
    }
    interface RuleUserDefineRulePlugin {
        /**
         * LogCollector plugin. For the list of supported plugins and parameter descriptions, see LogCollector plugin overview.
         */
        processors?: pulumi.Input<string>;
    }
    interface RuleUserDefineRuleShardHashKey {
        /**
         * HashKey of the log group, used to specify the shard to which the current log group will be written. The value range for this parameter is [00000000000000000000000000000000-ffffffffffffffffffffffffffffffff).
         */
        hashKey?: pulumi.Input<string>;
    }
    interface ScheduleSqlTaskRequestCycle {
        /**
         * Cron expression, with a minimum granularity of minutes, using 24-hour format. For example, 0 18 * * * means execution at 18:00 every day.
         */
        cronTab?: pulumi.Input<string>;
        /**
         * If Type is set to Cron, you must also set the time zone.
         */
        cronTimeZone?: pulumi.Input<string>;
        /**
         * Scheduling period or the time point for periodic execution (minutes from 00:00). Range: 1–1440 minutes.
         */
        time: pulumi.Input<number>;
        /**
         * Scheduling period type. Options: Period, Fixed, Cron.
         */
        type: pulumi.Input<string>;
    }
    interface ShipperContentInfo {
        /**
         * CSV format log content configuration.
         */
        csvInfo?: pulumi.Input<inputs.tls.ShipperContentInfoCsvInfo>;
        /**
         * Log content parsing format. Delivery to TOS supports json, jsonl, csv; delivery to Kafka supports original, json.
         */
        format?: pulumi.Input<string>;
        /**
         * JSON/JSONL format log content configuration.
         */
        jsonInfo?: pulumi.Input<inputs.tls.ShipperContentInfoJsonInfo>;
    }
    interface ShipperContentInfoCsvInfo {
        /**
         * Delimiter. Supports comma, tab, pipe, semicolon, space.
         */
        delimiter?: pulumi.Input<string>;
        /**
         * Escape character. When field content contains a delimiter, use an escape character to enclose it. Supports single quote, double quote, or empty character.
         */
        escapeChar?: pulumi.Input<string>;
        /**
         * Fields to be delivered. Supports letters, numbers, and _-./. Cannot start with an underscore. Length: 1–128.
         */
        keys?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Content for invalid field padding. Length: 0–128.
         */
        nonFieldContent?: pulumi.Input<string>;
        /**
         * Whether to print the key in the first row.
         */
        printHeader?: pulumi.Input<boolean>;
    }
    interface ShipperContentInfoJsonInfo {
        /**
         * Enable flag.
         */
        enable?: pulumi.Input<boolean>;
        /**
         * Whether to enable escaping. Must be set to true.
         */
        escape?: pulumi.Input<boolean>;
        /**
         * Delivery field list; if not configured, all fields will be delivered. When delivering in JSON/JSONL format, if this parameter is not set, all fields will be delivered, including **content** (required), **source**, **path**, **time**, **image_name**, **container_name**, **pod_name**, **pod_uid**, namespace, **tag****client_ip**, and **tag****receive_time**.
         */
        keys?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ShipperKafkaShipperInfo {
        /**
         * Compression format; supports snappy, gzip, lz4, none.
         */
        compress?: pulumi.Input<string>;
        /**
         * Delivery end time, in milliseconds. If not set, delivery continues indefinitely. Note: Milliseconds will be truncated. For example, if 1776761323455 is entered, it will become 1776761323000; if 1776761323 is entered, it will become 1776761323000.
         */
        endTime?: pulumi.Input<number>;
        /**
         * Kafka instance.
         */
        instance?: pulumi.Input<string>;
        /**
         * Kafka topic name. All log data delivered through this configuration will be sent to this topic.
         */
        kafkaTopic?: pulumi.Input<string>;
        /**
         * Start time. If not configured, defaults to the current time. Note: Millisecond data will be ignored. For example, if 1776761323455 is entered, the result will be 1776761323000; if 1776761323 is entered, the result will be 1776761323000.
         */
        startTime?: pulumi.Input<number>;
    }
    interface ShipperTosShipperInfo {
        /**
         * Select a TOS bucket. Must be in the same region as the source log topic. Can only contain numbers, hyphens (-), and letters a–z. Must start and end with a number or letter. Length: 3–63 characters.
         */
        bucket?: pulumi.Input<string>;
        /**
         * Compression format; supports snappy, gzip, lz4, none.
         */
        compress?: pulumi.Input<string>;
        /**
         * Delivery interval in seconds, range: 300–900.
         */
        interval?: pulumi.Input<number>;
        /**
         * Maximum raw file size per partition for delivery, in MiB. Range: 5–256.
         */
        maxSize?: pulumi.Input<number>;
        /**
         * Partition rule for log delivery. Subdirectory naming format supports strftime syntax. Default: %Y/%m/%d/%H/%M.
         */
        partitionFormat?: pulumi.Input<string>;
        /**
         * Top-level directory name for the bucket. Cannot start with / or \, and cannot use consecutive /. Cannot use .. as a folder name. Duplicate names are not allowed within the same bucket.
         */
        prefix?: pulumi.Input<string>;
    }
    interface TopicTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace tos {
    interface BucketAcl {
        /**
         * Enable object default bucket ACL inheritance. true: Enable object default bucket ACL inheritance. false: Disable object default bucket ACL inheritance.
         */
        bucketAclDelivered?: pulumi.Input<boolean>;
        grants?: pulumi.Input<pulumi.Input<inputs.tos.BucketAclGrant>[]>;
        /**
         * Object owner
         */
        owner?: pulumi.Input<inputs.tos.BucketAclOwner>;
    }
    interface BucketAclGrant {
        /**
         * Bucket access permissions. Includes private, public-read, public-read-write, authenticated-read, bucket-owner-read, bucket-owner-full-control, log-delivery-write, bucket-owner-entrusted, default.
         */
        acl?: pulumi.Input<string>;
        /**
         * Grant all permissions to the specified user
         */
        grantFullControl?: pulumi.Input<string>;
        /**
         * Grant read permission to the specified user
         */
        grantRead?: pulumi.Input<string>;
        /**
         * Grant permission to specified user to view bucket ACL
         */
        grantReadAcp?: pulumi.Input<string>;
        /**
         * Grant write permission to specified user
         */
        grantWrite?: pulumi.Input<string>;
        /**
         * Grant permission to the specified user to modify and delete bucket ACL
         */
        grantWriteAcp?: pulumi.Input<string>;
    }
    interface BucketAclOwner {
        /**
         * Display name
         */
        displayName?: pulumi.Input<string>;
        /**
         * Account ID
         */
        ownerId?: pulumi.Input<string>;
    }
    interface BucketCorsCorsRule {
        /**
         * Specify the response headers allowed for cross-origin requests.
         */
        allowedHeaders?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Specify the allowed methods for cross-origin requests.
         */
        allowedMethods?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Specify the allowed origins for cross-origin requests.
         */
        allowedOrigins?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Specify additional headers to include in the CORS response to provide extra information to the client.
         */
        exposeHeaders?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Specify the cache duration for OPTIONS request responses on the client side, in seconds. Default is 3600.
         */
        maxAgeSeconds?: pulumi.Input<number>;
        /**
         * Whether to return the Vary: Origin header
         */
        responseVary?: pulumi.Input<boolean>;
    }
    interface BucketInventoryDestination {
        /**
         * Bucket information related to the inventory files.
         */
        tosBucketDestination?: pulumi.Input<inputs.tos.BucketInventoryDestinationTosBucketDestination>;
    }
    interface BucketInventoryDestinationTosBucketDestination {
        /**
         * Account ID of the bucket owner.
         */
        accountId?: pulumi.Input<string>;
        /**
         * Specify the bucket to store the inventory files.
         */
        bucket?: pulumi.Input<string>;
        /**
         * Inventory file format. Value is CSV, meaning the inventory file is in CSV format compressed with GZIP.
         */
        format?: pulumi.Input<string>;
        /**
         * Prefix for the storage path of inventory files. By default, files are saved under tos*bucket*inventory/sourceBucketName/inventoryId/YYYY-MM-DDTHH-MMZ/files in the target bucket.
         */
        prefix?: pulumi.Input<string>;
        /**
         * Role name used to grant permission to read all files from the source bucket and write files to the target bucket. The role must have TOS read/write and service access permissions. You can also use the default TOS role TosArchiveTOSInventory.
         */
        role?: pulumi.Input<string>;
    }
    interface BucketInventoryFilter {
        /**
         * Prefix matching information for exported files. If not set, an inventory of all objects in the bucket is generated by default.
         */
        prefix?: pulumi.Input<string>;
    }
    interface BucketInventoryOptionalFields {
        /**
         * Information about exported inventory files.
         */
        fields?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface BucketInventorySchedule {
        /**
         * Export frequency for inventory files. Options: Daily: export inventory files daily. Weekly: export inventory files weekly. Once: export inventory files once.
         */
        frequency?: pulumi.Input<string>;
    }
    interface BucketLifecycleConfig {
        /**
         * Specify expiration attributes for unmerged multipart tasks (fragments)
         */
        abortInCompleteMultipartUpload?: pulumi.Input<inputs.tos.BucketLifecycleConfigAbortInCompleteMultipartUpload>;
        /**
         * Expiration attribute for deleting the latest version object in the lifecycle rule based on last modified time
         */
        expiration?: pulumi.Input<inputs.tos.BucketLifecycleConfigExpiration>;
        /**
         * Filter conditions for applying the rule
         */
        filter?: pulumi.Input<inputs.tos.BucketLifecycleConfigFilter>;
        /**
         * Rule ID
         */
        lifecycleRuleId?: pulumi.Input<string>;
        noCurrentVersionExpiration?: pulumi.Input<inputs.tos.BucketLifecycleConfigNoCurrentVersionExpiration>;
        nonCurrentVersionTransitions?: pulumi.Input<pulumi.Input<inputs.tos.BucketLifecycleConfigNonCurrentVersionTransition>[]>;
        /**
         * Prefix to which the rule applies
         */
        prefix?: pulumi.Input<string>;
        /**
         * Enable rule. Includes Enabled, Disabled.
         */
        status?: pulumi.Input<string>;
        tags?: pulumi.Input<pulumi.Input<inputs.tos.BucketLifecycleConfigTag>[]>;
        transitions?: pulumi.Input<pulumi.Input<inputs.tos.BucketLifecycleConfigTransition>[]>;
    }
    interface BucketLifecycleConfigAbortInCompleteMultipartUpload {
        /**
         * Specify lifecycle rule for unmerged multipart tasks (fragments), number of days to delete after task initialization
         */
        daysAfterInitiation?: pulumi.Input<number>;
    }
    interface BucketLifecycleConfigExpiration {
        /**
         * Specific date for deleting the latest version object in the lifecycle rule based on last modified time
         */
        date?: pulumi.Input<string>;
        /**
         * Number of days for deleting the latest version object based on last modified time in lifecycle rules
         */
        days?: pulumi.Input<number>;
    }
    interface BucketLifecycleConfigFilter {
        /**
         * Equality condition status. Includes Enabled, Disabled
         */
        greaterThanIncludeEqual?: pulumi.Input<string>;
        /**
         * Equality condition status. Includes Enabled, Disabled
         */
        lessThanIncludeEqual?: pulumi.Input<string>;
        /**
         * Apply rule to objects larger than the specified size
         */
        objectSizeGreaterThan?: pulumi.Input<number>;
        /**
         * Apply rule to objects smaller than the specified size
         */
        objectSizeLessThan?: pulumi.Input<number>;
    }
    interface BucketLifecycleConfigNoCurrentVersionExpiration {
        /**
         * Specific date for deleting historical version objects in the lifecycle rule based on last modified time
         */
        nonCurrentDate?: pulumi.Input<string>;
        /**
         * Number of days to delete historical version objects in the lifecycle rule based on last modified time
         */
        nonCurrentDays?: pulumi.Input<number>;
    }
    interface BucketLifecycleConfigNonCurrentVersionTransition {
        /**
         * Specific date for historical version object transition in lifecycle rules based on last modified time
         */
        nonCurrentDate?: pulumi.Input<string>;
        /**
         * Number of days to transition historical version objects in the lifecycle rule based on last modified time
         */
        nonCurrentDays?: pulumi.Input<number>;
        /**
         * Storage class. Includes STANDARD, IA, ARCHIVE*FR, INTELLIGENT*TIERING, COLD*ARCHIVE, ARCHIVE, DEEP*COLD_ARCHIVE
         */
        storageClass?: pulumi.Input<string>;
    }
    interface BucketLifecycleConfigTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface BucketLifecycleConfigTransition {
        /**
         * Specific date for latest version object transition in lifecycle rules based on last modified time
         */
        date?: pulumi.Input<string>;
        /**
         * Number of days to transition the latest version object in the lifecycle rule based on last modified time
         */
        days?: pulumi.Input<number>;
        /**
         * Storage class for historical version object transition in lifecycle rules based on last modified time. Includes STANDARD, IA, ARCHIVE*FR, INTELLIGENT*TIERING, COLD*ARCHIVE, ARCHIVE, DEEP*COLD_ARCHIVE
         */
        storageClass?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRule {
        /**
         * Conditions that trigger the back-to-origin function.
         */
        condition?: pulumi.Input<inputs.tos.BucketMirrorBackRuleCondition>;
        /**
         * Rule ID. The unique identifier for the back-to-origin rule configured on the current bucket. You can set this yourself to distinguish between multiple rules. Restrictions:
         * Characters supported: letters, numbers,   - and _.
         * Maximum length: 32 characters.
         */
        id?: pulumi.Input<string>;
        /**
         * Back-to-origin redirect configuration.
         */
        redirect?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirect>;
    }
    interface BucketMirrorBackRuleCondition {
        /**
         * Supports triggering origin fetch only for specified domains. The domain must be able to access the bucket; it is recommended to use a custom domain bound to the bucket. Limit: supports up to 30 domains.
         */
        allowHosts?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Error code that triggers origin fetch. When a download request returns this error code, origin fetch is triggered. Limit: currently only supports 404.
         */
        httpCode?: pulumi.Input<number>;
        /**
         * Request types that trigger back-to-origin. Value description:
         * ["GET","HEAD"]: Both GetObject and HeadObject requests can trigger back-to-origin.
         * ["GET"]: Only GetObject requests can trigger back-to-origin.
         * Default is ["GET"].
         */
        httpMethods?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Object name prefix for matching origin fetch objects. Limit: supports up to 512 characters.
         */
        keyPrefix?: pulumi.Input<string>;
        /**
         * Object name suffix for matching origin fetch objects. Limit: supports up to 512 characters.
         */
        keySuffix?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRuleRedirect {
        fetchHeaderToMetaDataRules?: pulumi.Input<pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectFetchHeaderToMetaDataRule>[]>;
        /**
         * Whether to fetch data from the configured origin after redirection. Value description: true: Fetch data from the configured origin after redirection. false: Do not fetch data from the configured origin after redirection.
         */
        fetchSourceOnRedirect?: pulumi.Input<boolean>;
        /**
         * Whether to include request parameters when fetching data after redirection. If not configured, inherits PassQuery settings: true: includes request parameters. false: does not include request parameters.
         */
        fetchSourceOnRedirectWithQuery?: pulumi.Input<boolean>;
        /**
         * If the result of mirror origin fetch is 3xx, whether to continue redirecting to the specified Location to fetch data. Value description: true: TOS will continue to request the address corresponding to Location. false: TOS will return 302.
         */
        followRedirect?: pulumi.Input<boolean>;
        /**
         * Specify the headers to include when mirroring back to origin.
         */
        mirrorHeader?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectMirrorHeader>;
        /**
         * List of origin response headers allowed to be passed through directly.
         */
        passHeaderFromSources?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Whether to include request parameters when performing redirect or mirror back-to-origin rules. Value description:
         * true: Include request parameters.
         * false: Do not include request parameters.
         */
        passQuery?: pulumi.Input<boolean>;
        /**
         * List of origin response status codes allowed to be passed through directly.
         */
        passStatusCodeFromSources?: pulumi.Input<pulumi.Input<number>[]>;
        /**
         * Back-to-origin address configuration when the origin server is a private bucket.
         */
        privateSource?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSource>;
        /**
         * Back-to-origin address configuration when the origin server is a public bucket.
         */
        publicSource?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPublicSource>;
        /**
         * Specify redirect type. Value range: Mirror: Mirror origin fetch. Async: Redirect origin fetch.
         */
        redirectType?: pulumi.Input<string>;
        /**
         * Define transformations for the object name when requesting the origin server.
         */
        transform?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectTransform>;
    }
    interface BucketMirrorBackRuleRedirectFetchHeaderToMetaDataRule {
        /**
         * Suffix appended when writing object metadata.
         */
        metaDataSuffix?: pulumi.Input<string>;
        /**
         * Origin response header name.
         */
        sourceHeader?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRuleRedirectMirrorHeader {
        /**
         * Whether to forward all HTTP headers to the origin. Values: true: forwards all HTTP headers to the origin. false: does not forward all HTTP headers to the origin. The following HTTP header types are not supported for forwarding: Host, Content-Length, Date, Authorization.
         */
        passAll?: pulumi.Input<boolean>;
        /**
         * Pass the specified headers to the origin server. Limit: up to 64.
         */
        passes?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Prohibit forwarding specified headers to the origin. Limit: maximum 64.
         */
        removes?: pulumi.Input<pulumi.Input<string>[]>;
        sets?: pulumi.Input<pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectMirrorHeaderSet>[]>;
    }
    interface BucketMirrorBackRuleRedirectMirrorHeaderSet {
        /**
         * Request header name.
         */
        key?: pulumi.Input<string>;
        /**
         * Request header value.
         */
        value?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRuleRedirectPrivateSource {
        /**
         * Back-to-origin address configuration when the origin server is a private bucket.
         */
        sourceEndpoint?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpoint>;
    }
    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpoint {
        followers?: pulumi.Input<pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollower>[]>;
        primaries?: pulumi.Input<pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimary>[]>;
    }
    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollower {
        /**
         * Name of the origin fetch bucket. Required when the origin is a private bucket.
         */
        bucketName?: pulumi.Input<string>;
        /**
         * Private back-to-origin authentication method. Required when the origin server is a private bucket.
         */
        credentialProvider?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProvider>;
        /**
         * Access domain name of the origin service provider, excluding bucket name, maximum length 255. Required for private buckets.
         */
        endpoint?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProvider {
        /**
         * Region where the origin fetch bucket is located. Required when using AK/SK authentication.
         */
        region?: pulumi.Input<string>;
        /**
         * Name of AssumeRole. Only when fetching from a private TOS bucket can AssumeRole be used for authentication. Role authentication and AK/SK authentication are mutually exclusive and cannot be set simultaneously.
         */
        role?: pulumi.Input<string>;
        /**
         * Authenticate using AK/SK.
         */
        staticCredential?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProviderStaticCredential>;
    }
    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProviderStaticCredential {
        /**
         * AccessKey ID of the origin bucket. Required when using AK/SK authentication.
         */
        ak?: pulumi.Input<string>;
        /**
         * SecretKey for the back-to-origin bucket. Required when using AK/SK authentication.
         */
        sk?: pulumi.Input<string>;
        /**
         * Encryption method used for SecretKey. Values:
         * Empty: SecretKey is in plaintext. After receiving the SecretKey, the server will encrypt and store it.
         * AES256: SecretKey has been encrypted using the AES256 algorithm on the server side. After receiving the SecretKey, the server will parse and encrypt it for storage.
         * Note: When a back-to-origin rule is created for the first time, the SecretKey is encrypted with AES256. If you modify the back-to-origin rule without changing the SecretKey parameter, you must first decrypt the SecretKey and then re-encrypt it for storage. Therefore, when calling the PutBucketMirrorBack API to modify the back-to-origin rule and only changing other parameters (not the SecretKey), you can set SKEncryptType to AES256.
         */
        skEncryptType?: pulumi.Input<string>;
        /**
         * Origin service provider. Values: BOS: Baidu Cloud. S3: Other cloud providers using the S3 storage protocol.
         */
        storageVendor?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimary {
        /**
         * Name of the origin fetch bucket. Required when the origin is a private bucket.
         */
        bucketName?: pulumi.Input<string>;
        /**
         * Private back-to-origin authentication method. Required when the origin server is a private bucket.
         */
        credentialProvider?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProvider>;
        /**
         * Access domain name of the origin service provider, excluding bucket name, maximum length 255. Required for private buckets.
         */
        endpoint?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProvider {
        /**
         * Region where the origin fetch bucket is located. Required when using AK/SK authentication.
         */
        region?: pulumi.Input<string>;
        /**
         * Name of AssumeRole. Only when fetching from a private TOS bucket can AssumeRole be used for authentication. Role authentication and AK/SK authentication are mutually exclusive and cannot be set simultaneously.
         */
        role?: pulumi.Input<string>;
        /**
         * Authenticate using AK/SK.
         */
        staticCredential?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProviderStaticCredential>;
    }
    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProviderStaticCredential {
        /**
         * AccessKey ID of the origin bucket. Required when using AK/SK authentication.
         */
        ak?: pulumi.Input<string>;
        /**
         * SecretKey for the back-to-origin bucket. Required when using AK/SK authentication.
         */
        sk?: pulumi.Input<string>;
        /**
         * Encryption method used for SecretKey. Values:
         * Empty: SecretKey is in plaintext. After receiving the SecretKey, the server will encrypt and store it.
         * AES256: SecretKey has been encrypted using the AES256 algorithm on the server side. After receiving the SecretKey, the server will parse and encrypt it for storage.
         * Note: When a back-to-origin rule is created for the first time, the SecretKey is encrypted with AES256. If you modify the back-to-origin rule without changing the SecretKey parameter, you must first decrypt the SecretKey and then re-encrypt it for storage. Therefore, when calling the PutBucketMirrorBack API to modify the back-to-origin rule and only changing other parameters (not the SecretKey), you can set SKEncryptType to AES256.
         */
        skEncryptType?: pulumi.Input<string>;
        /**
         * Origin service provider. Values: BOS: Baidu Cloud. S3: Other cloud providers using the S3 storage protocol.
         */
        storageVendor?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRuleRedirectPublicSource {
        /**
         * Whether to always use the configured origin address.
         */
        fixedEndpoint?: pulumi.Input<boolean>;
        /**
         * Publicly accessible origin address.
         */
        sourceEndpoint?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPublicSourceSourceEndpoint>;
    }
    interface BucketMirrorBackRuleRedirectPublicSourceSourceEndpoint {
        /**
         * Origin address. Limit: Maximum length 255, supports up to 5 origin fetch addresses. When all origin fetches fail in Primary, an origin is selected from this configuration.
         */
        followers?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Origin address. Limit: Maximum length 255, supports up to 5 origin fetch addresses.
         */
        primaries?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface BucketMirrorBackRuleRedirectTransform {
        /**
         * Object name prefix to be replaced when requesting the origin.
         */
        replaceKeyPrefix?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectTransformReplaceKeyPrefix>;
        /**
         * Prefix added before the object name when requesting the origin server. Limit: up to 512 characters.
         */
        withKeyPrefix?: pulumi.Input<string>;
        /**
         * Prefix added before the object name when requesting the origin server. Limit: up to 512 characters.
         */
        withKeySuffix?: pulumi.Input<string>;
    }
    interface BucketMirrorBackRuleRedirectTransformReplaceKeyPrefix {
        /**
         * Object name prefix to be replaced when requesting the origin. Limit: Supports up to 512 characters.
         */
        keyPrefix?: pulumi.Input<string>;
        /**
         * Value of the object name prefix after replacement when requesting the origin. Limit: Supports up to 512 characters.
         */
        replaceWith?: pulumi.Input<string>;
    }
    interface BucketNotificationNotificationRule {
        /**
         * Event notification delivery targets. Must include at least one target and supports up to five different targets.
         */
        destination?: pulumi.Input<inputs.tos.BucketNotificationNotificationRuleDestination>;
        /**
         * Event type. List of events supported by TOS.
         */
        events?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Filter rules.
         */
        filter?: pulumi.Input<inputs.tos.BucketNotificationNotificationRuleFilter>;
        /**
         * Event notification rule name. Naming rules: Event names created under the same bucket must be unique. Maximum length is 255 characters. If not set, TOS will automatically generate a rule name.
         */
        ruleId?: pulumi.Input<string>;
    }
    interface BucketNotificationNotificationRuleDestination {
        kafkas?: pulumi.Input<pulumi.Input<inputs.tos.BucketNotificationNotificationRuleDestinationKafka>[]>;
        rocketMqs?: pulumi.Input<pulumi.Input<inputs.tos.BucketNotificationNotificationRuleDestinationRocketMq>[]>;
        veFaaS?: pulumi.Input<pulumi.Input<inputs.tos.BucketNotificationNotificationRuleDestinationVeFaa>[]>;
    }
    interface BucketNotificationNotificationRuleDestinationKafka {
        /**
         * Kafka instance ID.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Region where the Kafka instance is located.
         */
        region?: pulumi.Input<string>;
        /**
         * Role TRN, used to authorize TOS to access Kafka service.
         */
        role?: pulumi.Input<string>;
        /**
         * Name of the Kafka topic.
         */
        topic?: pulumi.Input<string>;
        /**
         * Kafka username.
         */
        user?: pulumi.Input<string>;
    }
    interface BucketNotificationNotificationRuleDestinationRocketMq {
        /**
         * RocketMQ AccessKey。
         */
        accessKeyId?: pulumi.Input<string>;
        /**
         * RocketMQ instance ID.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Role TRN, used to authorize TOS to access RocketMQ service.
         */
        role?: pulumi.Input<string>;
        /**
         * Name of the RocketMQ topic.
         */
        topic?: pulumi.Input<string>;
    }
    interface BucketNotificationNotificationRuleDestinationVeFaa {
        /**
         * Function ID for event delivery.
         */
        functionId?: pulumi.Input<string>;
    }
    interface BucketNotificationNotificationRuleFilter {
        /**
         * Object filter information.
         */
        tosKey?: pulumi.Input<inputs.tos.BucketNotificationNotificationRuleFilterTosKey>;
    }
    interface BucketNotificationNotificationRuleFilterTosKey {
        filterRules?: pulumi.Input<pulumi.Input<inputs.tos.BucketNotificationNotificationRuleFilterTosKeyFilterRule>[]>;
    }
    interface BucketNotificationNotificationRuleFilterTosKeyFilterRule {
        /**
         * Matching conditions. The values are as follows: prefix: prefix; suffix: suffix.
         */
        name?: pulumi.Input<string>;
        /**
         * Matched prefix and suffix information.
         */
        value?: pulumi.Input<string>;
    }
    interface BucketObjectLockConfiguration {
        /**
         * Enable retention policy Only Enabled is supported, which means the retention policy is enabled
         */
        objectLockEnabled?: pulumi.Input<string>;
        /**
         * Bucket retention policy rules
         */
        rule?: pulumi.Input<inputs.tos.BucketObjectLockConfigurationRule>;
    }
    interface BucketObjectLockConfigurationRule {
        /**
         * Default bucket retention policy
         */
        defaultRetention?: pulumi.Input<inputs.tos.BucketObjectLockConfigurationRuleDefaultRetention>;
    }
    interface BucketObjectLockConfigurationRuleDefaultRetention {
        /**
         * Object lock days Objects cannot be deleted or overwritten during the specified number of days. Measured in days
         */
        days?: pulumi.Input<number>;
        /**
         * Retention policy mode Only COMPLIANCE is supported, which means compliance mode. In this mode, no user can delete or overwrite locked objects during the retention period
         */
        mode?: pulumi.Input<string>;
        /**
         * Object lock years Objects cannot be deleted or overwritten during the specified number of years. Measured in years, with one year equal to 365 days
         */
        years?: pulumi.Input<number>;
    }
    interface BucketRealtimeLogRealTimeLog {
        /**
         * Role name. Used to grant TOS Object Storage permission to create resources such as projects and topics in Log Service TLS and to write logs
         */
        role: pulumi.Input<string>;
        /**
         * Log project ID
         */
        tlsProjectId?: pulumi.Input<string>;
        /**
         * Log topic ID
         */
        tlsTopicId?: pulumi.Input<string>;
        /**
         * For topics created using the TOS service, only "true" is allowed as a value
         */
        useServiceTopic: pulumi.Input<boolean>;
    }
    interface BucketTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace transitrouter {
    interface DirectConnectGatewayAttachmentTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface PeerAttachmentTag {
        /**
         * Tag key for cross-region connection user tags. Length must be between 1 and 128 characters. Case-sensitive; cannot start with any case combination of sys:. Cannot start or end with a space character. Allowed characters include letters, numbers, space character, underscore (_), period (.), colon (:), slash (/), equals sign (=), plus sign (+), minus sign (-), and @. Note: Tag keys for the same resource must be unique. If this parameter is not provided or no value is specified, the default is empty.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for the cross-region connection user tag. Length limit: 0–255 characters. Case-sensitive. Cannot start or end with a space. Allowed characters: letters, numbers, spaces (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @. Note: If this parameter is provided, Tags.N.Key must be provided first.
         */
        value?: pulumi.Input<string>;
    }
    interface TransitRouterAttachment {
        /**
         * Whether to automatically synchronize TR routes to the network instance route table. true: Yes. false: No.
         */
        autoPublishRouteEnabled?: pulumi.Input<boolean>;
        /**
         * Business status of the network instance connection. Values: Normal: Normal. FinancialLocked: Financially locked.
         */
        businessStatus?: pulumi.Input<string>;
        /**
         * Creation time of the network instance connection.
         */
        creationTime?: pulumi.Input<string>;
        /**
         * Deletion time of the network instance connection.
         */
        deletedTime?: pulumi.Input<string>;
        /**
         * Description of the network instance connection.
         */
        description?: pulumi.Input<string>;
        /**
         * Whether IPv6 is enabled. true: yes. false: no
         */
        ipv6Enabled?: pulumi.Input<boolean>;
        /**
         * Shutdown time due to overdue payment for the network instance connection
         */
        overdueTime?: pulumi.Input<string>;
        /**
         * ID of the network instance
         */
        resourceId?: pulumi.Input<string>;
        /**
         * Type of network instance associated with the network instance connection. VPC: Virtual Private Cloud. VPN: VPN connection. DirectConnectGateway: Direct Connect Gateway. TransitRouter: Transit Router
         */
        resourceType?: pulumi.Input<string>;
        /**
         * Status of the network instance connection. Creating: creating. Deleting: deleting. Pending: configuring. Available: available
         */
        status?: pulumi.Input<string>;
        tags?: pulumi.Input<pulumi.Input<inputs.transitrouter.TransitRouterAttachmentTag>[]>;
        /**
         * Network instance connection ID.
         */
        transitRouterAttachmentId?: pulumi.Input<string>;
        /**
         * Name of the network instance connection
         */
        transitRouterAttachmentName?: pulumi.Input<string>;
        /**
         * ID of the forwarding policy associated with the cross-region connection
         */
        transitRouterForwardPolicyTableId?: pulumi.Input<string>;
        /**
         * Transit router instance ID.
         */
        transitRouterId?: pulumi.Input<string>;
        /**
         * Route table ID associated with the forwarding of the network instance connection.
         */
        transitRouterRouteTableId?: pulumi.Input<string>;
        /**
         * ID of the flow marking policy associated with the cross-region connection
         */
        transitRouterTrafficQosMarkingPolicyId?: pulumi.Input<string>;
        /**
         * ID of the flow queue policy associated with the cross-region connection
         */
        transitRouterTrafficQosQueuePolicyId?: pulumi.Input<string>;
        /**
         * Last operation time of the network instance connection
         */
        updateTime?: pulumi.Input<string>;
    }
    interface TransitRouterAttachmentTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface TransitRouterBandwidthPackageAllocation {
        /**
         * Time when the bandwidth package was associated with the cross-region connection.
         */
        allocateTime?: pulumi.Input<string>;
        /**
         * Bandwidth peak of the cross-region connection, in Mbps.
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Region ID of the local transit router instance in the cross-region connection.
         */
        localRegionId?: pulumi.Input<string>;
        /**
         * Region ID of the peer transit router instance in the cross-region connection.
         */
        peerRegionId?: pulumi.Input<string>;
        /**
         * ID of the cross-region connection.
         */
        transitRouterPeerAttachmentId?: pulumi.Input<string>;
    }
    interface TransitRouterBandwidthPackageTag {
        /**
         * Tag key of the tag.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface TransitRouterRouteTableTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface TransitRouterTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface VpcAttachmentAttachPoint {
        /**
         * Subnet ID of the connection point.
         */
        subnetId: pulumi.Input<string>;
        /**
         * Availability zone ID of the connection point.
         */
        zoneId: pulumi.Input<string>;
    }
    interface VpcAttachmentTag {
        /**
         * Tag key for user tag.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for user tag.
         */
        value?: pulumi.Input<string>;
    }
    interface VpnAttachmentTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace vedbm {
    interface AllowListAssociatedInstance {
        /**
         * Instance ID.
         */
        instanceId?: pulumi.Input<string>;
    }
    interface DatabaseDatabasesPrivilege {
        /**
         * Account name to be authorized
         */
        accountName?: pulumi.Input<string>;
        /**
         * Database permission type: ReadWrite/ReadOnly/DDLOnly/DMLOnly/Custom
         */
        accountPrivilege?: pulumi.Input<string>;
        /**
         * Specific SQL operation permissions, separated by English commas; required for Custom type
         */
        accountPrivilegeDetails?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface EndpointPrivateAddresses {
        /**
         * Resolution method, fixed as false
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Instance intranet access domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * Public network ID
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP address
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network type
         */
        networkType?: pulumi.Input<string>;
        /**
         * Subnet ID
         */
        subnetId?: pulumi.Input<string>;
    }
    interface EndpointPublicAddresses {
        /**
         * Resolution method, fixed as false
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Instance intranet access domain name
         */
        domain?: pulumi.Input<string>;
        /**
         * Public network ID
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP address
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network type
         */
        networkType?: pulumi.Input<string>;
        /**
         * Subnet ID
         */
        subnetId?: pulumi.Input<string>;
    }
    interface InstanceChargeDetail {
        /**
         * Whether to enable auto-renewal in prepaid scenarios. Values: true: auto-renewal. false: no auto-renewal.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Billing expiration time for prepaid scenarios, format: yyyy-MM-ddTHH:mm:ssZ (UTC time)
         */
        chargeEndTime?: pulumi.Input<string>;
        /**
         * Billing start time. Format: yyyy-MM-ddTHH:mm:ssZ (UTC time)
         */
        chargeStartTime?: pulumi.Input<string>;
        /**
         * Payment status: Normal: Normal. Overdue: Overdue. Shutdown: Shutdown
         */
        chargeStatus?: pulumi.Input<string>;
        /**
         * Billing type. PostPaid: Pay-as-you-go. PrePaid: yearly/monthly subscription
         */
        chargeType?: pulumi.Input<string>;
        /**
         * Estimated release time when shut down due to overdue payment. Format: yyyy-MM-ddTHH:mm:ssZ (UTC time)
         */
        overdueReclaimTime?: pulumi.Input<string>;
        /**
         * Shutdown time for overdue payments. Format: yyyy-MM-ddTHH:mm:ssZ (UTC time).
         */
        overdueTime?: pulumi.Input<string>;
        /**
         * Purchase duration for prepaid scenarios.
         */
        period?: pulumi.Input<number>;
        /**
         * Purchase period for prepaid scenarios. Month: monthly subscription. Year: annual subscription.
         */
        periodUnit?: pulumi.Input<string>;
    }
    interface InstanceEndpoint {
        addresses?: pulumi.Input<pulumi.Input<inputs.vedbm.InstanceEndpointAddress>[]>;
        /**
         * Whether to allow automatic addition of new nodes. Values: true: yes. false: no.
         */
        autoAddNewNodes?: pulumi.Input<boolean>;
        /**
         * Consistency level, applicable only to read-write mode connection endpoints. Values: Eventual: eventual consistency. Session: session consistency. Global: global consistency.
         */
        consistLevel?: pulumi.Input<string>;
        /**
         * When latency is high, the timeout for read-only nodes to synchronize the latest data, in microseconds (us). Range: 1us~100000000us
         */
        consistTimeout?: pulumi.Input<number>;
        /**
         * Timeout policy for read-only node data synchronization. Supports the following two policies: ReturnError: Returns SQL error (wait replication complete timeout, please retry). ReadMaster: Sends request to the primary node.
         */
        consistTimeoutAction?: pulumi.Input<string>;
        /**
         * Address description
         */
        description?: pulumi.Input<string>;
        /**
         * Whether to enable transaction splitting. Only effective for read-write mode endpoints. Values: true: yes. false: no.
         */
        distributedTransaction?: pulumi.Input<boolean>;
        /**
         * Instance connection endpoint ID.
         */
        endpointId?: pulumi.Input<string>;
        /**
         * Instance connection endpoint name.
         */
        endpointName?: pulumi.Input<string>;
        /**
         * Connection endpoint type. Values: Cluster: default endpoint. Primary: primary node endpoint. Custom: custom endpoint.
         */
        endpointType?: pulumi.Input<string>;
        /**
         * Whether the primary node accepts read requests. Applies only to read/write mode endpoints. true: Yes. false: No
         */
        masterAcceptReadRequests?: pulumi.Input<boolean>;
        /**
         * Node list configured for the connection endpoint.
         */
        nodeIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Endpoint read/write mode. Options: ReadWrite: Read/write. ReadOnly: Read-only
         */
        readWriteMode?: pulumi.Input<string>;
    }
    interface InstanceEndpointAddress {
        /**
         * Parsing method. The current return value can only be false.
         */
        dnsVisibility?: pulumi.Input<boolean>;
        /**
         * Instance private access domain name.
         */
        domain?: pulumi.Input<string>;
        /**
         * Public network ID.
         */
        eipId?: pulumi.Input<string>;
        /**
         * IP address.
         */
        ipAddress?: pulumi.Input<string>;
        /**
         * Network type: Private: private network VPC. Public: public access.
         */
        networkType?: pulumi.Input<string>;
        /**
         * Instance private network access port.
         */
        port?: pulumi.Input<string>;
        /**
         * Subnet ID. The subnet must belong to the selected availability zone.
         */
        subnetId?: pulumi.Input<string>;
    }
    interface InstanceMaintenanceWindow {
        /**
         * Maintenance cycle granularity. Default value: Week.
         */
        dayKind?: pulumi.Input<string>;
        /**
         * Specify which day of the month is the maintenance window. Default is empty, meaning every day is specified.
         */
        dayOfMonths?: pulumi.Input<pulumi.Input<number>[]>;
        /**
         * Which day of the week is the maintenance window. Default value is every day: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday.
         */
        dayOfWeeks?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Instance maintenance window. Format: HH:mmZ-HH:mmZ (UTC time).
         */
        maintenanceTime?: pulumi.Input<string>;
    }
    interface InstanceNode {
        /**
         * Node failover priority. Range: 0~15. Higher values indicate higher priority
         */
        failoverPriority?: pulumi.Input<number>;
        /**
         * Memory size, in GiB.
         */
        memory?: pulumi.Input<number>;
        /**
         * Node ID
         */
        nodeId?: pulumi.Input<string>;
        /**
         * Node specification.
         */
        nodeSpec?: pulumi.Input<string>;
        /**
         * Node type. Values: Primary: primary node. ReadOnly: read-only node.
         */
        nodeType?: pulumi.Input<string>;
        /**
         * CPU size. For example, a value of 1 indicates a CPU size of 1U.
         */
        vCpu?: pulumi.Input<number>;
        /**
         * Availability zone ID
         */
        zoneId?: pulumi.Input<string>;
    }
    interface InstanceTag {
        /**
         * User tag key. Length range: 1~128 characters. Allows input of characters from all languages, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals (=), plus (+), hyphens (-), and @ (@). If the tag key starts or ends with a space, the system will automatically remove it
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value. Allows input of characters from all languages, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals (=), plus (+), hyphens (-), and @ (@). Case-sensitive. If the tag value starts or ends with a space, the system will automatically remove it
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace vefaas {
    interface FunctionAsyncTaskConfig {
        /**
         * Asynchronous task callback target configuration
         */
        destinationConfig?: pulumi.Input<inputs.vefaas.FunctionAsyncTaskConfigDestinationConfig>;
        /**
         * Whether to enable asynchronous task
         */
        enableAsyncTask?: pulumi.Input<boolean>;
        /**
         * Number of retry attempts for asynchronous task failures. Available values: 0–3
         */
        maxRetry?: pulumi.Input<number>;
    }
    interface FunctionAsyncTaskConfigDestinationConfig {
        /**
         * Callback target configuration when the task fails
         */
        onFailure?: pulumi.Input<inputs.vefaas.FunctionAsyncTaskConfigDestinationConfigOnFailure>;
        /**
         * Callback target configuration when the task succeeds
         */
        onSuccess?: pulumi.Input<inputs.vefaas.FunctionAsyncTaskConfigDestinationConfigOnSuccess>;
    }
    interface FunctionAsyncTaskConfigDestinationConfigOnFailure {
        /**
         * Specific callback target. Set the value to empty ("") to disable this callback
         */
        destination?: pulumi.Input<string>;
    }
    interface FunctionAsyncTaskConfigDestinationConfigOnSuccess {
        /**
         * Specific callback target. Set the value to empty ("") to disable this callback
         */
        destination?: pulumi.Input<string>;
    }
    interface FunctionDependencyInstallStatus {
        /**
         * Task creation time.
         */
        createTime?: pulumi.Input<string>;
        /**
         * Task completion time. The task is considered complete when it is in one of the following statuses: Canceled: Canceled. Timeout: Timed out. Failed: Failed. Succeeded: Succeeded.
         */
        finishTime?: pulumi.Input<string>;
        /**
         * Task status. Possible values are as follows: Enqueued: Queued. Dequeued: Dequeued. InProgress: In progress. Canceling/Canceled: Canceling/Canceled. Timeout: Timed out. Failed: Failed. Succeeded: Succeeded.
         */
        status?: pulumi.Input<string>;
    }
    interface FunctionEnv {
        /**
         * Environment variable key. 1–63 characters; can include letters, numbers, and underscores (_), but cannot start with a number. Key must be unique within the same function
         */
        key?: pulumi.Input<string>;
        /**
         * Environment variable value
         */
        value?: pulumi.Input<string>;
    }
    interface FunctionNasStorage {
        /**
         * Enable NAS storage mount. true: enabled, store data in NAS. false: disabled.
         */
        enableNas?: pulumi.Input<boolean>;
        nasConfigs?: pulumi.Input<pulumi.Input<inputs.vefaas.FunctionNasStorageNasConfig>[]>;
    }
    interface FunctionNasStorageNasConfig {
        /**
         * NAS file system ID.
         */
        fileSystemId?: pulumi.Input<string>;
        /**
         * User group in the file system. Customization is not currently supported. If this parameter is provided, its value is 1000 (consistent with the function run user gid)
         */
        gid?: pulumi.Input<number>;
        /**
         * Function local mount directory. Length: 1–128 characters, must start with “/”, supports uppercase and lowercase letters, numbers, and special characters (  - . _ ~ / : @ = + ? #).
         */
        localMountPath?: pulumi.Input<string>;
        /**
         * NAS mount point ID
         */
        mountPointId?: pulumi.Input<string>;
        /**
         * Remote directory in the file system. Length: 1–128 characters, must start with “/”, supports uppercase and lowercase letters, numbers, and special characters (  - . _ ~ / : @ = + ? #)
         */
        remotePath?: pulumi.Input<string>;
        /**
         * The user in the file system cannot be customized for now. If this parameter is provided, the value must be 1000 (consistent with the function run user uid).
         */
        uid?: pulumi.Input<number>;
    }
    interface FunctionSourceAccessConfig {
        /**
         * Image repository password
         */
        password?: pulumi.Input<string>;
        /**
         * Image repository username
         */
        username?: pulumi.Input<string>;
    }
    interface FunctionTag {
        /**
         * Function tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Function tag value
         */
        value?: pulumi.Input<string>;
    }
    interface FunctionTlsConfig {
        /**
         * TLS log feature toggle. true: enabled, function stdout/stderr logs will be collected to the specified log project and log topic in Log Service. false: disabled, logs will not be collected
         */
        enableLog?: pulumi.Input<boolean>;
        /**
         * TLS log project ID
         */
        tlsProjectId?: pulumi.Input<string>;
        /**
         * TLS log topic ID.
         */
        tlsTopicId?: pulumi.Input<string>;
    }
    interface FunctionTosMountConfig {
        /**
         * AKSK with TOS domain access permission.
         */
        credentials?: pulumi.Input<inputs.vefaas.FunctionTosMountConfigCredentials>;
        /**
         * Enable TOS storage mount.
         */
        enableTos?: pulumi.Input<boolean>;
        mountPoints?: pulumi.Input<pulumi.Input<inputs.vefaas.FunctionTosMountConfigMountPoint>[]>;
    }
    interface FunctionTosMountConfigCredentials {
        /**
         * Account AccessKey ID
         */
        accessKeyId?: pulumi.Input<string>;
        /**
         * Account Secret Access Key
         */
        secretAccessKey?: pulumi.Input<string>;
    }
    interface FunctionTosMountConfigMountPoint {
        /**
         * TOS bucket name.
         */
        bucketName?: pulumi.Input<string>;
        /**
         * Mounted TOS Bucket path.
         */
        bucketPath?: pulumi.Input<string>;
        /**
         * TOS access domain name.
         */
        endpoint?: pulumi.Input<string>;
        /**
         * Function local mount directory.
         */
        localMountPath?: pulumi.Input<string>;
        /**
         * Function local directory access permission. After mounting a TOS bucket, whether the function's local mount directory is read-only. true: read-only; false (default): read/write
         */
        readOnly?: pulumi.Input<boolean>;
    }
    interface FunctionVpcConfig {
        /**
         * Function public network access switch. Whether to access the public network via veFaaS VPC shared NAT gateway. Values: true: enabled, access public network via default network interface. Public outbound traffic fees apply. false: disabled, function cannot access public network via default network interface.
         */
        enableSharedInternetAccess?: pulumi.Input<boolean>;
        /**
         * Whether the function enables private network access
         */
        enableVpc?: pulumi.Input<boolean>;
        /**
         * Security group ID
         */
        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Subnet ID
         */
        subnetIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * VPC ID. If the VPC ID is an empty string, it means the current VPC configuration will be deleted
         */
        vpcId?: pulumi.Input<string>;
    }
    interface KafkaTriggerKafkaCredentials {
        /**
         * Kafka authentication mechanism. Options: PLAIN, SCRAM-SHA-256.
         */
        mechanism: pulumi.Input<string>;
        /**
         * SASL/PLAIN password set when creating the Kafka instance.
         */
        password: pulumi.Input<string>;
        /**
         * SASL/PLAIN username set when creating the Kafka instance.
         */
        username: pulumi.Input<string>;
    }
    interface SandboxEnv {
        /**
         * Environment variable key
         */
        key?: pulumi.Input<string>;
        /**
         * Environment variable value
         */
        value?: pulumi.Input<string>;
    }
    interface SandboxInstanceImageInfo {
        /**
         * Startup command for the sandbox instance program. To specify a script file, use an absolute path and ensure the script has executable permissions
         */
        command?: pulumi.Input<string>;
        /**
         * Preheated image address used by the sandbox instance
         */
        image?: pulumi.Input<string>;
        /**
         * Pre-warmed image ID used by the sandbox instance.
         */
        imageId?: pulumi.Input<string>;
        /**
         * Listening port of the sandbox instance image.
         */
        port?: pulumi.Input<number>;
    }
    interface SandboxInstanceTosMountConfig {
        /**
         * Whether instance-level TOS mount is enabled for the sandbox instance. Parameter description: true: yes, false: no
         */
        enable?: pulumi.Input<boolean>;
        tosMountPoints?: pulumi.Input<pulumi.Input<inputs.vefaas.SandboxInstanceTosMountConfigTosMountPoint>[]>;
    }
    interface SandboxInstanceTosMountConfigTosMountPoint {
        /**
         * TOS remote directory mounted by the sandbox instance
         */
        bucketPath?: pulumi.Input<string>;
        /**
         * Local directory of the TOS bucket mounted by the sandbox instance. If this directory is the local directory configured for TOS storage mount in the sandbox application, the system modifies the corresponding TOS BucketPath based on the specified local directory
         */
        localMountPath?: pulumi.Input<string>;
    }
    interface SandboxMetadata {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace vepfs {
    interface InstanceCapacityInfo {
        /**
         * Total file system capacity, unit: TiB. Note: Disk balancing time varies based on cluster capacity, cluster load, and other factors. For clusters above the PiB level, expansion typically requires day-level disk balancing time. The expansion capacity becomes effective (and is billed) only after disk balancing is complete.
         */
        totalTiB?: pulumi.Input<number>;
        /**
         * Used capacity (GiB).
         */
        usedGiB?: pulumi.Input<number>;
    }
    interface InstanceTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface MountServiceAttachFileSystem {
        /**
         * Account ID.
         */
        accountId?: pulumi.Input<string>;
        /**
         * User mount path.
         */
        customerPath?: pulumi.Input<string>;
        /**
         * File system ID.
         */
        fileSystemId?: pulumi.Input<string>;
        /**
         * File system name.
         */
        fileSystemName?: pulumi.Input<string>;
        /**
         * Binding status. Details: Attaching: Attaching. AttachError: Attachment failed. Attached: Attached. Detaching: Detaching. DetachError: Detachment failed.
         */
        status?: pulumi.Input<string>;
    }
    interface MountServiceNode {
        /**
         * Node initial password.
         */
        defaultPassword?: pulumi.Input<string>;
        /**
         * Node instance ID.
         */
        nodeId?: pulumi.Input<string>;
    }
}
export declare namespace vke {
    interface AddonStatus {
        conditions?: pulumi.Input<pulumi.Input<inputs.vke.AddonStatusCondition>[]>;
        /**
         * Component status. Parameter values include: Running, Failed, Creating, Deleting, Updating
         */
        phase?: pulumi.Input<string>;
    }
    interface AddonStatusCondition {
    }
    interface ClusterClusterConfig {
        /**
         * Cluster API Server access IPv4 address information
         */
        apiServerEndpoints?: pulumi.Input<inputs.vke.ClusterClusterConfigApiServerEndpoints>;
        /**
         * Cluster API Server public access configuration. This parameter is returned only when ApiServerPublicAccessEnable=true
         */
        apiServerPublicAccessConfig?: pulumi.Input<inputs.vke.ClusterClusterConfigApiServerPublicAccessConfig>;
        /**
         * Node public access configuration. Parameter value description: false: Disabled. true: Enabled
         */
        apiServerPublicAccessEnabled?: pulumi.Input<boolean>;
        /**
         * Cluster network protocol stack. Parameter value description: Ipv4: Ipv4 single stack. Ipv6: [Invitation test · Trial application] Ipv6 single stack. DualStack: [Invitation test · Trial application] Ipv4 and Ipv6 dual stack
         */
        ipFamily?: pulumi.Input<string>;
        /**
         * Node public access configuration. Parameter value description: false: Disabled. true: Enabled
         */
        resourcePublicAccessDefaultEnabled?: pulumi.Input<boolean>;
        /**
         * Security group used by the cluster control plane and nodes.
         */
        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Subnet ID for cluster control plane communication within the private network.
         */
        subnetIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Private network (VPC) ID where the cluster control plane and some nodes are located.
         */
        vpcId?: pulumi.Input<string>;
    }
    interface ClusterClusterConfigApiServerEndpoints {
        /**
         * Cluster API Server private IPv4 address.
         */
        privateIp?: pulumi.Input<inputs.vke.ClusterClusterConfigApiServerEndpointsPrivateIp>;
        /**
         * Cluster API Server public IPv4 address
         */
        publicIp?: pulumi.Input<inputs.vke.ClusterClusterConfigApiServerEndpointsPublicIp>;
    }
    interface ClusterClusterConfigApiServerEndpointsPrivateIp {
        /**
         * IPv4 address of the private network IP.
         */
        ipv4?: pulumi.Input<string>;
    }
    interface ClusterClusterConfigApiServerEndpointsPublicIp {
        /**
         * IPv4 address of the public IP.
         */
        ipv4?: pulumi.Input<string>;
    }
    interface ClusterClusterConfigApiServerPublicAccessConfig {
        /**
         * Public access network configuration. This parameter is returned only when ApiServerPublicAccessEnable=true
         */
        publicAccessNetworkConfig?: pulumi.Input<inputs.vke.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfig>;
    }
    interface ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfig {
        /**
         * Peak bandwidth of the public IP, unit: Mbps
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Billing type for public IP: 2: Pay-as-you-go by bandwidth cap. 3: Pay-as-you-go by actual traffic.
         */
        billingType?: pulumi.Input<number>;
        /**
         * Line type of the public IP. Parameter value description: BGP: BGP (multi-line)
         */
        isp?: pulumi.Input<string>;
    }
    interface ClusterIrsaConfig {
        /**
         * Identifier for accepting tokens
         */
        audience?: pulumi.Input<string>;
        /**
         * Whether to enable IRSA feature. Parameter values: true: enabled; false: not enabled.
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * OIDC (OpenID Connect) provider URL, the unique identifier for the OIDC provider.
         */
        issuer?: pulumi.Input<string>;
        /**
         * JWKS (JSON Web Key Set) URL. The public keys in the file are used to verify any JWT (JSON Web Tokens) returned from the OIDC provider.
         */
        jwksUrl?: pulumi.Input<string>;
        /**
         * OIDC provider TRN.
         */
        oidcTrn?: pulumi.Input<string>;
        /**
         * OIDC provider configuration document in JSON format, containing information about the OIDC provider.
         */
        openIdConfigUrl?: pulumi.Input<string>;
    }
    interface ClusterLoggingConfig {
        /**
         * Cluster log project (Log Project) ID. If empty, the cluster log project has not been created.
         */
        logProjectId?: pulumi.Input<string>;
        logSetups?: pulumi.Input<pulumi.Input<inputs.vke.ClusterLoggingConfigLogSetup>[]>;
    }
    interface ClusterLoggingConfigLogSetup {
        /**
         * Whether to enable this log option. Parameter values: true: enabled; false: not enabled.
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Retention period of logs in log service, in days. 3650 days means permanent storage.
         */
        logTtl?: pulumi.Input<number>;
        /**
         * Currently enabled log types. Parameter values: Audit: cluster audit log; KubeApiServer: kube-apiserver component log; KubeScheduler: kube-scheduler component log; KubeControllerManager: kube-controller-manager component log.
         */
        logType?: pulumi.Input<string>;
    }
    interface ClusterMonitoringConfig {
        componentConfigs?: pulumi.Input<pulumi.Input<inputs.vke.ClusterMonitoringConfigComponentConfig>[]>;
        /**
         * Whether to enable external Prometheus to collect control plane component metrics for the cluster. Parameter values: true: enabled. false: not enabled.
         */
        enableMetricsExternalCollection?: pulumi.Input<boolean>;
        /**
         * Workspace ID to which the monitoring data belongs.
         */
        workspaceId?: pulumi.Input<string>;
    }
    interface ClusterMonitoringConfigComponentConfig {
        /**
         * Whether to enable this monitoring component. true means enabled; false means disabled.
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Name of the monitoring component, such as 'prometheus', 'grafana', etc.
         */
        name?: pulumi.Input<string>;
    }
    interface ClusterNodeStatistics {
        /**
         * Total number of nodes in Phase=Creating.
         */
        creatingCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Deleting.
         */
        deletingCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Failed.
         */
        failedCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Running.
         */
        runningCount?: pulumi.Input<number>;
        /**
         * Total number of nodes.
         */
        totalCount?: pulumi.Input<number>;
        /**
         * Total number of nodes in Phase=Updating.
         */
        updatingCount?: pulumi.Input<number>;
    }
    interface ClusterPodsConfig {
        /**
         * Flannel network configuration.
         */
        flannelConfig?: pulumi.Input<inputs.vke.ClusterPodsConfigFlannelConfig>;
        /**
         * Container (Pod) network model (CNI). Parameter values: Flannel: Flannel network model, an independent underlay container network model. VpcCniShared: VPC-CNI network model, an underlay container network model implemented with ENI (Elastic Network Interface) on a private network.
         */
        podNetworkMode?: pulumi.Input<string>;
        /**
         * VPC-CNI network configuration.
         */
        vpcCniConfig?: pulumi.Input<inputs.vke.ClusterPodsConfigVpcCniConfig>;
    }
    interface ClusterPodsConfigFlannelConfig {
        /**
         * Maximum number of Pod instances per node for the Flannel container network model. Values: 64 (default), 16, 32, 128, 256.
         */
        maxPodsPerNode?: pulumi.Input<number>;
        /**
         * Pod CIDR for Flannel container network.
         */
        podCidrs?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * List of Pod subnet IDs for the Flannel container network model.
         */
        subnetIds?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ClusterPodsConfigVpcCniConfig {
        /**
         * List of Pod subnet IDs for the VPC-CNI container network model.
         */
        subnetIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Whether to enable Trunk mode for the VPC-CNI container network model
         */
        trunkEniEnabled?: pulumi.Input<boolean>;
    }
    interface ClusterServicesConfig {
        /**
         * IPv4 private network address exposed by Kubernetes Service.
         */
        serviceCidrsv4s?: pulumi.Input<pulumi.Input<string>[]>;
    }
    interface ClusterStatus {
        conditions?: pulumi.Input<pulumi.Input<inputs.vke.ClusterStatusCondition>[]>;
        /**
         * Cluster status phase.
         */
        phase?: pulumi.Input<string>;
    }
    interface ClusterStatusCondition {
        /**
         * Condition type
         */
        type?: pulumi.Input<string>;
    }
    interface ClusterTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface DefaultNodePoolAutoScaling {
        /**
         * Configure the desired number of nodes in the node pool.
         */
        desiredReplicas?: pulumi.Input<number>;
        /**
         * Configure the switch for node pool auto scaling. Parameter values: false: disabled true: enabled
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Configure the maximum number of nodes in the node pool
         */
        maxReplicas?: pulumi.Input<number>;
        /**
         * Configure the minimum number of nodes in the node pool
         */
        minReplicas?: pulumi.Input<number>;
        /**
         * Priority
         */
        priority?: pulumi.Input<number>;
        /**
         * Scaling group ID
         */
        scalingGroupId?: pulumi.Input<string>;
        /**
         * Multi-subnet scheduling policy for the node pool. Parameter value description: ZoneBalance: availability zone balancing policy. Priority: subnet priority policy.
         */
        subnetPolicy?: pulumi.Input<string>;
    }
    interface DefaultNodePoolKubernetesConfig {
        /**
         * Whether to disable the automatic synchronization of label taints to existing nodes. Parameter value description: true: disabled, automatic synchronization is turned off. false: not disabled, automatic synchronization is turned on.
         */
        autoSyncDisabled?: pulumi.Input<boolean>;
        /**
         * Node blocking configuration. Parameter value description: false: not blocked. true: blocked
         */
        cordon?: pulumi.Input<boolean>;
        /**
         * Kubelet component configuration
         */
        kubeletConfig?: pulumi.Input<inputs.vke.DefaultNodePoolKubernetesConfigKubeletConfig>;
        labels?: pulumi.Input<pulumi.Input<inputs.vke.DefaultNodePoolKubernetesConfigLabel>[]>;
        /**
         * Prefix of the metadata name for node objects in Kubernetes.
         */
        namePrefix?: pulumi.Input<string>;
        /**
         * Suffix of the metadata name for node objects in Kubernetes.
         */
        nameSuffix?: pulumi.Input<string>;
        /**
         * Whether the metadata name of the node object in Kubernetes uses the ECS host name. Values: true: use ECS host name as node name. false: do not use ECS host name as node name
         */
        nameUseHostname?: pulumi.Input<boolean>;
        taints?: pulumi.Input<pulumi.Input<inputs.vke.DefaultNodePoolKubernetesConfigTaint>[]>;
    }
    interface DefaultNodePoolKubernetesConfigKubeletConfig {
        /**
         * Configure kubelet's CpuManagerPolicy. Includes none and static strategies
         */
        cpuManagerPolicy?: pulumi.Input<string>;
        /**
         * Feature gate.
         */
        featureGates?: pulumi.Input<inputs.vke.DefaultNodePoolKubernetesConfigKubeletConfigFeatureGates>;
        /**
         * Maximum number of burst requests sent to the API server per second. Does not include events and node heartbeat APIs, whose rate limits are controlled by a different set of flags.
         */
        kubeApiBurst?: pulumi.Input<number>;
        /**
         * Queries per second (QPS) for communication with apiserver. Does not include event and node heartbeat APIs; their rate limits are controlled by a different set of flags
         */
        kubeApiQps?: pulumi.Input<number>;
        kubeReserveds?: pulumi.Input<pulumi.Input<inputs.vke.DefaultNodePoolKubernetesConfigKubeletConfigKubeReserved>[]>;
        /**
         * Configure the maximum number of Pods supported by kubelet
         */
        maxPods?: pulumi.Input<number>;
        /**
         * Set the maximum number of burst image pulls. Temporarily allow the number of image pulls specified by this parameter, provided it does not exceed the RegistryPullQps setting
         */
        registryBurst?: pulumi.Input<number>;
        /**
         * Can be used to limit the QPS cap for the image repository
         */
        registryPullQps?: pulumi.Input<number>;
        /**
         * Pull images one by one
         */
        serializeImagePulls?: pulumi.Input<boolean>;
        systemReserveds?: pulumi.Input<pulumi.Input<inputs.vke.DefaultNodePoolKubernetesConfigKubeletConfigSystemReserved>[]>;
        /**
         * Topology management policy. Values: none: (default) topology management policy disabled. restricted: kubelet only accepts Pods that achieve optimal NUMA (Non-Uniform Memory Access) on requested resources. best-effort: kubelet prioritizes Pods that achieve NUMA on CPU and device resources. single-numa-node: kubelet only allows Pods that achieve NUMA on CPU and device resources within the same node.
         */
        topologyManagerPolicy?: pulumi.Input<string>;
        /**
         * Resource granularity for topology management strategy. Values: container: resource alignment at container level. pod: resource alignment at Pod level
         */
        topologyManagerScope?: pulumi.Input<string>;
    }
    interface DefaultNodePoolKubernetesConfigKubeletConfigFeatureGates {
        /**
         * Whether to enable the feature switch for local vertical Pod autoscaling
         */
        inPlacePodVerticalScaling?: pulumi.Input<boolean>;
        /**
         * Enable QoSResourceManager feature switch. Options:   - true to enable   - false to disable
         */
        qoSResourceManager?: pulumi.Input<boolean>;
    }
    interface DefaultNodePoolKubernetesConfigKubeletConfigKubeReserved {
        /**
         * Resource name. Values: cpu or memory
         */
        name?: pulumi.Input<string>;
        /**
         * Specify the resource quantity.   - For cpu, example value: 200m   - For memory, example value: 1G
         */
        quantity?: pulumi.Input<string>;
    }
    interface DefaultNodePoolKubernetesConfigKubeletConfigSystemReserved {
        /**
         * Resource name. Values: cpu or memory.
         */
        name?: pulumi.Input<string>;
        /**
         * Resource quantity for the specified resource.   - For cpu, example value: 200m   - For memory, example value: 1G
         */
        quantity?: pulumi.Input<string>;
    }
    interface DefaultNodePoolKubernetesConfigLabel {
        /**
         * Label key.
         */
        key?: pulumi.Input<string>;
        /**
         * Label value
         */
        value?: pulumi.Input<string>;
    }
    interface DefaultNodePoolKubernetesConfigTaint {
        /**
         * Taint effect. Values: NoSchedule (default): do not schedule. NoExecute: evict pods that do not tolerate the taint. PreferNoSchedule: avoid scheduling if possible.
         */
        effect?: pulumi.Input<string>;
        /**
         * Taint key
         */
        key?: pulumi.Input<string>;
        /**
         * Taint value
         */
        value?: pulumi.Input<string>;
    }
    interface DefaultNodePoolManagement {
        /**
         * Whether managed mode is enabled for the node pool. Values:   - true: enabled   - false: disabled
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Check self-healing configuration.
         */
        remedyConfig?: pulumi.Input<inputs.vke.DefaultNodePoolManagementRemedyConfig>;
    }
    interface DefaultNodePoolManagementRemedyConfig {
        /**
         * Enable self-healing check
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Self-healing rule ID
         */
        remedyId?: pulumi.Input<string>;
    }
    interface DefaultNodePoolNodeConfig {
        /**
         * Whether the first data disk on the node has been configured, formatted, and mounted as the storage directory for container images and logs. Parameter values: false: not configured and formatted true: configured and formatted
         */
        additionalContainerStorageEnabled?: pulumi.Input<boolean>;
        /**
         * Whether the cloud server instance is automatically renewed upon expiration. Parameter values: true: auto renewal false: no auto renewal This parameter is returned only when InstanceChargeType=PrePaid.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Automatic renewal duration for cloud server instance, in months. This parameter is returned only when AutoRenew=true.
         */
        autoRenewPeriod?: pulumi.Input<number>;
        dataVolumes?: pulumi.Input<pulumi.Input<inputs.vke.DefaultNodePoolNodeConfigDataVolume>[]>;
        /**
         * Group number of the instance in the deployment set. 0 means not set
         */
        deploymentSetGroupNumber?: pulumi.Input<number>;
        /**
         * Deployment set ID to be added to the instance
         */
        deploymentSetId?: pulumi.Input<string>;
        /**
         * Host name corresponding to the node
         */
        hostname?: pulumi.Input<string>;
        /**
         * High performance computing cluster ID. When the node pool is configured with high performance computing GPU node types, returns the high performance computing cluster ID
         */
        hpcClusterIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Image ID used by the cloud server corresponding to the node
         */
        imageId?: pulumi.Input<string>;
        /**
         * Custom script executed after creating and initializing the node. Shell script in Base64 encoding
         */
        initializeScript?: pulumi.Input<string>;
        /**
         * Billing type for cloud server instance. Parameter value description: PostPaid: pay-as-you-go. PrePaid: subscription (annual/monthly).
         */
        instanceChargeType?: pulumi.Input<string>;
        /**
         * Node (instance) name
         */
        instanceName?: pulumi.Input<string>;
        /**
         * List of cloud server instance type IDs corresponding to the node
         */
        instanceTypeIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Configure the mixed strategy for spot and pay-as-you-go instances. This strategy takes effect when SpotStrategy is set to SpotAsPriceGo
         */
        instancesDistribution?: pulumi.Input<inputs.vke.DefaultNodePoolNodeConfigInstancesDistribution>;
        /**
         * Node name prefix. An empty string or nil means the node name prefix policy is not enabled
         */
        namePrefix?: pulumi.Input<string>;
        /**
         * Network communication mode between nodes
         */
        networkTrafficMode?: pulumi.Input<string>;
        /**
         * Duration for purchasing cloud server instance, in months. This parameter is returned only when InstanceChargeType=PrePaid
         */
        period?: pulumi.Input<number>;
        /**
         * Script executed before deploying nodes
         */
        preScript?: pulumi.Input<string>;
        /**
         * The project to which the ECS belongs. Each ECS can only belong to one project.
         */
        projectName?: pulumi.Input<string>;
        /**
         * Configuration for automatic public network access for nodes
         */
        publicAccessConfig?: pulumi.Input<inputs.vke.DefaultNodePoolNodeConfigPublicAccessConfig>;
        /**
         * Whether the node automatically enables public network access. Values:   - false: disabled   - true: enabled
         */
        publicAccessEnabled?: pulumi.Input<boolean>;
        /**
         * Node security configuration.
         */
        security?: pulumi.Input<inputs.vke.DefaultNodePoolNodeConfigSecurity>;
        /**
         * Preemptive policy for pay-as-you-go billing. When InstanceChargeType=PostPaid: NoSpot: regular pay-as-you-go instance. SpotAsPriceGo: system auto-bidding, follows current market price.
         */
        spotStrategy?: pulumi.Input<string>;
        /**
         * List of subnet IDs to which the node network belongs.
         */
        subnetIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * System disk configuration for the node
         */
        systemVolume?: pulumi.Input<inputs.vke.DefaultNodePoolNodeConfigSystemVolume>;
        tags?: pulumi.Input<pulumi.Input<inputs.vke.DefaultNodePoolNodeConfigTag>[]>;
    }
    interface DefaultNodePoolNodeConfigDataVolume {
        /**
         * File system. Options:   - Ext4 (default)   - Xfs
         */
        fileSystem?: pulumi.Input<string>;
        /**
         * Target mount directory after disk formatting.
         */
        mountPoint?: pulumi.Input<string>;
        /**
         * Placement group ID
         */
        placementGroupId?: pulumi.Input<string>;
        /**
         * Disk capacity, in GiB
         */
        size?: pulumi.Input<number>;
        /**
         * Create a data disk using a snapshot. You can call the DescribeSnapshots API to query the snapshot ID. Note: Only ultra-fast SSD and efficient cloud disks support creating disks from snapshots. Only snapshots in 'available' status can be used to create new disks; snapshots in 'creating', 'rolling back', 'deleting', or 'error' status cannot be used to create new disks
         */
        snapshotId?: pulumi.Input<string>;
        /**
         * Placement subgroup
         */
        subgroupNumber?: pulumi.Input<number>;
        /**
         * Disk type: ESSD*PL0: ultra-fast SSD cloud disk with performance level PL0. ESSD*FlexPL: ultra-fast SSD cloud disk with performance level PL1.
         */
        type?: pulumi.Input<string>;
    }
    interface DefaultNodePoolNodeConfigInstancesDistribution {
        /**
         * Capacity rebalancing. Value range:   - true: enables this feature. When a preemptible instance is about to be reclaimed, a new preemptible instance is proactively created for compensation.   - false (default): disables this feature. Waits until the preemptible instance is reclaimed before scaling out to make up the instance count.
         */
        capacityRebalance?: pulumi.Input<boolean>;
        /**
         * Pay-as-you-go instance fallback feature. Value range:   - true: enables this feature. If all preemptible instances fail to purchase due to insufficient inventory, pay-as-you-go instances will be attempted   - false (default): disables this feature. When scaling preemptible instances, only the configured preemptible instances are attempted
         */
        compensateWithOnDemand?: pulumi.Input<boolean>;
        /**
         * Base capacity size. The base capacity is always pay-as-you-go instances. Value range: [0,500], default: 0
         */
        onDemandBaseCapacity?: pulumi.Input<number>;
        /**
         * Proportion of pay-as-you-go instances for capacity exceeding the base capacity. Value range [0, 100]. 0 means only preemptible instances are produced for excess capacity; 100 means only pay-as-you-go instances are produced. Default is 0.
         */
        onDemandPercentageAboveBaseCapacity?: pulumi.Input<number>;
    }
    interface DefaultNodePoolNodeConfigPublicAccessConfig {
        /**
         * Peak bandwidth for the public IP, unit: Mbps
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Billing type for public IP: 2: Pay-as-you-go by bandwidth cap. 3: Pay-as-you-go by actual traffic.
         */
        billingType?: pulumi.Input<number>;
        /**
         * Public IP line type. Parameter description: BGP: BGP (multi-line)
         */
        isp?: pulumi.Input<string>;
    }
    interface DefaultNodePoolNodeConfigSecurity {
        /**
         * Node access configuration
         */
        login?: pulumi.Input<inputs.vke.DefaultNodePoolNodeConfigSecurityLogin>;
        /**
         * List of security group IDs for the node network
         */
        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node security policy. Parameter value description: Hids: host security hardening
         */
        securityStrategies?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Whether security hardening is enabled for the node. Parameter value description: true: enabled. false: not enabled.
         */
        securityStrategyEnabled?: pulumi.Input<boolean>;
    }
    interface DefaultNodePoolNodeConfigSecurityLogin {
        /**
         * Root user login password in Base64 encoding. Follow the cloud server password requirements: 8–30 characters, cannot start with / or $6$, must include at least three of the following: lowercase letters a–z, uppercase letters A–Z, numbers 0–9, special characters ( ) ` ~ ! @ # $ % ^ & * _   - + = | { } [ ] : ; ' < > , . ? /
         */
        password?: pulumi.Input<string>;
        /**
         * SSH key pair name. Please ensure the key pair is already created or hosted in the cloud server
         */
        sshKeyPairName?: pulumi.Input<string>;
        /**
         * Node access login method. Parameter value description: Password: password login. SshKeyPair: SSH key pair login.
         */
        type?: pulumi.Input<string>;
    }
    interface DefaultNodePoolNodeConfigSystemVolume {
        /**
         * Placement group ID
         */
        placementGroupId?: pulumi.Input<string>;
        /**
         * Cloud disk capacity, in GiB. Value description: default: 40 GiB. Ultra-fast SSD (ESSD*PL0, ESSD*FlexPL): 40–2048 GiB
         */
        size?: pulumi.Input<number>;
        /**
         * Placement subgroup
         */
        subgroupNumber?: pulumi.Input<number>;
        /**
         * Cloud disk type: ESSD*PL0: (default) Ultra SSD with performance level PL0. ESSD*FlexPL: Ultra SSD with performance level PL1
         */
        type?: pulumi.Input<string>;
    }
    interface DefaultNodePoolNodeConfigTag {
        /**
         * Label key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface DefaultNodePoolNodeStatistics {
        /**
         * Total number of nodes with Phase=Creating.
         */
        creatingCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Deleting.
         */
        deletingCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Failed
         */
        failedCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Running
         */
        runningCount?: pulumi.Input<number>;
        /**
         * Total number of nodes in the node pool.
         */
        totalCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Updating
         */
        updatingCount?: pulumi.Input<number>;
    }
    interface DefaultNodePoolStatus {
        conditions?: pulumi.Input<pulumi.Input<inputs.vke.DefaultNodePoolStatusCondition>[]>;
        /**
         * Status of the node pool. Parameter values: Creating, Running, Updating, Deleting, Failed, Scaling.
         */
        phase?: pulumi.Input<string>;
    }
    interface DefaultNodePoolStatusCondition {
        /**
         * Status conditions under the current primary state of the node pool, indicating the reasons for entering this state. There can be multiple reasons. Parameter values: ProgressingOk, ResourceCleanupFailed, Unknown, ClusterNotRunning.
         */
        type?: pulumi.Input<string>;
    }
    interface DefaultNodePoolTag {
        /**
         * Label key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface NodeKubernetesConfig {
        /**
         * Node lock configuration. Options: false (default): not locked; true: locked
         */
        cordon?: pulumi.Input<boolean>;
        labels?: pulumi.Input<pulumi.Input<inputs.vke.NodeKubernetesConfigLabel>[]>;
        taints?: pulumi.Input<pulumi.Input<inputs.vke.NodeKubernetesConfigTaint>[]>;
    }
    interface NodeKubernetesConfigLabel {
        /**
         * Label key. A valid label key consists of two parts: \n\n and \n\n, separated by a slash (/). \n\n is required and supports uppercase and lowercase English letters, numbers, hyphens (-), underscores (_), and periods (.), must start and end with a letter or number, and must not exceed 63 characters. \n\n is optional. If specified, \n\n must be a DNS subdomain: a series of DNS labels separated by periods (.), with a maximum length of 253 characters. The total length of \n\n and \n\n must not exceed 82 characters.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value, up to 63 characters (can be empty). Can start and end with an English letter (upper or lower case) or a digit. Supported special characters: hyphen (-), underscore (_), period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface NodeKubernetesConfigTaint {
        /**
         * Taint effect. Options: NoSchedule (default): Do not schedule. NoExecute: Evict Pods that do not tolerate the taint. PreferNoSchedule: Avoid scheduling if possible.
         */
        effect?: pulumi.Input<string>;
        /**
         * Taint key. A valid taint key has two segments: \n\n and \n\n, separated by a slash (/). \n\n is required and supports English letters (case-sensitive), numbers, hyphen (-), underscore (_), and period (.), must start and end with a letter or number, and be no longer than 63 characters. \n\n is optional. If specified, \n\n must be a DNS subdomain: a series of DNS labels separated by periods (.), no longer than 253 characters. The total length of \n\n and \n\n must not exceed 82 characters.
         */
        key?: pulumi.Input<string>;
        /**
         * Taint value, up to 63 characters (can be empty). Must start and end with an English letter or number. Supports special characters: hyphen (-), underscore (_), and period (.).
         */
        value?: pulumi.Input<string>;
    }
    interface NodePoolAutoScaling {
        /**
         * Configure the expected number of nodes in the node pool
         */
        desiredReplicas?: pulumi.Input<number>;
        /**
         * Configure the node pool auto scaling feature switch. Parameter values: false: disabled. true: enabled.
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Configure the maximum number of nodes in the node pool
         */
        maxReplicas?: pulumi.Input<number>;
        /**
         * Minimum number of nodes configured for the node pool
         */
        minReplicas?: pulumi.Input<number>;
        /**
         * Priority
         */
        priority?: pulumi.Input<number>;
        /**
         * Scaling group ID
         */
        scalingGroupId?: pulumi.Input<string>;
        /**
         * Multi-subnet scheduling strategy for the node pool. Parameter values: ZoneBalance: availability zone balancing strategy. Priority: subnet priority strategy.
         */
        subnetPolicy?: pulumi.Input<string>;
    }
    interface NodePoolKubernetesConfig {
        /**
         * Disable automatic synchronization of labels and taints to existing nodes. Parameter values: true: disable (turn off automatic sync). false: do not disable (turn on automatic sync)
         */
        autoSyncDisabled?: pulumi.Input<boolean>;
        /**
         * Node pool Containerd configuration
         */
        containerdConfig?: pulumi.Input<inputs.vke.NodePoolKubernetesConfigContainerdConfig>;
        /**
         * Node blocking configuration. Parameter values: false: not blocked; true: blocked
         */
        cordon?: pulumi.Input<boolean>;
        /**
         * Kubelet component configuration
         */
        kubeletConfig?: pulumi.Input<inputs.vke.NodePoolKubernetesConfigKubeletConfig>;
        labels?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolKubernetesConfigLabel>[]>;
        /**
         * Prefix for node object metadata name in Kubernetes
         */
        namePrefix?: pulumi.Input<string>;
        /**
         * Suffix for node object metadata name in Kubernetes
         */
        nameSuffix?: pulumi.Input<string>;
        /**
         * Whether the node object metadata name in Kubernetes uses the ECS host name. Values: true: use ECS host name as node name; false: do not use ECS host name as node name
         */
        nameUseHostname?: pulumi.Input<boolean>;
        taints?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolKubernetesConfigTaint>[]>;
    }
    interface NodePoolKubernetesConfigContainerdConfig {
        /**
         * Specify the container image repository address to skip certificate verification.
         */
        insecureRegistries?: pulumi.Input<pulumi.Input<string>[]>;
        registryProxyConfigs?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolKubernetesConfigContainerdConfigRegistryProxyConfig>[]>;
    }
    interface NodePoolKubernetesConfigContainerdConfigRegistryProxyConfig {
        /**
         * Proxy address.
         */
        proxyEndpoints?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Container image repository address.
         */
        registry?: pulumi.Input<string>;
    }
    interface NodePoolKubernetesConfigKubeletConfig {
        /**
         * Configure kubelet CpuManagerPolicy. Supports none and static policies
         */
        cpuManagerPolicy?: pulumi.Input<string>;
        evictionHards?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolKubernetesConfigKubeletConfigEvictionHard>[]>;
        /**
         * Feature gate
         */
        featureGates?: pulumi.Input<inputs.vke.NodePoolKubernetesConfigKubeletConfigFeatureGates>;
        /**
         * Maximum burst request rate sent to the API server per second. Excludes events and node heartbeat APIs, whose rate limits are controlled by a different set of flags
         */
        kubeApiBurst?: pulumi.Input<number>;
        /**
         * Queries per second (QPS) for communication with apiserver. Events and node heartbeat APIs are not included; their rate limits are controlled by a different set of flags.
         */
        kubeApiQps?: pulumi.Input<number>;
        kubeReserveds?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolKubernetesConfigKubeletConfigKubeReserved>[]>;
        /**
         * Configure the maximum number of Pods supported by kubelet
         */
        maxPods?: pulumi.Input<number>;
        /**
         * Set the maximum number of burst image pulls. Temporarily allows the number of image pulls specified by this parameter, provided it does not exceed the RegistryPullQps setting
         */
        registryBurst?: pulumi.Input<number>;
        /**
         * Used to limit the QPS cap for the image repository
         */
        registryPullQps?: pulumi.Input<number>;
        /**
         * Pull images sequentially
         */
        serializeImagePulls?: pulumi.Input<boolean>;
        systemReserveds?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolKubernetesConfigKubeletConfigSystemReserved>[]>;
        /**
         * Topology management policy. Values: none (default): disables topology management policy. restricted: kubelet only accepts Pods that achieve optimal NUMA (Non-Uniform Memory Access) on requested resources. best-effort: kubelet prioritizes Pods that achieve NUMA on CPU and device resources. single-numa-node: kubelet only allows Pods that achieve NUMA on CPU and device resources within the same node
         */
        topologyManagerPolicy?: pulumi.Input<string>;
        /**
         * Resource granularity for topology management policy. Values: container: resource alignment at container level pod: resource alignment at Pod level
         */
        topologyManagerScope?: pulumi.Input<string>;
    }
    interface NodePoolKubernetesConfigKubeletConfigEvictionHard {
        /**
         * Hard threshold name. Options: memory.available, nodefs.available, nodefs.inodesFree, imagefs.available
         */
        key?: pulumi.Input<string>;
        /**
         * Hard threshold value.
         */
        value?: pulumi.Input<string>;
    }
    interface NodePoolKubernetesConfigKubeletConfigFeatureGates {
        /**
         * Enable local vertical Pod autoscaling feature toggle
         */
        inPlacePodVerticalScaling?: pulumi.Input<boolean>;
        /**
         * Whether to enable the QoSResourceManager feature switch. Values:   - true enabled;   - false disabled
         */
        qoSResourceManager?: pulumi.Input<boolean>;
    }
    interface NodePoolKubernetesConfigKubeletConfigKubeReserved {
        /**
         * Resource name. Valid values: cpu or memory.
         */
        name?: pulumi.Input<string>;
        /**
         * Specify the resource quantity.   - For cpu, example value: 200m   - For memory, example value: 1G
         */
        quantity?: pulumi.Input<string>;
    }
    interface NodePoolKubernetesConfigKubeletConfigSystemReserved {
        /**
         * Resource name. Valid values: cpu or memory.
         */
        name?: pulumi.Input<string>;
        /**
         * Resource quantity for the specified resource.   - For cpu, example value: 200m.   - For memory, example value: 1G.
         */
        quantity?: pulumi.Input<string>;
    }
    interface NodePoolKubernetesConfigLabel {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Label value.
         */
        value?: pulumi.Input<string>;
    }
    interface NodePoolKubernetesConfigTaint {
        /**
         * Taint effect. Values: NoSchedule: (default) Do not schedule. NoExecute: Evict pods that do not tolerate the taint. PreferNoSchedule: Prefer not to schedule.
         */
        effect?: pulumi.Input<string>;
        /**
         * Taint key.
         */
        key?: pulumi.Input<string>;
        /**
         * Taint value
         */
        value?: pulumi.Input<string>;
    }
    interface NodePoolManagement {
        /**
         * Enable managed mode for node pool. Options:   - true: on   - false: off
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Check self-healing configuration.
         */
        remedyConfig?: pulumi.Input<inputs.vke.NodePoolManagementRemedyConfig>;
    }
    interface NodePoolManagementRemedyConfig {
        /**
         * Enable self-healing check
         */
        enabled?: pulumi.Input<boolean>;
        /**
         * Self-healing rule ID
         */
        remedyId?: pulumi.Input<string>;
    }
    interface NodePoolNodeConfig {
        /**
         * Whether the first data disk of the node is configured, formatted, and mounted as the storage directory for container images and logs. Parameter values: false: not configured and formatted; true: configured and formatted
         */
        additionalContainerStorageEnabled?: pulumi.Input<boolean>;
        /**
         * Whether the cloud server instance will be automatically renewed upon expiration. Parameter description: true: auto renewal false: no auto renewal This parameter is returned only when InstanceChargeType=PrePaid.
         */
        autoRenew?: pulumi.Input<boolean>;
        /**
         * Automatic renewal duration for cloud server instances, in months. This parameter is returned only when AutoRenew=true
         */
        autoRenewPeriod?: pulumi.Input<number>;
        dataVolumes?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolNodeConfigDataVolume>[]>;
        /**
         * Group number of the instance in the deployment set; 0 means not set
         */
        deploymentSetGroupNumber?: pulumi.Input<number>;
        /**
         * Deployment Set ID to be added to the instance
         */
        deploymentSetId?: pulumi.Input<string>;
        /**
         * The host name corresponding to the node.
         */
        hostname?: pulumi.Input<string>;
        /**
         * High performance computing cluster ID. When the node pool is configured with high performance computing GPU node types, returns the high performance computing cluster ID
         */
        hpcClusterIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Image ID used by the cloud server corresponding to the node
         */
        imageId?: pulumi.Input<string>;
        /**
         * Custom script executed after node creation and initialization. Shell script in Base64 encoding
         */
        initializeScript?: pulumi.Input<string>;
        /**
         * Cloud server instance billing type. Parameter values: PostPaid: pay-as-you-go. PrePaid: subscription (annual/monthly).
         */
        instanceChargeType?: pulumi.Input<string>;
        /**
         * Node (instance) name
         */
        instanceName?: pulumi.Input<string>;
        /**
         * List of cloud server instance type IDs corresponding to the nodes
         */
        instanceTypeIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Set the mixed strategy for spot and pay-as-you-go instances. This strategy takes effect when SpotStrategy is SpotAsPriceGo.
         */
        instancesDistribution?: pulumi.Input<inputs.vke.NodePoolNodeConfigInstancesDistribution>;
        /**
         * Node name prefix. An empty string or nil means the node name prefix policy is not enabled.
         */
        namePrefix?: pulumi.Input<string>;
        /**
         * Network communication mode between nodes
         */
        networkTrafficMode?: pulumi.Input<string>;
        /**
         * Purchase duration for cloud server instances, in months. This parameter is returned only when InstanceChargeType=PrePaid
         */
        period?: pulumi.Input<number>;
        /**
         * Script to execute before deploying the node
         */
        preScript?: pulumi.Input<string>;
        /**
         * Project to which the ECS belongs. Each ECS can only belong to one project.
         */
        projectName?: pulumi.Input<string>;
        /**
         * Configuration for automatic public network access for nodes
         */
        publicAccessConfig?: pulumi.Input<inputs.vke.NodePoolNodeConfigPublicAccessConfig>;
        /**
         * Enable public network access for nodes automatically. Options:   - false: off   - true: on
         */
        publicAccessEnabled?: pulumi.Input<boolean>;
        /**
         * Node security configuration
         */
        security?: pulumi.Input<inputs.vke.NodePoolNodeConfigSecurity>;
        /**
         * Spot pricing strategy for pay-as-you-go billing. When InstanceChargeType=PostPaid: NoSpot: Standard pay-as-you-go instance. SpotAsPriceGo: System automatically bids, following the current market price.
         */
        spotStrategy?: pulumi.Input<string>;
        /**
         * List of subnet IDs for the node network.
         */
        subnetIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * System disk configuration for the node
         */
        systemVolume?: pulumi.Input<inputs.vke.NodePoolNodeConfigSystemVolume>;
        tags?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolNodeConfigTag>[]>;
    }
    interface NodePoolNodeConfigDataVolume {
        /**
         * File system. Options:   - Ext4 (default)   - Xfs
         */
        fileSystem?: pulumi.Input<string>;
        /**
         * Target mount directory after disk formatting.
         */
        mountPoint?: pulumi.Input<string>;
        /**
         * Placement group ID
         */
        placementGroupId?: pulumi.Input<string>;
        /**
         * Disk capacity, in GiB.
         */
        size?: pulumi.Input<number>;
        /**
         * Create a data disk from a snapshot. You can call the DescribeSnapshots API to query the snapshot ID. Note: Only Ultra SSD and High-performance Cloud Disk support creating disks from snapshots. Only snapshots in the 'available' status can be used to create new disks. Snapshots in 'creating', 'rolling back', 'deleting', or 'error' status cannot be used to create new disks.
         */
        snapshotId?: pulumi.Input<string>;
        /**
         * Placement subgroup
         */
        subgroupNumber?: pulumi.Input<number>;
        /**
         * Disk type: ESSD*PL0: ultra-fast SSD disk with performance level PL0. ESSD*FlexPL: ultra-fast SSD disk with performance level PL1
         */
        type?: pulumi.Input<string>;
    }
    interface NodePoolNodeConfigInstancesDistribution {
        /**
         * Capacity rebalancing. Value range:   - true: enables this feature. When a preemptible instance is about to be reclaimed, proactively creates a new preemptible instance for compensation.   - false (default): disables this feature. Waits until the preemptible instance is reclaimed before scaling out to make up the instance count
         */
        capacityRebalance?: pulumi.Input<boolean>;
        /**
         * On-demand instance fallback feature. Value range:   - true: enable this feature; when all preemptible instances fail to purchase due to insufficient inventory or other reasons, attempt to purchase on-demand instances   - false (default): disable this feature; only attempt to purchase configured preemptible instances when scaling up
         */
        compensateWithOnDemand?: pulumi.Input<boolean>;
        /**
         * Size of the base capacity. The base capacity is always pay-as-you-go instances. Value range: [0,500], default is 0.
         */
        onDemandBaseCapacity?: pulumi.Input<number>;
        /**
         * Proportion of pay-as-you-go instances in the part exceeding the base capacity. Value range: [0, 100]. 0 means only preemptible instances are produced for the part exceeding the base capacity; 100 means only pay-as-you-go instances are produced. Default value is 0.
         */
        onDemandPercentageAboveBaseCapacity?: pulumi.Input<number>;
    }
    interface NodePoolNodeConfigPublicAccessConfig {
        /**
         * Peak bandwidth for public IP, unit: Mbps
         */
        bandwidth?: pulumi.Input<number>;
        /**
         * Billing type for public IP: 2: pay-as-you-go by bandwidth cap. 3: pay-as-you-go by actual traffic.
         */
        billingType?: pulumi.Input<number>;
        /**
         * Public IP line type. Parameter description: BGP: BGP (multi-line)
         */
        isp?: pulumi.Input<string>;
    }
    interface NodePoolNodeConfigSecurity {
        /**
         * Node access configuration.
         */
        login?: pulumi.Input<inputs.vke.NodePoolNodeConfigSecurityLogin>;
        /**
         * List of security group IDs for the node network
         */
        securityGroupIds?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Node security policy. Parameter description: Hids: Host security hardening.
         */
        securityStrategies?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Whether the node has enabled security hardening configuration. Parameter values: true: enabled; false: not enabled
         */
        securityStrategyEnabled?: pulumi.Input<boolean>;
    }
    interface NodePoolNodeConfigSecurityLogin {
        /**
         * Root user login password in Base64 encoding. Follow the cloud server's requirements for instance passwords: 8–30 characters in length, must not start with / or $6$, supports the following character types and must include at least three types: lowercase letters a–z, uppercase letters A–Z, numbers 0–9, special characters ( ) ` ~ ! @ # $ % ^ & * _   - + = | { } [ ] : ; ' < > , . ? /
         */
        password?: pulumi.Input<string>;
        /**
         * SSH key pair name. Ensure the key pair is already created or hosted in the cloud server
         */
        sshKeyPairName?: pulumi.Input<string>;
        /**
         * Node access login method. Parameter values: Password: password login; SshKeyPair: SSH key pair login
         */
        type?: pulumi.Input<string>;
    }
    interface NodePoolNodeConfigSystemVolume {
        /**
         * Placement group ID
         */
        placementGroupId?: pulumi.Input<string>;
        /**
         * Disk capacity, in GiB. Value description: Default: 40 GiB. Ultra-fast SSD (ESSD*PL0, ESSD*FlexPL): 40–2048 GiB
         */
        size?: pulumi.Input<number>;
        /**
         * Placement subgroup
         */
        subgroupNumber?: pulumi.Input<number>;
        /**
         * Cloud disk types: ESSD*PL0: (default) Ultra-fast SSD cloud disk with performance level PL0. ESSD*FlexPL: Ultra-fast SSD cloud disk with performance level PL1.
         */
        type?: pulumi.Input<string>;
    }
    interface NodePoolNodeConfigTag {
        /**
         * Label key
         */
        key?: pulumi.Input<string>;
        /**
         * Label value.
         */
        value?: pulumi.Input<string>;
    }
    interface NodePoolNodeStatistics {
        /**
         * Total number of nodes in Phase=Creating.
         */
        creatingCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Deleting
         */
        deletingCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Failed
         */
        failedCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Running
         */
        runningCount?: pulumi.Input<number>;
        /**
         * Total number of nodes in the node pool
         */
        totalCount?: pulumi.Input<number>;
        /**
         * Total number of nodes with Phase=Updating
         */
        updatingCount?: pulumi.Input<number>;
    }
    interface NodePoolStatus {
        conditions?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolStatusCondition>[]>;
        /**
         * Status of the node pool. Parameter values: Creating, Running, Updating, Deleting, Failed, Scaling
         */
        phase?: pulumi.Input<string>;
    }
    interface NodePoolStatusCondition {
        /**
         * Status conditions for the node pool in the current main state, i.e., the reasons for entering this main state. There can be multiple reasons. Parameter values: ProgressingOk, ResourceCleanupFailed, Unknown, ClusterNotRunning.
         */
        type?: pulumi.Input<string>;
    }
    interface NodePoolTag {
        /**
         * Label key
         */
        key?: pulumi.Input<string>;
        /**
         * Label value.
         */
        value?: pulumi.Input<string>;
    }
    interface NodeStatus {
        conditions?: pulumi.Input<pulumi.Input<inputs.vke.NodeStatusCondition>[]>;
        /**
         * Node status. Parameter values: Creating, Running, Deleting, Failed, Updating.
         */
        phase?: pulumi.Input<string>;
    }
    interface NodeStatusCondition {
        /**
         * Status condition under the node's current primary state, indicating the reason for entering this primary state. There can be multiple reasons. Parameter values: Progressing, Ok, Unschedulable, InitilizeFailed, NotReady, Balance, ResourceCleanupFailed, Unknown.
         */
        type?: pulumi.Input<string>;
    }
}
export declare namespace vmp {
    interface AlertingRuleAnnotation {
        /**
         * Tag or annotation key
         */
        name?: pulumi.Input<string>;
        /**
         * Tag or annotation value. If set to empty, the key will be deleted
         */
        value?: pulumi.Input<string>;
    }
    interface AlertingRuleLabel {
        /**
         * Tag or annotation key
         */
        name?: pulumi.Input<string>;
        /**
         * Tag or annotation value. If set to empty, the key will be deleted
         */
        value?: pulumi.Input<string>;
    }
    interface AlertingRuleLevel {
        /**
         * Alert rule comparison condition. Options: >, >=, <, <=, ==, !=
         */
        comparator?: pulumi.Input<string>;
        /**
         * Alert duration. Possible values: 0s, 1m, 2m, 5m, 10m
         */
        for?: pulumi.Input<string>;
        /**
         * Alert rule severity. Currently supports P0, P1, or P2
         */
        level?: pulumi.Input<string>;
        /**
         * Alert rule threshold
         */
        threshold?: pulumi.Input<number>;
    }
    interface AlertingRuleQuery {
        /**
         * Query statement
         */
        promQl?: pulumi.Input<string>;
        /**
         * Workspace ID
         */
        workspaceId?: pulumi.Input<string>;
    }
    interface AlertingRuleTag {
        /**
         * Tag or annotation key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag or annotation value. If set to empty, the key will be deleted
         */
        value?: pulumi.Input<string>;
    }
    interface WorkspaceInstanceType {
        /**
         * Maximum active time series count
         */
        activeSeries?: pulumi.Input<number>;
        /**
         * Number of availability zones (az)
         */
        availabilityZoneReplicas?: pulumi.Input<number>;
        calculatePriceParams?: pulumi.Input<pulumi.Input<inputs.vmp.WorkspaceInstanceTypeCalculatePriceParam>[]>;
        /**
         * Downsampling policy
         */
        downsamplingPeriods?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Maximum samples written per second
         */
        ingestSamplesPerSecond?: pulumi.Input<number>;
        /**
         * Maximum query concurrency
         */
        queryConcurrency?: pulumi.Input<number>;
        /**
         * Maximum query QPS
         */
        queryPerSecond?: pulumi.Input<number>;
        /**
         * Number of data replicas per availability zone (az)
         */
        replicasPerZone?: pulumi.Input<number>;
        /**
         * Maximum data retention period
         */
        retentionPeriod?: pulumi.Input<string>;
        /**
         * Maximum samples scanned per second
         */
        scanSamplesPerSecond?: pulumi.Input<number>;
        /**
         * Maximum time series scanned per second
         */
        scanSeriesPerSecond?: pulumi.Input<number>;
    }
    interface WorkspaceInstanceTypeCalculatePriceParam {
        calChargeItemLists?: pulumi.Input<pulumi.Input<inputs.vmp.WorkspaceInstanceTypeCalculatePriceParamCalChargeItemList>[]>;
        /**
         * Configuration item code.
         */
        configurationCode?: pulumi.Input<string>;
        /**
         * Billing cycle.
         */
        period?: pulumi.Input<string>;
    }
    interface WorkspaceInstanceTypeCalculatePriceParamCalChargeItemList {
        /**
         * Billing item attribute value.
         */
        attrValue?: pulumi.Input<string>;
        /**
         * Billing item code.
         */
        chargeItemCode?: pulumi.Input<string>;
    }
    interface WorkspaceQuota {
        /**
         * Maximum active time series count. Integer, default range is 1–50000000
         */
        activeSeries?: pulumi.Input<number>;
        /**
         * Metric ingestion rate, i.e., maximum samples written per second. Integer, default range is 1–5000000
         */
        ingestSamplesPerSecond?: pulumi.Input<number>;
        /**
         * Workspace public Query bandwidth (Mbps).
         */
        publicQueryBandwidth?: pulumi.Input<number>;
        /**
         * Workspace public RemoteWrite bandwidth (Mbps).
         */
        publicWriteBandwidth?: pulumi.Input<number>;
        /**
         * Maximum query QPS. Integer, default range is 1–500
         */
        queryPerSecond?: pulumi.Input<number>;
        /**
         * Maximum samples scanned per second. Integer, default range is 1–1000000000
         */
        scanSamplesPerSecond?: pulumi.Input<number>;
        /**
         * Maximum time series scanned per second. Integer, default range is 1–200000
         */
        scanSeriesPerSecond?: pulumi.Input<number>;
    }
    interface WorkspaceTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface WorkspaceUsage {
        /**
         * Active time series count
         */
        activeSeries?: pulumi.Input<number>;
        /**
         * Samples written per second
         */
        ingestedSamplesPerSecond?: pulumi.Input<number>;
    }
}
export declare namespace vpc {
    interface BandwidthPackageEipAddress {
        /**
         * Allocation ID
         */
        allocationId?: pulumi.Input<string>;
    }
    interface BandwidthPackageTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface EipTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface EniPrimaryIpAddress {
        /**
         * Information about the public IP associated with the primary private IPv4 address of the network interface.
         */
        associatedElasticIp?: pulumi.Input<inputs.vpc.EniPrimaryIpAddressAssociatedElasticIp>;
        /**
         * Indicates whether this is the primary private IPv4 address.
         */
        primary?: pulumi.Input<boolean>;
        /**
         * Private IP address of the network interface.
         */
        privateIpAddress?: pulumi.Input<string>;
    }
    interface EniPrimaryIpAddressAssociatedElasticIp {
        /**
         * Public IP ID
         */
        allocationId?: pulumi.Input<string>;
        /**
         * Public IP address
         */
        eipAddress?: pulumi.Input<string>;
        /**
         * Whether the public IP is released when the cloud server instance is deleted. Only pay-as-you-go public IPs bound to the primary NIC's primary private IP are valid. When enabled, if the cloud server instance is automatically reclaimed by the system (24 hours after unsubscription, upon expiration, or due to overdue payment) or deleted via the DeleteInstances API, the public IP is released along with the instance. true: yes, false: no
         */
        releaseWithInstance?: pulumi.Input<boolean>;
    }
    interface EniPrivateIpSet {
        /**
         * Information about the public IP associated with the primary private IPv4 address of the network interface.
         */
        associatedElasticIp?: pulumi.Input<inputs.vpc.EniPrivateIpSetAssociatedElasticIp>;
        /**
         * Private IP address of the network interface.
         */
        privateIpAddress?: pulumi.Input<string>;
    }
    interface EniPrivateIpSetAssociatedElasticIp {
        /**
         * Public IP ID
         */
        allocationId?: pulumi.Input<string>;
    }
    interface EniTag {
        /**
         * Tag key for the user tag.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for the user tag.
         */
        value?: pulumi.Input<string>;
    }
    interface FlowLogTag {
        /**
         * User label tag key. Length must be 1–128 characters. Supports input of characters from any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ symbols (@). If the tag key starts or ends with a space, the system automatically removes it.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value. Supports input in any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). Case sensitive. If the tag value starts or ends with a space, the system will automatically remove it.
         */
        value?: pulumi.Input<string>;
    }
    interface HaVipTag {
        /**
         * Tag key for user tags. Length range: 1–128 characters. Supports input of characters in any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). If the tag key starts or ends with a space, the system automatically removes it
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for user tags. Supports input of characters in any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). Case sensitive. If the tag value starts or ends with a space, the system automatically removes it
         */
        value?: pulumi.Input<string>;
    }
    interface Ipv6AddressBandwidthTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface Ipv6GatewayTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface NetworkAclDefaultEgressAclEntry {
        /**
         * For inbound rules, specifies the source address range. For outbound rules, specifies the destination address range. Supports CIDR and IPv4 address ranges. Default value: none.
         */
        cidrIp?: pulumi.Input<string>;
        /**
         * Rule description.
         */
        description?: pulumi.Input<string>;
        /**
         * Rule ID.
         */
        networkAclEntryId?: pulumi.Input<string>;
        /**
         * Rule name.
         */
        networkAclEntryName?: pulumi.Input<string>;
        /**
         * Authorization policy. accept: Allow access. drop: Deny access. No denial message is returned; the requester only experiences a timeout or similar connection failure.
         */
        policy?: pulumi.Input<string>;
        /**
         * Destination port range for the rule. If the direction rule protocol is all, icmp, or gre, the port range is -1/-1, meaning no port restriction. If the protocol is tcp or udp, the port range is 1–65535, formatted as 1/200, 80/80, indicating ports 1 to 200, or port 80.
         */
        port?: pulumi.Input<string>;
        /**
         * Priority of direction rules. Lower numbers indicate higher priority. Default value if not specified: 1.
         */
        priority?: pulumi.Input<number>;
        /**
         * Protocol type. tcp: TCP protocol. udp: UDP protocol. icmp: ICMP protocol. icmpv6: ICMPV6 protocol. gre: GRE protocol. all: Supports all protocols.
         */
        protocol?: pulumi.Input<string>;
    }
    interface NetworkAclDefaultIngressAclEntry {
        /**
         * For inbound rules, specifies the source address range. For outbound rules, specifies the destination address range. Supports CIDR and IPv4 address ranges. Default value: none.
         */
        cidrIp?: pulumi.Input<string>;
        /**
         * Rule description.
         */
        description?: pulumi.Input<string>;
        /**
         * Rule ID.
         */
        networkAclEntryId?: pulumi.Input<string>;
        /**
         * Rule name.
         */
        networkAclEntryName?: pulumi.Input<string>;
        /**
         * Authorization policy. accept: Allow access. drop: Deny access. No denial message is returned; the requester only experiences a timeout or similar connection failure.
         */
        policy?: pulumi.Input<string>;
        /**
         * Destination port range for the rule. If the direction rule protocol is all, icmp, or gre, the port range is -1/-1, meaning no port restriction. If the protocol is tcp or udp, the port range is 1–65535, formatted as 1/200, 80/80, indicating ports 1 to 200, or port 80.
         */
        port?: pulumi.Input<string>;
        /**
         * Priority of direction rules. Lower numbers indicate higher priority. Default value if not specified: 1.
         */
        priority?: pulumi.Input<number>;
        /**
         * Protocol type. tcp: TCP protocol. udp: UDP protocol. icmp: ICMP protocol. icmpv6: ICMPV6 protocol. gre: GRE protocol. all: Supports all protocols.
         */
        protocol?: pulumi.Input<string>;
    }
    interface NetworkAclEgressAclEntry {
        /**
         * For inbound rules, specifies the source address range. For outbound rules, specifies the destination address range. Supports CIDR and IPv4 address ranges. Default value: none.
         */
        cidrIp?: pulumi.Input<string>;
        /**
         * Rule description.
         */
        description?: pulumi.Input<string>;
        /**
         * Rule name.
         */
        networkAclEntryName?: pulumi.Input<string>;
        /**
         * Authorization policy. accept: Allow access. drop: Deny access. No denial message is returned; the requester only experiences a timeout or similar connection failure.
         */
        policy?: pulumi.Input<string>;
        /**
         * Destination port range for the rule. If the direction rule protocol is all, icmp, or gre, the port range is -1/-1, meaning no port restriction. If the protocol is tcp or udp, the port range is 1–65535, formatted as 1/200, 80/80, indicating ports 1 to 200, or port 80.
         */
        port?: pulumi.Input<string>;
        /**
         * Protocol type. tcp: TCP protocol. udp: UDP protocol. icmp: ICMP protocol. icmpv6: ICMPV6 protocol. gre: GRE protocol. all: Supports all protocols.
         */
        protocol?: pulumi.Input<string>;
    }
    interface NetworkAclIngressAclEntry {
        /**
         * For inbound rules, specifies the source address range. For outbound rules, specifies the destination address range. Supports CIDR and IPv4 address ranges. Default value: none.
         */
        cidrIp?: pulumi.Input<string>;
        /**
         * Rule description.
         */
        description?: pulumi.Input<string>;
        /**
         * Rule name.
         */
        networkAclEntryName?: pulumi.Input<string>;
        /**
         * Authorization policy. accept: Allow access. drop: Deny access. No denial message is returned; the requester only experiences a timeout or similar connection failure.
         */
        policy?: pulumi.Input<string>;
        /**
         * Destination port range for the rule. If the direction rule protocol is all, icmp, or gre, the port range is -1/-1, meaning no port restriction. If the protocol is tcp or udp, the port range is 1–65535, formatted as 1/200, 80/80, indicating ports 1 to 200, or port 80.
         */
        port?: pulumi.Input<string>;
        /**
         * Protocol type. tcp: TCP protocol. udp: UDP protocol. icmp: ICMP protocol. icmpv6: ICMPV6 protocol. gre: GRE protocol. all: Supports all protocols.
         */
        protocol?: pulumi.Input<string>;
    }
    interface NetworkAclResource {
        /**
         * Associated resource ID.
         */
        resourceId?: pulumi.Input<string>;
    }
    interface NetworkAclTag {
        /**
         * User tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value.
         */
        value?: pulumi.Input<string>;
    }
    interface PrefixListAssociationsRouteTable {
        /**
         * ID of the associated resource.
         */
        resourceId?: pulumi.Input<string>;
        /**
         * Type of associated resource. VpcRouteTable: route table; VpcSecurityGroup: security group.
         */
        resourceType?: pulumi.Input<string>;
    }
    interface PrefixListAssociationsSecurityGroup {
        /**
         * ID of the associated resource.
         */
        resourceId?: pulumi.Input<string>;
        /**
         * Type of associated resource. VpcRouteTable: route table; VpcSecurityGroup: security group.
         */
        resourceType?: pulumi.Input<string>;
    }
    interface PrefixListPrefixListEntry {
        /**
         * CIDR of the prefix list entry.
         */
        cidr?: pulumi.Input<string>;
        /**
         * Description of the prefix list entry. Length limit: 0–255 characters. Must start with a letter, Chinese character, or number. Can include English comma (,), period (.), underscore (_), space ( ), equals sign (=), hyphen (-), Chinese comma (，), and Chinese period (。).
         */
        description?: pulumi.Input<string>;
    }
    interface PrefixListTag {
        /**
         * Tag key of the user tag.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value of the user tag.
         */
        value?: pulumi.Input<string>;
    }
    interface RouteTableCustomRouteEntry {
        /**
         * Route Entry Description
         */
        description?: pulumi.Input<string>;
        /**
         * Destination CIDR of the route entry
         */
        destinationCidrBlock?: pulumi.Input<string>;
        /**
         * Prefix List ID
         */
        destinationPrefixListId?: pulumi.Input<string>;
        /**
         * Next Hop Resource ID
         */
        nextHopId?: pulumi.Input<string>;
        /**
         * Name of the next hop resource for the route entry
         */
        nextHopName?: pulumi.Input<string>;
        /**
         * Next hop type for custom route entry. 1. Instance: ECS instance 2. HaVip: High availability virtual IP 3. NetworkInterface: Secondary network interface 4. NatGW: NAT gateway 5. VpnGW: VPN gateway 6. TransitRouter: Transit router 7. IPv6GW: IPv6 gateway 8. CloudConnector: Cloud connector 9. GWLBEndpoint: Gateway load balancer endpoint
         */
        nextHopType?: pulumi.Input<string>;
        /**
         * Route Entry Name
         */
        routeEntryName?: pulumi.Input<string>;
    }
    interface RouteTableSystemRouteEntry {
        /**
         * Route Entry Description
         */
        description?: pulumi.Input<string>;
        /**
         * Destination CIDR of the route entry
         */
        destinationCidrBlock?: pulumi.Input<string>;
        /**
         * Prefix List ID
         */
        destinationPrefixListId?: pulumi.Input<string>;
        /**
         * Next Hop Resource ID
         */
        nextHopId?: pulumi.Input<string>;
        /**
         * Name of the next hop resource for the route entry
         */
        nextHopName?: pulumi.Input<string>;
        /**
         * Next hop type for custom route entry. 1. Instance: ECS instance 2. HaVip: High availability virtual IP 3. NetworkInterface: Secondary network interface 4. NatGW: NAT gateway 5. VpnGW: VPN gateway 6. TransitRouter: Transit router 7. IPv6GW: IPv6 gateway 8. CloudConnector: Cloud connector 9. GWLBEndpoint: Gateway load balancer endpoint
         */
        nextHopType?: pulumi.Input<string>;
        /**
         * Prefix List CIDR
         */
        prefixListCidrBlocks?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Route Entry ID
         */
        routeEntryId?: pulumi.Input<string>;
        /**
         * Route Entry Name
         */
        routeEntryName?: pulumi.Input<string>;
        /**
         * Route Table ID
         */
        routeTableId?: pulumi.Input<string>;
        /**
         * Route entry status. 1. Pending: Pending creation 2. Available: Available
         */
        status?: pulumi.Input<string>;
        /**
         * Route entry type. 1. Custom: Custom route entry 2. System: System default route entry
         */
        type?: pulumi.Input<string>;
        /**
         * ID of the private network to which the route entry belongs
         */
        vpcId?: pulumi.Input<string>;
    }
    interface RouteTableTag {
        /**
         * User tag key
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value
         */
        value?: pulumi.Input<string>;
    }
    interface SecurityGroupEgressPermission {
        /**
         * IPv4 CIDR or IPv6 CIDR of the source address
         */
        cidrIp?: pulumi.Input<string>;
        /**
         * Description for the security group rule. Must start with a letter, Chinese character, or number. Can include English comma (,), period (.), underscore (_), space ( ), equals sign (=), hyphen (-), Chinese comma (，), and Chinese period (。). Length: 1–255 characters. If not specified, the original configuration is retained
         */
        description?: pulumi.Input<string>;
        /**
         * Security group rule direction. ingress: inbound direction. egress: outbound direction
         */
        direction?: pulumi.Input<string>;
        /**
         * Access policy. For resources specified by CidrIp, SourceGroupId, or PrefixListId, refers to the NICs in the security group. Values: accept (allow), drop (deny)
         */
        policy?: pulumi.Input<string>;
        /**
         * Port range end value. 1. When Protocol is set to tcp or udp, the valid range is 1–65535. 2. When Protocol is set to icmp, icmpv6, or all, only -1 is supported, indicating no port restriction
         */
        portEnd?: pulumi.Input<number>;
        /**
         * Port range start value. 1. When Protocol is tcp or udp, range is 1–65535. 2. When Protocol is icmp, icmpv6, or all, only -1 is supported, meaning no port restriction
         */
        portStart?: pulumi.Input<number>;
        /**
         * Prefix list ID
         */
        prefixListId?: pulumi.Input<string>;
        /**
         * Security group rule priority. Lower numbers indicate higher priority. Value range: 1–100. Default: 1 if not specified
         */
        priority?: pulumi.Input<number>;
        /**
         * Protocol type. tcp, udp, icmp, icmpv6, all
         */
        protocol?: pulumi.Input<string>;
        /**
         * Source address security group ID. All NIC addresses in this security group are used as source addresses
         */
        sourceGroupId?: pulumi.Input<string>;
    }
    interface SecurityGroupIngressPermission {
        /**
         * IPv4 CIDR or IPv6 CIDR of the source address
         */
        cidrIp?: pulumi.Input<string>;
        /**
         * Description for the security group rule. Must start with a letter, Chinese character, or number. Can include English comma (,), period (.), underscore (_), space ( ), equals sign (=), hyphen (-), Chinese comma (，), and Chinese period (。). Length: 1–255 characters. If not specified, the original configuration is retained
         */
        description?: pulumi.Input<string>;
        /**
         * Security group rule direction. ingress: inbound direction. egress: outbound direction
         */
        direction?: pulumi.Input<string>;
        /**
         * Access policy. For resources specified by CidrIp, SourceGroupId, or PrefixListId, refers to the NICs in the security group. Values: accept (allow), drop (deny)
         */
        policy?: pulumi.Input<string>;
        /**
         * Port range end value. 1. When Protocol is set to tcp or udp, the valid range is 1–65535. 2. When Protocol is set to icmp, icmpv6, or all, only -1 is supported, indicating no port restriction
         */
        portEnd?: pulumi.Input<number>;
        /**
         * Port range start value. 1. When Protocol is tcp or udp, range is 1–65535. 2. When Protocol is icmp, icmpv6, or all, only -1 is supported, meaning no port restriction
         */
        portStart?: pulumi.Input<number>;
        /**
         * Prefix list ID
         */
        prefixListId?: pulumi.Input<string>;
        /**
         * Security group rule priority. Lower numbers indicate higher priority. Value range: 1–100. Default: 1 if not specified
         */
        priority?: pulumi.Input<number>;
        /**
         * Protocol type. tcp, udp, icmp, icmpv6, all
         */
        protocol?: pulumi.Input<string>;
        /**
         * Source address security group ID. All NIC addresses in this security group are used as source addresses
         */
        sourceGroupId?: pulumi.Input<string>;
    }
    interface SecurityGroupTag {
        /**
         * User tag key
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value
         */
        value?: pulumi.Input<string>;
    }
    interface SubnetRouteTable {
        /**
         * ID of the route table associated with the subnet
         */
        routeTableId?: pulumi.Input<string>;
        /**
         * Type of route table associated with the subnet. 1. System: System route table. 2. Custom: Custom route table
         */
        routeTableType?: pulumi.Input<string>;
    }
    interface SubnetTag {
        /**
         * User tag key
         */
        key?: pulumi.Input<string>;
        /**
         * User tag value
         */
        value?: pulumi.Input<string>;
    }
    interface TrafficMirrorFilterEgressFilterRule {
        /**
         * Filter rule instance description
         */
        description?: pulumi.Input<string>;
        /**
         * Filter rule destination address
         */
        destinationCidrBlock?: pulumi.Input<string>;
        /**
         * Filter rule destination port range
         */
        destinationPortRange?: pulumi.Input<string>;
        /**
         * Filter rule action. accept: Enable traffic mirroring. reject: Do not enable traffic mirroring
         */
        policy?: pulumi.Input<string>;
        /**
         * Filter rule priority
         */
        priority?: pulumi.Input<number>;
        /**
         * Project name
         */
        projectName?: pulumi.Input<string>;
        /**
         * Filter rule protocol type
         */
        protocol?: pulumi.Input<string>;
        /**
         * Filter rule source address
         */
        sourceCidrBlock?: pulumi.Input<string>;
        /**
         * Filter rule source port range
         */
        sourcePortRange?: pulumi.Input<string>;
        /**
         * Filter rule status
         */
        status?: pulumi.Input<string>;
        /**
         * Filter rule direction. egress: Outbound. ingress: Inbound
         */
        trafficDirection?: pulumi.Input<string>;
        /**
         * Filter condition instance ID
         */
        trafficMirrorFilterId?: pulumi.Input<string>;
        /**
         * Filter rule instance ID
         */
        trafficMirrorFilterRuleId?: pulumi.Input<string>;
    }
    interface TrafficMirrorFilterIngressFilterRule {
        /**
         * Filter rule instance description
         */
        description?: pulumi.Input<string>;
        /**
         * Filter rule destination address
         */
        destinationCidrBlock?: pulumi.Input<string>;
        /**
         * Filter rule destination port range
         */
        destinationPortRange?: pulumi.Input<string>;
        /**
         * Filter rule action. accept: Enable traffic mirroring. reject: Do not enable traffic mirroring
         */
        policy?: pulumi.Input<string>;
        /**
         * Filter rule priority
         */
        priority?: pulumi.Input<number>;
        /**
         * Project name
         */
        projectName?: pulumi.Input<string>;
        /**
         * Filter rule protocol type
         */
        protocol?: pulumi.Input<string>;
        /**
         * Filter rule source address
         */
        sourceCidrBlock?: pulumi.Input<string>;
        /**
         * Filter rule source port range
         */
        sourcePortRange?: pulumi.Input<string>;
        /**
         * Filter rule status
         */
        status?: pulumi.Input<string>;
        /**
         * Filter rule direction. egress: Outbound. ingress: Inbound
         */
        trafficDirection?: pulumi.Input<string>;
        /**
         * Filter condition instance ID
         */
        trafficMirrorFilterId?: pulumi.Input<string>;
        /**
         * Filter rule instance ID
         */
        trafficMirrorFilterRuleId?: pulumi.Input<string>;
    }
    interface TrafficMirrorFilterTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface TrafficMirrorSessionTag {
        /**
         * Tag key
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface TrafficMirrorTargetTag {
        /**
         * Tag key. Length must be between 1 and 128 characters. Supports input of characters from any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). If the tag key starts or ends with a space, the system will automatically remove it.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value. Length must be between 0 and 256 characters. If not specified, the default is empty. Supports input of characters from any language, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). Case sensitive. If the tag value starts or ends with a space, the system will automatically remove it.
         */
        value?: pulumi.Input<string>;
    }
    interface VpcAssociateCen {
        /**
         * ID of the CEN.
         */
        cenId?: pulumi.Input<string>;
        /**
         * User ID of the CEN.
         */
        cenOwnerId?: pulumi.Input<string>;
        /**
         * Status of the VPC in the CEN. Loading: loading, Loaded: loaded
         */
        cenStatus?: pulumi.Input<string>;
    }
    interface VpcTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace vpn {
    interface CustomerGatewayTag {
        /**
         * Tag key for user tag
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for user tag
         */
        value?: pulumi.Input<string>;
    }
    interface SslVpnClientCertTag {
        /**
         * Tag key (Key) for SSL client certificate tags. Parameter   - N: indicates the sequence number of the tag key, range: 1–20. Multiple tag keys are separated by &. Naming rules: Cannot start with any combination of 'sys:' in any case. Can only contain language characters, numbers, spaces, and English symbols '_', '.', ':', '/', '=', '+', '-', '@'. Length must be between 1–128 characters. Note: Duplicate tag keys are not allowed for the same resource.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value (Value) for SSL client certificate tags. Parameter   - N: indicates the sequence number of the tag value, range: 1–20. Multiple tag values are separated by &. Naming rules: Can only contain language characters, numbers, spaces, and English symbols '_', '.', ':', '/', '=', '+', '-', '@'. Can be empty, length must be between 0–256 characters. Case-sensitive, cannot start or end with a space. Note: If Tags.N.Value is provided, Tags.N.Key must also be provided.
         */
        value?: pulumi.Input<string>;
    }
    interface SslVpnServerTag {
        /**
         * Tag key for the SSL server label (Key). Naming rules: Must not start with any case combination of sys:. Only letters, numbers, spaces, and the following English symbols are allowed: "_", ".", ":", "/", "=", "+", "-", "@". Length must be between 1 and 128 characters. Note: Tag keys for the same resource must be unique.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value for the SSL server label (Value). Naming rules: Only letters, numbers, spaces, and the following English symbols are allowed: "_", ".", ":", "/", "=", "+", "-", "@". Can be empty. Length must be between 0 and 256 characters. Case sensitive. Cannot start or end with a space. Note: If Tags.N.Value is provided, Tags.N.Key must also be provided.
         */
        value?: pulumi.Input<string>;
    }
    interface VpnConnectionBgpInfo {
        /**
         * Enable dynamic route propagation. false (default): No, use static routing mode. true: Yes, use BGP routing mode.
         */
        enableBgp?: pulumi.Input<boolean>;
        /**
         * The ASN of the VPN gateway.
         */
        localAsn?: pulumi.Input<number>;
        /**
         * The local tunnel IP, which is the BGP address configured on the VPN gateway and defaults to the first host address of BgpConfig.TunnelCidr. This address must be an IP address within the IPsec tunnel subnet. If BgpConfig.EnableBgp is set to true, this parameter must be provided.
         */
        localBgpIp?: pulumi.Input<string>;
        /**
         * ASN of the customer gateway.
         */
        peerAsn?: pulumi.Input<number>;
        /**
         * BGP peer IP, that is, the BGP address on the customer gateway side.
         */
        peerBgpIp?: pulumi.Input<string>;
        /**
         * Status of the BGP connection. Up: BGP connection is normal. Down: BGP connection is not working.
         */
        sessionStatus?: pulumi.Input<string>;
        /**
         * CIDR address range for the local and peer IPs of the BGP session.
         */
        tunnelCidr?: pulumi.Input<string>;
    }
    interface VpnConnectionHealthChecker {
        /**
         * Interval for performing health checks
         */
        checkInterval?: pulumi.Input<number>;
        /**
         * Health check result. Up: Normal. Down: Abnormal.
         */
        checkResult?: pulumi.Input<string>;
        /**
         * ID of the IPsec connection health check
         */
        checkerId?: pulumi.Input<string>;
        /**
         * Health check unhealthy threshold. If the health check result is 'abnormal' for the specified number of consecutive times, the IPsec connection is considered unhealthy.
         */
        downTime?: pulumi.Input<number>;
        /**
         * Health check source IP.
         */
        localIp?: pulumi.Input<string>;
        /**
         * Health check target IP.
         */
        remoteIp?: pulumi.Input<string>;
        /**
         * Health check response timeout. If the IPsec connection does not respond correctly within the specified response time, it is considered 'abnormal' for health check.
         */
        timeout?: pulumi.Input<number>;
        /**
         * Health check threshold. If the specified number of consecutive health checks are all 'healthy', the IPsec connection is considered 'healthy' by health check.
         */
        upTime?: pulumi.Input<number>;
    }
    interface VpnConnectionIkeConfig {
        /**
         * Authentication algorithm for phase one.
         */
        authAlg?: pulumi.Input<string>;
        /**
         * DH (Diffie-Hellman) key exchange algorithm used in phase 1 negotiation. Valid values: group1, group2 (default), group5, group14
         */
        dhGroup?: pulumi.Input<string>;
        /**
         * Encryption algorithm for phase 1 negotiation.
         */
        encAlg?: pulumi.Input<string>;
        /**
         * Lifetime of the SA for phase 1 negotiation. After the lifetime is exceeded, negotiation restarts. Value range: 900~86400, unit: seconds. Default: 86400.
         */
        lifetime?: pulumi.Input<number>;
        /**
         * Identifier of the VPN gateway, used for phase 1 negotiation. Supports IP format and FQDN (Fully Qualified Domain Name) format. If not specified, defaults to the current VPN gateway's egress IP address. If you manually set it to FQDN format, it is recommended to set the negotiation mode to 'aggressive'. Maximum length is 100 characters. Only uppercase and lowercase letters, special characters ~ ` | ! @ # $ % ^ ( )   - _ + = [ ] { } \ , . / : ; and digits are allowed.
         */
        localId?: pulumi.Input<string>;
        /**
         * Negotiation mode for phase 1. This parameter is required only when IkeConfig.Version is ikev1. Valid values: main (default), aggressive
         */
        mode?: pulumi.Input<string>;
        /**
         * Pre-shared key used for identity authentication between the VPN gateway and the user gateway in phase 1. Must not exceed 100 characters and can only contain uppercase and lowercase letters, special symbols ~ ` | ! @ # $ % ^ ( )   - _ + = [ ] { } \ , . / : ;, and numbers.
         */
        psk?: pulumi.Input<string>;
        /**
         * Identifier of the customer gateway, used for phase one negotiation. Supports IP format and FQDN (Fully Qualified Domain Name) format. If not specified, defaults to the public IP address of the currently selected customer gateway. If you manually set it to FQDN format, it is recommended to set the negotiation mode to 'aggressive'. Maximum length is 100 characters. Only uppercase and lowercase letters, special characters ~ ` | ! @ # $ % ^ ( )   - _ + = [ ] { } \ , . / : ;, and digits are allowed.
         */
        remoteId?: pulumi.Input<string>;
        /**
         * Version of the IKE key exchange protocol. Valid values: ikev1, ikev2 (default).
         */
        version?: pulumi.Input<string>;
    }
    interface VpnConnectionIpsecConfig {
        /**
         * Authentication algorithm for phase 2 negotiation
         */
        authAlg?: pulumi.Input<string>;
        /**
         * DH (Diffie-Hellman) key exchange algorithm used in phase 2
         */
        dhGroup?: pulumi.Input<string>;
        /**
         * Encryption algorithm for phase 2 negotiation
         */
        encAlg?: pulumi.Input<string>;
        /**
         * Lifetime of the SA for phase 2 negotiation. Negotiation will be re-initiated after the lifetime expires.
         */
        lifetime?: pulumi.Input<number>;
    }
    interface VpnConnectionTag {
        /**
         * Tag key.
         */
        key?: pulumi.Input<string>;
        /**
         * Tag value
         */
        value?: pulumi.Input<string>;
    }
    interface VpnConnectionTunnelOption {
        /**
         * IPsec tunnel status. ike*sa*negotiation*failed: Phase one negotiation failed; nike*sa*negotiation*completed: Phase one negotiation succeeded; nipsec*sa*negotiation*failed: Phase two negotiation failed; nipsec*sa*negotiation*completed: Phase two negotiation succeeded.
         */
        connectStatus?: pulumi.Input<string>;
        /**
         * ID of the customer gateway associated with the IPsec connection.
         */
        customerGatewayId?: pulumi.Input<string>;
        /**
         * Status of the DPD feature.
         */
        dpdAction?: pulumi.Input<string>;
        /**
         * IKE configuration information for the IPsec connection.
         */
        ikeConfig?: pulumi.Input<inputs.vpn.VpnConnectionTunnelOptionIkeConfig>;
        /**
         * Information about the IPsec configuration in the IPsec connection.
         */
        ipsecConfig?: pulumi.Input<inputs.vpn.VpnConnectionTunnelOptionIpsecConfig>;
        /**
         * Whether to enable NAT traversal
         */
        natTraversal?: pulumi.Input<boolean>;
        /**
         * The role of the tunnel.
         */
        role?: pulumi.Input<string>;
        /**
         * BGP session information.
         */
        tunnelBgpInfo?: pulumi.Input<inputs.vpn.VpnConnectionTunnelOptionTunnelBgpInfo>;
        /**
         * Tunnel ID of the IPsec connection.
         */
        tunnelId?: pulumi.Input<string>;
    }
    interface VpnConnectionTunnelOptionIkeConfig {
        /**
         * Authentication algorithm for phase one.
         */
        authAlg?: pulumi.Input<string>;
        /**
         * DH (Diffie-Hellman) key exchange algorithm used in phase 1 negotiation. Valid values: group1, group2 (default), group5, group14
         */
        dhGroup?: pulumi.Input<string>;
        /**
         * Encryption algorithm for phase 1 negotiation.
         */
        encAlg?: pulumi.Input<string>;
        /**
         * Lifetime of the SA for phase 1 negotiation. After the lifetime is exceeded, negotiation restarts. Value range: 900~86400, unit: seconds. Default: 86400.
         */
        lifetime?: pulumi.Input<number>;
        /**
         * Identifier of the VPN gateway, used for phase 1 negotiation. Supports IP format and FQDN (Fully Qualified Domain Name) format. If not specified, defaults to the current VPN gateway's egress IP address. If you manually set it to FQDN format, it is recommended to set the negotiation mode to 'aggressive'. Maximum length is 100 characters. Only uppercase and lowercase letters, special characters ~ ` | ! @ # $ % ^ ( )   - _ + = [ ] { } \ , . / : ; and digits are allowed.
         */
        localId?: pulumi.Input<string>;
        /**
         * Negotiation mode for phase 1. This parameter is required only when IkeConfig.Version is ikev1. Valid values: main (default), aggressive
         */
        mode?: pulumi.Input<string>;
        /**
         * Pre-shared key used for identity authentication between the VPN gateway and the user gateway in phase 1. Must not exceed 100 characters and can only contain uppercase and lowercase letters, special symbols ~ ` | ! @ # $ % ^ ( )   - _ + = [ ] { } \ , . / : ;, and numbers.
         */
        psk?: pulumi.Input<string>;
        /**
         * Identifier of the customer gateway, used for phase one negotiation. Supports IP format and FQDN (Fully Qualified Domain Name) format. If not specified, defaults to the public IP address of the currently selected customer gateway. If you manually set it to FQDN format, it is recommended to set the negotiation mode to 'aggressive'. Maximum length is 100 characters. Only uppercase and lowercase letters, special characters ~ ` | ! @ # $ % ^ ( )   - _ + = [ ] { } \ , . / : ;, and digits are allowed.
         */
        remoteId?: pulumi.Input<string>;
        /**
         * Version of the IKE key exchange protocol. Valid values: ikev1, ikev2 (default).
         */
        version?: pulumi.Input<string>;
    }
    interface VpnConnectionTunnelOptionIpsecConfig {
        /**
         * Authentication algorithm for phase 2 negotiation
         */
        authAlg?: pulumi.Input<string>;
        /**
         * DH (Diffie-Hellman) key exchange algorithm used in phase 2
         */
        dhGroup?: pulumi.Input<string>;
        /**
         * Encryption algorithm for phase 2 negotiation
         */
        encAlg?: pulumi.Input<string>;
        /**
         * Lifetime of the SA for phase 2 negotiation. Negotiation will be re-initiated after the lifetime expires.
         */
        lifetime?: pulumi.Input<number>;
    }
    interface VpnConnectionTunnelOptionTunnelBgpInfo {
        /**
         * Enable dynamic route propagation. false (default): No, use static routing mode. true: Yes, use BGP routing mode.
         */
        enableBgp?: pulumi.Input<boolean>;
        /**
         * The ASN of the VPN gateway.
         */
        localAsn?: pulumi.Input<number>;
        /**
         * BGP address. Defaults to the first host address of TunnelOptions.N.BGPConfig.TunnelCidr. This address must be an IP address within the IPsec tunnel CIDR block. If EnableTunnelsBgp is set to true, this parameter must be specified.
         */
        localBgpIp?: pulumi.Input<string>;
        /**
         * ASN of the customer gateway.
         */
        peerAsn?: pulumi.Input<number>;
        /**
         * BGP peer IP, that is, the BGP address on the customer gateway side.
         */
        peerBgpIp?: pulumi.Input<string>;
        /**
         * Status of the BGP connection. Up: BGP connection is normal. Down: BGP connection is not working.
         */
        sessionStatus?: pulumi.Input<string>;
        /**
         * The CIDR address range for the local and peer IPs of the BGP session. This range must be within the 169.254.0.0/16 subnet with a subnet mask length of 30. If EnableTunnelsBgp is set to true, this parameter must be provided.
         */
        tunnelCidr?: pulumi.Input<string>;
    }
    interface VpnGatewayRouteAsPath {
        /**
         * AS path sequence. If the AS path type is Sequence, the returned data is the original ASN sequence, such as [65533]. If the AS path type is Set, it indicates that the AS path has been aggregated, and the returned data is the aggregated ASN sequence, such as [4,5].
         */
        numbers?: pulumi.Input<pulumi.Input<number>[]>;
        /**
         * AS path type. Sequence: normal ordered sequence; Set: aggregated sequence.
         */
        type?: pulumi.Input<string>;
    }
    interface VpnGatewayTag {
        /**
         * VPN gateway tag key (Key). Parameter   - N: Indicates the sequence number of the tag key, value range: 1–20. Multiple tag keys are separated by &. Naming rules: Cannot start with any combination of volc: or sys: (case-insensitive). Can only contain language characters, numbers, spaces, and English symbols '_', '.', ':', '/', '=', '+', '-', '@'. Length limit: 1–128 characters. Note: Tag keys for the same resource must not be duplicated.
         */
        key?: pulumi.Input<string>;
        /**
         * VPN gateway tag value (Value). Parameter   - N: Indicates the sequence number of the tag value, value range: 1–20. Multiple tag values are separated by &. Naming rules: Can only contain language characters, numbers, spaces, and English symbols '_', '.', ':', '/', '=', '+', '-', '@'. Can be empty. Length limit: 0–256 characters. Case-sensitive. Cannot start or end with a space. Note: If Tags.N.Value is provided, Tags.N.Key must also be provided.
         */
        value?: pulumi.Input<string>;
    }
}
export declare namespace waf {
    interface DomainBackendGroup {
        /**
         * Access port number.
         */
        accessPorts?: pulumi.Input<pulumi.Input<number>[]>;
        backends?: pulumi.Input<pulumi.Input<inputs.waf.DomainBackendGroupBackend>[]>;
        /**
         * Origin group name.
         */
        name?: pulumi.Input<string>;
    }
    interface DomainBackendGroupBackend {
        /**
         * Origin IP address
         */
        ip?: pulumi.Input<string>;
        /**
         * Origin port
         */
        port?: pulumi.Input<number>;
        /**
         * Origin protocol.
         */
        protocol?: pulumi.Input<string>;
        /**
         * Origin weight
         */
        weight?: pulumi.Input<number>;
    }
    interface DomainCloudAccessConfig {
        /**
         * Access protocol type
         */
        accessProtocol?: pulumi.Input<string>;
        /**
         * Protection mode
         */
        defenceMode?: pulumi.Input<number>;
        /**
         * Load balancing instance ID.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Load balancer instance name.
         */
        instanceName?: pulumi.Input<string>;
        /**
         * Load balancing listener ID.
         */
        listenerId?: pulumi.Input<string>;
        /**
         * Disassociated from ALB
         */
        lostAssociationFromAlb?: pulumi.Input<number>;
        /**
         * Listener forwarding rule port number
         */
        port?: pulumi.Input<string>;
        /**
         * Protocol type for listener forwarding rules.
         */
        protocol?: pulumi.Input<string>;
    }
    interface DomainProtocolPorts {
        /**
         * HTTP protocol port number
         */
        http?: pulumi.Input<pulumi.Input<number>[]>;
        /**
         * HTTPS protocol port number
         */
        https?: pulumi.Input<pulumi.Input<number>[]>;
    }
    interface DomainTcpListenerConfig {
        /**
         * Access protocol type
         */
        accessProtocol?: pulumi.Input<string>;
        /**
         * Protection mode
         */
        defenceMode?: pulumi.Input<number>;
        /**
         * Instance ID.
         */
        instanceId?: pulumi.Input<string>;
        /**
         * Instance name.
         */
        instanceName?: pulumi.Input<string>;
        /**
         * Listener ID.
         */
        listenerId?: pulumi.Input<string>;
        /**
         * Disassociated from ALB
         */
        lostAssociationFromAlb?: pulumi.Input<number>;
        /**
         * Listener port number
         */
        port?: pulumi.Input<string>;
        /**
         * Listener protocol type.
         */
        protocol?: pulumi.Input<string>;
    }
    interface DomainTlsFieldsConfig {
        headersConfig?: pulumi.Input<inputs.waf.DomainTlsFieldsConfigHeadersConfig>;
    }
    interface DomainTlsFieldsConfigHeadersConfig {
        /**
         * Record all header fields
         */
        enable?: pulumi.Input<number>;
        /**
         * Exception header fields. Exclude the specified fields from the JSON to help save log storage space.
         */
        excludedKeyLists?: pulumi.Input<pulumi.Input<string>[]>;
        /**
         * Statistics header fields. Use the specified fields for log analysis and alerts.
         */
        statisticalKeyLists?: pulumi.Input<pulumi.Input<string>[]>;
    }
}