@pulumi/consul/types/input.d.ts

A Pulumi package for creating and managing consul resources.

import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
export interface AclAuthMethodNamespaceRule {
    /**
     * If the namespace rule's `selector` matches then this is used to control the namespace where the token is created.
     */
    bindNamespace: pulumi.Input<string>;
    /**
     * Specifies the expression used to match this namespace rule against valid identities returned from an auth method validation.
     */
    selector?: pulumi.Input<string>;
}
export interface AclBindingRuleBindVars {
    /**
     * The name of node, workload identity or service.
     */
    name?: pulumi.Input<string>;
}
export interface AclRoleNodeIdentity {
    /**
     * Specifies the node's datacenter.
     */
    datacenter: pulumi.Input<string>;
    /**
     * The name of the node.
     */
    nodeName: pulumi.Input<string>;
}
export interface AclRoleServiceIdentity {
    /**
     * The datacenters the effective policy is valid within. When no datacenters are provided the effective policy is valid in all datacenters including those which do not yet exist but may in the future.
     */
    datacenters?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The name of the service.
     */
    serviceName: pulumi.Input<string>;
}
export interface AclRoleTemplatedPolicy {
    /**
     * Specifies the datacenters the effective policy is valid within.
     */
    datacenters?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The name of the templated policies.
     */
    templateName: pulumi.Input<string>;
    /**
     * The templated policy variables.
     */
    templateVariables?: pulumi.Input<inputs.AclRoleTemplatedPolicyTemplateVariables>;
}
export interface AclRoleTemplatedPolicyTemplateVariables {
    /**
     * The name of node, workload identity or service.
     */
    name?: pulumi.Input<string>;
}
export interface AclTokenNodeIdentity {
    /**
     * The datacenter of the node.
     */
    datacenter: pulumi.Input<string>;
    /**
     * The name of the node.
     */
    nodeName: pulumi.Input<string>;
}
export interface AclTokenServiceIdentity {
    /**
     * Specifies the datacenters the effective policy is valid within.
     */
    datacenters?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The name of the service.
     */
    serviceName: pulumi.Input<string>;
}
export interface AclTokenTemplatedPolicy {
    /**
     * Specifies the datacenters the effective policy is valid within.
     */
    datacenters?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The name of the templated policies.
     */
    templateName: pulumi.Input<string>;
    /**
     * The templated policy variables.
     */
    templateVariables?: pulumi.Input<inputs.AclTokenTemplatedPolicyTemplateVariables>;
}
export interface AclTokenTemplatedPolicyTemplateVariables {
    /**
     * The name of node, workload identity or service.
     */
    name?: pulumi.Input<string>;
}
export interface CatalogEntryService {
    /**
     * The address of the service. Defaults to the
     * node address.
     */
    address?: pulumi.Input<string>;
    /**
     * The ID of the service. Defaults to the `name`.
     */
    id?: pulumi.Input<string>;
    /**
     * The name of the service
     */
    name: pulumi.Input<string>;
    /**
     * The port of the service.
     */
    port?: pulumi.Input<number>;
    /**
     * A list of values that are opaque to Consul,
     * but can be used to distinguish between services or nodes.
     */
    tags?: pulumi.Input<pulumi.Input<string>[]>;
}
export interface ConfigEntryServiceDefaultsDestination {
    addresses: pulumi.Input<pulumi.Input<string>[]>;
    port: pulumi.Input<number>;
}
export interface ConfigEntryServiceDefaultsEnvoyExtension {
    arguments?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    consulVersion?: pulumi.Input<string>;
    envoyVersion?: pulumi.Input<string>;
    name?: pulumi.Input<string>;
    required?: pulumi.Input<boolean>;
}
export interface ConfigEntryServiceDefaultsExpose {
    checks?: pulumi.Input<boolean>;
    paths?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsExposePath>[]>;
}
export interface ConfigEntryServiceDefaultsExposePath {
    listenerPort?: pulumi.Input<number>;
    localPathPort?: pulumi.Input<number>;
    path?: pulumi.Input<string>;
    protocol?: pulumi.Input<string>;
}
export interface ConfigEntryServiceDefaultsMeshGateway {
    mode: pulumi.Input<string>;
}
export interface ConfigEntryServiceDefaultsTransparentProxy {
    dialedDirectly: pulumi.Input<boolean>;
    outboundListenerPort: pulumi.Input<number>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfig {
    /**
     * Specifies configurations that set default upstream settings. For information about overriding the default configurations for in for individual upstreams, refer to UpstreamConfig.Overrides.
     */
    defaults?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsUpstreamConfigDefault>[]>;
    /**
     * Specifies options that override the default upstream configurations for individual upstreams.
     */
    overrides?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsUpstreamConfigOverride>[]>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfigDefault {
    /**
     * Sets the strategy for allocating outbound connections from upstreams across Envoy proxy threads.
     */
    balanceOutboundConnections?: pulumi.Input<string>;
    connectTimeoutMs?: pulumi.Input<number>;
    /**
     * Map that specifies a set of limits to apply to when connecting upstream services.
     */
    limits?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsUpstreamConfigDefaultLimit>[]>;
    /**
     * Specifies the default mesh gateway mode field for all upstreams.
     */
    meshGateways?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGateway>[]>;
    /**
     * Map that specifies a set of rules that enable Consul to remove hosts from the upstream cluster that are unreachable or that return errors.
     */
    passiveHealthChecks?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheck>[]>;
    /**
     * Specifies the default protocol for the service.
     */
    protocol?: pulumi.Input<string>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfigDefaultLimit {
    /**
     * Specifies the maximum number of concurrent requests.
     */
    maxConcurrentRequests?: pulumi.Input<number>;
    /**
     * Specifies the maximum number of connections a service instance can establish against the upstream.
     */
    maxConnections?: pulumi.Input<number>;
    /**
     * Specifies the maximum number of requests that are queued while waiting for a connection to establish.
     */
    maxPendingRequests?: pulumi.Input<number>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGateway {
    mode?: pulumi.Input<string>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheck {
    /**
     * Specifies the minimum amount of time that an ejected host must remain outside the cluster before rejoining.
     */
    baseEjectionTime?: pulumi.Input<string>;
    /**
     * Specifies a percentage that indicates how many times out of 100 that Consul ejects the host when it detects an outlier status.
     */
    enforcingConsecutive5xx?: pulumi.Input<number>;
    /**
     * Specifies the time between checks.
     */
    interval?: pulumi.Input<string>;
    /**
     * Specifies the maximum percentage of an upstream cluster that Consul ejects when the proxy reports an outlier.
     */
    maxEjectionPercent?: pulumi.Input<number>;
    /**
     * Specifies the number of consecutive failures allowed per check interval. If exceeded, Consul removes the host from the load balancer.
     */
    maxFailures?: pulumi.Input<number>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfigOverride {
    /**
     * Sets the strategy for allocating outbound connections from upstreams across Envoy proxy threads.
     */
    balanceOutboundConnections?: pulumi.Input<string>;
    connectTimeoutMs?: pulumi.Input<number>;
    envoyListenerJson?: pulumi.Input<string>;
    /**
     * Map that specifies a set of limits to apply to when connecting upstream services.
     */
    limits?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsUpstreamConfigOverrideLimit>[]>;
    /**
     * Specifies the default mesh gateway mode field for all upstreams.
     */
    meshGateways?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGateway>[]>;
    /**
     * Specifies the name of the service you are setting the defaults for.
     */
    name?: pulumi.Input<string>;
    /**
     * Specifies the namespace containing the upstream service that the configuration applies to.
     */
    namespace?: pulumi.Input<string>;
    /**
     * Specifies the name of the name of the Consul admin partition that the configuration entry applies to.
     */
    partition?: pulumi.Input<string>;
    /**
     * Map that specifies a set of rules that enable Consul to remove hosts from the upstream cluster that are unreachable or that return errors.
     */
    passiveHealthChecks?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheck>[]>;
    /**
     * Specifies the peer name of the upstream service that the configuration applies to.
     */
    peer?: pulumi.Input<string>;
    /**
     * Specifies the default protocol for the service.
     */
    protocol?: pulumi.Input<string>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfigOverrideLimit {
    /**
     * Specifies the maximum number of concurrent requests.
     */
    maxConcurrentRequests?: pulumi.Input<number>;
    /**
     * Specifies the maximum number of connections a service instance can establish against the upstream.
     */
    maxConnections?: pulumi.Input<number>;
    /**
     * Specifies the maximum number of requests that are queued while waiting for a connection to establish.
     */
    maxPendingRequests?: pulumi.Input<number>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGateway {
    mode?: pulumi.Input<string>;
}
export interface ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheck {
    /**
     * Specifies the minimum amount of time that an ejected host must remain outside the cluster before rejoining.
     */
    baseEjectionTime?: pulumi.Input<string>;
    /**
     * Specifies a percentage that indicates how many times out of 100 that Consul ejects the host when it detects an outlier status.
     */
    enforcingConsecutive5xx?: pulumi.Input<number>;
    /**
     * Specifies the time between checks.
     */
    interval?: pulumi.Input<string>;
    /**
     * Specifies the maximum percentage of an upstream cluster that Consul ejects when the proxy reports an outlier.
     */
    maxEjectionPercent?: pulumi.Input<number>;
    /**
     * Specifies the number of consecutive failures allowed per check interval. If exceeded, Consul removes the host from the load balancer.
     */
    maxFailures?: pulumi.Input<number>;
}
export interface ConfigEntryServiceIntentionsJwt {
    /**
     * Specifies the names of one or more previously configured JWT provider configuration entries, which include the information necessary to validate a JSON web token.
     */
    providers?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceIntentionsJwtProvider>[]>;
}
export interface ConfigEntryServiceIntentionsJwtProvider {
    /**
     * Specifies the name of a JWT provider defined in the Name field of the jwt-provider configuration entry.
     */
    name?: pulumi.Input<string>;
    /**
     * Specifies additional token information to verify beyond what is configured in the JWT provider configuration entry.
     */
    verifyClaims?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceIntentionsJwtProviderVerifyClaim>[]>;
}
export interface ConfigEntryServiceIntentionsJwtProviderVerifyClaim {
    /**
     * Specifies the path to the claim in the JSON web token.
     */
    paths?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Specifies the value to match on when verifying the the claim designated in path.
     */
    value?: pulumi.Input<string>;
}
export interface ConfigEntryServiceIntentionsSource {
    /**
     * Specifies the action to take when the source sends traffic to the destination service.
     */
    action?: pulumi.Input<string>;
    /**
     * Specifies a description of the intention.
     */
    description?: pulumi.Input<string>;
    /**
     * Specifies the name of the source that the intention allows or denies traffic from.
     */
    name?: pulumi.Input<string>;
    /**
     * Specifies the traffic source namespace that the intention allows or denies traffic from.
     */
    namespace?: pulumi.Input<string>;
    /**
     * Specifies the name of an admin partition that the intention allows or denies traffic from.
     */
    partition?: pulumi.Input<string>;
    /**
     * Specifies the name of a peered Consul cluster that the intention allows or denies traffic from
     */
    peer?: pulumi.Input<string>;
    /**
     * Specifies a list of permissions for L7 traffic sources. The list contains one or more actions and a set of match criteria for each action.
     */
    permissions?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceIntentionsSourcePermission>[]>;
    /**
     * The Precedence field contains a read-only integer. Consul generates the value based on name configurations for the source and destination services.
     */
    precedence?: pulumi.Input<number>;
    /**
     * Specifies the name of a sameness group that the intention allows or denies traffic from.
     */
    samenessGroup?: pulumi.Input<string>;
    /**
     * Specifies the type of destination service that the configuration entry applies to.
     */
    type?: pulumi.Input<string>;
}
export interface ConfigEntryServiceIntentionsSourcePermission {
    /**
     * Specifies the action to take when the source sends traffic to the destination service. The value is either allow or deny.
     */
    action: pulumi.Input<string>;
    /**
     * Specifies a set of HTTP-specific match criteria.
     */
    https: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceIntentionsSourcePermissionHttp>[]>;
}
export interface ConfigEntryServiceIntentionsSourcePermissionHttp {
    /**
     * Specifies a header name and matching criteria for HTTP request headers.
     */
    headers?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceIntentionsSourcePermissionHttpHeader>[]>;
    /**
     * Specifies a list of HTTP methods.
     */
    methods?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Specifies an exact path to match on the HTTP request path.
     */
    pathExact?: pulumi.Input<string>;
    /**
     * Specifies a path prefix to match on the HTTP request path.
     */
    pathPrefix?: pulumi.Input<string>;
    /**
     * Defines a regular expression to match on the HTTP request path.
     */
    pathRegex?: pulumi.Input<string>;
}
export interface ConfigEntryServiceIntentionsSourcePermissionHttpHeader {
    /**
     * Specifies a value for the header key set in the Name field. If the request header value matches the Exact value, Consul applies the permission.
     */
    exact?: pulumi.Input<string>;
    /**
     * Inverts the matching logic configured in the Header.
     */
    invert?: pulumi.Input<boolean>;
    /**
     * Specifies the name of the header to match.
     */
    name: pulumi.Input<string>;
    /**
     * Specifies a prefix value for the header key set in the Name field.
     */
    prefix?: pulumi.Input<string>;
    /**
     * Enables a match if the header configured in the Name field appears in the request. Consul matches on any value as long as the header key appears in the request.
     */
    present?: pulumi.Input<boolean>;
    /**
     * Specifies a regular expression pattern as the value for the header key set in the Name field.
     */
    regex?: pulumi.Input<string>;
    /**
     * Specifies a suffix value for the header key set in the Name field.
     */
    suffix?: pulumi.Input<string>;
}
export interface ConfigEntryServiceResolverFailover {
    /**
     * Specifies an ordered list of datacenters at the failover location to attempt connections to during a failover scenario. When Consul cannot establish a connection with the first datacenter in the list, it proceeds sequentially until establishing a connection with another datacenter.
     */
    datacenters?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Specifies the namespace at the failover location where the failover services are deployed.
     */
    namespace?: pulumi.Input<string>;
    /**
     * Specifies the sameness group at the failover location where the failover services are deployed.
     */
    samenessGroup?: pulumi.Input<string>;
    /**
     * Specifies the name of the service to resolve at the failover location during a failover scenario.
     */
    service?: pulumi.Input<string>;
    /**
     * Specifies the name of a subset of service instances to resolve at the failover location during a failover scenario.
     */
    serviceSubset?: pulumi.Input<string>;
    /**
     * Name of subset.
     */
    subsetName: pulumi.Input<string>;
    /**
     * Specifies a fixed list of failover targets to try during failover. This list can express complicated failover scenarios.
     */
    targets?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceResolverFailoverTarget>[]>;
}
export interface ConfigEntryServiceResolverFailoverTarget {
    /**
     * Specifies the WAN federated datacenter to use for the failover target. If empty, the current datacenter is used.
     */
    datacenter?: pulumi.Input<string>;
    /**
     * Specifies the namespace to use for the failover target. If empty, the default namespace is used.
     */
    namespace?: pulumi.Input<string>;
    /**
     * Specifies the admin partition within the same datacenter to use for the failover target. If empty, the default partition is used.
     */
    partition?: pulumi.Input<string>;
    /**
     * Specifies the destination cluster peer to resolve the target service name from.
     */
    peer?: pulumi.Input<string>;
    /**
     * Specifies the service name to use for the failover target. If empty, the current service name is used.
     */
    service?: pulumi.Input<string>;
    /**
     * Specifies the named subset to use for the failover target. If empty, the default subset for the requested service name is used.
     */
    serviceSubset?: pulumi.Input<string>;
}
export interface ConfigEntryServiceResolverLoadBalancer {
    /**
     * Specifies a list of hash policies to use for hashing load balancing algorithms. Consul evaluates hash policies individually and combines them so that identical lists result in the same hash.
     */
    hashPolicies?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceResolverLoadBalancerHashPolicy>[]>;
    /**
     * Specifies configuration for the least*request policy type.
     */
    leastRequestConfigs?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceResolverLoadBalancerLeastRequestConfig>[]>;
    /**
     * Specifies the type of load balancing policy for selecting a host.
     */
    policy?: pulumi.Input<string>;
    /**
     * Specifies configuration for the ring*hash policy type.
     */
    ringHashConfigs?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceResolverLoadBalancerRingHashConfig>[]>;
}
export interface ConfigEntryServiceResolverLoadBalancerHashPolicy {
    /**
     * Specifies additional configuration options for the cookie hash policy type.
     */
    cookieConfigs?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfig>[]>;
    /**
     * Specifies the attribute type to hash on. You cannot specify the Field parameter if SourceIP is also configured.
     */
    field?: pulumi.Input<string>;
    /**
     * Specifies the value to hash, such as a header name, cookie name, or a URL query parameter name.
     */
    fieldValue?: pulumi.Input<string>;
    /**
     * Determines if the hash type should be source IP address.
     */
    sourceIp?: pulumi.Input<boolean>;
    /**
     * Determines if Consul should stop computing the hash when multiple hash policies are present.
     */
    terminal?: pulumi.Input<boolean>;
}
export interface ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfig {
    /**
     * Specifies the path to set for the cookie.
     */
    path?: pulumi.Input<string>;
    /**
     * Directs Consul to generate a session cookie with no expiration.
     */
    session?: pulumi.Input<boolean>;
    /**
     * Specifies the TTL for generated cookies. Cannot be specified for session cookies.
     */
    ttl?: pulumi.Input<string>;
}
export interface ConfigEntryServiceResolverLoadBalancerLeastRequestConfig {
    choiceCount?: pulumi.Input<number>;
}
export interface ConfigEntryServiceResolverLoadBalancerRingHashConfig {
    /**
     * Determines the maximum number of entries in the hash ring.
     */
    maximumRingSize?: pulumi.Input<number>;
    /**
     * Determines the minimum number of entries in the hash ring.
     */
    minimumRingSize?: pulumi.Input<number>;
}
export interface ConfigEntryServiceResolverRedirect {
    /**
     * Specifies the datacenter at the redirect’s destination that resolves local upstream requests.
     */
    datacenter?: pulumi.Input<string>;
    /**
     * Specifies the namespace at the redirect’s destination that resolves local upstream requests.
     */
    namespace?: pulumi.Input<string>;
    /**
     * Specifies the admin partition at the redirect’s destination that resolves local upstream requests.
     */
    partition?: pulumi.Input<string>;
    /**
     * Specifies the cluster with an active cluster peering connection at the redirect’s destination that resolves local upstream requests.
     */
    peer?: pulumi.Input<string>;
    /**
     * Specifies the sameness group at the redirect’s destination that resolves local upstream requests.
     */
    samenessGroup?: pulumi.Input<string>;
    /**
     * Specifies the name of a service at the redirect’s destination that resolves local upstream requests.
     */
    service?: pulumi.Input<string>;
    /**
     * Specifies the name of a subset of services at the redirect’s destination that resolves local upstream requests. If empty, the default subset is used. If specified, you must also specify at least one of the following in the same Redirect map: Service, Namespace, andDatacenter.
     */
    serviceSubset?: pulumi.Input<string>;
}
export interface ConfigEntryServiceResolverSubset {
    /**
     * Specifies an expression that filters the DNS elements of service instances that belong to the subset. If empty, all healthy instances of a service are returned.
     */
    filter: pulumi.Input<string>;
    /**
     * Name of subset.
     */
    name: pulumi.Input<string>;
    /**
     * Determines if instances that return a warning from a health check are allowed to resolve a request. When set to false, instances with passing and warning states are considered healthy. When set to true, only instances with a passing health check state are considered healthy.
     */
    onlyPassing: pulumi.Input<boolean>;
}
export interface ConfigEntryServiceRouterRoute {
    /**
     * Specifies the target service to route matching requests to, as well as behavior for the request to follow when routed.
     */
    destination?: pulumi.Input<inputs.ConfigEntryServiceRouterRouteDestination>;
    /**
     * Describes a set of criteria that Consul compares incoming L7 traffic with.
     */
    match?: pulumi.Input<inputs.ConfigEntryServiceRouterRouteMatch>;
}
export interface ConfigEntryServiceRouterRouteDestination {
    /**
     * Specifies the total amount of time permitted for the request stream to be idle.
     */
    idleTimeout?: pulumi.Input<string>;
    /**
     * Specifies the Consul namespace to resolve the service from instead of the current namespace.
     */
    namespace?: pulumi.Input<string>;
    /**
     * Specifies the number of times to retry the request when a retry condition occurs.
     */
    numRetries?: pulumi.Input<number>;
    /**
     * Specifies the Consul admin partition to resolve the service from instead of the current partition.
     */
    partition?: pulumi.Input<string>;
    /**
     * Specifies rewrites to the HTTP request path before proxying it to its final destination.
     */
    prefixRewrite?: pulumi.Input<string>;
    /**
     * Specifies a set of HTTP-specific header modification rules applied to requests routed with the service router.
     */
    requestHeaders?: pulumi.Input<inputs.ConfigEntryServiceRouterRouteDestinationRequestHeaders>;
    /**
     * Specifies the total amount of time permitted for the entire downstream request to be processed, including retry attempts.
     */
    requestTimeout?: pulumi.Input<string>;
    /**
     * Specifies a set of HTTP-specific header modification rules applied to responses routed with the service router.
     */
    responseHeaders?: pulumi.Input<inputs.ConfigEntryServiceRouterRouteDestinationResponseHeaders>;
    /**
     * Specifies that connection failure errors that trigger a retry request.
     */
    retryOnConnectFailure?: pulumi.Input<boolean>;
    /**
     * Specifies a list of integers for HTTP response status codes that trigger a retry request.
     */
    retryOnStatusCodes?: pulumi.Input<pulumi.Input<number>[]>;
    /**
     * Specifies a list of conditions for Consul to retry requests based on the response from an upstream service.
     */
    retryOns?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Specifies the name of the service to resolve.
     */
    service?: pulumi.Input<string>;
    /**
     * Specifies a named subset of the given service to resolve instead of the one defined as that service's `defaultSubset` in the service resolver configuration entry.
     */
    serviceSubset?: pulumi.Input<string>;
}
export interface ConfigEntryServiceRouterRouteDestinationRequestHeaders {
    /**
     * Defines a set of key-value pairs to add to the header. Use header names as the keys.
     */
    add?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Defines a list of headers to remove.
     */
    removes?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Defines a set of key-value pairs to add to the request header or to replace existing header values with.
     */
    set?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
}
export interface ConfigEntryServiceRouterRouteDestinationResponseHeaders {
    /**
     * Defines a set of key-value pairs to add to the header. Use header names as the keys
     */
    add?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Defines a list of headers to remove.
     */
    removes?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Defines a set of key-value pairs to add to the response header or to replace existing header values with
     */
    set?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
}
export interface ConfigEntryServiceRouterRouteMatch {
    /**
     * Specifies a set of HTTP criteria used to evaluate incoming L7 traffic for matches.
     */
    http?: pulumi.Input<inputs.ConfigEntryServiceRouterRouteMatchHttp>;
}
export interface ConfigEntryServiceRouterRouteMatchHttp {
    /**
     * Specifies information in the HTTP request header to match with.
     */
    headers?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceRouterRouteMatchHttpHeader>[]>;
    /**
     * Specifies HTTP methods that the match applies to.
     */
    methods?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Specifies the exact path to match on the HTTP request path.
     */
    pathExact?: pulumi.Input<string>;
    /**
     * Specifies the path prefix to match on the HTTP request path.
     */
    pathPrefix?: pulumi.Input<string>;
    /**
     * Specifies a regular expression to match on the HTTP request path.
     */
    pathRegex?: pulumi.Input<string>;
    /**
     * Specifies information to match to on HTTP query parameters.
     */
    queryParams?: pulumi.Input<pulumi.Input<inputs.ConfigEntryServiceRouterRouteMatchHttpQueryParam>[]>;
}
export interface ConfigEntryServiceRouterRouteMatchHttpHeader {
    /**
     * Specifies that a request matches when the header with the given name is this exact value.
     */
    exact?: pulumi.Input<string>;
    /**
     * Specifies that the logic for the HTTP header match should be inverted.
     */
    invert?: pulumi.Input<boolean>;
    /**
     * Specifies the name of the HTTP header to match.
     */
    name?: pulumi.Input<string>;
    /**
     * Specifies that a request matches when the header with the given name has this prefix.
     */
    prefix?: pulumi.Input<string>;
    /**
     * Specifies that a request matches when the value in the `name` argument is present anywhere in the HTTP header.
     */
    present?: pulumi.Input<boolean>;
    /**
     * Specifies that a request matches when the header with the given name matches this regular expression.
     */
    regex?: pulumi.Input<string>;
    /**
     * Specifies that a request matches when the header with the given name has this suffix.
     */
    suffix?: pulumi.Input<string>;
}
export interface ConfigEntryServiceRouterRouteMatchHttpQueryParam {
    /**
     * Specifies that a request matches when the query parameter with the given name is this exact value.
     */
    exact?: pulumi.Input<string>;
    /**
     * Specifies the name of the HTTP query parameter to match.
     */
    name?: pulumi.Input<string>;
    /**
     * Specifies that a request matches when the value in the `name` argument is present anywhere in the HTTP query parameter.
     */
    present?: pulumi.Input<boolean>;
    /**
     * Specifies that a request matches when the query parameter with the given name matches this regular expression.
     */
    regex?: pulumi.Input<string>;
}
export interface ConfigEntryServiceSplitterSplit {
    /**
     * Specifies the namespace to use in the FQDN when resolving the service.
     */
    namespace?: pulumi.Input<string>;
    /**
     * Specifies the admin partition to use in the FQDN when resolving the service.
     */
    partition?: pulumi.Input<string>;
    /**
     * Specifies a set of HTTP-specific header modification rules applied to requests routed with the service split. You cannot configure request headers if the listener protocol is set to `tcp`.
     */
    requestHeaders?: pulumi.Input<inputs.ConfigEntryServiceSplitterSplitRequestHeaders>;
    /**
     * Specifies a set of HTTP-specific header modification rules applied to responses routed with the service split. You cannot configure request headers if the listener protocol is set to `tcp`.
     */
    responseHeaders?: pulumi.Input<inputs.ConfigEntryServiceSplitterSplitResponseHeaders>;
    /**
     * Specifies the name of the service to resolve.
     */
    service: pulumi.Input<string>;
    /**
     * Specifies a subset of the service to resolve. A service subset assigns a name to a specific subset of discoverable service instances within a datacenter, such as `version2` or `canary`. All services have an unnamed default subset that returns all healthy instances.
     */
    serviceSubset?: pulumi.Input<string>;
    /**
     * Specifies the percentage of traffic sent to the set of service instances specified in the `service` field. Each weight must be a floating integer between `0` and `100`. The smallest representable value is `.01`. The sum of weights across all splits must add up to `100`.
     */
    weight: pulumi.Input<number>;
}
export interface ConfigEntryServiceSplitterSplitRequestHeaders {
    /**
     * Map of one or more key-value pairs. Defines a set of key-value pairs to add to the header. Use header names as the keys. Header names are not case-sensitive. If header values with the same name already exist, the value is appended and Consul applies both headers.
     */
    add?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Defines an list of headers to remove. Consul removes only headers containing exact matches. Header names are not case-sensitive.
     */
    removes?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Map of one or more key-value pairs. Defines a set of key-value pairs to add to the request header or to replace existing header values with. Use header names as the keys. Header names are not case-sensitive. If header values with the same names already exist, Consul replaces the header values.
     */
    set?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
}
export interface ConfigEntryServiceSplitterSplitResponseHeaders {
    /**
     * Map of one or more key-value pairs. Defines a set of key-value pairs to add to the header. Use header names as the keys. Header names are not case-sensitive. If header values with the same name already exist, the value is appended and Consul applies both headers.
     */
    add?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Defines an list of headers to remove. Consul removes only headers containing exact matches. Header names are not case-sensitive.
     */
    removes?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Map of one or more key-value pairs. Defines a set of key-value pairs to add to the request header or to replace existing header values with. Use header names as the keys. Header names are not case-sensitive. If header values with the same names already exist, Consul replaces the header values.
     */
    set?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
}
export interface GetCatalogNodesQueryOption {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: boolean;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to then the datacenter in the provider setup.
     */
    datacenter?: string;
    near?: string;
    nodeMeta?: {
        [key: string]: string;
    };
    partition?: string;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: boolean;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: string;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: number;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: string;
}
export interface GetCatalogNodesQueryOptionArgs {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: pulumi.Input<boolean>;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to then the datacenter in the provider setup.
     */
    datacenter?: pulumi.Input<string>;
    near?: pulumi.Input<string>;
    nodeMeta?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    partition?: pulumi.Input<string>;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: pulumi.Input<boolean>;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: pulumi.Input<string>;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: pulumi.Input<number>;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: pulumi.Input<string>;
}
export interface GetCatalogServiceQueryOption {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: boolean;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to.
     */
    datacenter?: string;
    /**
     * The namespace to lookup the service.
     */
    namespace?: string;
    near?: string;
    nodeMeta?: {
        [key: string]: string;
    };
    partition?: string;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: boolean;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: string;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: number;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: string;
}
export interface GetCatalogServiceQueryOptionArgs {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: pulumi.Input<boolean>;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to.
     */
    datacenter?: pulumi.Input<string>;
    /**
     * The namespace to lookup the service.
     */
    namespace?: pulumi.Input<string>;
    near?: pulumi.Input<string>;
    nodeMeta?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    partition?: pulumi.Input<string>;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: pulumi.Input<boolean>;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: pulumi.Input<string>;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: pulumi.Input<number>;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: pulumi.Input<string>;
}
export interface GetCatalogServicesQueryOption {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: boolean;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to.
     */
    datacenter?: string;
    /**
     * The namespace to lookup the services.
     */
    namespace?: string;
    near?: string;
    nodeMeta?: {
        [key: string]: string;
    };
    partition?: string;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: boolean;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: string;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: number;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: string;
}
export interface GetCatalogServicesQueryOptionArgs {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: pulumi.Input<boolean>;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to.
     */
    datacenter?: pulumi.Input<string>;
    /**
     * The namespace to lookup the services.
     */
    namespace?: pulumi.Input<string>;
    near?: pulumi.Input<string>;
    nodeMeta?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    partition?: pulumi.Input<string>;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: pulumi.Input<boolean>;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: pulumi.Input<string>;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: pulumi.Input<number>;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: pulumi.Input<string>;
}
export interface GetKeyPrefixSubkeyCollection {
    /**
     * This is the default value to set for `var.<name>`
     * if the key does not exist in Consul. Defaults to an empty string.
     */
    default?: string;
    /**
     * This is the name of the key. This value of the
     * key is exposed as `var.<name>`. This is not the path of the subkey
     * in Consul.
     */
    name: string;
    /**
     * This is the subkey path in Consul (which will be appended
     * to the given `pathPrefix`) to construct the full key that will be used
     * to read the value.
     */
    path: string;
}
export interface GetKeyPrefixSubkeyCollectionArgs {
    /**
     * This is the default value to set for `var.<name>`
     * if the key does not exist in Consul. Defaults to an empty string.
     */
    default?: pulumi.Input<string>;
    /**
     * This is the name of the key. This value of the
     * key is exposed as `var.<name>`. This is not the path of the subkey
     * in Consul.
     */
    name: pulumi.Input<string>;
    /**
     * This is the subkey path in Consul (which will be appended
     * to the given `pathPrefix`) to construct the full key that will be used
     * to read the value.
     */
    path: pulumi.Input<string>;
}
export interface GetKeysKey {
    /**
     * This is the default value to set for `var.<name>` if the key does not exist in Consul. Defaults to an empty string.
     */
    default?: string;
    /**
     * This is the name of the key. This value of the key is exposed as `var.<name>`. This is not the path of the key in Consul.
     */
    name: string;
    /**
     * This is the path in Consul that should be read or written to.
     */
    path: string;
}
export interface GetKeysKeyArgs {
    /**
     * This is the default value to set for `var.<name>` if the key does not exist in Consul. Defaults to an empty string.
     */
    default?: pulumi.Input<string>;
    /**
     * This is the name of the key. This value of the key is exposed as `var.<name>`. This is not the path of the key in Consul.
     */
    name: pulumi.Input<string>;
    /**
     * This is the path in Consul that should be read or written to.
     */
    path: pulumi.Input<string>;
}
export interface GetNodesQueryOption {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: boolean;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to then the datacenter in the provider setup.
     */
    datacenter?: string;
    near?: string;
    nodeMeta?: {
        [key: string]: string;
    };
    partition?: string;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: boolean;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: string;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: number;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: string;
}
export interface GetNodesQueryOptionArgs {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: pulumi.Input<boolean>;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to then the datacenter in the provider setup.
     */
    datacenter?: pulumi.Input<string>;
    near?: pulumi.Input<string>;
    nodeMeta?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    partition?: pulumi.Input<string>;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: pulumi.Input<boolean>;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: pulumi.Input<string>;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: pulumi.Input<number>;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: pulumi.Input<string>;
}
export interface GetServiceQueryOption {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: boolean;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to.
     */
    datacenter?: string;
    /**
     * The namespace to lookup the service.
     */
    namespace?: string;
    near?: string;
    nodeMeta?: {
        [key: string]: string;
    };
    partition?: string;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: boolean;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: string;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: number;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: string;
}
export interface GetServiceQueryOptionArgs {
    /**
     * When `true`, the default, allow responses from
     * Consul servers that are followers.
     */
    allowStale?: pulumi.Input<boolean>;
    /**
     * The Consul datacenter to query.  Defaults to the
     * same value found in `queryOptions` parameter specified below, or if that is
     * empty, the `datacenter` value found in the Consul agent that this provider is
     * configured to talk to.
     */
    datacenter?: pulumi.Input<string>;
    /**
     * The namespace to lookup the service.
     */
    namespace?: pulumi.Input<string>;
    near?: pulumi.Input<string>;
    nodeMeta?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    partition?: pulumi.Input<string>;
    /**
     * When `true` force the client to perform a
     * read on at least quorum servers and verify the result is the same.  Defaults
     * to `false`.
     */
    requireConsistent?: pulumi.Input<boolean>;
    /**
     * Specify the Consul ACL token to use when performing the
     * request.  This defaults to the same API token configured by the `consul`
     * provider but may be overridden if necessary.
     */
    token?: pulumi.Input<string>;
    /**
     * Index number used to enable blocking queries.
     */
    waitIndex?: pulumi.Input<number>;
    /**
     * Max time the client should wait for a blocking query
     * to return.
     */
    waitTime?: pulumi.Input<string>;
}
export interface GetServicesQueryOption {
    /**
     * When `true`, the defau