import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
/**
 * Represents a ServiceAttachment resource.
 *
 * To get more information about ServiceAttachment, see:
 *
 * * [API documentation](https://cloud.google.com/compute/docs/reference/beta/serviceAttachments)
 * * How-to Guides
 *     * [Configuring Private Service Connect to access services](https://cloud.google.com/vpc/docs/configure-private-service-connect-services)
 *
 * ## Example Usage
 *
 * ### Service Attachment Basic
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const producerServiceHealthCheck = new gcp.compute.HealthCheck("producer_service_health_check", {
 *     name: "producer-service-health-check",
 *     checkIntervalSec: 1,
 *     timeoutSec: 1,
 *     tcpHealthCheck: {
 *         port: 80,
 *     },
 * });
 * const producerServiceBackend = new gcp.compute.RegionBackendService("producer_service_backend", {
 *     name: "producer-service",
 *     region: "us-west2",
 *     healthChecks: producerServiceHealthCheck.id,
 * });
 * const pscIlbNetwork = new gcp.compute.Network("psc_ilb_network", {
 *     name: "psc-ilb-network",
 *     autoCreateSubnetworks: false,
 * });
 * const pscIlbProducerSubnetwork = new gcp.compute.Subnetwork("psc_ilb_producer_subnetwork", {
 *     name: "psc-ilb-producer-subnetwork",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     ipCidrRange: "10.0.0.0/16",
 * });
 * const pscIlbTargetService = new gcp.compute.ForwardingRule("psc_ilb_target_service", {
 *     name: "producer-forwarding-rule",
 *     region: "us-west2",
 *     loadBalancingScheme: "INTERNAL",
 *     backendService: producerServiceBackend.id,
 *     allPorts: true,
 *     network: pscIlbNetwork.name,
 *     subnetwork: pscIlbProducerSubnetwork.name,
 * });
 * const pscIlbNat = new gcp.compute.Subnetwork("psc_ilb_nat", {
 *     name: "psc-ilb-nat",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     purpose: "PRIVATE_SERVICE_CONNECT",
 *     ipCidrRange: "10.1.0.0/16",
 * });
 * const pscIlbServiceAttachment = new gcp.compute.ServiceAttachment("psc_ilb_service_attachment", {
 *     name: "my-psc-ilb",
 *     region: "us-west2",
 *     description: "A service attachment configured with Terraform",
 *     domainNames: ["gcp.tfacc.hashicorptest.com."],
 *     enableProxyProtocol: true,
 *     connectionPreference: "ACCEPT_AUTOMATIC",
 *     natSubnets: [pscIlbNat.id],
 *     targetService: pscIlbTargetService.id,
 * });
 * const pscIlbConsumerAddress = new gcp.compute.Address("psc_ilb_consumer_address", {
 *     name: "psc-ilb-consumer-address",
 *     region: "us-west2",
 *     subnetwork: "default",
 *     addressType: "INTERNAL",
 * });
 * const pscIlbConsumer = new gcp.compute.ForwardingRule("psc_ilb_consumer", {
 *     name: "psc-ilb-consumer-forwarding-rule",
 *     region: "us-west2",
 *     target: pscIlbServiceAttachment.id,
 *     loadBalancingScheme: "",
 *     network: "default",
 *     ipAddress: pscIlbConsumerAddress.id,
 * });
 * ```
 * ### Service Attachment Explicit Projects
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const producerServiceHealthCheck = new gcp.compute.HealthCheck("producer_service_health_check", {
 *     name: "producer-service-health-check",
 *     checkIntervalSec: 1,
 *     timeoutSec: 1,
 *     tcpHealthCheck: {
 *         port: 80,
 *     },
 * });
 * const producerServiceBackend = new gcp.compute.RegionBackendService("producer_service_backend", {
 *     name: "producer-service",
 *     region: "us-west2",
 *     healthChecks: producerServiceHealthCheck.id,
 * });
 * const pscIlbNetwork = new gcp.compute.Network("psc_ilb_network", {
 *     name: "psc-ilb-network",
 *     autoCreateSubnetworks: false,
 * });
 * const pscIlbProducerSubnetwork = new gcp.compute.Subnetwork("psc_ilb_producer_subnetwork", {
 *     name: "psc-ilb-producer-subnetwork",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     ipCidrRange: "10.0.0.0/16",
 * });
 * const pscIlbTargetService = new gcp.compute.ForwardingRule("psc_ilb_target_service", {
 *     name: "producer-forwarding-rule",
 *     region: "us-west2",
 *     loadBalancingScheme: "INTERNAL",
 *     backendService: producerServiceBackend.id,
 *     allPorts: true,
 *     network: pscIlbNetwork.name,
 *     subnetwork: pscIlbProducerSubnetwork.name,
 * });
 * const pscIlbNat = new gcp.compute.Subnetwork("psc_ilb_nat", {
 *     name: "psc-ilb-nat",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     purpose: "PRIVATE_SERVICE_CONNECT",
 *     ipCidrRange: "10.1.0.0/16",
 * });
 * const pscIlbServiceAttachment = new gcp.compute.ServiceAttachment("psc_ilb_service_attachment", {
 *     name: "my-psc-ilb",
 *     region: "us-west2",
 *     description: "A service attachment configured with Terraform",
 *     domainNames: ["gcp.tfacc.hashicorptest.com."],
 *     enableProxyProtocol: true,
 *     connectionPreference: "ACCEPT_MANUAL",
 *     natSubnets: [pscIlbNat.id],
 *     targetService: pscIlbTargetService.id,
 *     consumerRejectLists: [
 *         "673497134629",
 *         "482878270665",
 *     ],
 *     consumerAcceptLists: [{
 *         projectIdOrNum: "658859330310",
 *         connectionLimit: 4,
 *     }],
 * });
 * const pscIlbConsumerAddress = new gcp.compute.Address("psc_ilb_consumer_address", {
 *     name: "psc-ilb-consumer-address",
 *     region: "us-west2",
 *     subnetwork: "default",
 *     addressType: "INTERNAL",
 * });
 * const pscIlbConsumer = new gcp.compute.ForwardingRule("psc_ilb_consumer", {
 *     name: "psc-ilb-consumer-forwarding-rule",
 *     region: "us-west2",
 *     target: pscIlbServiceAttachment.id,
 *     loadBalancingScheme: "",
 *     network: "default",
 *     ipAddress: pscIlbConsumerAddress.id,
 * });
 * ```
 * ### Service Attachment Explicit Networks
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const pscIlbConsumerNetwork = new gcp.compute.Network("psc_ilb_consumer_network", {
 *     name: "psc-ilb-consumer-network",
 *     autoCreateSubnetworks: false,
 * });
 * const producerServiceHealthCheck = new gcp.compute.HealthCheck("producer_service_health_check", {
 *     name: "producer-service-health-check",
 *     checkIntervalSec: 1,
 *     timeoutSec: 1,
 *     tcpHealthCheck: {
 *         port: 80,
 *     },
 * });
 * const producerServiceBackend = new gcp.compute.RegionBackendService("producer_service_backend", {
 *     name: "producer-service",
 *     region: "us-west2",
 *     healthChecks: producerServiceHealthCheck.id,
 * });
 * const pscIlbNetwork = new gcp.compute.Network("psc_ilb_network", {
 *     name: "psc-ilb-network",
 *     autoCreateSubnetworks: false,
 * });
 * const pscIlbProducerSubnetwork = new gcp.compute.Subnetwork("psc_ilb_producer_subnetwork", {
 *     name: "psc-ilb-producer-subnetwork",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     ipCidrRange: "10.0.0.0/16",
 * });
 * const pscIlbTargetService = new gcp.compute.ForwardingRule("psc_ilb_target_service", {
 *     name: "producer-forwarding-rule",
 *     region: "us-west2",
 *     loadBalancingScheme: "INTERNAL",
 *     backendService: producerServiceBackend.id,
 *     allPorts: true,
 *     network: pscIlbNetwork.name,
 *     subnetwork: pscIlbProducerSubnetwork.name,
 * });
 * const pscIlbNat = new gcp.compute.Subnetwork("psc_ilb_nat", {
 *     name: "psc-ilb-nat",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     purpose: "PRIVATE_SERVICE_CONNECT",
 *     ipCidrRange: "10.1.0.0/16",
 * });
 * const pscIlbServiceAttachment = new gcp.compute.ServiceAttachment("psc_ilb_service_attachment", {
 *     name: "my-psc-ilb",
 *     region: "us-west2",
 *     description: "A service attachment configured with Terraform",
 *     enableProxyProtocol: false,
 *     connectionPreference: "ACCEPT_MANUAL",
 *     natSubnets: [pscIlbNat.id],
 *     targetService: pscIlbTargetService.id,
 *     consumerAcceptLists: [{
 *         networkUrl: pscIlbConsumerNetwork.selfLink,
 *         connectionLimit: 1,
 *     }],
 * });
 * const pscIlbConsumerSubnetwork = new gcp.compute.Subnetwork("psc_ilb_consumer_subnetwork", {
 *     name: "psc-ilb-consumer-network",
 *     ipCidrRange: "10.0.0.0/16",
 *     region: "us-west2",
 *     network: pscIlbConsumerNetwork.id,
 * });
 * const pscIlbConsumerAddress = new gcp.compute.Address("psc_ilb_consumer_address", {
 *     name: "psc-ilb-consumer-address",
 *     region: "us-west2",
 *     subnetwork: pscIlbConsumerSubnetwork.id,
 *     addressType: "INTERNAL",
 * });
 * const pscIlbConsumer = new gcp.compute.ForwardingRule("psc_ilb_consumer", {
 *     name: "psc-ilb-consumer-forwarding-rule",
 *     region: "us-west2",
 *     target: pscIlbServiceAttachment.id,
 *     loadBalancingScheme: "",
 *     network: pscIlbConsumerNetwork.id,
 *     subnetwork: pscIlbConsumerSubnetwork.id,
 *     ipAddress: pscIlbConsumerAddress.id,
 * });
 * ```
 * ### Service Attachment Reconcile Connections
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const producerServiceHealthCheck = new gcp.compute.HealthCheck("producer_service_health_check", {
 *     name: "producer-service-health-check",
 *     checkIntervalSec: 1,
 *     timeoutSec: 1,
 *     tcpHealthCheck: {
 *         port: 80,
 *     },
 * });
 * const producerServiceBackend = new gcp.compute.RegionBackendService("producer_service_backend", {
 *     name: "producer-service",
 *     region: "us-west2",
 *     healthChecks: producerServiceHealthCheck.id,
 * });
 * const pscIlbNetwork = new gcp.compute.Network("psc_ilb_network", {
 *     name: "psc-ilb-network",
 *     autoCreateSubnetworks: false,
 * });
 * const pscIlbProducerSubnetwork = new gcp.compute.Subnetwork("psc_ilb_producer_subnetwork", {
 *     name: "psc-ilb-producer-subnetwork",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     ipCidrRange: "10.0.0.0/16",
 * });
 * const pscIlbTargetService = new gcp.compute.ForwardingRule("psc_ilb_target_service", {
 *     name: "producer-forwarding-rule",
 *     region: "us-west2",
 *     loadBalancingScheme: "INTERNAL",
 *     backendService: producerServiceBackend.id,
 *     allPorts: true,
 *     network: pscIlbNetwork.name,
 *     subnetwork: pscIlbProducerSubnetwork.name,
 * });
 * const pscIlbNat = new gcp.compute.Subnetwork("psc_ilb_nat", {
 *     name: "psc-ilb-nat",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     purpose: "PRIVATE_SERVICE_CONNECT",
 *     ipCidrRange: "10.1.0.0/16",
 * });
 * const pscIlbServiceAttachment = new gcp.compute.ServiceAttachment("psc_ilb_service_attachment", {
 *     name: "my-psc-ilb",
 *     region: "us-west2",
 *     description: "A service attachment configured with Terraform",
 *     domainNames: ["gcp.tfacc.hashicorptest.com."],
 *     enableProxyProtocol: true,
 *     connectionPreference: "ACCEPT_MANUAL",
 *     natSubnets: [pscIlbNat.id],
 *     targetService: pscIlbTargetService.id,
 *     consumerRejectLists: [
 *         "673497134629",
 *         "482878270665",
 *     ],
 *     consumerAcceptLists: [{
 *         projectIdOrNum: "658859330310",
 *         connectionLimit: 4,
 *     }],
 *     reconcileConnections: false,
 * });
 * ```
 * ### Service Attachment Tunneling Config
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const producerServiceHealthCheck = new gcp.compute.HealthCheck("producer_service_health_check", {
 *     name: "producer-service-health-check",
 *     checkIntervalSec: 1,
 *     timeoutSec: 1,
 *     tcpHealthCheck: {
 *         port: 80,
 *     },
 * });
 * const producerServiceBackend = new gcp.compute.RegionBackendService("producer_service_backend", {
 *     name: "producer-service",
 *     region: "us-west2",
 *     healthChecks: producerServiceHealthCheck.id,
 * });
 * const pscIlbNetwork = new gcp.compute.Network("psc_ilb_network", {
 *     name: "psc-ilb-network",
 *     autoCreateSubnetworks: false,
 * });
 * const pscIlbProducerSubnetwork = new gcp.compute.Subnetwork("psc_ilb_producer_subnetwork", {
 *     name: "psc-ilb-producer-subnetwork",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     ipCidrRange: "10.0.0.0/16",
 * });
 * const pscIlbTargetService = new gcp.compute.ForwardingRule("psc_ilb_target_service", {
 *     name: "producer-forwarding-rule",
 *     region: "us-west2",
 *     loadBalancingScheme: "INTERNAL",
 *     backendService: producerServiceBackend.id,
 *     allPorts: true,
 *     network: pscIlbNetwork.name,
 *     subnetwork: pscIlbProducerSubnetwork.name,
 * });
 * const pscIlbNat = new gcp.compute.Subnetwork("psc_ilb_nat", {
 *     name: "psc-ilb-nat",
 *     region: "us-west2",
 *     network: pscIlbNetwork.id,
 *     purpose: "PRIVATE_SERVICE_CONNECT",
 *     ipCidrRange: "10.1.0.0/16",
 * });
 * const pscIlbServiceAttachment = new gcp.compute.ServiceAttachment("psc_ilb_service_attachment", {
 *     name: "my-psc-ilb",
 *     region: "us-west2",
 *     description: "A service attachment configured with tunneling",
 *     enableProxyProtocol: false,
 *     connectionPreference: "ACCEPT_AUTOMATIC",
 *     natSubnets: [pscIlbNat.id],
 *     targetService: pscIlbTargetService.id,
 *     tunnelingConfig: {
 *         routingMode: "REGIONAL",
 *         encapsulationProfile: "IPV4",
 *     },
 * });
 * ```
 * ### Service Attachment Cross Region Ilb
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const healthCheck = new gcp.compute.HealthCheck("health_check", {
 *     name: "sa",
 *     checkIntervalSec: 1,
 *     timeoutSec: 1,
 *     tcpHealthCheck: {
 *         port: 80,
 *     },
 * });
 * const backendService = new gcp.compute.BackendService("backend_service", {
 *     name: "sa",
 *     loadBalancingScheme: "INTERNAL_MANAGED",
 *     healthChecks: healthCheck.id,
 * });
 * const urlMap = new gcp.compute.URLMap("url_map", {
 *     name: "sa",
 *     description: "Url map.",
 *     defaultService: backendService.id,
 * });
 * const httpProxy = new gcp.compute.TargetHttpProxy("http_proxy", {
 *     name: "sa",
 *     description: "a description",
 *     urlMap: urlMap.id,
 * });
 * const network = new gcp.compute.Network("network", {
 *     name: "sa",
 *     autoCreateSubnetworks: false,
 * });
 * const subnetworkProxy = new gcp.compute.Subnetwork("subnetwork_proxy", {
 *     name: "sa-proxy",
 *     region: "us-central1",
 *     network: network.id,
 *     purpose: "GLOBAL_MANAGED_PROXY",
 *     role: "ACTIVE",
 *     ipCidrRange: "10.2.0.0/16",
 * });
 * const subnetwork = new gcp.compute.Subnetwork("subnetwork", {
 *     name: "sa",
 *     region: "us-central1",
 *     network: network.id,
 *     ipCidrRange: "10.0.0.0/16",
 * });
 * const forwardingRule = new gcp.compute.GlobalForwardingRule("forwarding_rule", {
 *     name: "sa",
 *     target: httpProxy.id,
 *     network: network.id,
 *     subnetwork: subnetwork.id,
 *     portRange: "80",
 *     loadBalancingScheme: "INTERNAL_MANAGED",
 * }, {
 *     dependsOn: [subnetworkProxy],
 * });
 * const subnetworkPsc = new gcp.compute.Subnetwork("subnetwork_psc", {
 *     name: "sa-psc",
 *     region: "us-central1",
 *     network: network.id,
 *     purpose: "PRIVATE_SERVICE_CONNECT",
 *     ipCidrRange: "10.1.0.0/16",
 * });
 * const pscIlbServiceAttachment = new gcp.compute.ServiceAttachment("psc_ilb_service_attachment", {
 *     name: "sa",
 *     region: "us-central1",
 *     description: "A service attachment configured with Terraform",
 *     connectionPreference: "ACCEPT_AUTOMATIC",
 *     enableProxyProtocol: false,
 *     natSubnets: [subnetworkPsc.id],
 *     targetService: forwardingRule.id,
 * });
 * ```
 *
 * ## Import
 *
 * ServiceAttachment can be imported using any of these accepted formats:
 *
 * * `projects/{{project}}/regions/{{region}}/serviceAttachments/{{name}}`
 *
 * * `{{project}}/{{region}}/{{name}}`
 *
 * * `{{region}}/{{name}}`
 *
 * * `{{name}}`
 *
 * When using the `pulumi import` command, ServiceAttachment can be imported using one of the formats above. For example:
 *
 * ```sh
 * $ pulumi import gcp:compute/serviceAttachment:ServiceAttachment default projects/{{project}}/regions/{{region}}/serviceAttachments/{{name}}
 * ```
 *
 * ```sh
 * $ pulumi import gcp:compute/serviceAttachment:ServiceAttachment default {{project}}/{{region}}/{{name}}
 * ```
 *
 * ```sh
 * $ pulumi import gcp:compute/serviceAttachment:ServiceAttachment default {{region}}/{{name}}
 * ```
 *
 * ```sh
 * $ pulumi import gcp:compute/serviceAttachment:ServiceAttachment default {{name}}
 * ```
 */
export declare class ServiceAttachment extends pulumi.CustomResource {
    /**
     * Get an existing ServiceAttachment resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: ServiceAttachmentState, opts?: pulumi.CustomResourceOptions): ServiceAttachment;
    /**
     * Returns true if the given object is an instance of ServiceAttachment.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is ServiceAttachment;
    /**
     * An array of the consumer forwarding rules connected to this service
     * attachment.
     * Structure is documented below.
     */
    readonly connectedEndpoints: pulumi.Output<outputs.compute.ServiceAttachmentConnectedEndpoint[]>;
    /**
     * The connection preference to use for this service attachment. Valid
     * values include "ACCEPT_AUTOMATIC", "ACCEPT_MANUAL".
     */
    readonly connectionPreference: pulumi.Output<string>;
    /**
     * An array of projects that are allowed to connect to this service
     * attachment.
     * Structure is documented below.
     */
    readonly consumerAcceptLists: pulumi.Output<outputs.compute.ServiceAttachmentConsumerAcceptList[] | undefined>;
    /**
     * An array of projects that are not allowed to connect to this service
     * attachment.
     */
    readonly consumerRejectLists: pulumi.Output<string[] | undefined>;
    /**
     * An optional description of this resource.
     */
    readonly description: pulumi.Output<string | undefined>;
    /**
     * If specified, the domain name will be used during the integration between
     * the PSC connected endpoints and the Cloud DNS. For example, this is a
     * valid domain name: "p.mycompany.com.". Current max number of domain names
     * supported is 1.
     */
    readonly domainNames: pulumi.Output<string[] | undefined>;
    /**
     * If true, enable the proxy protocol which is for supplying client TCP/IP
     * address data in TCP connections that traverse proxies on their way to
     * destination servers.
     */
    readonly enableProxyProtocol: pulumi.Output<boolean>;
    /**
     * Fingerprint of this resource. This field is used internally during
     * updates of this resource.
     */
    readonly fingerprint: pulumi.Output<string>;
    /**
     * Name of the resource. The name must be 1-63 characters long, and
     * comply with RFC1035. Specifically, the name must be 1-63 characters
     * long and match the regular expression `a-z?`
     * which means the first character must be a lowercase letter, and all
     * following characters must be a dash, lowercase letter, or digit,
     * except the last character, which cannot be a dash.
     */
    readonly name: pulumi.Output<string>;
    /**
     * An array of subnets that is provided for NAT in this service attachment.
     */
    readonly natSubnets: pulumi.Output<string[]>;
    /**
     * The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    readonly project: pulumi.Output<string>;
    /**
     * The number of consumer spokes that connected Private Service Connect endpoints can be propagated to through Network Connectivity Center.
     * This limit lets the service producer limit how many propagated Private Service Connect connections can be established to this service attachment from a single consumer.
     * If the connection preference of the service attachment is ACCEPT_MANUAL, the limit applies to each project or network that is listed in the consumer accept list.
     * If the connection preference of the service attachment is ACCEPT_AUTOMATIC, the limit applies to each project that contains a connected endpoint.
     * If unspecified, the default propagated connection limit is 250. To explicitly send a zero value, set `sendPropagatedConnectionLimitIfZero = true`.
     */
    readonly propagatedConnectionLimit: pulumi.Output<number>;
    /**
     * An 128-bit global unique ID of the PSC service attachment.
     * Structure is documented below.
     */
    readonly pscServiceAttachmentIds: pulumi.Output<outputs.compute.ServiceAttachmentPscServiceAttachmentId[]>;
    /**
     * This flag determines whether a consumer accept/reject list change can reconcile the statuses of existing ACCEPTED or REJECTED PSC endpoints.
     * If false, connection policy update will only affect existing PENDING PSC endpoints. Existing ACCEPTED/REJECTED endpoints will remain untouched regardless how the connection policy is modified .
     * If true, update will affect both PENDING and ACCEPTED/REJECTED PSC endpoints. For example, an ACCEPTED PSC endpoint will be moved to REJECTED if its project is added to the reject list.
     */
    readonly reconcileConnections: pulumi.Output<boolean>;
    /**
     * URL of the region where the resource resides.
     */
    readonly region: pulumi.Output<string>;
    /**
     * The URI of the created resource.
     */
    readonly selfLink: pulumi.Output<string>;
    /**
     * Controls the behavior of propagated_connection_limit.
     * When false, setting propagatedConnectionLimit to zero causes the provider to use to the API's default value.
     * When true, the provider will set propagatedConnectionLimit to zero.
     * Defaults to false.
     */
    readonly sendPropagatedConnectionLimitIfZero: pulumi.Output<boolean | undefined>;
    /**
     * If true, show NAT IPs of all connected endpoints.
     */
    readonly showNatIps: pulumi.Output<boolean | undefined>;
    /**
     * The URL of a service serving the endpoint identified by this service attachment.
     */
    readonly targetService: pulumi.Output<string>;
    /**
     * Tunneling configuration for this service attachment.
     * Structure is documented below.
     */
    readonly tunnelingConfig: pulumi.Output<outputs.compute.ServiceAttachmentTunnelingConfig | undefined>;
    /**
     * Create a ServiceAttachment resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: ServiceAttachmentArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering ServiceAttachment resources.
 */
export interface ServiceAttachmentState {
    /**
     * An array of the consumer forwarding rules connected to this service
     * attachment.
     * Structure is documented below.
     */
    connectedEndpoints?: pulumi.Input<pulumi.Input<inputs.compute.ServiceAttachmentConnectedEndpoint>[]>;
    /**
     * The connection preference to use for this service attachment. Valid
     * values include "ACCEPT_AUTOMATIC", "ACCEPT_MANUAL".
     */
    connectionPreference?: pulumi.Input<string>;
    /**
     * An array of projects that are allowed to connect to this service
     * attachment.
     * Structure is documented below.
     */
    consumerAcceptLists?: pulumi.Input<pulumi.Input<inputs.compute.ServiceAttachmentConsumerAcceptList>[]>;
    /**
     * An array of projects that are not allowed to connect to this service
     * attachment.
     */
    consumerRejectLists?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * An optional description of this resource.
     */
    description?: pulumi.Input<string>;
    /**
     * If specified, the domain name will be used during the integration between
     * the PSC connected endpoints and the Cloud DNS. For example, this is a
     * valid domain name: "p.mycompany.com.". Current max number of domain names
     * supported is 1.
     */
    domainNames?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * If true, enable the proxy protocol which is for supplying client TCP/IP
     * address data in TCP connections that traverse proxies on their way to
     * destination servers.
     */
    enableProxyProtocol?: pulumi.Input<boolean>;
    /**
     * Fingerprint of this resource. This field is used internally during
     * updates of this resource.
     */
    fingerprint?: pulumi.Input<string>;
    /**
     * Name of the resource. The name must be 1-63 characters long, and
     * comply with RFC1035. Specifically, the name must be 1-63 characters
     * long and match the regular expression `a-z?`
     * which means the first character must be a lowercase letter, and all
     * following characters must be a dash, lowercase letter, or digit,
     * except the last character, which cannot be a dash.
     */
    name?: pulumi.Input<string>;
    /**
     * An array of subnets that is provided for NAT in this service attachment.
     */
    natSubnets?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    project?: pulumi.Input<string>;
    /**
     * The number of consumer spokes that connected Private Service Connect endpoints can be propagated to through Network Connectivity Center.
     * This limit lets the service producer limit how many propagated Private Service Connect connections can be established to this service attachment from a single consumer.
     * If the connection preference of the service attachment is ACCEPT_MANUAL, the limit applies to each project or network that is listed in the consumer accept list.
     * If the connection preference of the service attachment is ACCEPT_AUTOMATIC, the limit applies to each project that contains a connected endpoint.
     * If unspecified, the default propagated connection limit is 250. To explicitly send a zero value, set `sendPropagatedConnectionLimitIfZero = true`.
     */
    propagatedConnectionLimit?: pulumi.Input<number>;
    /**
     * An 128-bit global unique ID of the PSC service attachment.
     * Structure is documented below.
     */
    pscServiceAttachmentIds?: pulumi.Input<pulumi.Input<inputs.compute.ServiceAttachmentPscServiceAttachmentId>[]>;
    /**
     * This flag determines whether a consumer accept/reject list change can reconcile the statuses of existing ACCEPTED or REJECTED PSC endpoints.
     * If false, connection policy update will only affect existing PENDING PSC endpoints. Existing ACCEPTED/REJECTED endpoints will remain untouched regardless how the connection policy is modified .
     * If true, update will affect both PENDING and ACCEPTED/REJECTED PSC endpoints. For example, an ACCEPTED PSC endpoint will be moved to REJECTED if its project is added to the reject list.
     */
    reconcileConnections?: pulumi.Input<boolean>;
    /**
     * URL of the region where the resource resides.
     */
    region?: pulumi.Input<string>;
    /**
     * The URI of the created resource.
     */
    selfLink?: pulumi.Input<string>;
    /**
     * Controls the behavior of propagated_connection_limit.
     * When false, setting propagatedConnectionLimit to zero causes the provider to use to the API's default value.
     * When true, the provider will set propagatedConnectionLimit to zero.
     * Defaults to false.
     */
    sendPropagatedConnectionLimitIfZero?: pulumi.Input<boolean>;
    /**
     * If true, show NAT IPs of all connected endpoints.
     */
    showNatIps?: pulumi.Input<boolean>;
    /**
     * The URL of a service serving the endpoint identified by this service attachment.
     */
    targetService?: pulumi.Input<string>;
    /**
     * Tunneling configuration for this service attachment.
     * Structure is documented below.
     */
    tunnelingConfig?: pulumi.Input<inputs.compute.ServiceAttachmentTunnelingConfig>;
}
/**
 * The set of arguments for constructing a ServiceAttachment resource.
 */
export interface ServiceAttachmentArgs {
    /**
     * The connection preference to use for this service attachment. Valid
     * values include "ACCEPT_AUTOMATIC", "ACCEPT_MANUAL".
     */
    connectionPreference: pulumi.Input<string>;
    /**
     * An array of projects that are allowed to connect to this service
     * attachment.
     * Structure is documented below.
     */
    consumerAcceptLists?: pulumi.Input<pulumi.Input<inputs.compute.ServiceAttachmentConsumerAcceptList>[]>;
    /**
     * An array of projects that are not allowed to connect to this service
     * attachment.
     */
    consumerRejectLists?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * An optional description of this resource.
     */
    description?: pulumi.Input<string>;
    /**
     * If specified, the domain name will be used during the integration between
     * the PSC connected endpoints and the Cloud DNS. For example, this is a
     * valid domain name: "p.mycompany.com.". Current max number of domain names
     * supported is 1.
     */
    domainNames?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * If true, enable the proxy protocol which is for supplying client TCP/IP
     * address data in TCP connections that traverse proxies on their way to
     * destination servers.
     */
    enableProxyProtocol: pulumi.Input<boolean>;
    /**
     * Name of the resource. The name must be 1-63 characters long, and
     * comply with RFC1035. Specifically, the name must be 1-63 characters
     * long and match the regular expression `a-z?`
     * which means the first character must be a lowercase letter, and all
     * following characters must be a dash, lowercase letter, or digit,
     * except the last character, which cannot be a dash.
     */
    name?: pulumi.Input<string>;
    /**
     * An array of subnets that is provided for NAT in this service attachment.
     */
    natSubnets: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    project?: pulumi.Input<string>;
    /**
     * The number of consumer spokes that connected Private Service Connect endpoints can be propagated to through Network Connectivity Center.
     * This limit lets the service producer limit how many propagated Private Service Connect connections can be established to this service attachment from a single consumer.
     * If the connection preference of the service attachment is ACCEPT_MANUAL, the limit applies to each project or network that is listed in the consumer accept list.
     * If the connection preference of the service attachment is ACCEPT_AUTOMATIC, the limit applies to each project that contains a connected endpoint.
     * If unspecified, the default propagated connection limit is 250. To explicitly send a zero value, set `sendPropagatedConnectionLimitIfZero = true`.
     */
    propagatedConnectionLimit?: pulumi.Input<number>;
    /**
     * This flag determines whether a consumer accept/reject list change can reconcile the statuses of existing ACCEPTED or REJECTED PSC endpoints.
     * If false, connection policy update will only affect existing PENDING PSC endpoints. Existing ACCEPTED/REJECTED endpoints will remain untouched regardless how the connection policy is modified .
     * If true, update will affect both PENDING and ACCEPTED/REJECTED PSC endpoints. For example, an ACCEPTED PSC endpoint will be moved to REJECTED if its project is added to the reject list.
     */
    reconcileConnections?: pulumi.Input<boolean>;
    /**
     * URL of the region where the resource resides.
     */
    region?: pulumi.Input<string>;
    /**
     * Controls the behavior of propagated_connection_limit.
     * When false, setting propagatedConnectionLimit to zero causes the provider to use to the API's default value.
     * When true, the provider will set propagatedConnectionLimit to zero.
     * Defaults to false.
     */
    sendPropagatedConnectionLimitIfZero?: pulumi.Input<boolean>;
    /**
     * If true, show NAT IPs of all connected endpoints.
     */
    showNatIps?: pulumi.Input<boolean>;
    /**
     * The URL of a service serving the endpoint identified by this service attachment.
     */
    targetService: pulumi.Input<string>;
    /**
     * Tunneling configuration for this service attachment.
     * Structure is documented below.
     */
    tunnelingConfig?: pulumi.Input<inputs.compute.ServiceAttachmentTunnelingConfig>;
}
