import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
/**
 * Resource schema for AWS::Cassandra::Table
 *
 * ## Example Usage
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myNewTable = new aws_native.cassandra.Table("myNewTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "Message",
 *         columnType: "ASCII",
 *     }],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myNewTable = new aws_native.cassandra.Table("myNewTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "Message",
 *         columnType: "ASCII",
 *     }],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myNewTable = new aws_native.cassandra.Table("myNewTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "id",
 *         columnType: "ASCII",
 *     }],
 *     clusteringKeyColumns: [{
 *         column: {
 *             columnName: "division",
 *             columnType: "ASCII",
 *         },
 *         orderBy: aws_native.cassandra.TableClusteringKeyColumnOrderBy.Asc,
 *     }],
 *     regularColumns: [
 *         {
 *             columnName: "name",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "region",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "project",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "role",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "pay_scale",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "vacation_hrs",
 *             columnType: "FLOAT",
 *         },
 *         {
 *             columnName: "manager_id",
 *             columnType: "TEXT",
 *         },
 *     ],
 *     billingMode: {
 *         mode: aws_native.cassandra.TableMode.Provisioned,
 *         provisionedThroughput: {
 *             readCapacityUnits: 5,
 *             writeCapacityUnits: 5,
 *         },
 *     },
 *     clientSideTimestampsEnabled: true,
 *     defaultTimeToLive: 63072000,
 *     pointInTimeRecoveryEnabled: true,
 *     tags: [
 *         {
 *             key: "tag1",
 *             value: "val1",
 *         },
 *         {
 *             key: "tag2",
 *             value: "val2",
 *         },
 *     ],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myNewTable = new aws_native.cassandra.Table("myNewTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "id",
 *         columnType: "ASCII",
 *     }],
 *     clusteringKeyColumns: [{
 *         column: {
 *             columnName: "division",
 *             columnType: "ASCII",
 *         },
 *         orderBy: aws_native.cassandra.TableClusteringKeyColumnOrderBy.Asc,
 *     }],
 *     regularColumns: [
 *         {
 *             columnName: "name",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "region",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "project",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "role",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "pay_scale",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "vacation_hrs",
 *             columnType: "FLOAT",
 *         },
 *         {
 *             columnName: "manager_id",
 *             columnType: "TEXT",
 *         },
 *     ],
 *     billingMode: {
 *         mode: aws_native.cassandra.TableMode.Provisioned,
 *         provisionedThroughput: {
 *             readCapacityUnits: 5,
 *             writeCapacityUnits: 5,
 *         },
 *     },
 *     clientSideTimestampsEnabled: true,
 *     defaultTimeToLive: 63072000,
 *     pointInTimeRecoveryEnabled: true,
 *     tags: [
 *         {
 *             key: "tag1",
 *             value: "val1",
 *         },
 *         {
 *             key: "tag2",
 *             value: "val2",
 *         },
 *     ],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myNewTable = new aws_native.cassandra.Table("myNewTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "id",
 *         columnType: "ASCII",
 *     }],
 *     clusteringKeyColumns: [{
 *         column: {
 *             columnName: "division",
 *             columnType: "ASCII",
 *         },
 *         orderBy: aws_native.cassandra.TableClusteringKeyColumnOrderBy.Asc,
 *     }],
 *     regularColumns: [
 *         {
 *             columnName: "name",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "region",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "project",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "role",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "pay_scale",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "vacation_hrs",
 *             columnType: "FLOAT",
 *         },
 *         {
 *             columnName: "manager_id",
 *             columnType: "TEXT",
 *         },
 *     ],
 *     billingMode: {
 *         mode: aws_native.cassandra.TableMode.Provisioned,
 *         provisionedThroughput: {
 *             readCapacityUnits: 5,
 *             writeCapacityUnits: 5,
 *         },
 *     },
 *     defaultTimeToLive: 63072000,
 *     encryptionSpecification: {
 *         encryptionType: aws_native.cassandra.TableEncryptionType.CustomerManagedKmsKey,
 *         kmsKeyIdentifier: "arn:aws:kms:eu-west-1:5555555555555:key/11111111-1111-111-1111-111111111111",
 *     },
 *     pointInTimeRecoveryEnabled: true,
 *     tags: [
 *         {
 *             key: "tag1",
 *             value: "val1",
 *         },
 *         {
 *             key: "tag2",
 *             value: "val2",
 *         },
 *     ],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myNewTable = new aws_native.cassandra.Table("myNewTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "id",
 *         columnType: "ASCII",
 *     }],
 *     clusteringKeyColumns: [{
 *         column: {
 *             columnName: "division",
 *             columnType: "ASCII",
 *         },
 *         orderBy: aws_native.cassandra.TableClusteringKeyColumnOrderBy.Asc,
 *     }],
 *     regularColumns: [
 *         {
 *             columnName: "name",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "region",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "project",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "role",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "pay_scale",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "vacation_hrs",
 *             columnType: "FLOAT",
 *         },
 *         {
 *             columnName: "manager_id",
 *             columnType: "TEXT",
 *         },
 *     ],
 *     billingMode: {
 *         mode: aws_native.cassandra.TableMode.Provisioned,
 *         provisionedThroughput: {
 *             readCapacityUnits: 5,
 *             writeCapacityUnits: 5,
 *         },
 *     },
 *     defaultTimeToLive: 63072000,
 *     encryptionSpecification: {
 *         encryptionType: aws_native.cassandra.TableEncryptionType.CustomerManagedKmsKey,
 *         kmsKeyIdentifier: "arn:aws:kms:eu-west-1:5555555555555:key/11111111-1111-111-1111-111111111111",
 *     },
 *     pointInTimeRecoveryEnabled: true,
 *     tags: [
 *         {
 *             key: "tag1",
 *             value: "val1",
 *         },
 *         {
 *             key: "tag2",
 *             value: "val2",
 *         },
 *     ],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myTable = new aws_native.cassandra.Table("myTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "Message",
 *         columnType: "ASCII",
 *     }],
 *     regularColumns: [
 *         {
 *             columnName: "name",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "region",
 *             columnType: "TEXT",
 *         },
 *     ],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myTable = new aws_native.cassandra.Table("myTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "Message",
 *         columnType: "ASCII",
 *     }],
 *     regularColumns: [
 *         {
 *             columnName: "name",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "region",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "project",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "role",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "pay_scale",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "vacation_hrs",
 *             columnType: "FLOAT",
 *         },
 *         {
 *             columnName: "manager_id",
 *             columnType: "TEXT",
 *         },
 *     ],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myTable = new aws_native.cassandra.Table("myTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "Message",
 *         columnType: "ASCII",
 *     }],
 *     regularColumns: [
 *         {
 *             columnName: "name",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "region",
 *             columnType: "TEXT",
 *         },
 *     ],
 * });
 *
 * ```
 * ### Example
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as aws_native from "@pulumi/aws-native";
 *
 * const myTable = new aws_native.cassandra.Table("myTable", {
 *     keyspaceName: "my_keyspace",
 *     tableName: "my_table",
 *     partitionKeyColumns: [{
 *         columnName: "Message",
 *         columnType: "ASCII",
 *     }],
 *     regularColumns: [
 *         {
 *             columnName: "name",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "region",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "project",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "role",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "pay_scale",
 *             columnType: "TEXT",
 *         },
 *         {
 *             columnName: "vacation_hrs",
 *             columnType: "FLOAT",
 *         },
 *         {
 *             columnName: "manager_id",
 *             columnType: "TEXT",
 *         },
 *     ],
 * });
 *
 * ```
 */
export declare class Table extends pulumi.CustomResource {
    /**
     * Get an existing Table 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 opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): Table;
    /**
     * Returns true if the given object is an instance of Table.  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 Table;
    /**
     * The optional auto scaling capacity settings for a table in provisioned capacity mode.
     */
    readonly autoScalingSpecifications: pulumi.Output<outputs.cassandra.TableAutoScalingSpecification | undefined>;
    /**
     * The billing mode for the table, which determines how you'll be charged for reads and writes:
     *
     * - *On-demand mode* (default) - You pay based on the actual reads and writes your application performs.
     * - *Provisioned mode* - Lets you specify the number of reads and writes per second that you need for your application.
     *
     * If you don't specify a value for this property, then the table will use on-demand mode.
     */
    readonly billingMode: pulumi.Output<outputs.cassandra.TableBillingMode | undefined>;
    /**
     * The settings for the CDC stream of a table. For more information about CDC streams, see [Working with change data capture (CDC) streams in Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/cdc.html) in the *Amazon Keyspaces Developer Guide* .
     */
    readonly cdcSpecification: pulumi.Output<outputs.cassandra.TableCdcSpecification | undefined>;
    /**
     * Indicates whether client side timestamps are enabled (true) or disabled (false) on the table. False by default, once it is enabled it cannot be disabled again.
     */
    readonly clientSideTimestampsEnabled: pulumi.Output<boolean | undefined>;
    /**
     * Clustering key columns of the table
     */
    readonly clusteringKeyColumns: pulumi.Output<outputs.cassandra.TableClusteringKeyColumn[] | undefined>;
    /**
     * Default TTL (Time To Live) in seconds, where zero is disabled. If the value is greater than zero, TTL is enabled for the entire table and an expiration timestamp is added to each column.
     */
    readonly defaultTimeToLive: pulumi.Output<number | undefined>;
    /**
     * The encryption at rest options for the table.
     *
     * - *AWS owned key* (default) - The key is owned by Amazon Keyspaces .
     * - *Customer managed key* - The key is stored in your account and is created, owned, and managed by you.
     *
     * > If you choose encryption with a customer managed key, you must specify a valid customer managed KMS key with permissions granted to Amazon Keyspaces.
     *
     * For more information, see [Encryption at rest in Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html) in the *Amazon Keyspaces Developer Guide* .
     */
    readonly encryptionSpecification: pulumi.Output<outputs.cassandra.TableEncryptionSpecification | undefined>;
    /**
     * Name for Cassandra keyspace
     */
    readonly keyspaceName: pulumi.Output<string>;
    /**
     * Partition key columns of the table
     */
    readonly partitionKeyColumns: pulumi.Output<outputs.cassandra.TableColumn[]>;
    /**
     * Indicates whether point in time recovery is enabled (true) or disabled (false) on the table
     */
    readonly pointInTimeRecoveryEnabled: pulumi.Output<boolean | undefined>;
    /**
     * Non-key columns of the table
     */
    readonly regularColumns: pulumi.Output<outputs.cassandra.TableColumn[] | undefined>;
    /**
     * The AWS Region specific settings of a multi-Region table.
     *
     * For a multi-Region table, you can configure the table's read capacity differently per AWS Region. You can do this by configuring the following parameters.
     *
     * - `region` : The Region where these settings are applied. (Required)
     * - `readCapacityUnits` : The provisioned read capacity units. (Optional)
     * - `readCapacityAutoScaling` : The read capacity auto scaling settings for the table. (Optional)
     */
    readonly replicaSpecifications: pulumi.Output<outputs.cassandra.TableReplicaSpecification[] | undefined>;
    /**
     * Name for Cassandra table
     */
    readonly tableName: pulumi.Output<string | undefined>;
    /**
     * An array of key-value pairs to apply to this resource
     */
    readonly tags: pulumi.Output<outputs.Tag[] | undefined>;
    readonly warmThroughput: pulumi.Output<outputs.cassandra.TableWarmThroughput | undefined>;
    /**
     * Create a Table 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: TableArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * The set of arguments for constructing a Table resource.
 */
export interface TableArgs {
    /**
     * The optional auto scaling capacity settings for a table in provisioned capacity mode.
     */
    autoScalingSpecifications?: pulumi.Input<inputs.cassandra.TableAutoScalingSpecificationArgs>;
    /**
     * The billing mode for the table, which determines how you'll be charged for reads and writes:
     *
     * - *On-demand mode* (default) - You pay based on the actual reads and writes your application performs.
     * - *Provisioned mode* - Lets you specify the number of reads and writes per second that you need for your application.
     *
     * If you don't specify a value for this property, then the table will use on-demand mode.
     */
    billingMode?: pulumi.Input<inputs.cassandra.TableBillingModeArgs>;
    /**
     * The settings for the CDC stream of a table. For more information about CDC streams, see [Working with change data capture (CDC) streams in Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/cdc.html) in the *Amazon Keyspaces Developer Guide* .
     */
    cdcSpecification?: pulumi.Input<inputs.cassandra.TableCdcSpecificationArgs>;
    /**
     * Indicates whether client side timestamps are enabled (true) or disabled (false) on the table. False by default, once it is enabled it cannot be disabled again.
     */
    clientSideTimestampsEnabled?: pulumi.Input<boolean>;
    /**
     * Clustering key columns of the table
     */
    clusteringKeyColumns?: pulumi.Input<pulumi.Input<inputs.cassandra.TableClusteringKeyColumnArgs>[]>;
    /**
     * Default TTL (Time To Live) in seconds, where zero is disabled. If the value is greater than zero, TTL is enabled for the entire table and an expiration timestamp is added to each column.
     */
    defaultTimeToLive?: pulumi.Input<number>;
    /**
     * The encryption at rest options for the table.
     *
     * - *AWS owned key* (default) - The key is owned by Amazon Keyspaces .
     * - *Customer managed key* - The key is stored in your account and is created, owned, and managed by you.
     *
     * > If you choose encryption with a customer managed key, you must specify a valid customer managed KMS key with permissions granted to Amazon Keyspaces.
     *
     * For more information, see [Encryption at rest in Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html) in the *Amazon Keyspaces Developer Guide* .
     */
    encryptionSpecification?: pulumi.Input<inputs.cassandra.TableEncryptionSpecificationArgs>;
    /**
     * Name for Cassandra keyspace
     */
    keyspaceName: pulumi.Input<string>;
    /**
     * Partition key columns of the table
     */
    partitionKeyColumns: pulumi.Input<pulumi.Input<inputs.cassandra.TableColumnArgs>[]>;
    /**
     * Indicates whether point in time recovery is enabled (true) or disabled (false) on the table
     */
    pointInTimeRecoveryEnabled?: pulumi.Input<boolean>;
    /**
     * Non-key columns of the table
     */
    regularColumns?: pulumi.Input<pulumi.Input<inputs.cassandra.TableColumnArgs>[]>;
    /**
     * The AWS Region specific settings of a multi-Region table.
     *
     * For a multi-Region table, you can configure the table's read capacity differently per AWS Region. You can do this by configuring the following parameters.
     *
     * - `region` : The Region where these settings are applied. (Required)
     * - `readCapacityUnits` : The provisioned read capacity units. (Optional)
     * - `readCapacityAutoScaling` : The read capacity auto scaling settings for the table. (Optional)
     */
    replicaSpecifications?: pulumi.Input<pulumi.Input<inputs.cassandra.TableReplicaSpecificationArgs>[]>;
    /**
     * Name for Cassandra table
     */
    tableName?: pulumi.Input<string>;
    /**
     * An array of key-value pairs to apply to this resource
     */
    tags?: pulumi.Input<pulumi.Input<inputs.TagArgs>[]>;
    warmThroughput?: pulumi.Input<inputs.cassandra.TableWarmThroughputArgs>;
}
