@propulsionworks/cloudformation 0.0.2 → 0.1.0

package/out/exports/resources.generated/aws-glue-job.d.ts

@@ -0,0 +1,192 @@
+import type { ResourceDefinition } from "../main.ts";
+export type GlueJob = ResourceDefinition<"AWS::Glue::Job", GlueJobProps>;
+/**
+ * The `AWS::Glue::Job` resource specifies an AWS Glue job in the data catalog. For more information, see [Adding Jobs in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/add-job.html) and [Job Structure](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-Job) in the *AWS Glue Developer Guide.*
+ */
+export type GlueJobProps = {
+    /**
+     * This parameter is no longer supported. Use `MaxCapacity` instead.
+     *
+     * The number of capacity units that are allocated to this job.
+     */
+    AllocatedCapacity?: number | undefined;
+    /**
+     * The code that executes a job.
+     */
+    Command: JobCommand;
+    /**
+     * The connections used for this job.
+     */
+    Connections?: ConnectionsList | undefined;
+    /**
+     * The default arguments for this job, specified as name-value pairs.
+     *
+     * You can specify arguments here that your own job-execution script consumes, in addition to arguments that AWS Glue itself consumes.
+     *
+     * For information about how to specify and consume your own job arguments, see [Calling AWS Glue APIs in Python](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html) in the *AWS Glue Developer Guide* .
+     *
+     * For information about the key-value pairs that AWS Glue consumes to set up your job, see [Special Parameters Used by AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html) in the *AWS Glue Developer Guide* .
+     */
+    DefaultArguments?: Record<string, unknown> | undefined;
+    /**
+     * A description of the job.
+     */
+    Description?: string | undefined;
+    /**
+     * Indicates whether the job is run with a standard or flexible execution class. The standard execution class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.
+     *
+     * The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary.
+     *
+     * Only jobs with AWS Glue version 3.0 and above and command type `glueetl` will be allowed to set `ExecutionClass` to `FLEX` . The flexible execution class is available for Spark jobs.
+     */
+    ExecutionClass?: string | undefined;
+    /**
+     * The maximum number of concurrent runs that are allowed for this job.
+     */
+    ExecutionProperty?: ExecutionProperty | undefined;
+    /**
+     * Glue version determines the versions of Apache Spark and Python that AWS Glue supports. The Python version indicates the version supported for jobs of type Spark.
+     *
+     * For more information about the available AWS Glue versions and corresponding Spark and Python versions, see [Glue version](https://docs.aws.amazon.com/glue/latest/dg/add-job.html) in the developer guide.
+     *
+     * Jobs that are created without specifying a Glue version default to the latest Glue version available.
+     */
+    GlueVersion?: string | undefined;
+    /**
+     * A mode that describes how a job was created. Valid values are:
+     *
+     * - `SCRIPT` - The job was created using the AWS Glue Studio script editor.
+     * - `VISUAL` - The job was created using the AWS Glue Studio visual editor.
+     * - `NOTEBOOK` - The job was created using an interactive sessions notebook.
+     *
+     * When the `JobMode` field is missing or null, `SCRIPT` is assigned as the default value.
+     */
+    JobMode?: string | undefined;
+    /**
+     * Specifies whether job run queuing is enabled for the job runs for this job.
+     *
+     * A value of true means job run queuing is enabled for the job runs. If false or not populated, the job runs will not be considered for queueing.
+     *
+     * If this field does not match the value set in the job run, then the value from the job run field will be used.
+     */
+    JobRunQueuingEnabled?: boolean | undefined;
+    /**
+     * This field is reserved for future use.
+     */
+    LogUri?: string | undefined;
+    /**
+     * This field specifies a day of the week and hour for a maintenance window for streaming jobs. AWS Glue periodically performs maintenance activities. During these maintenance windows, AWS Glue will need to restart your streaming jobs.
+     *
+     * AWS Glue will restart the job within 3 hours of the specified maintenance window. For instance, if you set up the maintenance window for Monday at 10:00AM GMT, your jobs will be restarted between 10:00AM GMT to 1:00PM GMT.
+     */
+    MaintenanceWindow?: string | undefined;
+    /**
+     * The number of AWS Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory.
+     *
+     * Do not set `Max Capacity` if using `WorkerType` and `NumberOfWorkers` .
+     *
+     * The value that can be allocated for `MaxCapacity` depends on whether you are running a Python shell job or an Apache Spark ETL job:
+     *
+     * - When you specify a Python shell job ( `JobCommand.Name` ="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.
+     * - When you specify an Apache Spark ETL job ( `JobCommand.Name` ="glueetl"), you can allocate from 2 to 100 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.
+     */
+    MaxCapacity?: number | undefined;
+    /**
+     * The maximum number of times to retry this job after a JobRun fails.
+     */
+    MaxRetries?: number | undefined;
+    /**
+     * The name you assign to this job definition.
+     */
+    Name?: string | undefined;
+    /**
+     * Non-overridable arguments for this job, specified as name-value pairs.
+     */
+    NonOverridableArguments?: Record<string, unknown> | undefined;
+    /**
+     * Specifies configuration properties of a notification.
+     */
+    NotificationProperty?: NotificationProperty | undefined;
+    /**
+     * The number of workers of a defined `workerType` that are allocated when a job runs.
+     *
+     * The maximum number of workers you can define are 299 for `G.1X` , and 149 for `G.2X` .
+     */
+    NumberOfWorkers?: number | undefined;
+    /**
+     * The name or Amazon Resource Name (ARN) of the IAM role associated with this job.
+     */
+    Role: string;
+    /**
+     * The name of the `SecurityConfiguration` structure to be used with this job.
+     */
+    SecurityConfiguration?: string | undefined;
+    /**
+     * The tags to use with this job.
+     */
+    Tags?: Record<string, unknown> | undefined;
+    /**
+     * The job timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters TIMEOUT status. The default is 2,880 minutes (48 hours).
+     */
+    Timeout?: number | undefined;
+    /**
+     * The type of predefined worker that is allocated when a job runs. Accepts a value of G.1X, G.2X, G.4X, G.8X or G.025X for Spark jobs. Accepts the value Z.2X for Ray jobs.
+     *
+     * - For the `G.1X` worker type, each worker maps to 1 DPU (4 vCPUs, 16 GB of memory) with 94GB disk, and provides 1 executor per worker. We recommend this worker type for workloads such as data transforms, joins, and queries, to offers a scalable and cost effective way to run most jobs.
+     * - For the `G.2X` worker type, each worker maps to 2 DPU (8 vCPUs, 32 GB of memory) with 138GB disk, and provides 1 executor per worker. We recommend this worker type for workloads such as data transforms, joins, and queries, to offers a scalable and cost effective way to run most jobs.
+     * - For the `G.4X` worker type, each worker maps to 4 DPU (16 vCPUs, 64 GB of memory) with 256GB disk, and provides 1 executor per worker. We recommend this worker type for jobs whose workloads contain your most demanding transforms, aggregations, joins, and queries. This worker type is available only for AWS Glue version 3.0 or later Spark ETL jobs in the following AWS Regions: US East (Ohio), US East (N. Virginia), US West (Oregon), Asia Pacific (Singapore), Asia Pacific (Sydney), Asia Pacific (Tokyo), Canada (Central), Europe (Frankfurt), Europe (Ireland), and Europe (Stockholm).
+     * - For the `G.8X` worker type, each worker maps to 8 DPU (32 vCPUs, 128 GB of memory) with 512GB disk, and provides 1 executor per worker. We recommend this worker type for jobs whose workloads contain your most demanding transforms, aggregations, joins, and queries. This worker type is available only for AWS Glue version 3.0 or later Spark ETL jobs, in the same AWS Regions as supported for the `G.4X` worker type.
+     * - For the `G.025X` worker type, each worker maps to 0.25 DPU (2 vCPUs, 4 GB of memory) with 84GB disk, and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for AWS Glue version 3.0 or later streaming jobs.
+     * - For the `Z.2X` worker type, each worker maps to 2 M-DPU (8vCPUs, 64 GB of memory) with 128 GB disk, and provides up to 8 Ray workers based on the autoscaler.
+     */
+    WorkerType?: "Standard" | "G.1X" | "G.2X" | "G.025X" | "G.4X" | "G.8X" | "Z.2X" | undefined;
+};
+/**
+ * Specifies the connections used by a job.
+ */
+export type ConnectionsList = {
+    /**
+     * A list of connections used by the job.
+     */
+    Connections?: string[] | undefined;
+};
+/**
+ * An execution property of a job.
+ */
+export type ExecutionProperty = {
+    /**
+     * The maximum number of concurrent runs allowed for the job. The default is 1. An error is returned when this threshold is reached. The maximum value you can specify is controlled by a service limit.
+     */
+    MaxConcurrentRuns?: number | undefined;
+};
+/**
+ * Specifies code executed when a job is run.
+ */
+export type JobCommand = {
+    /**
+     * The name of the job command. For an Apache Spark ETL job, this must be `glueetl` . For a Python shell job, it must be `pythonshell` . For an Apache Spark streaming ETL job, this must be `gluestreaming` . For a Ray job, this must be `glueray` .
+     */
+    Name?: string | undefined;
+    /**
+     * The Python version being used to execute a Python shell job. Allowed values are 3 or 3.9. Version 2 is deprecated.
+     */
+    PythonVersion?: string | undefined;
+    /**
+     * In Ray jobs, Runtime is used to specify the versions of Ray, Python and additional libraries available in your environment. This field is not used in other job types. For supported runtime environment values, see [Working with Ray jobs](https://docs.aws.amazon.com/glue/latest/dg/ray-jobs-section.html) in the AWS Glue Developer Guide.
+     */
+    Runtime?: string | undefined;
+    /**
+     * Specifies the Amazon Simple Storage Service (Amazon S3) path to a script that executes a job (required).
+     */
+    ScriptLocation?: string | undefined;
+};
+/**
+ * Specifies configuration properties of a notification.
+ */
+export type NotificationProperty = {
+    /**
+     * After a job run starts, the number of minutes to wait before sending a job run delay notification.
+     */
+    NotifyDelayAfter?: number | undefined;
+};
+//# sourceMappingURL=aws-glue-job.d.ts.map

package/out/exports/resources.generated/aws-glue-mltransform.d.ts

@@ -0,0 +1,205 @@
+import type { ResourceDefinitionWithAttributes } from "../main.ts";
+export type GlueMLTransform = ResourceDefinitionWithAttributes<"AWS::Glue::MLTransform", GlueMLTransformProps, GlueMLTransformAttribs>;
+/**
+ * The AWS::Glue::MLTransform is an AWS Glue resource type that manages machine learning transforms.
+ */
+export type GlueMLTransformProps = {
+    /**
+     * A user-defined, long-form description text for the machine learning transform.
+     */
+    Description?: string | undefined;
+    /**
+     * This value determines which version of AWS Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see [AWS Glue Versions](https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions) in the developer guide.
+     */
+    GlueVersion?: string | undefined;
+    /**
+     * A list of AWS Glue table definitions used by the transform.
+     */
+    InputRecordTables: InputRecordTables;
+    /**
+     * The number of AWS Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the [AWS Glue pricing page](https://docs.aws.amazon.com/glue/pricing/) .
+     *
+     * `MaxCapacity` is a mutually exclusive option with `NumberOfWorkers` and `WorkerType` .
+     *
+     * - If either `NumberOfWorkers` or `WorkerType` is set, then `MaxCapacity` cannot be set.
+     * - If `MaxCapacity` is set then neither `NumberOfWorkers` or `WorkerType` can be set.
+     * - If `WorkerType` is set, then `NumberOfWorkers` is required (and vice versa).
+     * - `MaxCapacity` and `NumberOfWorkers` must both be at least 1.
+     *
+     * When the `WorkerType` field is set to a value other than `Standard` , the `MaxCapacity` field is set automatically and becomes read-only.
+     */
+    MaxCapacity?: number | undefined;
+    /**
+     * The maximum number of times to retry after an `MLTaskRun` of the machine learning transform fails.
+     */
+    MaxRetries?: number | undefined;
+    /**
+     * A user-defined name for the machine learning transform. Names are required to be unique. `Name` is optional:
+     *
+     * - If you supply `Name` , the stack cannot be repeatedly created.
+     * - If `Name` is not provided, a randomly generated name will be used instead.
+     */
+    Name?: string | undefined;
+    /**
+     * The number of workers of a defined `workerType` that are allocated when a task of the transform runs.
+     *
+     * If `WorkerType` is set, then `NumberOfWorkers` is required (and vice versa).
+     */
+    NumberOfWorkers?: number | undefined;
+    /**
+     * The name or Amazon Resource Name (ARN) of the IAM role with the required permissions. The required permissions include both AWS Glue service role permissions to AWS Glue resources, and Amazon S3 permissions required by the transform.
+     *
+     * - This role needs AWS Glue service role permissions to allow access to resources in AWS Glue . See [Attach a Policy to IAM Users That Access AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/attach-policy-iam-user.html) .
+     * - This role needs permission to your Amazon Simple Storage Service (Amazon S3) sources, targets, temporary directory, scripts, and any libraries used by the task run for this transform.
+     */
+    Role: string;
+    /**
+     * The tags to use with this machine learning transform. You may use tags to limit access to the machine learning transform. For more information about tags in AWS Glue , see [AWS Tags in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html) in the developer guide.
+     */
+    Tags?: Record<string, unknown> | undefined;
+    /**
+     * The timeout in minutes of the machine learning transform.
+     */
+    Timeout?: number | undefined;
+    /**
+     * The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning
+     * transforms can access user data encrypted in Amazon S3 using KMS.
+     *
+     * Additionally, imported labels and trained transforms can now be encrypted using a customer provided
+     * KMS key.
+     */
+    TransformEncryption?: TransformEncryption | undefined;
+    /**
+     * The algorithm-specific parameters that are associated with the machine learning transform.
+     */
+    TransformParameters: TransformParameters;
+    /**
+     * The type of predefined worker that is allocated when a task of this transform runs. Accepts a value of Standard, G.1X, or G.2X.
+     *
+     * - For the `Standard` worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.
+     * - For the `G.1X` worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.
+     * - For the `G.2X` worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.
+     *
+     * `MaxCapacity` is a mutually exclusive option with `NumberOfWorkers` and `WorkerType` .
+     *
+     * - If either `NumberOfWorkers` or `WorkerType` is set, then `MaxCapacity` cannot be set.
+     * - If `MaxCapacity` is set then neither `NumberOfWorkers` or `WorkerType` can be set.
+     * - If `WorkerType` is set, then `NumberOfWorkers` is required (and vice versa).
+     * - `MaxCapacity` and `NumberOfWorkers` must both be at least 1.
+     */
+    WorkerType?: string | undefined;
+};
+export type GlueMLTransformAttribs = {
+    Id: string;
+};
+/**
+ * The parameters to configure the find matches transform.
+ */
+export type FindMatchesParameters = {
+    /**
+     * The value that is selected when tuning your transform for a balance between accuracy and cost. A value of 0.5 means that the system balances accuracy and cost concerns. A value of 1.0 means a bias purely for accuracy, which typically results in a higher cost, sometimes substantially higher. A value of 0.0 means a bias purely for cost, which results in a less accurate `FindMatches` transform, sometimes with unacceptable accuracy.
+     *
+     * Accuracy measures how well the transform finds true positives and true negatives. Increasing accuracy requires more machine resources and cost. But it also results in increased recall.
+     *
+     * Cost measures how many compute resources, and thus money, are consumed to run the transform.
+     */
+    AccuracyCostTradeoff?: number | undefined;
+    /**
+     * The value to switch on or off to force the output to match the provided labels from users. If the value is `True` , the `find matches` transform forces the output to match the provided labels. The results override the normal conflation results. If the value is `False` , the `find matches` transform does not ensure all the labels provided are respected, and the results rely on the trained model.
+     *
+     * Note that setting this value to true may increase the conflation execution time.
+     */
+    EnforceProvidedLabels?: boolean | undefined;
+    /**
+     * The value selected when tuning your transform for a balance between precision and recall. A value of 0.5 means no preference; a value of 1.0 means a bias purely for precision, and a value of 0.0 means a bias for recall. Because this is a tradeoff, choosing values close to 1.0 means very low recall, and choosing values close to 0.0 results in very low precision.
+     *
+     * The precision metric indicates how often your model is correct when it predicts a match.
+     *
+     * The recall metric indicates that for an actual match, how often your model predicts the match.
+     */
+    PrecisionRecallTradeoff?: number | undefined;
+    /**
+     * The name of a column that uniquely identifies rows in the source table. Used to help identify matching records.
+     */
+    PrimaryKeyColumnName: string;
+};
+/**
+ * The database and table in the AWS Glue Data Catalog that is used for input or output data.
+ */
+export type GlueTables = {
+    /**
+     * A unique identifier for the AWS Glue Data Catalog .
+     */
+    CatalogId?: string | undefined;
+    /**
+     * The name of the connection to the AWS Glue Data Catalog .
+     */
+    ConnectionName?: string | undefined;
+    /**
+     * A database name in the AWS Glue Data Catalog .
+     */
+    DatabaseName: string;
+    /**
+     * A table name in the AWS Glue Data Catalog .
+     */
+    TableName: string;
+};
+/**
+ * A list of AWS Glue table definitions used by the transform.
+ */
+export type InputRecordTables = {
+    /**
+     * The database and table in the AWS Glue Data Catalog that is used for input or output data.
+     */
+    GlueTables?: GlueTables[] | undefined;
+};
+/**
+ * The encryption-at-rest settings of the transform that apply to accessing user data.
+ */
+export type MLUserDataEncryption = {
+    /**
+     * The ID for the customer-provided KMS key.
+     */
+    KmsKeyId?: string | undefined;
+    /**
+     * The encryption mode applied to user data. Valid values are:
+     *
+     * - DISABLED: encryption is disabled.
+     * - SSEKMS: use of server-side encryption with AWS Key Management Service (SSE-KMS) for user data
+     * stored in Amazon S3.
+     */
+    MLUserDataEncryptionMode: string;
+};
+/**
+ * The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning
+ * transforms can access user data encrypted in Amazon S3 using KMS.
+ *
+ * Additionally, imported labels and trained transforms can now be encrypted using a customer provided
+ * KMS key.
+ */
+export type TransformEncryption = {
+    /**
+     * The encryption-at-rest settings of the transform that apply to accessing user data.
+     */
+    MLUserDataEncryption?: MLUserDataEncryption | undefined;
+    /**
+     * The name of the security configuration.
+     */
+    TaskRunSecurityConfigurationName?: string | undefined;
+};
+/**
+ * The algorithm-specific parameters that are associated with the machine learning transform.
+ */
+export type TransformParameters = {
+    /**
+     * The parameters for the find matches algorithm.
+     */
+    FindMatchesParameters?: FindMatchesParameters | undefined;
+    /**
+     * The type of machine learning transform. `FIND_MATCHES` is the only option.
+     *
+     * For information about the types of machine learning transforms, see [Working with machine learning transforms](https://docs.aws.amazon.com/glue/latest/dg/console-machine-learning-transforms.html) .
+     */
+    TransformType: string;
+};
+//# sourceMappingURL=aws-glue-mltransform.d.ts.map

package/out/exports/resources.generated/aws-glue-partition.d.ts

@@ -0,0 +1,208 @@
+import type { ResourceDefinitionWithAttributes } from "../main.ts";
+export type GluePartition = ResourceDefinitionWithAttributes<"AWS::Glue::Partition", GluePartitionProps, GluePartitionAttribs>;
+/**
+ * The `AWS::Glue::Partition` resource creates an AWS Glue partition, which represents a slice of table data. For more information, see [CreatePartition Action](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-CreatePartition) and [Partition Structure](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-Partition) in the *AWS Glue Developer Guide* .
+ */
+export type GluePartitionProps = {
+    /**
+     * The AWS account ID of the catalog in which the partion is to be created.
+     *
+     * > To specify the account ID, you can use the `Ref` intrinsic function with the `AWS::AccountId` pseudo parameter. For example: `!Ref AWS::AccountId`
+     */
+    CatalogId: string;
+    /**
+     * The name of the catalog database in which to create the partition.
+     */
+    DatabaseName: string;
+    /**
+     * The structure used to create and update a partition.
+     */
+    PartitionInput: PartitionInput;
+    /**
+     * The name of the metadata table in which the partition is to be created.
+     */
+    TableName: string;
+};
+export type GluePartitionAttribs = {
+    Id: string;
+};
+/**
+ * A column in a `Table` .
+ */
+export type Column = {
+    /**
+     * A free-form text comment.
+     */
+    Comment?: string | undefined;
+    /**
+     * The name of the `Column` .
+     */
+    Name: string;
+    /**
+     * The data type of the `Column` .
+     */
+    Type?: string | undefined;
+};
+/**
+ * Specifies the sort order of a sorted column.
+ */
+export type Order = {
+    /**
+     * The name of the column.
+     */
+    Column: string;
+    /**
+     * Indicates that the column is sorted in ascending order ( `== 1` ), or in descending order ( `==0` ).
+     */
+    SortOrder?: number | undefined;
+};
+/**
+ * The structure used to create and update a partition.
+ */
+export type PartitionInput = {
+    /**
+     * These key-value pairs define partition parameters.
+     */
+    Parameters?: Record<string, unknown> | undefined;
+    /**
+     * Provides information about the physical location where the partition is stored.
+     */
+    StorageDescriptor?: StorageDescriptor | undefined;
+    /**
+     * The values of the partition. Although this parameter is not required by the SDK, you must specify this parameter for a valid input.
+     *
+     * The values for the keys for the new partition must be passed as an array of String objects that must be ordered in the same order as the partition keys appearing in the Amazon S3 prefix. Otherwise AWS Glue will add the values to the wrong keys.
+     */
+    Values: string[];
+};
+/**
+ * A structure that contains schema identity fields. Either this or the `SchemaVersionId` has to be
+ * provided.
+ */
+export type SchemaId = {
+    /**
+     * The name of the schema registry that contains the schema.
+     */
+    RegistryName?: string | undefined;
+    /**
+     * The Amazon Resource Name (ARN) of the schema. One of `SchemaArn` or `SchemaName` has to be
+     * provided.
+     */
+    SchemaArn?: string | undefined;
+    /**
+     * The name of the schema. One of `SchemaArn` or `SchemaName` has to be provided.
+     */
+    SchemaName?: string | undefined;
+};
+/**
+ * An object that references a schema stored in the AWS Glue Schema Registry.
+ */
+export type SchemaReference = {
+    /**
+     * A structure that contains schema identity fields. Either this or the `SchemaVersionId` has to be
+     * provided.
+     */
+    SchemaId?: SchemaId | undefined;
+    /**
+     * The unique ID assigned to a version of the schema. Either this or the `SchemaId` has to be provided.
+     */
+    SchemaVersionId?: string | undefined;
+    /**
+     * The version number of the schema.
+     */
+    SchemaVersionNumber?: number | undefined;
+};
+/**
+ * Information about a serialization/deserialization program (SerDe) that serves as an extractor and loader.
+ */
+export type SerdeInfo = {
+    /**
+     * Name of the SerDe.
+     */
+    Name?: string | undefined;
+    /**
+     * These key-value pairs define initialization parameters for the SerDe.
+     */
+    Parameters?: Record<string, unknown> | undefined;
+    /**
+     * Usually the class that implements the SerDe. An example is `org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe` .
+     */
+    SerializationLibrary?: string | undefined;
+};
+/**
+ * Specifies skewed values in a table. Skewed values are those that occur with very high frequency.
+ */
+export type SkewedInfo = {
+    /**
+     * A list of names of columns that contain skewed values.
+     */
+    SkewedColumnNames?: string[] | undefined;
+    /**
+     * A mapping of skewed values to the columns that contain them.
+     */
+    SkewedColumnValueLocationMaps?: Record<string, unknown> | undefined;
+    /**
+     * A list of values that appear so frequently as to be considered skewed.
+     */
+    SkewedColumnValues?: string[] | undefined;
+};
+/**
+ * Describes the physical storage of table data.
+ */
+export type StorageDescriptor = {
+    /**
+     * A list of reducer grouping columns, clustering columns, and bucketing columns in the table.
+     */
+    BucketColumns?: string[] | undefined;
+    /**
+     * A list of the `Columns` in the table.
+     */
+    Columns?: Column[] | undefined;
+    /**
+     * `True` if the data in the table is compressed, or `False` if not.
+     */
+    Compressed?: boolean | undefined;
+    /**
+     * The input format: `SequenceFileInputFormat` (binary), or `TextInputFormat` , or a custom format.
+     */
+    InputFormat?: string | undefined;
+    /**
+     * The physical location of the table. By default, this takes the form of the warehouse location, followed by the database location in the warehouse, followed by the table name.
+     */
+    Location?: string | undefined;
+    /**
+     * The number of buckets.
+     *
+     * You must specify this property if the partition contains any dimension columns.
+     */
+    NumberOfBuckets?: number | undefined;
+    /**
+     * The output format: `SequenceFileOutputFormat` (binary), or `IgnoreKeyTextOutputFormat` , or a custom format.
+     */
+    OutputFormat?: string | undefined;
+    /**
+     * The user-supplied properties in key-value form.
+     */
+    Parameters?: Record<string, unknown> | undefined;
+    /**
+     * An object that references a schema stored in the AWS Glue Schema Registry.
+     */
+    SchemaReference?: SchemaReference | undefined;
+    /**
+     * The serialization/deserialization (SerDe) information.
+     */
+    SerdeInfo?: SerdeInfo | undefined;
+    /**
+     * The information about values that appear frequently in a column (skewed values).
+     */
+    SkewedInfo?: SkewedInfo | undefined;
+    /**
+     * A list specifying the sort order of each bucket in the table.
+     */
+    SortColumns?: Order[] | undefined;
+    /**
+     * `True` if the table data is stored in subdirectories, or `False` if not.
+     */
+    StoredAsSubDirectories?: boolean | undefined;
+};
+//# sourceMappingURL=aws-glue-partition.d.ts.map

package/out/exports/resources.generated/aws-glue-registry.d.ts

@@ -0,0 +1,31 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type GlueRegistry = ResourceDefinitionWithAttributes<"AWS::Glue::Registry", GlueRegistryProps, GlueRegistryAttribs>;
+/**
+ * The AWS::Glue::Registry is an AWS Glue resource type that manages registries of schemas in the AWS Glue Schema Registry.
+ */
+export type GlueRegistryProps = {
+    /**
+     * A description of the registry.
+     * @minLength 0
+     * @maxLength 1000
+     */
+    Description?: string | undefined;
+    /**
+     * The name of the registry.
+     * @minLength 1
+     * @maxLength 255
+     */
+    Name: string;
+    /**
+     * AWS tags that contain a key value pair and may be searched by console, command line, or API.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type GlueRegistryAttribs = {
+    /**
+     * Amazon Resource Name for the created Registry.
+     * @pattern arn:aws(-(cn|us-gov|iso(-[bef])?))?:glue:.*
+     */
+    Arn: string;
+};
+//# sourceMappingURL=aws-glue-registry.d.ts.map