Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that FinSpace User Environment Management service can respond with.

Structs

AutoScalingConfiguration

The configuration based on which FinSpace will scale in or scale out nodes in your cluster.

CapacityConfiguration

A structure for the metadata of a cluster. It includes information like the CPUs needed, memory of instances, and number of instances.

ChangeRequest

A list of change request objects.

CodeConfiguration

The structure of the customer code available within the running cluster.

CustomDnsServer

A list of DNS server name and server IP. This is used to set up Route-53 outbound resolvers.

Environment

Represents an FinSpace environment.

ErrorInfo

Provides details in the event of a failed flow, including the error type and the related error message.

FederationParameters

Configuration information when authentication mode is FEDERATED.

IcmpTypeCode

Defines the ICMP protocol that consists of the ICMP type and code.

KxAttachedCluster

The structure containing the metadata of the attached clusters.

KxCacheStorageConfiguration

The configuration for read only disk cache associated with a cluster.

KxChangesetListEntry

Details of changeset.

KxCluster

The details of a kdb cluster.

KxClusterCodeDeploymentConfiguration

The configuration that allows you to choose how you want to update code on a cluster. Depending on the option you choose, you can reduce the time it takes to update the cluster.

KxCommandLineArgument

Defines the key-value pairs to make them available inside the cluster.

KxDatabaseCacheConfiguration

The structure of database cache configuration that is used for mapping database paths to cache types in clusters.

KxDatabaseConfiguration

The configuration of data that is available for querying from this database.

KxDatabaseListEntry

Details about a FinSpace managed kdb database

KxDataviewActiveVersion

The active version of the dataview that is currently in use by this cluster.

KxDataviewConfiguration

The structure that stores the configuration details of a dataview.

KxDataviewListEntry

A collection of kdb dataview entries.

KxDataviewSegmentConfiguration

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.

KxDeploymentConfiguration

The configuration that allows you to choose how you want to update the databases on a cluster. Depending on the option you choose, you can reduce the time it takes to update the cluster.

KxEnvironment

The details of a kdb environment.

KxNas1Configuration

The structure containing the size and type of the network attached storage (NAS_1) file system volume.

KxNode

A structure that stores metadata for a kdb node.

KxSavedownStorageConfiguration

The size and type of temporary storage that is used to hold data during the savedown process. All the data written to this storage space is lost when the cluster node is restarted.

KxScalingGroup

A structure for storing metadata of scaling group.

KxScalingGroupConfiguration

The structure that stores the capacity configuration details of a scaling group.

KxUser

A structure that stores metadata for a kdb user.

KxVolume

The structure that contains the metadata of the volume.

NetworkAclEntry

The network access control list (ACL) is an optional layer of security for your VPC that acts as a firewall for controlling traffic in and out of one or more subnets. The entry is a set of numbered ingress and egress rules that determine whether a packet should be allowed in or out of a subnet associated with the ACL. We process the entries in the ACL according to the rule numbers, in ascending order.

PortRange

The range of ports the rule applies to.

SuperuserParameters

Configuration information for the superuser.

TickerplantLogConfiguration

A configuration to store the 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.

TransitGatewayConfiguration

The structure of the transit gateway and network configuration that is used to connect the kdb environment to an internal network.

Volume

The structure that consists of name and type of volume.

VpcConfiguration

Configuration details about the network where the Privatelink endpoint of the cluster resides.

Enums

AutoScalingMetric

When writing a match expression against AutoScalingMetric, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChangeType

When writing a match expression against ChangeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChangesetStatus

When writing a match expression against ChangesetStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DnsStatus

When writing a match expression against DnsStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EnvironmentStatus

When writing a match expression against EnvironmentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ErrorDetails

When writing a match expression against ErrorDetails, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FederationMode

When writing a match expression against FederationMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

IpAddressType

When writing a match expression against IpAddressType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxAzMode

When writing a match expression against KxAzMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxClusterCodeDeploymentStrategy

When writing a match expression against KxClusterCodeDeploymentStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxClusterStatus

When writing a match expression against KxClusterStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxClusterType

When writing a match expression against KxClusterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxDataviewStatus

When writing a match expression against KxDataviewStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxDeploymentStrategy

When writing a match expression against KxDeploymentStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxNas1Type

When writing a match expression against KxNas1Type, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxNodeStatus

When writing a match expression against KxNodeStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxSavedownStorageType

When writing a match expression against KxSavedownStorageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxScalingGroupStatus

When writing a match expression against KxScalingGroupStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxVolumeStatus

When writing a match expression against KxVolumeStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KxVolumeType

When writing a match expression against KxVolumeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RuleAction

When writing a match expression against RuleAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TgwStatus

When writing a match expression against TgwStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

VolumeType

When writing a match expression against VolumeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.