capo-codecatalyst 0.1.0__py3-none-any.whl

capo_codecatalyst/types/get_dev_environment_request.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetDevEnvironmentRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.uuid
+
+
+class GetDevEnvironmentRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    project_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+    id: "capo_codecatalyst.types.uuid.Uuid"
+    """<p>The system-generated unique ID of the Dev Environment for which you want to view information. To retrieve a list of Dev Environment IDs, use <a>ListDevEnvironments</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDevEnvironmentRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetDevEnvironmentRequest:
+    out: GetDevEnvironmentRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codecatalyst/types/get_dev_environment_response.py

@@ -0,0 +1,169 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetDevEnvironmentResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.dev_environment_repository_summaries
+    import capo_codecatalyst.types.dev_environment_status
+    import capo_codecatalyst.types.ides
+    import capo_codecatalyst.types.inactivity_timeout_minutes
+    import capo_codecatalyst.types.instance_type
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.persistent_storage
+    import capo_codecatalyst.types.status_reason
+    import capo_codecatalyst.types.timestamp
+    import capo_codecatalyst.types.uuid
+
+
+class GetDevEnvironmentResponse(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    project_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+    id: "capo_codecatalyst.types.uuid.Uuid"
+    """<p>The system-generated unique ID of the Dev Environment. </p>"""
+    last_updated_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The time when the Dev Environment was last updated, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+    creator_id: "str"
+    """<p>The system-generated unique ID of the user who created the Dev Environment. </p>"""
+    status: "capo_codecatalyst.types.dev_environment_status.DevEnvironmentStatus"
+    """<p>The current status of the Dev Environment.</p>"""
+    status_reason: NotRequired["capo_codecatalyst.types.status_reason.StatusReason"]
+    """<p>The reason for the status.</p>"""
+    repositories: "capo_codecatalyst.types.dev_environment_repository_summaries.DevEnvironmentRepositorySummaries"
+    """<p>The source repository that contains the branch cloned into the Dev Environment. </p>"""
+    alias: NotRequired["str"]
+    """<p>The user-specified alias for the Dev Environment. </p>"""
+    ides: NotRequired["capo_codecatalyst.types.ides.Ides"]
+    """<p>Information about the integrated development environment (IDE) configured for the Dev Environment. </p>"""
+    instance_type: "capo_codecatalyst.types.instance_type.InstanceType"
+    """<p>The Amazon EC2 instace type to use for the Dev Environment. </p>"""
+    inactivity_timeout_minutes: (
+        "capo_codecatalyst.types.inactivity_timeout_minutes.InactivityTimeoutMinutes"
+    )
+    """<p>The amount of time the Dev Environment will run without any activity detected before stopping, in minutes.</p>"""
+    persistent_storage: "capo_codecatalyst.types.persistent_storage.PersistentStorage"
+    """<p>Information about the amount of storage allocated to the Dev Environment. By default, a Dev Environment is configured to have 16GB of persistent storage.</p>"""
+    vpc_connection_name: NotRequired["capo_codecatalyst.types.name_string.NameString"]
+    """<p>The name of the connection used to connect to Amazon VPC used when the Dev Environment was created, if any.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDevEnvironmentResponse) -> dict:
+    out: dict = {}
+    out["spaceName"] = value["space_name"]
+    out["projectName"] = value["project_name"]
+    out["id"] = value["id"]
+    import capo_codecatalyst._protocol.serialize
+
+    out["lastUpdatedTime"] = capo_codecatalyst._protocol.serialize.fmt_date_time(
+        value["last_updated_time"]
+    )
+    out["creatorId"] = value["creator_id"]
+    out["status"] = value["status"]
+    if "status_reason" in value:
+        out["statusReason"] = value["status_reason"]
+    import capo_codecatalyst.types.dev_environment_repository_summaries
+
+    out["repositories"] = (
+        capo_codecatalyst.types.dev_environment_repository_summaries.serialize_json(
+            value["repositories"]
+        )
+    )
+    if "alias" in value:
+        out["alias"] = value["alias"]
+    if "ides" in value:
+        import capo_codecatalyst.types.ides
+
+        out["ides"] = capo_codecatalyst.types.ides.serialize_json(value["ides"])
+    out["instanceType"] = value["instance_type"]
+    out["inactivityTimeoutMinutes"] = value.get("inactivity_timeout_minutes", 0)
+    import capo_codecatalyst.types.persistent_storage
+
+    out["persistentStorage"] = (
+        capo_codecatalyst.types.persistent_storage.serialize_json(
+            value["persistent_storage"]
+        )
+    )
+    if "vpc_connection_name" in value:
+        out["vpcConnectionName"] = value["vpc_connection_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetDevEnvironmentResponse:
+    out: GetDevEnvironmentResponse = {}  # type: ignore[typeddict-item]
+    if data.get("spaceName") is not None:
+        out["space_name"] = data["spaceName"]
+    else:
+        raise DeserializationError("GetDevEnvironmentResponse.space_name required")
+    if data.get("projectName") is not None:
+        out["project_name"] = data["projectName"]
+    else:
+        raise DeserializationError("GetDevEnvironmentResponse.project_name required")
+    if data.get("id") is not None:
+        out["id"] = data["id"]
+    else:
+        raise DeserializationError("GetDevEnvironmentResponse.id required")
+    if data.get("lastUpdatedTime") is not None:
+        import datetime
+
+        out["last_updated_time"] = datetime.datetime.fromisoformat(
+            data["lastUpdatedTime"].replace("Z", "+00:00")
+        )
+    else:
+        raise DeserializationError(
+            "GetDevEnvironmentResponse.last_updated_time required"
+        )
+    if data.get("creatorId") is not None:
+        out["creator_id"] = data["creatorId"]
+    else:
+        raise DeserializationError("GetDevEnvironmentResponse.creator_id required")
+    if data.get("status") is not None:
+        out["status"] = data["status"]
+    else:
+        raise DeserializationError("GetDevEnvironmentResponse.status required")
+    if data.get("statusReason") is not None:
+        out["status_reason"] = data["statusReason"]
+    if data.get("repositories") is not None:
+        import capo_codecatalyst.types.dev_environment_repository_summaries
+
+        out["repositories"] = (
+            capo_codecatalyst.types.dev_environment_repository_summaries.deserialize_json(
+                data["repositories"]
+            )
+        )
+    else:
+        raise DeserializationError("GetDevEnvironmentResponse.repositories required")
+    if data.get("alias") is not None:
+        out["alias"] = data["alias"]
+    if data.get("ides") is not None:
+        import capo_codecatalyst.types.ides
+
+        out["ides"] = capo_codecatalyst.types.ides.deserialize_json(data["ides"])
+    if data.get("instanceType") is not None:
+        out["instance_type"] = data["instanceType"]
+    else:
+        raise DeserializationError("GetDevEnvironmentResponse.instance_type required")
+    if data.get("inactivityTimeoutMinutes") is not None:
+        out["inactivity_timeout_minutes"] = data["inactivityTimeoutMinutes"]
+    else:
+        out["inactivity_timeout_minutes"] = 0
+    if data.get("persistentStorage") is not None:
+        import capo_codecatalyst.types.persistent_storage
+
+        out["persistent_storage"] = (
+            capo_codecatalyst.types.persistent_storage.deserialize_json(
+                data["persistentStorage"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GetDevEnvironmentResponse.persistent_storage required"
+        )
+    if data.get("vpcConnectionName") is not None:
+        out["vpc_connection_name"] = data["vpcConnectionName"]
+    return out

capo_codecatalyst/types/get_project_request.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetProjectRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+
+
+class GetProjectRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetProjectRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetProjectRequest:
+    out: GetProjectRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codecatalyst/types/get_project_response.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetProjectResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+
+
+class GetProjectResponse(TypedDict, closed=True):
+    space_name: NotRequired["capo_codecatalyst.types.name_string.NameString"]
+    """<p>The name of the space.</p>"""
+    name: "str"
+    """<p>The name of the project in the space.</p>"""
+    display_name: NotRequired["str"]
+    """<p>The friendly name of the project displayed to users in Amazon CodeCatalyst.</p>"""
+    description: NotRequired["str"]
+    """<p>The description of the project.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetProjectResponse) -> dict:
+    out: dict = {}
+    if "space_name" in value:
+        out["spaceName"] = value["space_name"]
+    out["name"] = value["name"]
+    if "display_name" in value:
+        out["displayName"] = value["display_name"]
+    if "description" in value:
+        out["description"] = value["description"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetProjectResponse:
+    out: GetProjectResponse = {}  # type: ignore[typeddict-item]
+    if data.get("spaceName") is not None:
+        out["space_name"] = data["spaceName"]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("GetProjectResponse.name required")
+    if data.get("displayName") is not None:
+        out["display_name"] = data["displayName"]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    return out

capo_codecatalyst/types/get_source_repository_clone_urls_request.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetSourceRepositoryCloneUrlsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.source_repository_name_string
+
+
+class GetSourceRepositoryCloneUrlsRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    project_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+    source_repository_name: "capo_codecatalyst.types.source_repository_name_string.SourceRepositoryNameString"
+    """<p>The name of the source repository.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetSourceRepositoryCloneUrlsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetSourceRepositoryCloneUrlsRequest:
+    out: GetSourceRepositoryCloneUrlsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codecatalyst/types/get_source_repository_clone_urls_response.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetSourceRepositoryCloneUrlsResponse``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+
+class GetSourceRepositoryCloneUrlsResponse(TypedDict, closed=True):
+    https: "str"
+    """<p>The HTTPS URL to use when cloning the source repository.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetSourceRepositoryCloneUrlsResponse) -> dict:
+    out: dict = {}
+    out["https"] = value["https"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetSourceRepositoryCloneUrlsResponse:
+    out: GetSourceRepositoryCloneUrlsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("https") is not None:
+        out["https"] = data["https"]
+    else:
+        raise DeserializationError(
+            "GetSourceRepositoryCloneUrlsResponse.https required"
+        )
+    return out

capo_codecatalyst/types/get_source_repository_request.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetSourceRepositoryRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.source_repository_name_string
+
+
+class GetSourceRepositoryRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    project_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+    name: "capo_codecatalyst.types.source_repository_name_string.SourceRepositoryNameString"
+    """<p>The name of the source repository.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetSourceRepositoryRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetSourceRepositoryRequest:
+    out: GetSourceRepositoryRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codecatalyst/types/get_source_repository_response.py

@@ -0,0 +1,88 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetSourceRepositoryResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.source_repository_description_string
+    import capo_codecatalyst.types.source_repository_name_string
+    import capo_codecatalyst.types.timestamp
+
+
+class GetSourceRepositoryResponse(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    project_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+    name: "capo_codecatalyst.types.source_repository_name_string.SourceRepositoryNameString"
+    """<p>The name of the source repository.</p>"""
+    description: NotRequired[
+        "capo_codecatalyst.types.source_repository_description_string.SourceRepositoryDescriptionString"
+    ]
+    """<p>The description of the source repository.</p>"""
+    last_updated_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The time the source repository was last updated, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+    created_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The time the source repository was created, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetSourceRepositoryResponse) -> dict:
+    out: dict = {}
+    out["spaceName"] = value["space_name"]
+    out["projectName"] = value["project_name"]
+    out["name"] = value["name"]
+    if "description" in value:
+        out["description"] = value["description"]
+    import capo_codecatalyst.types.timestamp
+
+    out["lastUpdatedTime"] = capo_codecatalyst.types.timestamp.serialize_json(
+        value["last_updated_time"]
+    )
+    import capo_codecatalyst.types.timestamp
+
+    out["createdTime"] = capo_codecatalyst.types.timestamp.serialize_json(
+        value["created_time"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GetSourceRepositoryResponse:
+    out: GetSourceRepositoryResponse = {}  # type: ignore[typeddict-item]
+    if data.get("spaceName") is not None:
+        out["space_name"] = data["spaceName"]
+    else:
+        raise DeserializationError("GetSourceRepositoryResponse.space_name required")
+    if data.get("projectName") is not None:
+        out["project_name"] = data["projectName"]
+    else:
+        raise DeserializationError("GetSourceRepositoryResponse.project_name required")
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("GetSourceRepositoryResponse.name required")
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("lastUpdatedTime") is not None:
+        import capo_codecatalyst.types.timestamp
+
+        out["last_updated_time"] = capo_codecatalyst.types.timestamp.deserialize_json(
+            data["lastUpdatedTime"]
+        )
+    else:
+        raise DeserializationError(
+            "GetSourceRepositoryResponse.last_updated_time required"
+        )
+    if data.get("createdTime") is not None:
+        import capo_codecatalyst.types.timestamp
+
+        out["created_time"] = capo_codecatalyst.types.timestamp.deserialize_json(
+            data["createdTime"]
+        )
+    else:
+        raise DeserializationError("GetSourceRepositoryResponse.created_time required")
+    return out

capo_codecatalyst/types/get_space_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetSpaceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+
+
+class GetSpaceRequest(TypedDict, closed=True):
+    name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetSpaceRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetSpaceRequest:
+    out: GetSpaceRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codecatalyst/types/get_space_response.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetSpaceResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.region_string
+
+
+class GetSpaceResponse(TypedDict, closed=True):
+    name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    region_name: "capo_codecatalyst.types.region_string.RegionString"
+    """<p>The Amazon Web Services Region where the space exists.</p>"""
+    display_name: NotRequired["str"]
+    """<p>The friendly name of the space displayed to users.</p>"""
+    description: NotRequired["str"]
+    """<p>The description of the space.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetSpaceResponse) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    out["regionName"] = value["region_name"]
+    if "display_name" in value:
+        out["displayName"] = value["display_name"]
+    if "description" in value:
+        out["description"] = value["description"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetSpaceResponse:
+    out: GetSpaceResponse = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("GetSpaceResponse.name required")
+    if data.get("regionName") is not None:
+        out["region_name"] = data["regionName"]
+    else:
+        raise DeserializationError("GetSpaceResponse.region_name required")
+    if data.get("displayName") is not None:
+        out["display_name"] = data["displayName"]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    return out

capo_codecatalyst/types/get_subscription_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetSubscriptionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+
+
+class GetSubscriptionRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetSubscriptionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetSubscriptionRequest:
+    out: GetSubscriptionRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codecatalyst/types/get_subscription_response.py

@@ -0,0 +1,59 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetSubscriptionResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.timestamp
+
+
+class GetSubscriptionResponse(TypedDict, closed=True):
+    subscription_type: NotRequired["str"]
+    """<p>The type of the billing plan for the space.</p>"""
+    aws_account_name: NotRequired["capo_codecatalyst.types.name_string.NameString"]
+    """<p>The display name of the Amazon Web Services account used for billing for the space.</p>"""
+    pending_subscription_type: NotRequired["str"]
+    r"""<p>The type of the billing plan that the space will be changed to at the start of the next billing cycle. This applies only to changes that reduce the functionality available for the space. Billing plan changes that increase functionality are applied immediately. For more information, see <a href=\"https://codecatalyst.aws/explore/pricing\">Pricing</a>.</p>"""
+    pending_subscription_start_time: NotRequired[
+        "capo_codecatalyst.types.timestamp.Timestamp"
+    ]
+    r"""<p>The day and time the pending change will be applied to the space, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetSubscriptionResponse) -> dict:
+    out: dict = {}
+    if "subscription_type" in value:
+        out["subscriptionType"] = value["subscription_type"]
+    if "aws_account_name" in value:
+        out["awsAccountName"] = value["aws_account_name"]
+    if "pending_subscription_type" in value:
+        out["pendingSubscriptionType"] = value["pending_subscription_type"]
+    if "pending_subscription_start_time" in value:
+        import capo_codecatalyst._protocol.serialize
+
+        out["pendingSubscriptionStartTime"] = (
+            capo_codecatalyst._protocol.serialize.fmt_date_time(
+                value["pending_subscription_start_time"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetSubscriptionResponse:
+    out: GetSubscriptionResponse = {}  # type: ignore[typeddict-item]
+    if data.get("subscriptionType") is not None:
+        out["subscription_type"] = data["subscriptionType"]
+    if data.get("awsAccountName") is not None:
+        out["aws_account_name"] = data["awsAccountName"]
+    if data.get("pendingSubscriptionType") is not None:
+        out["pending_subscription_type"] = data["pendingSubscriptionType"]
+    if data.get("pendingSubscriptionStartTime") is not None:
+        import datetime
+
+        out["pending_subscription_start_time"] = datetime.datetime.fromisoformat(
+            data["pendingSubscriptionStartTime"].replace("Z", "+00:00")
+        )
+    return out

capo_codecatalyst/types/get_user_details_request.py

@@ -0,0 +1,21 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#GetUserDetailsRequest``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class GetUserDetailsRequest(TypedDict, closed=True):
+    id: NotRequired["str"]
+    """<p>The system-generated unique ID of the user. </p>"""
+    user_name: NotRequired["str"]
+    """<p>The name of the user as displayed in Amazon CodeCatalyst.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetUserDetailsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetUserDetailsRequest:
+    out: GetUserDetailsRequest = {}  # type: ignore[typeddict-item]
+    return out