export declare const DnsKeySpecAlgorithm: {
    readonly Rsasha1: "rsasha1";
    readonly Rsasha256: "rsasha256";
    readonly Rsasha512: "rsasha512";
    readonly Ecdsap256sha256: "ecdsap256sha256";
    readonly Ecdsap384sha384: "ecdsap384sha384";
};
/**
 * String mnemonic specifying the DNSSEC algorithm of this key.
 */
export type DnsKeySpecAlgorithm = (typeof DnsKeySpecAlgorithm)[keyof typeof DnsKeySpecAlgorithm];
export declare const DnsKeySpecKeyType: {
    readonly KeySigning: "keySigning";
    readonly ZoneSigning: "zoneSigning";
};
/**
 * Specifies whether this is a key signing key (KSK) or a zone signing key (ZSK). Key signing keys have the Secure Entry Point flag set and, when active, are only used to sign resource record sets of type DNSKEY. Zone signing keys do not have the Secure Entry Point flag set and are used to sign all other types of resource record sets.
 */
export type DnsKeySpecKeyType = (typeof DnsKeySpecKeyType)[keyof typeof DnsKeySpecKeyType];
export declare const GoogleIamV1AuditLogConfigLogType: {
    /**
     * Default case. Should never be this.
     */
    readonly LogTypeUnspecified: "LOG_TYPE_UNSPECIFIED";
    /**
     * Admin reads. Example: CloudIAM getIamPolicy
     */
    readonly AdminRead: "ADMIN_READ";
    /**
     * Data writes. Example: CloudSQL Users create
     */
    readonly DataWrite: "DATA_WRITE";
    /**
     * Data reads. Example: CloudSQL Users list
     */
    readonly DataRead: "DATA_READ";
};
/**
 * The log type that this config enables.
 */
export type GoogleIamV1AuditLogConfigLogType = (typeof GoogleIamV1AuditLogConfigLogType)[keyof typeof GoogleIamV1AuditLogConfigLogType];
export declare const ManagedZoneDnsSecConfigNonExistence: {
    readonly Nsec: "nsec";
    readonly Nsec3: "nsec3";
};
/**
 * Specifies the mechanism for authenticated denial-of-existence responses. Can only be changed while the state is OFF.
 */
export type ManagedZoneDnsSecConfigNonExistence = (typeof ManagedZoneDnsSecConfigNonExistence)[keyof typeof ManagedZoneDnsSecConfigNonExistence];
export declare const ManagedZoneDnsSecConfigState: {
    /**
     * DNSSEC is disabled; the zone is not signed.
     */
    readonly Off: "off";
    /**
     * DNSSEC is enabled; the zone is signed and fully managed.
     */
    readonly On: "on";
    /**
     * DNSSEC is enabled, but in a "transfer" mode.
     */
    readonly Transfer: "transfer";
};
/**
 * Specifies whether DNSSEC is enabled, and what mode it is in.
 */
export type ManagedZoneDnsSecConfigState = (typeof ManagedZoneDnsSecConfigState)[keyof typeof ManagedZoneDnsSecConfigState];
export declare const ManagedZoneForwardingConfigNameServerTargetForwardingPath: {
    /**
     * Cloud DNS makes forwarding decisions based on address ranges; that is, RFC1918 addresses forward to the target through the VPC and non-RFC1918 addresses forward to the target through the internet
     */
    readonly Default: "default";
    /**
     * Cloud DNS always forwards to this target through the VPC.
     */
    readonly Private: "private";
};
/**
 * Forwarding path for this NameServerTarget. If unset or set to DEFAULT, Cloud DNS makes forwarding decisions based on IP address ranges; that is, RFC1918 addresses go to the VPC network, non-RFC1918 addresses go to the internet. When set to PRIVATE, Cloud DNS always sends queries through the VPC network for this target.
 */
export type ManagedZoneForwardingConfigNameServerTargetForwardingPath = (typeof ManagedZoneForwardingConfigNameServerTargetForwardingPath)[keyof typeof ManagedZoneForwardingConfigNameServerTargetForwardingPath];
export declare const ManagedZoneVisibility: {
    readonly Public: "public";
    readonly Private: "private";
};
/**
 * The zone's visibility: public zones are exposed to the Internet, while private zones are visible only to Virtual Private Cloud resources.
 */
export type ManagedZoneVisibility = (typeof ManagedZoneVisibility)[keyof typeof ManagedZoneVisibility];
export declare const PolicyAlternativeNameServerConfigTargetNameServerForwardingPath: {
    /**
     * Cloud DNS makes forwarding decision based on IP address ranges; that is, RFC1918 addresses forward to the target through the VPC and non-RFC1918 addresses forward to the target through the internet
     */
    readonly Default: "default";
    /**
     * Cloud DNS always forwards to this target through the VPC.
     */
    readonly Private: "private";
};
/**
 * Forwarding path for this TargetNameServer. If unset or set to DEFAULT, Cloud DNS makes forwarding decisions based on address ranges; that is, RFC1918 addresses go to the VPC network, non-RFC1918 addresses go to the internet. When set to PRIVATE, Cloud DNS always sends queries through the VPC network for this target.
 */
export type PolicyAlternativeNameServerConfigTargetNameServerForwardingPath = (typeof PolicyAlternativeNameServerConfigTargetNameServerForwardingPath)[keyof typeof PolicyAlternativeNameServerConfigTargetNameServerForwardingPath];
export declare const RRSetRoutingPolicyLoadBalancerTargetIpProtocol: {
    readonly Undefined: "undefined";
    readonly Tcp: "tcp";
    readonly Udp: "udp";
};
/**
 * The protocol of the load balancer to health check.
 */
export type RRSetRoutingPolicyLoadBalancerTargetIpProtocol = (typeof RRSetRoutingPolicyLoadBalancerTargetIpProtocol)[keyof typeof RRSetRoutingPolicyLoadBalancerTargetIpProtocol];
export declare const RRSetRoutingPolicyLoadBalancerTargetLoadBalancerType: {
    readonly None: "none";
    readonly GlobalL7ilb: "globalL7ilb";
    readonly RegionalL4ilb: "regionalL4ilb";
    readonly RegionalL7ilb: "regionalL7ilb";
};
/**
 * The type of load balancer specified by this target. This value must match the configuration of the load balancer located at the LoadBalancerTarget's IP address, port, and region. Use the following: - *regionalL4ilb*: for a regional internal passthrough Network Load Balancer. - *regionalL7ilb*: for a regional internal Application Load Balancer. - *globalL7ilb*: for a global internal Application Load Balancer.
 */
export type RRSetRoutingPolicyLoadBalancerTargetLoadBalancerType = (typeof RRSetRoutingPolicyLoadBalancerTargetLoadBalancerType)[keyof typeof RRSetRoutingPolicyLoadBalancerTargetLoadBalancerType];
export declare const ResponsePolicyRuleBehavior: {
    readonly BehaviorUnspecified: "behaviorUnspecified";
    /**
     * Skip a less-specific ResponsePolicyRule and continue normal query logic. This can be used with a less-specific wildcard selector to exempt a subset of the wildcard ResponsePolicyRule from the ResponsePolicy behavior and query the public Internet instead. For instance, if these rules exist: *.example.com -> LocalData 1.2.3.4 foo.example.com -> Behavior 'bypassResponsePolicy' Then a query for 'foo.example.com' skips the wildcard. This additionally functions to facilitate the allowlist feature. RPZs can be applied to multiple levels in the (eventually org, folder, project, network) hierarchy. If a rule is applied at a higher level of the hierarchy, adding a passthru rule at a lower level will supersede that, and a query from an affected vm to that domain will be exempt from the RPZ and proceed to normal resolution behavior.
     */
    readonly BypassResponsePolicy: "bypassResponsePolicy";
};
/**
 * Answer this query with a behavior rather than DNS data.
 */
export type ResponsePolicyRuleBehavior = (typeof ResponsePolicyRuleBehavior)[keyof typeof ResponsePolicyRuleBehavior];