capo-redshift-serverless 0.1.0__py3-none-any.whl

capo_redshift_serverless/types/create_snapshot_copy_configuration_response.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CreateSnapshotCopyConfigurationResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_redshift_serverless.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.snapshot_copy_configuration
+
+
+class CreateSnapshotCopyConfigurationResponse(TypedDict, closed=True):
+    snapshot_copy_configuration: "capo_redshift_serverless.types.snapshot_copy_configuration.SnapshotCopyConfiguration"
+    """<p>The snapshot copy configuration object that is returned.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateSnapshotCopyConfigurationResponse) -> dict:
+    out: dict = {}
+    import capo_redshift_serverless.types.snapshot_copy_configuration
+
+    out["snapshotCopyConfiguration"] = (
+        capo_redshift_serverless.types.snapshot_copy_configuration.serialize_aws_json_1_1(
+            value["snapshot_copy_configuration"]
+        )
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateSnapshotCopyConfigurationResponse:
+    out: CreateSnapshotCopyConfigurationResponse = {}  # type: ignore[typeddict-item]
+    if data.get("snapshotCopyConfiguration") is not None:
+        import capo_redshift_serverless.types.snapshot_copy_configuration
+
+        out["snapshot_copy_configuration"] = (
+            capo_redshift_serverless.types.snapshot_copy_configuration.deserialize_aws_json_1_1(
+                data["snapshotCopyConfiguration"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateSnapshotCopyConfigurationResponse.snapshot_copy_configuration required"
+        )
+    return out

capo_redshift_serverless/types/create_snapshot_request.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CreateSnapshotRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_redshift_serverless.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.tag_list
+
+
+class CreateSnapshotRequest(TypedDict, closed=True):
+    namespace_name: "str"
+    """<p>The namespace to create a snapshot for.</p>"""
+    snapshot_name: "str"
+    """<p>The name of the snapshot.</p>"""
+    retention_period: NotRequired["int"]
+    """<p>How long to retain the created snapshot.</p>"""
+    tags: NotRequired["capo_redshift_serverless.types.tag_list.TagList"]
+    r"""<p>An array of <a href=\"https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_Tag.html\">Tag objects</a> to associate with the snapshot.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateSnapshotRequest) -> dict:
+    out: dict = {}
+    out["namespaceName"] = value["namespace_name"]
+    out["snapshotName"] = value["snapshot_name"]
+    if "retention_period" in value:
+        out["retentionPeriod"] = value["retention_period"]
+    if "tags" in value:
+        import capo_redshift_serverless.types.tag_list
+
+        out["tags"] = capo_redshift_serverless.types.tag_list.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateSnapshotRequest:
+    out: CreateSnapshotRequest = {}  # type: ignore[typeddict-item]
+    if data.get("namespaceName") is not None:
+        out["namespace_name"] = data["namespaceName"]
+    else:
+        raise DeserializationError("CreateSnapshotRequest.namespace_name required")
+    if data.get("snapshotName") is not None:
+        out["snapshot_name"] = data["snapshotName"]
+    else:
+        raise DeserializationError("CreateSnapshotRequest.snapshot_name required")
+    if data.get("retentionPeriod") is not None:
+        out["retention_period"] = data["retentionPeriod"]
+    if data.get("tags") is not None:
+        import capo_redshift_serverless.types.tag_list
+
+        out["tags"] = capo_redshift_serverless.types.tag_list.deserialize_aws_json_1_1(
+            data["tags"]
+        )
+    return out

capo_redshift_serverless/types/create_snapshot_response.py

@@ -0,0 +1,40 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CreateSnapshotResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.snapshot
+
+
+class CreateSnapshotResponse(TypedDict, closed=True):
+    snapshot: NotRequired["capo_redshift_serverless.types.snapshot.Snapshot"]
+    """<p>The created snapshot object.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateSnapshotResponse) -> dict:
+    out: dict = {}
+    if "snapshot" in value:
+        import capo_redshift_serverless.types.snapshot
+
+        out["snapshot"] = (
+            capo_redshift_serverless.types.snapshot.serialize_aws_json_1_1(
+                value["snapshot"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateSnapshotResponse:
+    out: CreateSnapshotResponse = {}  # type: ignore[typeddict-item]
+    if data.get("snapshot") is not None:
+        import capo_redshift_serverless.types.snapshot
+
+        out["snapshot"] = (
+            capo_redshift_serverless.types.snapshot.deserialize_aws_json_1_1(
+                data["snapshot"]
+            )
+        )
+    return out

capo_redshift_serverless/types/create_snapshot_schedule_action_parameters.py

@@ -0,0 +1,66 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CreateSnapshotScheduleActionParameters``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_redshift_serverless.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.namespace_name
+    import capo_redshift_serverless.types.snapshot_name_prefix
+    import capo_redshift_serverless.types.tag_list
+
+
+class CreateSnapshotScheduleActionParameters(TypedDict, closed=True):
+    namespace_name: "capo_redshift_serverless.types.namespace_name.NamespaceName"
+    """<p>The name of the namespace for which you want to configure a scheduled action to create a snapshot.</p>"""
+    snapshot_name_prefix: (
+        "capo_redshift_serverless.types.snapshot_name_prefix.SnapshotNamePrefix"
+    )
+    """<p>A string prefix that is attached to the name of the snapshot created by the scheduled action. The final name of the snapshot is the string prefix appended by the date and time of when the snapshot was created.</p>"""
+    retention_period: NotRequired["int"]
+    """<p>The retention period of the snapshot created by the scheduled action.</p>"""
+    tags: NotRequired["capo_redshift_serverless.types.tag_list.TagList"]
+    r"""<p>An array of <a href=\"https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_Tag.html\">Tag objects</a> to associate with the snapshot.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateSnapshotScheduleActionParameters) -> dict:
+    out: dict = {}
+    out["namespaceName"] = value["namespace_name"]
+    out["snapshotNamePrefix"] = value["snapshot_name_prefix"]
+    if "retention_period" in value:
+        out["retentionPeriod"] = value["retention_period"]
+    if "tags" in value:
+        import capo_redshift_serverless.types.tag_list
+
+        out["tags"] = capo_redshift_serverless.types.tag_list.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateSnapshotScheduleActionParameters:
+    out: CreateSnapshotScheduleActionParameters = {}  # type: ignore[typeddict-item]
+    if data.get("namespaceName") is not None:
+        out["namespace_name"] = data["namespaceName"]
+    else:
+        raise DeserializationError(
+            "CreateSnapshotScheduleActionParameters.namespace_name required"
+        )
+    if data.get("snapshotNamePrefix") is not None:
+        out["snapshot_name_prefix"] = data["snapshotNamePrefix"]
+    else:
+        raise DeserializationError(
+            "CreateSnapshotScheduleActionParameters.snapshot_name_prefix required"
+        )
+    if data.get("retentionPeriod") is not None:
+        out["retention_period"] = data["retentionPeriod"]
+    if data.get("tags") is not None:
+        import capo_redshift_serverless.types.tag_list
+
+        out["tags"] = capo_redshift_serverless.types.tag_list.deserialize_aws_json_1_1(
+            data["tags"]
+        )
+    return out

capo_redshift_serverless/types/create_usage_limit_request.py

@@ -0,0 +1,65 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CreateUsageLimitRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_redshift_serverless.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.usage_limit_breach_action
+    import capo_redshift_serverless.types.usage_limit_period
+    import capo_redshift_serverless.types.usage_limit_usage_type
+
+
+class CreateUsageLimitRequest(TypedDict, closed=True):
+    resource_arn: "str"
+    """<p>The Amazon Resource Name (ARN) of the Amazon Redshift Serverless resource to create the usage limit for.</p>"""
+    usage_type: (
+        "capo_redshift_serverless.types.usage_limit_usage_type.UsageLimitUsageType"
+    )
+    """<p>The type of Amazon Redshift Serverless usage to create a usage limit for.</p>"""
+    amount: "int"
+    """<p>The limit amount. If time-based, this amount is in Redshift Processing Units (RPU) consumed per hour. If data-based, this amount is in terabytes (TB) of data transferred between Regions in cross-account sharing. The value must be a positive number.</p>"""
+    period: NotRequired[
+        "capo_redshift_serverless.types.usage_limit_period.UsageLimitPeriod"
+    ]
+    """<p>The time period that the amount applies to. A weekly period begins on Sunday. The default is monthly.</p>"""
+    breach_action: NotRequired[
+        "capo_redshift_serverless.types.usage_limit_breach_action.UsageLimitBreachAction"
+    ]
+    """<p>The action that Amazon Redshift Serverless takes when the limit is reached. The default is log.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateUsageLimitRequest) -> dict:
+    out: dict = {}
+    out["resourceArn"] = value["resource_arn"]
+    out["usageType"] = value["usage_type"]
+    out["amount"] = value["amount"]
+    if "period" in value:
+        out["period"] = value["period"]
+    if "breach_action" in value:
+        out["breachAction"] = value["breach_action"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateUsageLimitRequest:
+    out: CreateUsageLimitRequest = {}  # type: ignore[typeddict-item]
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("CreateUsageLimitRequest.resource_arn required")
+    if data.get("usageType") is not None:
+        out["usage_type"] = data["usageType"]
+    else:
+        raise DeserializationError("CreateUsageLimitRequest.usage_type required")
+    if data.get("amount") is not None:
+        out["amount"] = data["amount"]
+    else:
+        raise DeserializationError("CreateUsageLimitRequest.amount required")
+    if data.get("period") is not None:
+        out["period"] = data["period"]
+    if data.get("breachAction") is not None:
+        out["breach_action"] = data["breachAction"]
+    return out

capo_redshift_serverless/types/create_usage_limit_response.py

@@ -0,0 +1,40 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CreateUsageLimitResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.usage_limit
+
+
+class CreateUsageLimitResponse(TypedDict, closed=True):
+    usage_limit: NotRequired["capo_redshift_serverless.types.usage_limit.UsageLimit"]
+    """<p>The returned usage limit object.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateUsageLimitResponse) -> dict:
+    out: dict = {}
+    if "usage_limit" in value:
+        import capo_redshift_serverless.types.usage_limit
+
+        out["usageLimit"] = (
+            capo_redshift_serverless.types.usage_limit.serialize_aws_json_1_1(
+                value["usage_limit"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateUsageLimitResponse:
+    out: CreateUsageLimitResponse = {}  # type: ignore[typeddict-item]
+    if data.get("usageLimit") is not None:
+        import capo_redshift_serverless.types.usage_limit
+
+        out["usage_limit"] = (
+            capo_redshift_serverless.types.usage_limit.deserialize_aws_json_1_1(
+                data["usageLimit"]
+            )
+        )
+    return out

capo_redshift_serverless/types/create_workgroup_request.py

@@ -0,0 +1,194 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CreateWorkgroupRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_redshift_serverless.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.config_parameter_list
+    import capo_redshift_serverless.types.ip_address_type
+    import capo_redshift_serverless.types.namespace_name
+    import capo_redshift_serverless.types.performance_target
+    import capo_redshift_serverless.types.security_group_id_list
+    import capo_redshift_serverless.types.subnet_id_list
+    import capo_redshift_serverless.types.tag_list
+    import capo_redshift_serverless.types.track_name
+    import capo_redshift_serverless.types.workgroup_name
+
+
+class CreateWorkgroupRequest(TypedDict, closed=True):
+    workgroup_name: "capo_redshift_serverless.types.workgroup_name.WorkgroupName"
+    """<p>The name of the created workgroup.</p>"""
+    namespace_name: "capo_redshift_serverless.types.namespace_name.NamespaceName"
+    """<p>The name of the namespace to associate with the workgroup.</p>"""
+    base_capacity: NotRequired["int"]
+    """<p>The base data warehouse capacity of the workgroup in Redshift Processing Units (RPUs).</p>"""
+    enhanced_vpc_routing: NotRequired["bool"]
+    """<p>The value that specifies whether to turn on enhanced virtual private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.</p>"""
+    config_parameters: NotRequired[
+        "capo_redshift_serverless.types.config_parameter_list.ConfigParameterList"
+    ]
+    r"""<p>An array of parameters to set for advanced control over a database. The options are <code>auto_mv</code>, <code>datestyle</code>, <code>enable_case_sensitive_identifier</code>, <code>enable_user_activity_logging</code>, <code>query_group</code>, <code>search_path</code>, <code>require_ssl</code>, <code>use_fips_ssl</code>, and either <code>wlm_json_configuration</code> or query monitoring metrics that let you define performance boundaries. You can either specify individual query monitoring metrics (such as <code>max_scan_row_count</code>, <code>max_query_execution_time</code>) or use <code>wlm_json_configuration</code> to define query queues with rules, but not both. If you're using <code>wlm_json_configuration</code>, the maximum size of <code>parameterValue</code> is 8000 characters. For more information about query monitoring rules and available metrics, see <a href=\"https://docs.aws.amazon.com/redshift/latest/dg/cm-c-wlm-query-monitoring-rules.html#cm-c-wlm-query-monitoring-metrics-serverless\"> Query monitoring metrics for Amazon Redshift Serverless</a>.</p>"""
+    security_group_ids: NotRequired[
+        "capo_redshift_serverless.types.security_group_id_list.SecurityGroupIdList"
+    ]
+    """<p>An array of security group IDs to associate with the workgroup.</p>"""
+    subnet_ids: NotRequired[
+        "capo_redshift_serverless.types.subnet_id_list.SubnetIdList"
+    ]
+    """<p>An array of VPC subnet IDs to associate with the workgroup.</p>"""
+    publicly_accessible: NotRequired["bool"]
+    """<p>A value that specifies whether the workgroup can be accessed from a public network.</p>"""
+    tags: NotRequired["capo_redshift_serverless.types.tag_list.TagList"]
+    """<p>A array of tag instances.</p>"""
+    port: NotRequired["int"]
+    """<p>The custom port to use when connecting to a workgroup. Valid port ranges are 5431-5455 and 8191-8215. The default is 5439.</p>"""
+    max_capacity: NotRequired["int"]
+    """<p>The maximum data-warehouse capacity Amazon Redshift Serverless uses to serve queries. The max capacity is specified in RPUs.</p>"""
+    price_performance_target: NotRequired[
+        "capo_redshift_serverless.types.performance_target.PerformanceTarget"
+    ]
+    """<p>An object that represents the price performance target settings for the workgroup.</p>"""
+    ip_address_type: NotRequired[
+        "capo_redshift_serverless.types.ip_address_type.IpAddressType"
+    ]
+    """<p>The IP address type that the workgroup supports. Possible values are <code>ipv4</code> and <code>dualstack</code>.</p>"""
+    track_name: NotRequired["capo_redshift_serverless.types.track_name.TrackName"]
+    """<p>An optional parameter for the name of the track for the workgroup. If you don't provide a track name, the workgroup is assigned to the <code>current</code> track.</p>"""
+    extra_compute_for_automatic_optimization: NotRequired["bool"]
+    """<p>If <code>true</code>, allocates additional compute resources for running automatic optimization operations.</p> <p>Default: false</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateWorkgroupRequest) -> dict:
+    out: dict = {}
+    out["workgroupName"] = value["workgroup_name"]
+    out["namespaceName"] = value["namespace_name"]
+    if "base_capacity" in value:
+        out["baseCapacity"] = value["base_capacity"]
+    if "enhanced_vpc_routing" in value:
+        out["enhancedVpcRouting"] = value["enhanced_vpc_routing"]
+    if "config_parameters" in value:
+        import capo_redshift_serverless.types.config_parameter_list
+
+        out["configParameters"] = (
+            capo_redshift_serverless.types.config_parameter_list.serialize_aws_json_1_1(
+                value["config_parameters"]
+            )
+        )
+    if "security_group_ids" in value:
+        import capo_redshift_serverless.types.security_group_id_list
+
+        out["securityGroupIds"] = (
+            capo_redshift_serverless.types.security_group_id_list.serialize_aws_json_1_1(
+                value["security_group_ids"]
+            )
+        )
+    if "subnet_ids" in value:
+        import capo_redshift_serverless.types.subnet_id_list
+
+        out["subnetIds"] = (
+            capo_redshift_serverless.types.subnet_id_list.serialize_aws_json_1_1(
+                value["subnet_ids"]
+            )
+        )
+    if "publicly_accessible" in value:
+        out["publiclyAccessible"] = value["publicly_accessible"]
+    if "tags" in value:
+        import capo_redshift_serverless.types.tag_list
+
+        out["tags"] = capo_redshift_serverless.types.tag_list.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    if "port" in value:
+        out["port"] = value["port"]
+    if "max_capacity" in value:
+        out["maxCapacity"] = value["max_capacity"]
+    if "price_performance_target" in value:
+        import capo_redshift_serverless.types.performance_target
+
+        out["pricePerformanceTarget"] = (
+            capo_redshift_serverless.types.performance_target.serialize_aws_json_1_1(
+                value["price_performance_target"]
+            )
+        )
+    if "ip_address_type" in value:
+        out["ipAddressType"] = value["ip_address_type"]
+    if "track_name" in value:
+        out["trackName"] = value["track_name"]
+    if "extra_compute_for_automatic_optimization" in value:
+        out["extraComputeForAutomaticOptimization"] = value[
+            "extra_compute_for_automatic_optimization"
+        ]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateWorkgroupRequest:
+    out: CreateWorkgroupRequest = {}  # type: ignore[typeddict-item]
+    if data.get("workgroupName") is not None:
+        out["workgroup_name"] = data["workgroupName"]
+    else:
+        raise DeserializationError("CreateWorkgroupRequest.workgroup_name required")
+    if data.get("namespaceName") is not None:
+        out["namespace_name"] = data["namespaceName"]
+    else:
+        raise DeserializationError("CreateWorkgroupRequest.namespace_name required")
+    if data.get("baseCapacity") is not None:
+        out["base_capacity"] = data["baseCapacity"]
+    if data.get("enhancedVpcRouting") is not None:
+        out["enhanced_vpc_routing"] = data["enhancedVpcRouting"]
+    if data.get("configParameters") is not None:
+        import capo_redshift_serverless.types.config_parameter_list
+
+        out["config_parameters"] = (
+            capo_redshift_serverless.types.config_parameter_list.deserialize_aws_json_1_1(
+                data["configParameters"]
+            )
+        )
+    if data.get("securityGroupIds") is not None:
+        import capo_redshift_serverless.types.security_group_id_list
+
+        out["security_group_ids"] = (
+            capo_redshift_serverless.types.security_group_id_list.deserialize_aws_json_1_1(
+                data["securityGroupIds"]
+            )
+        )
+    if data.get("subnetIds") is not None:
+        import capo_redshift_serverless.types.subnet_id_list
+
+        out["subnet_ids"] = (
+            capo_redshift_serverless.types.subnet_id_list.deserialize_aws_json_1_1(
+                data["subnetIds"]
+            )
+        )
+    if data.get("publiclyAccessible") is not None:
+        out["publicly_accessible"] = data["publiclyAccessible"]
+    if data.get("tags") is not None:
+        import capo_redshift_serverless.types.tag_list
+
+        out["tags"] = capo_redshift_serverless.types.tag_list.deserialize_aws_json_1_1(
+            data["tags"]
+        )
+    if data.get("port") is not None:
+        out["port"] = data["port"]
+    if data.get("maxCapacity") is not None:
+        out["max_capacity"] = data["maxCapacity"]
+    if data.get("pricePerformanceTarget") is not None:
+        import capo_redshift_serverless.types.performance_target
+
+        out["price_performance_target"] = (
+            capo_redshift_serverless.types.performance_target.deserialize_aws_json_1_1(
+                data["pricePerformanceTarget"]
+            )
+        )
+    if data.get("ipAddressType") is not None:
+        out["ip_address_type"] = data["ipAddressType"]
+    if data.get("trackName") is not None:
+        out["track_name"] = data["trackName"]
+    if data.get("extraComputeForAutomaticOptimization") is not None:
+        out["extra_compute_for_automatic_optimization"] = data[
+            "extraComputeForAutomaticOptimization"
+        ]
+    return out

capo_redshift_serverless/types/create_workgroup_response.py

@@ -0,0 +1,40 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CreateWorkgroupResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.workgroup
+
+
+class CreateWorkgroupResponse(TypedDict, closed=True):
+    workgroup: NotRequired["capo_redshift_serverless.types.workgroup.Workgroup"]
+    """<p>The created workgroup object.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateWorkgroupResponse) -> dict:
+    out: dict = {}
+    if "workgroup" in value:
+        import capo_redshift_serverless.types.workgroup
+
+        out["workgroup"] = (
+            capo_redshift_serverless.types.workgroup.serialize_aws_json_1_1(
+                value["workgroup"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateWorkgroupResponse:
+    out: CreateWorkgroupResponse = {}  # type: ignore[typeddict-item]
+    if data.get("workgroup") is not None:
+        import capo_redshift_serverless.types.workgroup
+
+        out["workgroup"] = (
+            capo_redshift_serverless.types.workgroup.deserialize_aws_json_1_1(
+                data["workgroup"]
+            )
+        )
+    return out

capo_redshift_serverless/types/currency_code.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CurrencyCode``."""
+
+from typing import TypeAlias
+
+CurrencyCode: TypeAlias = str

capo_redshift_serverless/types/custom_domain_certificate_arn_string.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CustomDomainCertificateArnString``."""
+
+from typing import TypeAlias
+
+CustomDomainCertificateArnString: TypeAlias = str

capo_redshift_serverless/types/custom_domain_name.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#CustomDomainName``."""
+
+from typing import TypeAlias
+
+CustomDomainName: TypeAlias = str

capo_redshift_serverless/types/db_name.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#DbName``."""
+
+from typing import TypeAlias
+
+DbName: TypeAlias = str

capo_redshift_serverless/types/db_password.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#DbPassword``."""
+
+from typing import TypeAlias
+
+DbPassword: TypeAlias = str

capo_redshift_serverless/types/db_user.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#DbUser``."""
+
+from typing import TypeAlias
+
+DbUser: TypeAlias = str

capo_redshift_serverless/types/delete_custom_domain_association_request.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#DeleteCustomDomainAssociationRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_redshift_serverless.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_redshift_serverless.types.custom_domain_name
+    import capo_redshift_serverless.types.workgroup_name
+
+
+class DeleteCustomDomainAssociationRequest(TypedDict, closed=True):
+    workgroup_name: "capo_redshift_serverless.types.workgroup_name.WorkgroupName"
+    """<p>The name of the workgroup associated with the database.</p>"""
+    custom_domain_name: (
+        "capo_redshift_serverless.types.custom_domain_name.CustomDomainName"
+    )
+    """<p>The custom domain name associated with the workgroup.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeleteCustomDomainAssociationRequest) -> dict:
+    out: dict = {}
+    out["workgroupName"] = value["workgroup_name"]
+    out["customDomainName"] = value["custom_domain_name"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeleteCustomDomainAssociationRequest:
+    out: DeleteCustomDomainAssociationRequest = {}  # type: ignore[typeddict-item]
+    if data.get("workgroupName") is not None:
+        out["workgroup_name"] = data["workgroupName"]
+    else:
+        raise DeserializationError(
+            "DeleteCustomDomainAssociationRequest.workgroup_name required"
+        )
+    if data.get("customDomainName") is not None:
+        out["custom_domain_name"] = data["customDomainName"]
+    else:
+        raise DeserializationError(
+            "DeleteCustomDomainAssociationRequest.custom_domain_name required"
+        )
+    return out

capo_redshift_serverless/types/delete_custom_domain_association_response.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.redshiftserverless#DeleteCustomDomainAssociationResponse``."""
+
+from typing_extensions import TypedDict
+
+
+class DeleteCustomDomainAssociationResponse(TypedDict, closed=True):
+    pass
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: DeleteCustomDomainAssociationResponse) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> DeleteCustomDomainAssociationResponse:
+    out: DeleteCustomDomainAssociationResponse = {}  # type: ignore[typeddict-item]
+    return out