finspace

type KxCluster struct {
	pulumi.CustomResourceState

	// Amazon Resource Name (ARN) identifier of the KX cluster.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
	AutoScalingConfiguration KxClusterAutoScalingConfigurationPtrOutput `pulumi:"autoScalingConfiguration"`
	// The availability zone identifiers for the requested regions. Required when `azMode` is set to SINGLE.
	AvailabilityZoneId pulumi.StringPtrOutput `pulumi:"availabilityZoneId"`
	// The number of availability zones you want to assign per cluster. This can be one of the following:
	// * SINGLE - Assigns one availability zone per cluster.
	// * MULTI - Assigns all the availability zones per cluster.
	AzMode pulumi.StringOutput `pulumi:"azMode"`
	// Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
	CacheStorageConfigurations KxClusterCacheStorageConfigurationArrayOutput `pulumi:"cacheStorageConfigurations"`
	// Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
	CapacityConfiguration KxClusterCapacityConfigurationPtrOutput `pulumi:"capacityConfiguration"`
	// Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
	Code KxClusterCodePtrOutput `pulumi:"code"`
	// List of key-value pairs to make available inside the cluster.
	CommandLineArguments pulumi.StringMapOutput `pulumi:"commandLineArguments"`
	// Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	CreatedTimestamp pulumi.StringOutput `pulumi:"createdTimestamp"`
	// KX database that will be available for querying. Defined below.
	Databases KxClusterDatabaseArrayOutput `pulumi:"databases"`
	// Description of the cluster.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringOutput `pulumi:"environmentId"`
	// An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
	ExecutionRole pulumi.StringPtrOutput `pulumi:"executionRole"`
	// Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
	InitializationScript pulumi.StringPtrOutput `pulumi:"initializationScript"`
	// Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	LastModifiedTimestamp pulumi.StringOutput `pulumi:"lastModifiedTimestamp"`
	// Unique name for the cluster that you want to create.
	Name pulumi.StringOutput `pulumi:"name"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// Version of FinSpace Managed kdb to run.
	ReleaseLabel pulumi.StringOutput `pulumi:"releaseLabel"`
	// Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose `type` as RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
	SavedownStorageConfiguration KxClusterSavedownStorageConfigurationPtrOutput `pulumi:"savedownStorageConfiguration"`
	// The structure that stores the configuration details of a scaling group.
	ScalingGroupConfiguration KxClusterScalingGroupConfigurationPtrOutput `pulumi:"scalingGroupConfiguration"`
	Status                    pulumi.StringOutput                         `pulumi:"status"`
	StatusReason              pulumi.StringOutput                         `pulumi:"statusReason"`
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
	TickerplantLogConfigurations KxClusterTickerplantLogConfigurationArrayOutput `pulumi:"tickerplantLogConfigurations"`
	// Type of KDB database. The following types are available:
	// * HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
	// * RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the `savedownStorageConfiguration` parameter.
	// * GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a  writable local storage.
	// * GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only `SINGLE` AZ mode.
	// * Tickerplant - A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
	Type pulumi.StringOutput `pulumi:"type"`
	// Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration.
	//
	// The following arguments are optional:
	VpcConfiguration KxClusterVpcConfigurationOutput `pulumi:"vpcConfiguration"`
}

type KxClusterArgs struct {
	// Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
	AutoScalingConfiguration KxClusterAutoScalingConfigurationPtrInput
	// The availability zone identifiers for the requested regions. Required when `azMode` is set to SINGLE.
	AvailabilityZoneId pulumi.StringPtrInput
	// The number of availability zones you want to assign per cluster. This can be one of the following:
	// * SINGLE - Assigns one availability zone per cluster.
	// * MULTI - Assigns all the availability zones per cluster.
	AzMode pulumi.StringInput
	// Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
	CacheStorageConfigurations KxClusterCacheStorageConfigurationArrayInput
	// Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
	CapacityConfiguration KxClusterCapacityConfigurationPtrInput
	// Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
	Code KxClusterCodePtrInput
	// List of key-value pairs to make available inside the cluster.
	CommandLineArguments pulumi.StringMapInput
	// KX database that will be available for querying. Defined below.
	Databases KxClusterDatabaseArrayInput
	// Description of the cluster.
	Description pulumi.StringPtrInput
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringInput
	// An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
	ExecutionRole pulumi.StringPtrInput
	// Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
	InitializationScript pulumi.StringPtrInput
	// Unique name for the cluster that you want to create.
	Name pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// Version of FinSpace Managed kdb to run.
	ReleaseLabel pulumi.StringInput
	// Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose `type` as RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
	SavedownStorageConfiguration KxClusterSavedownStorageConfigurationPtrInput
	// The structure that stores the configuration details of a scaling group.
	ScalingGroupConfiguration KxClusterScalingGroupConfigurationPtrInput
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
	TickerplantLogConfigurations KxClusterTickerplantLogConfigurationArrayInput
	// Type of KDB database. The following types are available:
	// * HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
	// * RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the `savedownStorageConfiguration` parameter.
	// * GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a  writable local storage.
	// * GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only `SINGLE` AZ mode.
	// * Tickerplant - A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
	Type pulumi.StringInput
	// Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration.
	//
	// The following arguments are optional:
	VpcConfiguration KxClusterVpcConfigurationInput
}

type KxClusterArray []KxClusterInput

type KxClusterArrayInput interface {
	pulumi.Input

	ToKxClusterArrayOutput() KxClusterArrayOutput
	ToKxClusterArrayOutputWithContext(context.Context) KxClusterArrayOutput
}

type KxClusterArrayOutput struct{ *pulumi.OutputState }

type KxClusterAutoScalingConfiguration struct {
	// Metric your cluster will track in order to scale in and out. For example, CPU_UTILIZATION_PERCENTAGE is the average CPU usage across all nodes in a cluster.
	AutoScalingMetric string `pulumi:"autoScalingMetric"`
	// Highest number of nodes to scale. Cannot be greater than 5
	MaxNodeCount int `pulumi:"maxNodeCount"`
	// Desired value of chosen `autoScalingMetric`. When metric drops below this value, cluster will scale in. When metric goes above this value, cluster will scale out. Can be set between 0 and 100 percent.
	MetricTarget float64 `pulumi:"metricTarget"`
	// Lowest number of nodes to scale. Must be at least 1 and less than the `maxNodeCount`. If nodes in cluster belong to multiple availability zones, then `minNodeCount` must be at least 3.
	MinNodeCount int `pulumi:"minNodeCount"`
	// Duration in seconds that FinSpace will wait after a scale in event before initiating another scaling event.
	ScaleInCooldownSeconds float64 `pulumi:"scaleInCooldownSeconds"`
	// Duration in seconds that FinSpace will wait after a scale out event before initiating another scaling event.
	ScaleOutCooldownSeconds float64 `pulumi:"scaleOutCooldownSeconds"`
}

type KxClusterAutoScalingConfigurationArgs struct {
	// Metric your cluster will track in order to scale in and out. For example, CPU_UTILIZATION_PERCENTAGE is the average CPU usage across all nodes in a cluster.
	AutoScalingMetric pulumi.StringInput `pulumi:"autoScalingMetric"`
	// Highest number of nodes to scale. Cannot be greater than 5
	MaxNodeCount pulumi.IntInput `pulumi:"maxNodeCount"`
	// Desired value of chosen `autoScalingMetric`. When metric drops below this value, cluster will scale in. When metric goes above this value, cluster will scale out. Can be set between 0 and 100 percent.
	MetricTarget pulumi.Float64Input `pulumi:"metricTarget"`
	// Lowest number of nodes to scale. Must be at least 1 and less than the `maxNodeCount`. If nodes in cluster belong to multiple availability zones, then `minNodeCount` must be at least 3.
	MinNodeCount pulumi.IntInput `pulumi:"minNodeCount"`
	// Duration in seconds that FinSpace will wait after a scale in event before initiating another scaling event.
	ScaleInCooldownSeconds pulumi.Float64Input `pulumi:"scaleInCooldownSeconds"`
	// Duration in seconds that FinSpace will wait after a scale out event before initiating another scaling event.
	ScaleOutCooldownSeconds pulumi.Float64Input `pulumi:"scaleOutCooldownSeconds"`
}

type KxClusterAutoScalingConfigurationInput interface {
	pulumi.Input

	ToKxClusterAutoScalingConfigurationOutput() KxClusterAutoScalingConfigurationOutput
	ToKxClusterAutoScalingConfigurationOutputWithContext(context.Context) KxClusterAutoScalingConfigurationOutput
}

type KxClusterAutoScalingConfigurationOutput struct{ *pulumi.OutputState }

type KxClusterAutoScalingConfigurationPtrInput interface {
	pulumi.Input

	ToKxClusterAutoScalingConfigurationPtrOutput() KxClusterAutoScalingConfigurationPtrOutput
	ToKxClusterAutoScalingConfigurationPtrOutputWithContext(context.Context) KxClusterAutoScalingConfigurationPtrOutput
}

type KxClusterAutoScalingConfigurationPtrOutput struct{ *pulumi.OutputState }

type KxClusterCacheStorageConfiguration struct {
	Size int `pulumi:"size"`
	// Type of KDB database. The following types are available:
	// * HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
	// * RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the `savedownStorageConfiguration` parameter.
	// * GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a  writable local storage.
	// * GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only `SINGLE` AZ mode.
	// * Tickerplant - A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
	Type string `pulumi:"type"`
}

type KxClusterCacheStorageConfigurationArgs struct {
	Size pulumi.IntInput `pulumi:"size"`
	// Type of KDB database. The following types are available:
	// * HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
	// * RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the `savedownStorageConfiguration` parameter.
	// * GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a  writable local storage.
	// * GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only `SINGLE` AZ mode.
	// * Tickerplant - A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
	Type pulumi.StringInput `pulumi:"type"`
}

type KxClusterCacheStorageConfigurationArray []KxClusterCacheStorageConfigurationInput

type KxClusterCacheStorageConfigurationArrayInput interface {
	pulumi.Input

	ToKxClusterCacheStorageConfigurationArrayOutput() KxClusterCacheStorageConfigurationArrayOutput
	ToKxClusterCacheStorageConfigurationArrayOutputWithContext(context.Context) KxClusterCacheStorageConfigurationArrayOutput
}

type KxClusterCacheStorageConfigurationArrayOutput struct{ *pulumi.OutputState }

type KxClusterCacheStorageConfigurationInput interface {
	pulumi.Input

	ToKxClusterCacheStorageConfigurationOutput() KxClusterCacheStorageConfigurationOutput
	ToKxClusterCacheStorageConfigurationOutputWithContext(context.Context) KxClusterCacheStorageConfigurationOutput
}

type KxClusterCacheStorageConfigurationOutput struct{ *pulumi.OutputState }

type KxClusterCapacityConfiguration struct {
	// Number of instances running in a cluster. Must be at least 1 and at most 5.
	NodeCount int `pulumi:"nodeCount"`
	// Determines the hardware of the host computer used for your cluster instance. Each node type offers different memory and storage capabilities. Choose a node type based on the requirements of the application or software that you plan to run on your instance.
	//
	// You can only specify one of the following values:
	// * kx.s.large - The node type with a configuration of 12 GiB memory and 2 vCPUs.
	// * kx.s.xlarge - The node type with a configuration of 27 GiB memory and 4 vCPUs.
	// * kx.s.2xlarge - The node type with a configuration of 54 GiB memory and 8 vCPUs.
	// * kx.s.4xlarge - The node type with a configuration of 108 GiB memory and 16 vCPUs.
	// * kx.s.8xlarge - The node type with a configuration of 216 GiB memory and 32 vCPUs.
	// * kx.s.16xlarge - The node type with a configuration of 432 GiB memory and 64 vCPUs.
	// * kx.s.32xlarge - The node type with a configuration of 864 GiB memory and 128 vCPUs.
	NodeType string `pulumi:"nodeType"`
}

type KxClusterCapacityConfigurationArgs struct {
	// Number of instances running in a cluster. Must be at least 1 and at most 5.
	NodeCount pulumi.IntInput `pulumi:"nodeCount"`
	// Determines the hardware of the host computer used for your cluster instance. Each node type offers different memory and storage capabilities. Choose a node type based on the requirements of the application or software that you plan to run on your instance.
	//
	// You can only specify one of the following values:
	// * kx.s.large - The node type with a configuration of 12 GiB memory and 2 vCPUs.
	// * kx.s.xlarge - The node type with a configuration of 27 GiB memory and 4 vCPUs.
	// * kx.s.2xlarge - The node type with a configuration of 54 GiB memory and 8 vCPUs.
	// * kx.s.4xlarge - The node type with a configuration of 108 GiB memory and 16 vCPUs.
	// * kx.s.8xlarge - The node type with a configuration of 216 GiB memory and 32 vCPUs.
	// * kx.s.16xlarge - The node type with a configuration of 432 GiB memory and 64 vCPUs.
	// * kx.s.32xlarge - The node type with a configuration of 864 GiB memory and 128 vCPUs.
	NodeType pulumi.StringInput `pulumi:"nodeType"`
}

type KxClusterCapacityConfigurationInput interface {
	pulumi.Input

	ToKxClusterCapacityConfigurationOutput() KxClusterCapacityConfigurationOutput
	ToKxClusterCapacityConfigurationOutputWithContext(context.Context) KxClusterCapacityConfigurationOutput
}

type KxClusterCapacityConfigurationOutput struct{ *pulumi.OutputState }

type KxClusterCapacityConfigurationPtrInput interface {
	pulumi.Input

	ToKxClusterCapacityConfigurationPtrOutput() KxClusterCapacityConfigurationPtrOutput
	ToKxClusterCapacityConfigurationPtrOutputWithContext(context.Context) KxClusterCapacityConfigurationPtrOutput
}

type KxClusterCapacityConfigurationPtrOutput struct{ *pulumi.OutputState }

type KxClusterCode struct {
	// Unique name for the S3 bucket.
	S3Bucket string `pulumi:"s3Bucket"`
	// Full S3 path (excluding bucket) to the .zip file that contains the code to be loaded onto the cluster when it’s started.
	S3Key string `pulumi:"s3Key"`
	// Version of an S3 Object.
	S3ObjectVersion *string `pulumi:"s3ObjectVersion"`
}

type KxClusterCodeArgs struct {
	// Unique name for the S3 bucket.
	S3Bucket pulumi.StringInput `pulumi:"s3Bucket"`
	// Full S3 path (excluding bucket) to the .zip file that contains the code to be loaded onto the cluster when it’s started.
	S3Key pulumi.StringInput `pulumi:"s3Key"`
	// Version of an S3 Object.
	S3ObjectVersion pulumi.StringPtrInput `pulumi:"s3ObjectVersion"`
}

type KxClusterCodeInput interface {
	pulumi.Input

	ToKxClusterCodeOutput() KxClusterCodeOutput
	ToKxClusterCodeOutputWithContext(context.Context) KxClusterCodeOutput
}

type KxClusterCodeOutput struct{ *pulumi.OutputState }

type KxClusterCodePtrInput interface {
	pulumi.Input

	ToKxClusterCodePtrOutput() KxClusterCodePtrOutput
	ToKxClusterCodePtrOutputWithContext(context.Context) KxClusterCodePtrOutput
}

type KxClusterCodePtrOutput struct{ *pulumi.OutputState }

type KxClusterDatabase struct {
	// Configuration details for the disk cache to increase performance reading from a KX database mounted to the cluster. See cache_configurations.
	CacheConfigurations []KxClusterDatabaseCacheConfiguration `pulumi:"cacheConfigurations"`
	// A unique identifier of the changeset that is associated with the cluster.
	ChangesetId *string `pulumi:"changesetId"`
	// Name of the KX database.
	DatabaseName string `pulumi:"databaseName"`
	// The name of the dataview to be used for caching historical data on disk. You cannot update to a different dataview name once a cluster is created. Use `lifecycle` `ignoreChanges` for database to prevent any undesirable behaviors.
	DataviewName *string `pulumi:"dataviewName"`
}

type KxClusterDatabaseArgs struct {
	// Configuration details for the disk cache to increase performance reading from a KX database mounted to the cluster. See cache_configurations.
	CacheConfigurations KxClusterDatabaseCacheConfigurationArrayInput `pulumi:"cacheConfigurations"`
	// A unique identifier of the changeset that is associated with the cluster.
	ChangesetId pulumi.StringPtrInput `pulumi:"changesetId"`
	// Name of the KX database.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// The name of the dataview to be used for caching historical data on disk. You cannot update to a different dataview name once a cluster is created. Use `lifecycle` `ignoreChanges` for database to prevent any undesirable behaviors.
	DataviewName pulumi.StringPtrInput `pulumi:"dataviewName"`
}

type KxClusterDatabaseArray []KxClusterDatabaseInput

type KxClusterDatabaseArrayInput interface {
	pulumi.Input

	ToKxClusterDatabaseArrayOutput() KxClusterDatabaseArrayOutput
	ToKxClusterDatabaseArrayOutputWithContext(context.Context) KxClusterDatabaseArrayOutput
}

type KxClusterDatabaseArrayOutput struct{ *pulumi.OutputState }

type KxClusterDatabaseCacheConfiguration struct {
	// Type of disk cache.
	CacheType string `pulumi:"cacheType"`
	// Paths within the database to cache.
	DbPaths []string `pulumi:"dbPaths"`
}

type KxClusterDatabaseCacheConfigurationArgs struct {
	// Type of disk cache.
	CacheType pulumi.StringInput `pulumi:"cacheType"`
	// Paths within the database to cache.
	DbPaths pulumi.StringArrayInput `pulumi:"dbPaths"`
}

type KxClusterDatabaseCacheConfigurationArray []KxClusterDatabaseCacheConfigurationInput

type KxClusterDatabaseCacheConfigurationArrayInput interface {
	pulumi.Input

	ToKxClusterDatabaseCacheConfigurationArrayOutput() KxClusterDatabaseCacheConfigurationArrayOutput
	ToKxClusterDatabaseCacheConfigurationArrayOutputWithContext(context.Context) KxClusterDatabaseCacheConfigurationArrayOutput
}

type KxClusterDatabaseCacheConfigurationArrayOutput struct{ *pulumi.OutputState }

type KxClusterDatabaseCacheConfigurationInput interface {
	pulumi.Input

	ToKxClusterDatabaseCacheConfigurationOutput() KxClusterDatabaseCacheConfigurationOutput
	ToKxClusterDatabaseCacheConfigurationOutputWithContext(context.Context) KxClusterDatabaseCacheConfigurationOutput
}

type KxClusterDatabaseCacheConfigurationOutput struct{ *pulumi.OutputState }

type KxClusterDatabaseInput interface {
	pulumi.Input

	ToKxClusterDatabaseOutput() KxClusterDatabaseOutput
	ToKxClusterDatabaseOutputWithContext(context.Context) KxClusterDatabaseOutput
}

type KxClusterDatabaseOutput struct{ *pulumi.OutputState }

type KxClusterInput interface {
	pulumi.Input

	ToKxClusterOutput() KxClusterOutput
	ToKxClusterOutputWithContext(ctx context.Context) KxClusterOutput
}

type KxClusterMap map[string]KxClusterInput

type KxClusterMapInput interface {
	pulumi.Input

	ToKxClusterMapOutput() KxClusterMapOutput
	ToKxClusterMapOutputWithContext(context.Context) KxClusterMapOutput
}

type KxClusterMapOutput struct{ *pulumi.OutputState }

type KxClusterOutput struct{ *pulumi.OutputState }

type KxClusterSavedownStorageConfiguration struct {
	// Size of temporary storage in gigabytes. Must be between 10 and 16000.
	Size *int `pulumi:"size"`
	// Type of writeable storage space for temporarily storing your savedown data. The valid values are:
	// * SDS01 - This type represents 3000 IOPS and io2 ebs volume type.
	Type *string `pulumi:"type"`
	// The name of the kdb volume that you want to use as writeable save-down storage for clusters.
	VolumeName *string `pulumi:"volumeName"`
}

type KxClusterSavedownStorageConfigurationArgs struct {
	// Size of temporary storage in gigabytes. Must be between 10 and 16000.
	Size pulumi.IntPtrInput `pulumi:"size"`
	// Type of writeable storage space for temporarily storing your savedown data. The valid values are:
	// * SDS01 - This type represents 3000 IOPS and io2 ebs volume type.
	Type pulumi.StringPtrInput `pulumi:"type"`
	// The name of the kdb volume that you want to use as writeable save-down storage for clusters.
	VolumeName pulumi.StringPtrInput `pulumi:"volumeName"`
}

type KxClusterSavedownStorageConfigurationInput interface {
	pulumi.Input

	ToKxClusterSavedownStorageConfigurationOutput() KxClusterSavedownStorageConfigurationOutput
	ToKxClusterSavedownStorageConfigurationOutputWithContext(context.Context) KxClusterSavedownStorageConfigurationOutput
}

type KxClusterSavedownStorageConfigurationOutput struct{ *pulumi.OutputState }

type KxClusterSavedownStorageConfigurationPtrInput interface {
	pulumi.Input

	ToKxClusterSavedownStorageConfigurationPtrOutput() KxClusterSavedownStorageConfigurationPtrOutput
	ToKxClusterSavedownStorageConfigurationPtrOutputWithContext(context.Context) KxClusterSavedownStorageConfigurationPtrOutput
}

type KxClusterSavedownStorageConfigurationPtrOutput struct{ *pulumi.OutputState }

type KxClusterScalingGroupConfiguration struct {
	// The number of vCPUs that you want to reserve for each node of this kdb cluster on the scaling group host.
	Cpu *float64 `pulumi:"cpu"`
	// An optional hard limit on the amount of memory a kdb cluster can use.
	MemoryLimit *int `pulumi:"memoryLimit"`
	// A reservation of the minimum amount of memory that should be available on the scaling group for a kdb cluster to be successfully placed in a scaling group.
	MemoryReservation int `pulumi:"memoryReservation"`
	// The number of kdb cluster nodes.
	NodeCount int `pulumi:"nodeCount"`
	// A unique identifier for the kdb scaling group.
	ScalingGroupName string `pulumi:"scalingGroupName"`
}

type KxClusterScalingGroupConfigurationArgs struct {
	// The number of vCPUs that you want to reserve for each node of this kdb cluster on the scaling group host.
	Cpu pulumi.Float64PtrInput `pulumi:"cpu"`
	// An optional hard limit on the amount of memory a kdb cluster can use.
	MemoryLimit pulumi.IntPtrInput `pulumi:"memoryLimit"`
	// A reservation of the minimum amount of memory that should be available on the scaling group for a kdb cluster to be successfully placed in a scaling group.
	MemoryReservation pulumi.IntInput `pulumi:"memoryReservation"`
	// The number of kdb cluster nodes.
	NodeCount pulumi.IntInput `pulumi:"nodeCount"`
	// A unique identifier for the kdb scaling group.
	ScalingGroupName pulumi.StringInput `pulumi:"scalingGroupName"`
}

type KxClusterScalingGroupConfigurationInput interface {
	pulumi.Input

	ToKxClusterScalingGroupConfigurationOutput() KxClusterScalingGroupConfigurationOutput
	ToKxClusterScalingGroupConfigurationOutputWithContext(context.Context) KxClusterScalingGroupConfigurationOutput
}

type KxClusterScalingGroupConfigurationOutput struct{ *pulumi.OutputState }

type KxClusterScalingGroupConfigurationPtrInput interface {
	pulumi.Input

	ToKxClusterScalingGroupConfigurationPtrOutput() KxClusterScalingGroupConfigurationPtrOutput
	ToKxClusterScalingGroupConfigurationPtrOutputWithContext(context.Context) KxClusterScalingGroupConfigurationPtrOutput
}

type KxClusterScalingGroupConfigurationPtrOutput struct{ *pulumi.OutputState }

type KxClusterState struct {
	// Amazon Resource Name (ARN) identifier of the KX cluster.
	Arn pulumi.StringPtrInput
	// Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
	AutoScalingConfiguration KxClusterAutoScalingConfigurationPtrInput
	// The availability zone identifiers for the requested regions. Required when `azMode` is set to SINGLE.
	AvailabilityZoneId pulumi.StringPtrInput
	// The number of availability zones you want to assign per cluster. This can be one of the following:
	// * SINGLE - Assigns one availability zone per cluster.
	// * MULTI - Assigns all the availability zones per cluster.
	AzMode pulumi.StringPtrInput
	// Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
	CacheStorageConfigurations KxClusterCacheStorageConfigurationArrayInput
	// Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
	CapacityConfiguration KxClusterCapacityConfigurationPtrInput
	// Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
	Code KxClusterCodePtrInput
	// List of key-value pairs to make available inside the cluster.
	CommandLineArguments pulumi.StringMapInput
	// Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	CreatedTimestamp pulumi.StringPtrInput
	// KX database that will be available for querying. Defined below.
	Databases KxClusterDatabaseArrayInput
	// Description of the cluster.
	Description pulumi.StringPtrInput
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringPtrInput
	// An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
	ExecutionRole pulumi.StringPtrInput
	// Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
	InitializationScript pulumi.StringPtrInput
	// Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	LastModifiedTimestamp pulumi.StringPtrInput
	// Unique name for the cluster that you want to create.
	Name pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// Version of FinSpace Managed kdb to run.
	ReleaseLabel pulumi.StringPtrInput
	// Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose `type` as RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
	SavedownStorageConfiguration KxClusterSavedownStorageConfigurationPtrInput
	// The structure that stores the configuration details of a scaling group.
	ScalingGroupConfiguration KxClusterScalingGroupConfigurationPtrInput
	Status                    pulumi.StringPtrInput
	StatusReason              pulumi.StringPtrInput
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
	// A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
	TickerplantLogConfigurations KxClusterTickerplantLogConfigurationArrayInput
	// Type of KDB database. The following types are available:
	// * HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
	// * RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the `savedownStorageConfiguration` parameter.
	// * GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a  writable local storage.
	// * GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only `SINGLE` AZ mode.
	// * Tickerplant - A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
	Type pulumi.StringPtrInput
	// Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration.
	//
	// The following arguments are optional:
	VpcConfiguration KxClusterVpcConfigurationPtrInput
}

type KxClusterTickerplantLogConfiguration struct {
	TickerplantLogVolumes []string `pulumi:"tickerplantLogVolumes"`
}

type KxClusterTickerplantLogConfigurationArgs struct {
	TickerplantLogVolumes pulumi.StringArrayInput `pulumi:"tickerplantLogVolumes"`
}

type KxClusterTickerplantLogConfigurationArray []KxClusterTickerplantLogConfigurationInput

type KxClusterTickerplantLogConfigurationArrayInput interface {
	pulumi.Input

	ToKxClusterTickerplantLogConfigurationArrayOutput() KxClusterTickerplantLogConfigurationArrayOutput
	ToKxClusterTickerplantLogConfigurationArrayOutputWithContext(context.Context) KxClusterTickerplantLogConfigurationArrayOutput
}

type KxClusterTickerplantLogConfigurationArrayOutput struct{ *pulumi.OutputState }

type KxClusterTickerplantLogConfigurationInput interface {
	pulumi.Input

	ToKxClusterTickerplantLogConfigurationOutput() KxClusterTickerplantLogConfigurationOutput
	ToKxClusterTickerplantLogConfigurationOutputWithContext(context.Context) KxClusterTickerplantLogConfigurationOutput
}

type KxClusterTickerplantLogConfigurationOutput struct{ *pulumi.OutputState }

type KxClusterVpcConfiguration struct {
	// IP address type for cluster network configuration parameters. The following type is available: IP_V4 - IP address version 4.
	IpAddressType string `pulumi:"ipAddressType"`
	// Unique identifier of the VPC security group applied to the VPC endpoint ENI for the cluster.
	// * ` subnetIds  `- (Required) Identifier of the subnet that the Privatelink VPC endpoint uses to connect to the cluster.
	SecurityGroupIds []string `pulumi:"securityGroupIds"`
	SubnetIds        []string `pulumi:"subnetIds"`
	// Identifier of the VPC endpoint
	VpcId string `pulumi:"vpcId"`
}

type KxClusterVpcConfigurationArgs struct {
	// IP address type for cluster network configuration parameters. The following type is available: IP_V4 - IP address version 4.
	IpAddressType pulumi.StringInput `pulumi:"ipAddressType"`
	// Unique identifier of the VPC security group applied to the VPC endpoint ENI for the cluster.
	// * ` subnetIds  `- (Required) Identifier of the subnet that the Privatelink VPC endpoint uses to connect to the cluster.
	SecurityGroupIds pulumi.StringArrayInput `pulumi:"securityGroupIds"`
	SubnetIds        pulumi.StringArrayInput `pulumi:"subnetIds"`
	// Identifier of the VPC endpoint
	VpcId pulumi.StringInput `pulumi:"vpcId"`
}

type KxClusterVpcConfigurationInput interface {
	pulumi.Input

	ToKxClusterVpcConfigurationOutput() KxClusterVpcConfigurationOutput
	ToKxClusterVpcConfigurationOutputWithContext(context.Context) KxClusterVpcConfigurationOutput
}

type KxClusterVpcConfigurationOutput struct{ *pulumi.OutputState }

type KxClusterVpcConfigurationPtrInput interface {
	pulumi.Input

	ToKxClusterVpcConfigurationPtrOutput() KxClusterVpcConfigurationPtrOutput
	ToKxClusterVpcConfigurationPtrOutputWithContext(context.Context) KxClusterVpcConfigurationPtrOutput
}

type KxClusterVpcConfigurationPtrOutput struct{ *pulumi.OutputState }

type KxDatabase struct {
	pulumi.CustomResourceState

	// Amazon Resource Name (ARN) identifier of the KX database.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Timestamp at which the databse is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	CreatedTimestamp pulumi.StringOutput `pulumi:"createdTimestamp"`
	// Description of the KX database.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringOutput `pulumi:"environmentId"`
	// Last timestamp at which the database was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	LastModifiedTimestamp pulumi.StringOutput `pulumi:"lastModifiedTimestamp"`
	// Name of the KX database.
	//
	// The following arguments are optional:
	Name pulumi.StringOutput `pulumi:"name"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

type KxDatabaseArgs struct {
	// Description of the KX database.
	Description pulumi.StringPtrInput
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringInput
	// Name of the KX database.
	//
	// The following arguments are optional:
	Name pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

type KxDatabaseArray []KxDatabaseInput

type KxDatabaseArrayInput interface {
	pulumi.Input

	ToKxDatabaseArrayOutput() KxDatabaseArrayOutput
	ToKxDatabaseArrayOutputWithContext(context.Context) KxDatabaseArrayOutput
}

type KxDatabaseArrayOutput struct{ *pulumi.OutputState }

type KxDatabaseInput interface {
	pulumi.Input

	ToKxDatabaseOutput() KxDatabaseOutput
	ToKxDatabaseOutputWithContext(ctx context.Context) KxDatabaseOutput
}

type KxDatabaseMap map[string]KxDatabaseInput

type KxDatabaseMapInput interface {
	pulumi.Input

	ToKxDatabaseMapOutput() KxDatabaseMapOutput
	ToKxDatabaseMapOutputWithContext(context.Context) KxDatabaseMapOutput
}

type KxDatabaseMapOutput struct{ *pulumi.OutputState }

type KxDatabaseOutput struct{ *pulumi.OutputState }

type KxDatabaseState struct {
	// Amazon Resource Name (ARN) identifier of the KX database.
	Arn pulumi.StringPtrInput
	// Timestamp at which the databse is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	CreatedTimestamp pulumi.StringPtrInput
	// Description of the KX database.
	Description pulumi.StringPtrInput
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringPtrInput
	// Last timestamp at which the database was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	LastModifiedTimestamp pulumi.StringPtrInput
	// Name of the KX database.
	//
	// The following arguments are optional:
	Name pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
}

type KxDataview struct {
	pulumi.CustomResourceState

	// Amazon Resource Name (ARN) identifier of the KX dataview.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The option to specify whether you want to apply all the future additions and corrections automatically to the dataview, when you ingest new changesets. The default value is false.
	AutoUpdate pulumi.BoolOutput `pulumi:"autoUpdate"`
	// The identifier of the availability zones. If attaching a volume, the volume must be in the same availability zone as the dataview that you are attaching to.
	AvailabilityZoneId pulumi.StringPtrOutput `pulumi:"availabilityZoneId"`
	// The number of availability zones you want to assign per cluster. This can be one of the following:
	// * `SINGLE` - Assigns one availability zone per cluster.
	// * `MULTI` - Assigns all the availability zones per cluster.
	AzMode pulumi.StringOutput `pulumi:"azMode"`
	// A unique identifier of the changeset of the database that you want to use to ingest data.
	ChangesetId pulumi.StringPtrOutput `pulumi:"changesetId"`
	// Timestamp at which the dataview was created in FinSpace. Value determined as epoch time in milliseconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000000.
	CreatedTimestamp pulumi.StringOutput `pulumi:"createdTimestamp"`
	// The name of the database where you want to create a dataview.
	DatabaseName pulumi.StringOutput `pulumi:"databaseName"`
	// A description for the dataview.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringOutput `pulumi:"environmentId"`
	// The last time that the dataview was updated in FinSpace. The value is determined as epoch time in milliseconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000000.
	LastModifiedTimestamp pulumi.StringOutput `pulumi:"lastModifiedTimestamp"`
	// A unique identifier for the dataview.
	//
	// The following arguments are optional:
	Name pulumi.StringOutput `pulumi:"name"`
	// The option to specify whether you want to make the dataview writable to perform database maintenance. The following are some considerations related to writable dataviews.
	// * You cannot create partial writable dataviews. When you create writeable dataviews you must provide the entire database path. You cannot perform updates on a writeable dataview. Hence, `autoUpdate` must be set as `false` if `readWrite` is `true` for a dataview.
	// * You must also use a unique volume for creating a writeable dataview. So, if you choose a volume that is already in use by another dataview, the dataview creation fails.
	// * Once you create a dataview as writeable, you cannot change it to read-only. So, you cannot update the `readWrite` parameter later.
	ReadWrite pulumi.BoolPtrOutput `pulumi:"readWrite"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// The configuration that contains the database path of the data that you want to place on each selected volume. Each segment must have a unique database path for each volume. If you do not explicitly specify any database path for a volume, they are accessible from the cluster through the default S3/object store segment. See segmentConfigurations below.
	SegmentConfigurations KxDataviewSegmentConfigurationArrayOutput `pulumi:"segmentConfigurations"`
	Status                pulumi.StringOutput                       `pulumi:"status"`
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

type KxDataviewArgs struct {
	// The option to specify whether you want to apply all the future additions and corrections automatically to the dataview, when you ingest new changesets. The default value is false.
	AutoUpdate pulumi.BoolInput
	// The identifier of the availability zones. If attaching a volume, the volume must be in the same availability zone as the dataview that you are attaching to.
	AvailabilityZoneId pulumi.StringPtrInput
	// The number of availability zones you want to assign per cluster. This can be one of the following:
	// * `SINGLE` - Assigns one availability zone per cluster.
	// * `MULTI` - Assigns all the availability zones per cluster.
	AzMode pulumi.StringInput
	// A unique identifier of the changeset of the database that you want to use to ingest data.
	ChangesetId pulumi.StringPtrInput
	// The name of the database where you want to create a dataview.
	DatabaseName pulumi.StringInput
	// A description for the dataview.
	Description pulumi.StringPtrInput
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringInput
	// A unique identifier for the dataview.
	//
	// The following arguments are optional:
	Name pulumi.StringPtrInput
	// The option to specify whether you want to make the dataview writable to perform database maintenance. The following are some considerations related to writable dataviews.
	// * You cannot create partial writable dataviews. When you create writeable dataviews you must provide the entire database path. You cannot perform updates on a writeable dataview. Hence, `autoUpdate` must be set as `false` if `readWrite` is `true` for a dataview.
	// * You must also use a unique volume for creating a writeable dataview. So, if you choose a volume that is already in use by another dataview, the dataview creation fails.
	// * Once you create a dataview as writeable, you cannot change it to read-only. So, you cannot update the `readWrite` parameter later.
	ReadWrite pulumi.BoolPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// The configuration that contains the database path of the data that you want to place on each selected volume. Each segment must have a unique database path for each volume. If you do not explicitly specify any database path for a volume, they are accessible from the cluster through the default S3/object store segment. See segmentConfigurations below.
	SegmentConfigurations KxDataviewSegmentConfigurationArrayInput
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

type KxDataviewArray []KxDataviewInput

type KxDataviewArrayInput interface {
	pulumi.Input

	ToKxDataviewArrayOutput() KxDataviewArrayOutput
	ToKxDataviewArrayOutputWithContext(context.Context) KxDataviewArrayOutput
}

type KxDataviewArrayOutput struct{ *pulumi.OutputState }

type KxDataviewInput interface {
	pulumi.Input

	ToKxDataviewOutput() KxDataviewOutput
	ToKxDataviewOutputWithContext(ctx context.Context) KxDataviewOutput
}

type KxDataviewMap map[string]KxDataviewInput

type KxDataviewMapInput interface {
	pulumi.Input

	ToKxDataviewMapOutput() KxDataviewMapOutput
	ToKxDataviewMapOutputWithContext(context.Context) KxDataviewMapOutput
}

type KxDataviewMapOutput struct{ *pulumi.OutputState }

type KxDataviewOutput struct{ *pulumi.OutputState }

type KxDataviewSegmentConfiguration struct {
	// The database path of the data that you want to place on each selected volume. Each segment must have a unique database path for each volume.
	DbPaths []string `pulumi:"dbPaths"`
	// Enables on-demand caching on the selected database path when a particular file or a column of the database is accessed. When on demand caching is **True**, dataviews perform minimal loading of files on the filesystem as needed. When it is set to **False**, everything is cached. The default value is **False**.
	OnDemand *bool `pulumi:"onDemand"`
	// The name of the volume that you want to attach to a dataview. This volume must be in the same availability zone as the dataview that you are attaching to.
	VolumeName string `pulumi:"volumeName"`
}

type KxDataviewSegmentConfigurationArgs struct {
	// The database path of the data that you want to place on each selected volume. Each segment must have a unique database path for each volume.
	DbPaths pulumi.StringArrayInput `pulumi:"dbPaths"`
	// Enables on-demand caching on the selected database path when a particular file or a column of the database is accessed. When on demand caching is **True**, dataviews perform minimal loading of files on the filesystem as needed. When it is set to **False**, everything is cached. The default value is **False**.
	OnDemand pulumi.BoolPtrInput `pulumi:"onDemand"`
	// The name of the volume that you want to attach to a dataview. This volume must be in the same availability zone as the dataview that you are attaching to.
	VolumeName pulumi.StringInput `pulumi:"volumeName"`
}

type KxDataviewSegmentConfigurationArray []KxDataviewSegmentConfigurationInput

type KxDataviewSegmentConfigurationArrayInput interface {
	pulumi.Input

	ToKxDataviewSegmentConfigurationArrayOutput() KxDataviewSegmentConfigurationArrayOutput
	ToKxDataviewSegmentConfigurationArrayOutputWithContext(context.Context) KxDataviewSegmentConfigurationArrayOutput
}

type KxDataviewSegmentConfigurationArrayOutput struct{ *pulumi.OutputState }

type KxDataviewSegmentConfigurationInput interface {
	pulumi.Input

	ToKxDataviewSegmentConfigurationOutput() KxDataviewSegmentConfigurationOutput
	ToKxDataviewSegmentConfigurationOutputWithContext(context.Context) KxDataviewSegmentConfigurationOutput
}

type KxDataviewSegmentConfigurationOutput struct{ *pulumi.OutputState }

type KxDataviewState struct {
	// Amazon Resource Name (ARN) identifier of the KX dataview.
	Arn pulumi.StringPtrInput
	// The option to specify whether you want to apply all the future additions and corrections automatically to the dataview, when you ingest new changesets. The default value is false.
	AutoUpdate pulumi.BoolPtrInput
	// The identifier of the availability zones. If attaching a volume, the volume must be in the same availability zone as the dataview that you are attaching to.
	AvailabilityZoneId pulumi.StringPtrInput
	// The number of availability zones you want to assign per cluster. This can be one of the following:
	// * `SINGLE` - Assigns one availability zone per cluster.
	// * `MULTI` - Assigns all the availability zones per cluster.
	AzMode pulumi.StringPtrInput
	// A unique identifier of the changeset of the database that you want to use to ingest data.
	ChangesetId pulumi.StringPtrInput
	// Timestamp at which the dataview was created in FinSpace. Value determined as epoch time in milliseconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000000.
	CreatedTimestamp pulumi.StringPtrInput
	// The name of the database where you want to create a dataview.
	DatabaseName pulumi.StringPtrInput
	// A description for the dataview.
	Description pulumi.StringPtrInput
	// Unique identifier for the KX environment.
	EnvironmentId pulumi.StringPtrInput
	// The last time that the dataview was updated in FinSpace. The value is determined as epoch time in milliseconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000000.
	LastModifiedTimestamp pulumi.StringPtrInput
	// A unique identifier for the dataview.
	//
	// The following arguments are optional:
	Name pulumi.StringPtrInput
	// The option to specify whether you want to make the dataview writable to perform database maintenance. The following are some considerations related to writable dataviews.
	// * You cannot create partial writable dataviews. When you create writeable dataviews you must provide the entire database path. You cannot perform updates on a writeable dataview. Hence, `autoUpdate` must be set as `false` if `readWrite` is `true` for a dataview.
	// * You must also use a unique volume for creating a writeable dataview. So, if you choose a volume that is already in use by another dataview, the dataview creation fails.
	// * Once you create a dataview as writeable, you cannot change it to read-only. So, you cannot update the `readWrite` parameter later.
	ReadWrite pulumi.BoolPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// The configuration that contains the database path of the data that you want to place on each selected volume. Each segment must have a unique database path for each volume. If you do not explicitly specify any database path for a volume, they are accessible from the cluster through the default S3/object store segment. See segmentConfigurations below.
	SegmentConfigurations KxDataviewSegmentConfigurationArrayInput
	Status                pulumi.StringPtrInput
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
}

type KxEnvironment struct {
	pulumi.CustomResourceState

	// Amazon Resource Name (ARN) identifier of the KX environment.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// AWS Availability Zone IDs that this environment is available in. Important when selecting VPC subnets to use in cluster creation.
	AvailabilityZones pulumi.StringArrayOutput `pulumi:"availabilityZones"`
	// Timestamp at which the environment is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	CreatedTimestamp pulumi.StringOutput `pulumi:"createdTimestamp"`
	// List of DNS server name and server IP. This is used to set up Route-53 outbound resolvers. Defined below.
	CustomDnsConfigurations KxEnvironmentCustomDnsConfigurationArrayOutput `pulumi:"customDnsConfigurations"`
	// Description for the KX environment.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Unique identifier for the AWS environment infrastructure account.
	InfrastructureAccountId pulumi.StringOutput `pulumi:"infrastructureAccountId"`
	// KMS key ID to encrypt your data in the FinSpace environment.
	//
	// The following arguments are optional:
	KmsKeyId pulumi.StringOutput `pulumi:"kmsKeyId"`
	// Last timestamp at which the environment was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
	LastModifiedTimestamp pulumi.StringOutput `pulumi:"lastModifiedTimestamp"`
	// Name of the KX environment that you want to create.
	Name pulumi.StringOutput `pulumi:"name"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// Status of environment creation
	Status pulumi.StringOutput `pulumi:"status"`
	// Key-value mapping of resource tags. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// Transit gateway and network configuration that is used to connect the KX environment to an internal network. Defined below.
	TransitGatewayConfiguration KxEnvironmentTransitGatewayConfigurationPtrOutput `pulumi:"transitGatewayConfiguration"`
}