capo-codeartifact 0.1.0__py3-none-any.whl

capo_codeartifact/types/dispose_package_versions_result.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#DisposePackageVersionsResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_version_error_map
+    import capo_codeartifact.types.successful_package_version_info_map
+
+
+class DisposePackageVersionsResult(TypedDict, closed=True):
+    successful_versions: NotRequired[
+        "capo_codeartifact.types.successful_package_version_info_map.SuccessfulPackageVersionInfoMap"
+    ]
+    """<p> A list of the package versions that were successfully disposed. </p>"""
+    failed_versions: NotRequired[
+        "capo_codeartifact.types.package_version_error_map.PackageVersionErrorMap"
+    ]
+    """<p> A <code>PackageVersionError</code> object that contains a map of errors codes for the disposed package versions that failed. The possible error codes are: </p> <ul> <li> <p> <code>ALREADY_EXISTS</code> </p> </li> <li> <p> <code>MISMATCHED_REVISION</code> </p> </li> <li> <p> <code>MISMATCHED_STATUS</code> </p> </li> <li> <p> <code>NOT_ALLOWED</code> </p> </li> <li> <p> <code>NOT_FOUND</code> </p> </li> <li> <p> <code>SKIPPED</code> </p> </li> </ul>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DisposePackageVersionsResult) -> dict:
+    out: dict = {}
+    if "successful_versions" in value:
+        import capo_codeartifact.types.successful_package_version_info_map
+
+        out["successfulVersions"] = (
+            capo_codeartifact.types.successful_package_version_info_map.serialize_json(
+                value["successful_versions"]
+            )
+        )
+    if "failed_versions" in value:
+        import capo_codeartifact.types.package_version_error_map
+
+        out["failedVersions"] = (
+            capo_codeartifact.types.package_version_error_map.serialize_json(
+                value["failed_versions"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> DisposePackageVersionsResult:
+    out: DisposePackageVersionsResult = {}  # type: ignore[typeddict-item]
+    if data.get("successfulVersions") is not None:
+        import capo_codeartifact.types.successful_package_version_info_map
+
+        out["successful_versions"] = (
+            capo_codeartifact.types.successful_package_version_info_map.deserialize_json(
+                data["successfulVersions"]
+            )
+        )
+    if data.get("failedVersions") is not None:
+        import capo_codeartifact.types.package_version_error_map
+
+        out["failed_versions"] = (
+            capo_codeartifact.types.package_version_error_map.deserialize_json(
+                data["failedVersions"]
+            )
+        )
+    return out

capo_codeartifact/types/domain_description.py

@@ -0,0 +1,100 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#DomainDescription``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.arn
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.domain_status
+    import capo_codeartifact.types.integer
+    import capo_codeartifact.types.long
+    import capo_codeartifact.types.timestamp
+
+
+class DomainDescription(TypedDict, closed=True):
+    name: NotRequired["capo_codeartifact.types.domain_name.DomainName"]
+    """<p> The name of the domain. </p>"""
+    owner: NotRequired["capo_codeartifact.types.account_id.AccountId"]
+    """<p> The Amazon Web Services account ID that owns the domain. </p>"""
+    arn: NotRequired["capo_codeartifact.types.arn.Arn"]
+    """<p> The Amazon Resource Name (ARN) of the domain. </p>"""
+    status: NotRequired["capo_codeartifact.types.domain_status.DomainStatus"]
+    """<p> The current status of a domain. </p>"""
+    created_time: NotRequired["capo_codeartifact.types.timestamp.Timestamp"]
+    """<p> A timestamp that represents the date and time the domain was created. </p>"""
+    encryption_key: NotRequired["capo_codeartifact.types.arn.Arn"]
+    """<p> The ARN of an Key Management Service (KMS) key associated with a domain. </p>"""
+    repository_count: "capo_codeartifact.types.integer.Integer"
+    """<p> The number of repositories in the domain. </p>"""
+    asset_size_bytes: "capo_codeartifact.types.long.Long"
+    """<p> The total size of all assets in the domain. </p>"""
+    s3_bucket_arn: NotRequired["capo_codeartifact.types.arn.Arn"]
+    """<p>The Amazon Resource Name (ARN) of the Amazon S3 bucket that is used to store package assets in the domain.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DomainDescription) -> dict:
+    out: dict = {}
+    if "name" in value:
+        out["name"] = value["name"]
+    if "owner" in value:
+        out["owner"] = value["owner"]
+    if "arn" in value:
+        out["arn"] = value["arn"]
+    if "status" in value:
+        import capo_codeartifact.types.domain_status
+
+        out["status"] = capo_codeartifact.types.domain_status.serialize_json(
+            value["status"]
+        )
+    if "created_time" in value:
+        import capo_codeartifact.types.timestamp
+
+        out["createdTime"] = capo_codeartifact.types.timestamp.serialize_json(
+            value["created_time"]
+        )
+    if "encryption_key" in value:
+        out["encryptionKey"] = value["encryption_key"]
+    out["repositoryCount"] = value.get("repository_count", 0)
+    out["assetSizeBytes"] = value.get("asset_size_bytes", 0)
+    if "s3_bucket_arn" in value:
+        out["s3BucketArn"] = value["s3_bucket_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> DomainDescription:
+    out: DomainDescription = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    if data.get("owner") is not None:
+        out["owner"] = data["owner"]
+    if data.get("arn") is not None:
+        out["arn"] = data["arn"]
+    if data.get("status") is not None:
+        import capo_codeartifact.types.domain_status
+
+        out["status"] = capo_codeartifact.types.domain_status.deserialize_json(
+            data["status"]
+        )
+    if data.get("createdTime") is not None:
+        import capo_codeartifact.types.timestamp
+
+        out["created_time"] = capo_codeartifact.types.timestamp.deserialize_json(
+            data["createdTime"]
+        )
+    if data.get("encryptionKey") is not None:
+        out["encryption_key"] = data["encryptionKey"]
+    if data.get("repositoryCount") is not None:
+        out["repository_count"] = data["repositoryCount"]
+    else:
+        out["repository_count"] = 0
+    if data.get("assetSizeBytes") is not None:
+        out["asset_size_bytes"] = data["assetSizeBytes"]
+    else:
+        out["asset_size_bytes"] = 0
+    if data.get("s3BucketArn") is not None:
+        out["s3_bucket_arn"] = data["s3BucketArn"]
+    return out

capo_codeartifact/types/domain_entry_point.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#DomainEntryPoint``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.external_connection_name
+    import capo_codeartifact.types.repository_name
+
+
+class DomainEntryPoint(TypedDict, closed=True):
+    repository_name: NotRequired[
+        "capo_codeartifact.types.repository_name.RepositoryName"
+    ]
+    """<p>The name of the repository that a package was originally published to.</p>"""
+    external_connection_name: NotRequired[
+        "capo_codeartifact.types.external_connection_name.ExternalConnectionName"
+    ]
+    """<p>The name of the external connection that a package was ingested from.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DomainEntryPoint) -> dict:
+    out: dict = {}
+    if "repository_name" in value:
+        out["repositoryName"] = value["repository_name"]
+    if "external_connection_name" in value:
+        out["externalConnectionName"] = value["external_connection_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> DomainEntryPoint:
+    out: DomainEntryPoint = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    if data.get("externalConnectionName") is not None:
+        out["external_connection_name"] = data["externalConnectionName"]
+    return out

capo_codeartifact/types/domain_name.py

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

capo_codeartifact/types/domain_status.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#DomainStatus``."""
+
+from typing import Literal, TypeAlias, cast
+
+DomainStatus: TypeAlias = Literal[
+    "Active",
+    "Deleted",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DomainStatus) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> DomainStatus:
+    return cast(DomainStatus, data)

capo_codeartifact/types/domain_summary.py

@@ -0,0 +1,78 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#DomainSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.arn
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.domain_status
+    import capo_codeartifact.types.timestamp
+
+
+class DomainSummary(TypedDict, closed=True):
+    name: NotRequired["capo_codeartifact.types.domain_name.DomainName"]
+    """<p> The name of the domain. </p>"""
+    owner: NotRequired["capo_codeartifact.types.account_id.AccountId"]
+    """<p> The 12-digit account number of the Amazon Web Services account that owns the domain. It does not include dashes or spaces. </p>"""
+    arn: NotRequired["capo_codeartifact.types.arn.Arn"]
+    """<p> The ARN of the domain. </p>"""
+    status: NotRequired["capo_codeartifact.types.domain_status.DomainStatus"]
+    """<p> A string that contains the status of the domain. </p>"""
+    created_time: NotRequired["capo_codeartifact.types.timestamp.Timestamp"]
+    """<p> A timestamp that contains the date and time the domain was created. </p>"""
+    encryption_key: NotRequired["capo_codeartifact.types.arn.Arn"]
+    """<p> The key used to encrypt the domain. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DomainSummary) -> dict:
+    out: dict = {}
+    if "name" in value:
+        out["name"] = value["name"]
+    if "owner" in value:
+        out["owner"] = value["owner"]
+    if "arn" in value:
+        out["arn"] = value["arn"]
+    if "status" in value:
+        import capo_codeartifact.types.domain_status
+
+        out["status"] = capo_codeartifact.types.domain_status.serialize_json(
+            value["status"]
+        )
+    if "created_time" in value:
+        import capo_codeartifact.types.timestamp
+
+        out["createdTime"] = capo_codeartifact.types.timestamp.serialize_json(
+            value["created_time"]
+        )
+    if "encryption_key" in value:
+        out["encryptionKey"] = value["encryption_key"]
+    return out
+
+
+def deserialize_json(data: dict) -> DomainSummary:
+    out: DomainSummary = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    if data.get("owner") is not None:
+        out["owner"] = data["owner"]
+    if data.get("arn") is not None:
+        out["arn"] = data["arn"]
+    if data.get("status") is not None:
+        import capo_codeartifact.types.domain_status
+
+        out["status"] = capo_codeartifact.types.domain_status.deserialize_json(
+            data["status"]
+        )
+    if data.get("createdTime") is not None:
+        import capo_codeartifact.types.timestamp
+
+        out["created_time"] = capo_codeartifact.types.timestamp.deserialize_json(
+            data["createdTime"]
+        )
+    if data.get("encryptionKey") is not None:
+        out["encryption_key"] = data["encryptionKey"]
+    return out

capo_codeartifact/types/domain_summary_list.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#DomainSummaryList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.domain_summary
+
+DomainSummaryList: TypeAlias = list[
+    "capo_codeartifact.types.domain_summary.DomainSummary"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DomainSummaryList) -> list:
+    import capo_codeartifact.types.domain_summary
+
+    out: list = []
+    for item in value:
+        out.append(capo_codeartifact.types.domain_summary.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> DomainSummaryList:
+    import capo_codeartifact.types.domain_summary
+
+    out: DomainSummaryList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_codeartifact.types.domain_summary.deserialize_json(item))
+    return out

capo_codeartifact/types/endpoint_type.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#EndpointType``."""
+
+from typing import Literal, TypeAlias, cast
+
+EndpointType: TypeAlias = Literal[
+    "dualstack",
+    "ipv4",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EndpointType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> EndpointType:
+    return cast(EndpointType, data)

capo_codeartifact/types/error_message.py

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

capo_codeartifact/types/external_connection_name.py

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

capo_codeartifact/types/external_connection_status.py

@@ -0,0 +1,14 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ExternalConnectionStatus``."""
+
+from typing import Literal, TypeAlias, cast
+
+ExternalConnectionStatus: TypeAlias = Literal["Available",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExternalConnectionStatus) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ExternalConnectionStatus:
+    return cast(ExternalConnectionStatus, data)

capo_codeartifact/types/get_associated_package_group_request.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#GetAssociatedPackageGroupRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.package_format
+    import capo_codeartifact.types.package_name
+    import capo_codeartifact.types.package_namespace
+
+
+class GetAssociatedPackageGroupRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain that contains the package from which to get the associated package group. </p>"""
+    domain_owner: NotRequired["capo_codeartifact.types.account_id.AccountId"]
+    """<p> The 12-digit account number of the Amazon Web Services account that owns the domain. It does not include dashes or spaces. </p>"""
+    format: "capo_codeartifact.types.package_format.PackageFormat"
+    """<p> The format of the package from which to get the associated package group. </p>"""
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace of the package from which to get the associated package group. The package component that specifies its namespace depends on its type. For example:</p> <note> <p>The namespace is required when getting associated package groups from packages of the following formats:</p> <ul> <li> <p>Maven</p> </li> <li> <p>Swift</p> </li> <li> <p>generic</p> </li> </ul> </note> <ul> <li> <p> The namespace of a Maven package version is its <code>groupId</code>. </p> </li> <li> <p> The namespace of an npm or Swift package version is its <code>scope</code>. </p> </li> <li> <p>The namespace of a generic package is its <code>namespace</code>.</p> </li> <li> <p> Python, NuGet, Ruby, and Cargo package versions do not contain a corresponding component, package versions of those formats do not have a namespace. </p> </li> </ul>"""
+    package: "capo_codeartifact.types.package_name.PackageName"
+    """<p> The package from which to get the associated package group. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAssociatedPackageGroupRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetAssociatedPackageGroupRequest:
+    out: GetAssociatedPackageGroupRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/get_associated_package_group_result.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#GetAssociatedPackageGroupResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_group_association_type
+    import capo_codeartifact.types.package_group_description
+
+
+class GetAssociatedPackageGroupResult(TypedDict, closed=True):
+    package_group: NotRequired[
+        "capo_codeartifact.types.package_group_description.PackageGroupDescription"
+    ]
+    """<p>The package group that is associated with the requested package.</p>"""
+    association_type: NotRequired[
+        "capo_codeartifact.types.package_group_association_type.PackageGroupAssociationType"
+    ]
+    """<p>Describes the strength of the association between the package and package group. A strong match is also known as an exact match, and a weak match is known as a relative match.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAssociatedPackageGroupResult) -> dict:
+    out: dict = {}
+    if "package_group" in value:
+        import capo_codeartifact.types.package_group_description
+
+        out["packageGroup"] = (
+            capo_codeartifact.types.package_group_description.serialize_json(
+                value["package_group"]
+            )
+        )
+    if "association_type" in value:
+        import capo_codeartifact.types.package_group_association_type
+
+        out["associationType"] = (
+            capo_codeartifact.types.package_group_association_type.serialize_json(
+                value["association_type"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetAssociatedPackageGroupResult:
+    out: GetAssociatedPackageGroupResult = {}  # type: ignore[typeddict-item]
+    if data.get("packageGroup") is not None:
+        import capo_codeartifact.types.package_group_description
+
+        out["package_group"] = (
+            capo_codeartifact.types.package_group_description.deserialize_json(
+                data["packageGroup"]
+            )
+        )
+    if data.get("associationType") is not None:
+        import capo_codeartifact.types.package_group_association_type
+
+        out["association_type"] = (
+            capo_codeartifact.types.package_group_association_type.deserialize_json(
+                data["associationType"]
+            )
+        )
+    return out

capo_codeartifact/types/get_authorization_token_request.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#GetAuthorizationTokenRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.authorization_token_duration_seconds
+    import capo_codeartifact.types.domain_name
+
+
+class GetAuthorizationTokenRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain that is in scope for the generated authorization token. </p>"""
+    domain_owner: NotRequired["capo_codeartifact.types.account_id.AccountId"]
+    """<p> The 12-digit account number of the Amazon Web Services account that owns the domain. It does not include dashes or spaces. </p>"""
+    duration_seconds: NotRequired[
+        "capo_codeartifact.types.authorization_token_duration_seconds.AuthorizationTokenDurationSeconds"
+    ]
+    """<p>The time, in seconds, that the generated authorization token is valid. Valid values are <code>0</code> and any number between <code>900</code> (15 minutes) and <code>43200</code> (12 hours). A value of <code>0</code> will set the expiration of the authorization token to the same expiration of the user's role's temporary credentials.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAuthorizationTokenRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetAuthorizationTokenRequest:
+    out: GetAuthorizationTokenRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/get_authorization_token_result.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#GetAuthorizationTokenResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.string
+    import capo_codeartifact.types.timestamp
+
+
+class GetAuthorizationTokenResult(TypedDict, closed=True):
+    authorization_token: NotRequired["capo_codeartifact.types.string.String"]
+    """<p> The returned authentication token. </p>"""
+    expiration: NotRequired["capo_codeartifact.types.timestamp.Timestamp"]
+    """<p> A timestamp that specifies the date and time the authorization token expires. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAuthorizationTokenResult) -> dict:
+    out: dict = {}
+    if "authorization_token" in value:
+        out["authorizationToken"] = value["authorization_token"]
+    if "expiration" in value:
+        import capo_codeartifact.types.timestamp
+
+        out["expiration"] = capo_codeartifact.types.timestamp.serialize_json(
+            value["expiration"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetAuthorizationTokenResult:
+    out: GetAuthorizationTokenResult = {}  # type: ignore[typeddict-item]
+    if data.get("authorizationToken") is not None:
+        out["authorization_token"] = data["authorizationToken"]
+    if data.get("expiration") is not None:
+        import capo_codeartifact.types.timestamp
+
+        out["expiration"] = capo_codeartifact.types.timestamp.deserialize_json(
+            data["expiration"]
+        )
+    return out

capo_codeartifact/types/get_domain_permissions_policy_request.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#GetDomainPermissionsPolicyRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.domain_name
+
+
+class GetDomainPermissionsPolicyRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain to which the resource policy is attached. </p>"""
+    domain_owner: NotRequired["capo_codeartifact.types.account_id.AccountId"]
+    """<p> The 12-digit account number of the Amazon Web Services account that owns the domain. It does not include dashes or spaces. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDomainPermissionsPolicyRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetDomainPermissionsPolicyRequest:
+    out: GetDomainPermissionsPolicyRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/get_domain_permissions_policy_result.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#GetDomainPermissionsPolicyResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.resource_policy
+
+
+class GetDomainPermissionsPolicyResult(TypedDict, closed=True):
+    policy: NotRequired["capo_codeartifact.types.resource_policy.ResourcePolicy"]
+    """<p> The returned resource policy. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDomainPermissionsPolicyResult) -> dict:
+    out: dict = {}
+    if "policy" in value:
+        import capo_codeartifact.types.resource_policy
+
+        out["policy"] = capo_codeartifact.types.resource_policy.serialize_json(
+            value["policy"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetDomainPermissionsPolicyResult:
+    out: GetDomainPermissionsPolicyResult = {}  # type: ignore[typeddict-item]
+    if data.get("policy") is not None:
+        import capo_codeartifact.types.resource_policy
+
+        out["policy"] = capo_codeartifact.types.resource_policy.deserialize_json(
+            data["policy"]
+        )
+    return out