import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
/**
 * A Google Cloud Redis instance.
 *
 * To get more information about Instance, see:
 *
 * * [API documentation](https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances)
 * * How-to Guides
 *     * [Official Documentation](https://cloud.google.com/memorystore/docs/redis/)
 *
 * ## Example Usage
 *
 * ### Redis Instance Basic
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const cache = new gcp.redis.Instance("cache", {
 *     name: "memory-cache",
 *     memorySizeGb: 1,
 *     deletionProtection: false,
 * });
 * ```
 * ### Redis Instance Full
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * // This example assumes this network already exists.
 * // The API creates a tenant network per network authorized for a
 * // Redis instance and that network is not deleted when the user-created
 * // network (authorized_network) is deleted, so this prevents issues
 * // with tenant network quota.
 * // If this network hasn't been created and you are using this example in your
 * // config, add an additional network resource or change
 * // this from "data"to "resource"
 * const redis_network = gcp.compute.getNetwork({
 *     name: "redis-test-network",
 * });
 * const cache = new gcp.redis.Instance("cache", {
 *     name: "ha-memory-cache",
 *     tier: "STANDARD_HA",
 *     memorySizeGb: 1,
 *     locationId: "us-central1-a",
 *     alternativeLocationId: "us-central1-f",
 *     authorizedNetwork: redis_network.then(redis_network => redis_network.id),
 *     redisVersion: "REDIS_7_2",
 *     displayName: "Test Instance",
 *     reservedIpRange: "192.168.0.0/29",
 *     labels: {
 *         my_key: "my_val",
 *         other_key: "other_val",
 *     },
 *     maintenancePolicy: {
 *         weeklyMaintenanceWindows: [{
 *             day: "TUESDAY",
 *             startTime: {
 *                 hours: 0,
 *                 minutes: 30,
 *                 seconds: 0,
 *                 nanos: 0,
 *             },
 *         }],
 *     },
 * });
 * ```
 * ### Redis Instance Full With Persistence Config
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const cache_persis = new gcp.redis.Instance("cache-persis", {
 *     name: "ha-memory-cache-persis",
 *     tier: "STANDARD_HA",
 *     memorySizeGb: 1,
 *     locationId: "us-central1-a",
 *     alternativeLocationId: "us-central1-f",
 *     persistenceConfig: {
 *         persistenceMode: "RDB",
 *         rdbSnapshotPeriod: "TWELVE_HOURS",
 *     },
 * });
 * ```
 * ### Redis Instance Private Service
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * // This example assumes this network already exists.
 * // The API creates a tenant network per network authorized for a
 * // Redis instance and that network is not deleted when the user-created
 * // network (authorized_network) is deleted, so this prevents issues
 * // with tenant network quota.
 * // If this network hasn't been created and you are using this example in your
 * // config, add an additional network resource or change
 * // this from "data"to "resource"
 * const redis_network = new gcp.compute.Network("redis-network", {name: "redis-test-network"});
 * const serviceRange = new gcp.compute.GlobalAddress("service_range", {
 *     name: "address",
 *     purpose: "VPC_PEERING",
 *     addressType: "INTERNAL",
 *     prefixLength: 16,
 *     network: redis_network.id,
 * });
 * const privateServiceConnection = new gcp.servicenetworking.Connection("private_service_connection", {
 *     network: redis_network.id,
 *     service: "servicenetworking.googleapis.com",
 *     reservedPeeringRanges: [serviceRange.name],
 * });
 * const cache = new gcp.redis.Instance("cache", {
 *     name: "private-cache",
 *     tier: "STANDARD_HA",
 *     memorySizeGb: 1,
 *     locationId: "us-central1-a",
 *     alternativeLocationId: "us-central1-f",
 *     authorizedNetwork: redis_network.id,
 *     connectMode: "PRIVATE_SERVICE_ACCESS",
 *     redisVersion: "REDIS_7_2",
 *     displayName: "Test Instance",
 * }, {
 *     dependsOn: [privateServiceConnection],
 * });
 * ```
 * ### Redis Instance Mrr
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * // This example assumes this network already exists.
 * // The API creates a tenant network per network authorized for a
 * // Redis instance and that network is not deleted when the user-created
 * // network (authorized_network) is deleted, so this prevents issues
 * // with tenant network quota.
 * // If this network hasn't been created and you are using this example in your
 * // config, add an additional network resource or change
 * // this from "data"to "resource"
 * const redis_network = gcp.compute.getNetwork({
 *     name: "redis-test-network",
 * });
 * const cache = new gcp.redis.Instance("cache", {
 *     name: "mrr-memory-cache",
 *     tier: "STANDARD_HA",
 *     memorySizeGb: 5,
 *     locationId: "us-central1-a",
 *     alternativeLocationId: "us-central1-f",
 *     authorizedNetwork: redis_network.then(redis_network => redis_network.id),
 *     redisVersion: "REDIS_7_2",
 *     displayName: "Terraform Test Instance",
 *     replicaCount: 5,
 *     readReplicasMode: "READ_REPLICAS_ENABLED",
 *     labels: {
 *         my_key: "my_val",
 *         other_key: "other_val",
 *     },
 * });
 * ```
 * ### Redis Instance Cmek
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const redisKeyring = new gcp.kms.KeyRing("redis_keyring", {
 *     name: "redis-keyring",
 *     location: "us-central1",
 * });
 * const redisKey = new gcp.kms.CryptoKey("redis_key", {
 *     name: "redis-key",
 *     keyRing: redisKeyring.id,
 * });
 * // This example assumes this network already exists.
 * // The API creates a tenant network per network authorized for a
 * // Redis instance and that network is not deleted when the user-created
 * // network (authorized_network) is deleted, so this prevents issues
 * // with tenant network quota.
 * // If this network hasn't been created and you are using this example in your
 * // config, add an additional network resource or change
 * // this from "data"to "resource"
 * const redis_network = gcp.compute.getNetwork({
 *     name: "redis-test-network",
 * });
 * const cache = new gcp.redis.Instance("cache", {
 *     name: "cmek-memory-cache",
 *     tier: "STANDARD_HA",
 *     memorySizeGb: 1,
 *     locationId: "us-central1-a",
 *     alternativeLocationId: "us-central1-f",
 *     authorizedNetwork: redis_network.then(redis_network => redis_network.id),
 *     redisVersion: "REDIS_7_2",
 *     displayName: "Terraform Test Instance",
 *     labels: {
 *         my_key: "my_val",
 *         other_key: "other_val",
 *     },
 *     customerManagedKey: redisKey.id,
 * });
 * ```
 *
 * ## Import
 *
 * Instance can be imported using any of these accepted formats:
 *
 * * `projects/{{project}}/locations/{{region}}/instances/{{name}}`
 *
 * * `{{project}}/{{region}}/{{name}}`
 *
 * * `{{region}}/{{name}}`
 *
 * * `{{name}}`
 *
 * When using the `pulumi import` command, Instance can be imported using one of the formats above. For example:
 *
 * ```sh
 * $ pulumi import gcp:redis/instance:Instance default projects/{{project}}/locations/{{region}}/instances/{{name}}
 * ```
 *
 * ```sh
 * $ pulumi import gcp:redis/instance:Instance default {{project}}/{{region}}/{{name}}
 * ```
 *
 * ```sh
 * $ pulumi import gcp:redis/instance:Instance default {{region}}/{{name}}
 * ```
 *
 * ```sh
 * $ pulumi import gcp:redis/instance:Instance default {{name}}
 * ```
 */
export declare class Instance extends pulumi.CustomResource {
    /**
     * Get an existing Instance 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?: InstanceState, opts?: pulumi.CustomResourceOptions): Instance;
    /**
     * Returns true if the given object is an instance of Instance.  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 Instance;
    /**
     * Only applicable to STANDARD_HA tier which protects the instance
     * against zonal failures by provisioning it across two zones.
     * If provided, it must be a different zone from the one provided in
     * [locationId].
     */
    readonly alternativeLocationId: pulumi.Output<string>;
    /**
     * Optional. Indicates whether OSS Redis AUTH is enabled for the
     * instance. If set to "true" AUTH is enabled on the instance.
     * Default value is "false" meaning AUTH is disabled.
     */
    readonly authEnabled: pulumi.Output<boolean | undefined>;
    /**
     * AUTH String set on the instance. This field will only be populated if authEnabled is true.
     */
    readonly authString: pulumi.Output<string>;
    /**
     * The full name of the Google Compute Engine network to which the
     * instance is connected. If left unspecified, the default network
     * will be used.
     */
    readonly authorizedNetwork: pulumi.Output<string>;
    /**
     * The connection mode of the Redis instance.
     * Default value is `DIRECT_PEERING`.
     * Possible values are: `DIRECT_PEERING`, `PRIVATE_SERVICE_ACCESS`.
     */
    readonly connectMode: pulumi.Output<string | undefined>;
    /**
     * (Output)
     * The time when the certificate was created.
     */
    readonly createTime: pulumi.Output<string>;
    /**
     * The current zone where the Redis endpoint is placed.
     * For Basic Tier instances, this will always be the same as the
     * [locationId] provided by the user at creation time. For Standard Tier
     * instances, this can be either [locationId] or [alternativeLocationId]
     * and can change after a failover event.
     */
    readonly currentLocationId: pulumi.Output<string>;
    /**
     * Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis
     * instance. If this is provided, CMEK is enabled.
     */
    readonly customerManagedKey: pulumi.Output<string | undefined>;
    readonly deletionProtection: pulumi.Output<boolean | undefined>;
    /**
     * An arbitrary and optional user-provided name for the instance.
     */
    readonly displayName: pulumi.Output<string | undefined>;
    /**
     * All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
     */
    readonly effectiveLabels: pulumi.Output<{
        [key: string]: string;
    }>;
    /**
     * The CIDR range of internal addresses that are reserved for this
     * instance. If not provided, the service will choose an unused /29
     * block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be
     * unique and non-overlapping with existing subnets in an authorized
     * network.
     */
    readonly effectiveReservedIpRange: pulumi.Output<string>;
    /**
     * Hostname or IP address of the exposed Redis endpoint used by clients
     * to connect to the service.
     */
    readonly host: pulumi.Output<string>;
    /**
     * Resource labels to represent user provided metadata.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effectiveLabels` for all of the labels present on the resource.
     */
    readonly labels: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * The zone where the instance will be provisioned. If not provided,
     * the service will choose a zone for the instance. For STANDARD_HA tier,
     * instances will be created across two zones for protection against
     * zonal failures. If [alternativeLocationId] is also provided, it must
     * be different from [locationId].
     */
    readonly locationId: pulumi.Output<string>;
    /**
     * Maintenance policy for an instance.
     * Structure is documented below.
     */
    readonly maintenancePolicy: pulumi.Output<outputs.redis.InstanceMaintenancePolicy | undefined>;
    /**
     * Upcoming maintenance schedule.
     * Structure is documented below.
     */
    readonly maintenanceSchedules: pulumi.Output<outputs.redis.InstanceMaintenanceSchedule[]>;
    /**
     * The self service update maintenance version.
     */
    readonly maintenanceVersion: pulumi.Output<string>;
    /**
     * Redis memory size in GiB.
     */
    readonly memorySizeGb: pulumi.Output<number>;
    /**
     * The ID of the instance or a fully qualified identifier for the instance.
     */
    readonly name: pulumi.Output<string>;
    /**
     * Output only. Info per node.
     * Structure is documented below.
     */
    readonly nodes: pulumi.Output<outputs.redis.InstanceNode[]>;
    /**
     * Persistence configuration for an instance.
     * Structure is documented below.
     */
    readonly persistenceConfig: pulumi.Output<outputs.redis.InstancePersistenceConfig>;
    /**
     * Output only. Cloud IAM identity used by import / export operations
     * to transfer data to/from Cloud Storage. Format is "serviceAccount:".
     * The value may change over time for a given instance so should be
     * checked before each import/export operation.
     */
    readonly persistenceIamIdentity: pulumi.Output<string>;
    /**
     * The port number of the exposed Redis endpoint.
     */
    readonly port: pulumi.Output<number>;
    /**
     * 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 combination of labels configured directly on the resource
     * and default labels configured on the provider.
     */
    readonly pulumiLabels: pulumi.Output<{
        [key: string]: string;
    }>;
    /**
     * Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only.
     * Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes
     * will exhibit some lag behind the primary. Write requests must target 'host'.
     */
    readonly readEndpoint: pulumi.Output<string>;
    /**
     * Output only. The port number of the exposed readonly redis endpoint. Standard tier only.
     * Write requests should target 'port'.
     */
    readonly readEndpointPort: pulumi.Output<number>;
    /**
     * Optional. Read replica mode. Can only be specified when trying to create the instance.
     * If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.
     * - READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the
     * instance cannot scale up or down the number of replicas.
     * - READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance
     * can scale up and down the number of replicas.
     * Possible values are: `READ_REPLICAS_DISABLED`, `READ_REPLICAS_ENABLED`.
     */
    readonly readReplicasMode: pulumi.Output<string>;
    /**
     * Redis configuration parameters, according to http://redis.io/topics/config.
     * Please check Memorystore documentation for the list of supported parameters:
     * https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
     */
    readonly redisConfigs: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * The version of Redis software. If not provided, latest supported
     * version will be used. Please check the API documentation linked
     * at the top for the latest valid values.
     */
    readonly redisVersion: pulumi.Output<string>;
    /**
     * The name of the Redis region of the instance.
     */
    readonly region: pulumi.Output<string>;
    /**
     * Optional. The number of replica nodes. The valid range for the Standard Tier with
     * read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled
     * for a Standard Tier instance, the only valid value is 1 and the default is 1.
     * The valid value for basic tier is 0 and the default is also 0.
     */
    readonly replicaCount: pulumi.Output<number>;
    /**
     * The CIDR range of internal addresses that are reserved for this
     * instance. If not provided, the service will choose an unused /29
     * block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be
     * unique and non-overlapping with existing subnets in an authorized
     * network.
     */
    readonly reservedIpRange: pulumi.Output<string>;
    /**
     * Optional. Additional IP range for node placement. Required when enabling read replicas on
     * an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or
     * "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address
     * range associated with the private service access connection, or "auto".
     */
    readonly secondaryIpRange: pulumi.Output<string>;
    /**
     * List of server CA certificates for the instance.
     * Structure is documented below.
     */
    readonly serverCaCerts: pulumi.Output<outputs.redis.InstanceServerCaCert[]>;
    /**
     * The service tier of the instance. Must be one of these values:
     * - BASIC: standalone instance
     * - STANDARD_HA: highly available primary/replica instances
     * Default value is `BASIC`.
     * Possible values are: `BASIC`, `STANDARD_HA`.
     */
    readonly tier: pulumi.Output<string | undefined>;
    /**
     * The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.
     * - SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication
     * Default value is `DISABLED`.
     * Possible values are: `SERVER_AUTHENTICATION`, `DISABLED`.
     */
    readonly transitEncryptionMode: pulumi.Output<string | undefined>;
    /**
     * Create a Instance 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: InstanceArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering Instance resources.
 */
export interface InstanceState {
    /**
     * Only applicable to STANDARD_HA tier which protects the instance
     * against zonal failures by provisioning it across two zones.
     * If provided, it must be a different zone from the one provided in
     * [locationId].
     */
    alternativeLocationId?: pulumi.Input<string>;
    /**
     * Optional. Indicates whether OSS Redis AUTH is enabled for the
     * instance. If set to "true" AUTH is enabled on the instance.
     * Default value is "false" meaning AUTH is disabled.
     */
    authEnabled?: pulumi.Input<boolean>;
    /**
     * AUTH String set on the instance. This field will only be populated if authEnabled is true.
     */
    authString?: pulumi.Input<string>;
    /**
     * The full name of the Google Compute Engine network to which the
     * instance is connected. If left unspecified, the default network
     * will be used.
     */
    authorizedNetwork?: pulumi.Input<string>;
    /**
     * The connection mode of the Redis instance.
     * Default value is `DIRECT_PEERING`.
     * Possible values are: `DIRECT_PEERING`, `PRIVATE_SERVICE_ACCESS`.
     */
    connectMode?: pulumi.Input<string>;
    /**
     * (Output)
     * The time when the certificate was created.
     */
    createTime?: pulumi.Input<string>;
    /**
     * The current zone where the Redis endpoint is placed.
     * For Basic Tier instances, this will always be the same as the
     * [locationId] provided by the user at creation time. For Standard Tier
     * instances, this can be either [locationId] or [alternativeLocationId]
     * and can change after a failover event.
     */
    currentLocationId?: pulumi.Input<string>;
    /**
     * Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis
     * instance. If this is provided, CMEK is enabled.
     */
    customerManagedKey?: pulumi.Input<string>;
    deletionProtection?: pulumi.Input<boolean>;
    /**
     * An arbitrary and optional user-provided name for the instance.
     */
    displayName?: pulumi.Input<string>;
    /**
     * All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
     */
    effectiveLabels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The CIDR range of internal addresses that are reserved for this
     * instance. If not provided, the service will choose an unused /29
     * block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be
     * unique and non-overlapping with existing subnets in an authorized
     * network.
     */
    effectiveReservedIpRange?: pulumi.Input<string>;
    /**
     * Hostname or IP address of the exposed Redis endpoint used by clients
     * to connect to the service.
     */
    host?: pulumi.Input<string>;
    /**
     * Resource labels to represent user provided metadata.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effectiveLabels` for all of the labels present on the resource.
     */
    labels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The zone where the instance will be provisioned. If not provided,
     * the service will choose a zone for the instance. For STANDARD_HA tier,
     * instances will be created across two zones for protection against
     * zonal failures. If [alternativeLocationId] is also provided, it must
     * be different from [locationId].
     */
    locationId?: pulumi.Input<string>;
    /**
     * Maintenance policy for an instance.
     * Structure is documented below.
     */
    maintenancePolicy?: pulumi.Input<inputs.redis.InstanceMaintenancePolicy>;
    /**
     * Upcoming maintenance schedule.
     * Structure is documented below.
     */
    maintenanceSchedules?: pulumi.Input<pulumi.Input<inputs.redis.InstanceMaintenanceSchedule>[]>;
    /**
     * The self service update maintenance version.
     */
    maintenanceVersion?: pulumi.Input<string>;
    /**
     * Redis memory size in GiB.
     */
    memorySizeGb?: pulumi.Input<number>;
    /**
     * The ID of the instance or a fully qualified identifier for the instance.
     */
    name?: pulumi.Input<string>;
    /**
     * Output only. Info per node.
     * Structure is documented below.
     */
    nodes?: pulumi.Input<pulumi.Input<inputs.redis.InstanceNode>[]>;
    /**
     * Persistence configuration for an instance.
     * Structure is documented below.
     */
    persistenceConfig?: pulumi.Input<inputs.redis.InstancePersistenceConfig>;
    /**
     * Output only. Cloud IAM identity used by import / export operations
     * to transfer data to/from Cloud Storage. Format is "serviceAccount:".
     * The value may change over time for a given instance so should be
     * checked before each import/export operation.
     */
    persistenceIamIdentity?: pulumi.Input<string>;
    /**
     * The port number of the exposed Redis endpoint.
     */
    port?: pulumi.Input<number>;
    /**
     * 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 combination of labels configured directly on the resource
     * and default labels configured on the provider.
     */
    pulumiLabels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only.
     * Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes
     * will exhibit some lag behind the primary. Write requests must target 'host'.
     */
    readEndpoint?: pulumi.Input<string>;
    /**
     * Output only. The port number of the exposed readonly redis endpoint. Standard tier only.
     * Write requests should target 'port'.
     */
    readEndpointPort?: pulumi.Input<number>;
    /**
     * Optional. Read replica mode. Can only be specified when trying to create the instance.
     * If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.
     * - READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the
     * instance cannot scale up or down the number of replicas.
     * - READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance
     * can scale up and down the number of replicas.
     * Possible values are: `READ_REPLICAS_DISABLED`, `READ_REPLICAS_ENABLED`.
     */
    readReplicasMode?: pulumi.Input<string>;
    /**
     * Redis configuration parameters, according to http://redis.io/topics/config.
     * Please check Memorystore documentation for the list of supported parameters:
     * https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
     */
    redisConfigs?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The version of Redis software. If not provided, latest supported
     * version will be used. Please check the API documentation linked
     * at the top for the latest valid values.
     */
    redisVersion?: pulumi.Input<string>;
    /**
     * The name of the Redis region of the instance.
     */
    region?: pulumi.Input<string>;
    /**
     * Optional. The number of replica nodes. The valid range for the Standard Tier with
     * read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled
     * for a Standard Tier instance, the only valid value is 1 and the default is 1.
     * The valid value for basic tier is 0 and the default is also 0.
     */
    replicaCount?: pulumi.Input<number>;
    /**
     * The CIDR range of internal addresses that are reserved for this
     * instance. If not provided, the service will choose an unused /29
     * block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be
     * unique and non-overlapping with existing subnets in an authorized
     * network.
     */
    reservedIpRange?: pulumi.Input<string>;
    /**
     * Optional. Additional IP range for node placement. Required when enabling read replicas on
     * an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or
     * "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address
     * range associated with the private service access connection, or "auto".
     */
    secondaryIpRange?: pulumi.Input<string>;
    /**
     * List of server CA certificates for the instance.
     * Structure is documented below.
     */
    serverCaCerts?: pulumi.Input<pulumi.Input<inputs.redis.InstanceServerCaCert>[]>;
    /**
     * The service tier of the instance. Must be one of these values:
     * - BASIC: standalone instance
     * - STANDARD_HA: highly available primary/replica instances
     * Default value is `BASIC`.
     * Possible values are: `BASIC`, `STANDARD_HA`.
     */
    tier?: pulumi.Input<string>;
    /**
     * The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.
     * - SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication
     * Default value is `DISABLED`.
     * Possible values are: `SERVER_AUTHENTICATION`, `DISABLED`.
     */
    transitEncryptionMode?: pulumi.Input<string>;
}
/**
 * The set of arguments for constructing a Instance resource.
 */
export interface InstanceArgs {
    /**
     * Only applicable to STANDARD_HA tier which protects the instance
     * against zonal failures by provisioning it across two zones.
     * If provided, it must be a different zone from the one provided in
     * [locationId].
     */
    alternativeLocationId?: pulumi.Input<string>;
    /**
     * Optional. Indicates whether OSS Redis AUTH is enabled for the
     * instance. If set to "true" AUTH is enabled on the instance.
     * Default value is "false" meaning AUTH is disabled.
     */
    authEnabled?: pulumi.Input<boolean>;
    /**
     * The full name of the Google Compute Engine network to which the
     * instance is connected. If left unspecified, the default network
     * will be used.
     */
    authorizedNetwork?: pulumi.Input<string>;
    /**
     * The connection mode of the Redis instance.
     * Default value is `DIRECT_PEERING`.
     * Possible values are: `DIRECT_PEERING`, `PRIVATE_SERVICE_ACCESS`.
     */
    connectMode?: pulumi.Input<string>;
    /**
     * Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis
     * instance. If this is provided, CMEK is enabled.
     */
    customerManagedKey?: pulumi.Input<string>;
    deletionProtection?: pulumi.Input<boolean>;
    /**
     * An arbitrary and optional user-provided name for the instance.
     */
    displayName?: pulumi.Input<string>;
    /**
     * Resource labels to represent user provided metadata.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effectiveLabels` for all of the labels present on the resource.
     */
    labels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The zone where the instance will be provisioned. If not provided,
     * the service will choose a zone for the instance. For STANDARD_HA tier,
     * instances will be created across two zones for protection against
     * zonal failures. If [alternativeLocationId] is also provided, it must
     * be different from [locationId].
     */
    locationId?: pulumi.Input<string>;
    /**
     * Maintenance policy for an instance.
     * Structure is documented below.
     */
    maintenancePolicy?: pulumi.Input<inputs.redis.InstanceMaintenancePolicy>;
    /**
     * The self service update maintenance version.
     */
    maintenanceVersion?: pulumi.Input<string>;
    /**
     * Redis memory size in GiB.
     */
    memorySizeGb: pulumi.Input<number>;
    /**
     * The ID of the instance or a fully qualified identifier for the instance.
     */
    name?: pulumi.Input<string>;
    /**
     * Persistence configuration for an instance.
     * Structure is documented below.
     */
    persistenceConfig?: pulumi.Input<inputs.redis.InstancePersistenceConfig>;
    /**
     * The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    project?: pulumi.Input<string>;
    /**
     * Optional. Read replica mode. Can only be specified when trying to create the instance.
     * If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.
     * - READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the
     * instance cannot scale up or down the number of replicas.
     * - READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance
     * can scale up and down the number of replicas.
     * Possible values are: `READ_REPLICAS_DISABLED`, `READ_REPLICAS_ENABLED`.
     */
    readReplicasMode?: pulumi.Input<string>;
    /**
     * Redis configuration parameters, according to http://redis.io/topics/config.
     * Please check Memorystore documentation for the list of supported parameters:
     * https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
     */
    redisConfigs?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The version of Redis software. If not provided, latest supported
     * version will be used. Please check the API documentation linked
     * at the top for the latest valid values.
     */
    redisVersion?: pulumi.Input<string>;
    /**
     * The name of the Redis region of the instance.
     */
    region?: pulumi.Input<string>;
    /**
     * Optional. The number of replica nodes. The valid range for the Standard Tier with
     * read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled
     * for a Standard Tier instance, the only valid value is 1 and the default is 1.
     * The valid value for basic tier is 0 and the default is also 0.
     */
    replicaCount?: pulumi.Input<number>;
    /**
     * The CIDR range of internal addresses that are reserved for this
     * instance. If not provided, the service will choose an unused /29
     * block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be
     * unique and non-overlapping with existing subnets in an authorized
     * network.
     */
    reservedIpRange?: pulumi.Input<string>;
    /**
     * Optional. Additional IP range for node placement. Required when enabling read replicas on
     * an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or
     * "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address
     * range associated with the private service access connection, or "auto".
     */
    secondaryIpRange?: pulumi.Input<string>;
    /**
     * The service tier of the instance. Must be one of these values:
     * - BASIC: standalone instance
     * - STANDARD_HA: highly available primary/replica instances
     * Default value is `BASIC`.
     * Possible values are: `BASIC`, `STANDARD_HA`.
     */
    tier?: pulumi.Input<string>;
    /**
     * The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.
     * - SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication
     * Default value is `DISABLED`.
     * Possible values are: `SERVER_AUTHENTICATION`, `DISABLED`.
     */
    transitEncryptionMode?: pulumi.Input<string>;
}
