capo-codeartifact 0.1.0__py3-none-any.whl

capo_codeartifact/types/asset_hashes.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#AssetHashes``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.hash_algorithm
+    import capo_codeartifact.types.hash_value
+
+AssetHashes: TypeAlias = dict[
+    "capo_codeartifact.types.hash_algorithm.HashAlgorithm",
+    "capo_codeartifact.types.hash_value.HashValue",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: AssetHashes) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        import capo_codeartifact.types.hash_algorithm
+
+        out[capo_codeartifact.types.hash_algorithm.serialize_json(key)] = value
+    return out
+
+
+def deserialize_json(data: dict) -> AssetHashes:
+    out: AssetHashes = {}
+    for key, value in data.items():
+        import capo_codeartifact.types.hash_algorithm
+
+        if value is None:
+            continue
+        out[capo_codeartifact.types.hash_algorithm.deserialize_json(key)] = value
+    return out

capo_codeartifact/types/asset_name.py

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

capo_codeartifact/types/asset_summary.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#AssetSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codeartifact.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.asset_hashes
+    import capo_codeartifact.types.asset_name
+    import capo_codeartifact.types.long_optional
+
+
+class AssetSummary(TypedDict, closed=True):
+    name: "capo_codeartifact.types.asset_name.AssetName"
+    """<p> The name of the asset. </p>"""
+    size: NotRequired["capo_codeartifact.types.long_optional.LongOptional"]
+    """<p> The size of the asset. </p>"""
+    hashes: NotRequired["capo_codeartifact.types.asset_hashes.AssetHashes"]
+    """<p> The hashes of the asset. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AssetSummary) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    if "size" in value:
+        out["size"] = value["size"]
+    if "hashes" in value:
+        import capo_codeartifact.types.asset_hashes
+
+        out["hashes"] = capo_codeartifact.types.asset_hashes.serialize_json(
+            value["hashes"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> AssetSummary:
+    out: AssetSummary = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("AssetSummary.name required")
+    if data.get("size") is not None:
+        out["size"] = data["size"]
+    if data.get("hashes") is not None:
+        import capo_codeartifact.types.asset_hashes
+
+        out["hashes"] = capo_codeartifact.types.asset_hashes.deserialize_json(
+            data["hashes"]
+        )
+    return out

capo_codeartifact/types/asset_summary_list.py

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

capo_codeartifact/types/associate_external_connection_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#AssociateExternalConnectionRequest``."""
+
+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.external_connection_name
+    import capo_codeartifact.types.repository_name
+
+
+class AssociateExternalConnectionRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p>The name of the domain that contains the repository.</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>"""
+    repository: "capo_codeartifact.types.repository_name.RepositoryName"
+    """<p> The name of the repository to which the external connection is added. </p>"""
+    external_connection: (
+        "capo_codeartifact.types.external_connection_name.ExternalConnectionName"
+    )
+    """<p> The name of the external connection to add to the repository. The following values are supported: </p> <ul> <li> <p> <code>public:npmjs</code> - for the npm public repository. </p> </li> <li> <p> <code>public:nuget-org</code> - for the NuGet Gallery. </p> </li> <li> <p> <code>public:pypi</code> - for the Python Package Index. </p> </li> <li> <p> <code>public:maven-central</code> - for Maven Central. </p> </li> <li> <p> <code>public:maven-googleandroid</code> - for the Google Android repository. </p> </li> <li> <p> <code>public:maven-gradleplugins</code> - for the Gradle plugins repository. </p> </li> <li> <p> <code>public:maven-commonsware</code> - for the CommonsWare Android repository. </p> </li> <li> <p> <code>public:maven-clojars</code> - for the Clojars repository. </p> </li> <li> <p> <code>public:ruby-gems-org</code> - for RubyGems.org. </p> </li> <li> <p> <code>public:crates-io</code> - for Crates.io. </p> </li> </ul>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AssociateExternalConnectionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> AssociateExternalConnectionRequest:
+    out: AssociateExternalConnectionRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/associate_external_connection_result.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#AssociateExternalConnectionResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.repository_description
+
+
+class AssociateExternalConnectionResult(TypedDict, closed=True):
+    repository: NotRequired[
+        "capo_codeartifact.types.repository_description.RepositoryDescription"
+    ]
+    """<p> Information about the connected repository after processing the request. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AssociateExternalConnectionResult) -> dict:
+    out: dict = {}
+    if "repository" in value:
+        import capo_codeartifact.types.repository_description
+
+        out["repository"] = (
+            capo_codeartifact.types.repository_description.serialize_json(
+                value["repository"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> AssociateExternalConnectionResult:
+    out: AssociateExternalConnectionResult = {}  # type: ignore[typeddict-item]
+    if data.get("repository") is not None:
+        import capo_codeartifact.types.repository_description
+
+        out["repository"] = (
+            capo_codeartifact.types.repository_description.deserialize_json(
+                data["repository"]
+            )
+        )
+    return out

capo_codeartifact/types/associated_package.py

@@ -0,0 +1,71 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#AssociatedPackage``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_format
+    import capo_codeartifact.types.package_group_association_type
+    import capo_codeartifact.types.package_name
+    import capo_codeartifact.types.package_namespace
+
+
+class AssociatedPackage(TypedDict, closed=True):
+    format: NotRequired["capo_codeartifact.types.package_format.PackageFormat"]
+    """<p>A format that specifies the type of the associated package.</p>"""
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace of the associated package. The package component that specifies its namespace depends on its type. For example:</p> <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: NotRequired["capo_codeartifact.types.package_name.PackageName"]
+    """<p> The name of the associated package. </p>"""
+    association_type: NotRequired[
+        "capo_codeartifact.types.package_group_association_type.PackageGroupAssociationType"
+    ]
+    r"""<p>Describes the strength of the association between the package and package group. A strong match can be thought of as an exact match, and a weak match can be thought of as a variation match, for example, the package name matches a variation of the package group pattern. For more information about package group pattern matching, including strong and weak matches, see <a href=\"https://docs.aws.amazon.com/codeartifact/latest/ug/package-group-definition-syntax-matching-behavior.html\">Package group definition syntax and matching behavior</a> in the <i>CodeArtifact User Guide</i>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AssociatedPackage) -> dict:
+    out: dict = {}
+    if "format" in value:
+        import capo_codeartifact.types.package_format
+
+        out["format"] = capo_codeartifact.types.package_format.serialize_json(
+            value["format"]
+        )
+    if "namespace" in value:
+        out["namespace"] = value["namespace"]
+    if "package" in value:
+        out["package"] = value["package"]
+    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) -> AssociatedPackage:
+    out: AssociatedPackage = {}  # type: ignore[typeddict-item]
+    if data.get("format") is not None:
+        import capo_codeartifact.types.package_format
+
+        out["format"] = capo_codeartifact.types.package_format.deserialize_json(
+            data["format"]
+        )
+    if data.get("namespace") is not None:
+        out["namespace"] = data["namespace"]
+    if data.get("package") is not None:
+        out["package"] = data["package"]
+    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/associated_package_list.py

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

capo_codeartifact/types/authorization_token_duration_seconds.py

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

capo_codeartifact/types/boolean_optional.py

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

capo_codeartifact/types/copy_package_versions_request.py

@@ -0,0 +1,96 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#CopyPackageVersionsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.boolean_optional
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.package_format
+    import capo_codeartifact.types.package_name
+    import capo_codeartifact.types.package_namespace
+    import capo_codeartifact.types.package_version_list
+    import capo_codeartifact.types.package_version_revision_map
+    import capo_codeartifact.types.repository_name
+
+
+class CopyPackageVersionsRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain that contains the source and destination repositories. </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>"""
+    source_repository: "capo_codeartifact.types.repository_name.RepositoryName"
+    """<p> The name of the repository that contains the package versions to be copied. </p>"""
+    destination_repository: "capo_codeartifact.types.repository_name.RepositoryName"
+    """<p> The name of the repository into which package versions are copied. </p>"""
+    format: "capo_codeartifact.types.package_format.PackageFormat"
+    """<p> The format of the package versions to be copied. </p>"""
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace of the package versions to be copied. The package component that specifies its namespace depends on its type. For example:</p> <note> <p>The namespace is required when copying package versions 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 name of the package that contains the versions to be copied. </p>"""
+    versions: NotRequired[
+        "capo_codeartifact.types.package_version_list.PackageVersionList"
+    ]
+    """<p> The versions of the package to be copied. </p> <note> <p> You must specify <code>versions</code> or <code>versionRevisions</code>. You cannot specify both. </p> </note>"""
+    version_revisions: NotRequired[
+        "capo_codeartifact.types.package_version_revision_map.PackageVersionRevisionMap"
+    ]
+    """<p> A list of key-value pairs. The keys are package versions and the values are package version revisions. A <code>CopyPackageVersion</code> operation succeeds if the specified versions in the source repository match the specified package version revision. </p> <note> <p> You must specify <code>versions</code> or <code>versionRevisions</code>. You cannot specify both. </p> </note>"""
+    allow_overwrite: NotRequired[
+        "capo_codeartifact.types.boolean_optional.BooleanOptional"
+    ]
+    """<p> Set to true to overwrite a package version that already exists in the destination repository. If set to false and the package version already exists in the destination repository, the package version is returned in the <code>failedVersions</code> field of the response with an <code>ALREADY_EXISTS</code> error code. </p>"""
+    include_from_upstream: NotRequired[
+        "capo_codeartifact.types.boolean_optional.BooleanOptional"
+    ]
+    r"""<p> Set to true to copy packages from repositories that are upstream from the source repository to the destination repository. The default setting is false. For more information, see <a href=\"https://docs.aws.amazon.com/codeartifact/latest/ug/repos-upstream.html\">Working with upstream repositories</a>. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CopyPackageVersionsRequest) -> dict:
+    out: dict = {}
+    if "versions" in value:
+        import capo_codeartifact.types.package_version_list
+
+        out["versions"] = capo_codeartifact.types.package_version_list.serialize_json(
+            value["versions"]
+        )
+    if "version_revisions" in value:
+        import capo_codeartifact.types.package_version_revision_map
+
+        out["versionRevisions"] = (
+            capo_codeartifact.types.package_version_revision_map.serialize_json(
+                value["version_revisions"]
+            )
+        )
+    if "allow_overwrite" in value:
+        out["allowOverwrite"] = value["allow_overwrite"]
+    if "include_from_upstream" in value:
+        out["includeFromUpstream"] = value["include_from_upstream"]
+    return out
+
+
+def deserialize_json(data: dict) -> CopyPackageVersionsRequest:
+    out: CopyPackageVersionsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("versions") is not None:
+        import capo_codeartifact.types.package_version_list
+
+        out["versions"] = capo_codeartifact.types.package_version_list.deserialize_json(
+            data["versions"]
+        )
+    if data.get("versionRevisions") is not None:
+        import capo_codeartifact.types.package_version_revision_map
+
+        out["version_revisions"] = (
+            capo_codeartifact.types.package_version_revision_map.deserialize_json(
+                data["versionRevisions"]
+            )
+        )
+    if data.get("allowOverwrite") is not None:
+        out["allow_overwrite"] = data["allowOverwrite"]
+    if data.get("includeFromUpstream") is not None:
+        out["include_from_upstream"] = data["includeFromUpstream"]
+    return out

capo_codeartifact/types/copy_package_versions_result.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#CopyPackageVersionsResult``."""
+
+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 CopyPackageVersionsResult(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 copied to your repository. </p>"""
+    failed_versions: NotRequired[
+        "capo_codeartifact.types.package_version_error_map.PackageVersionErrorMap"
+    ]
+    """<p> A map of package versions that failed to copy and their error codes. The possible error codes are in the <code>PackageVersionError</code> data type. They 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: CopyPackageVersionsResult) -> 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) -> CopyPackageVersionsResult:
+    out: CopyPackageVersionsResult = {}  # 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/create_domain_request.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#CreateDomainRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.arn
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.tag_list
+
+
+class CreateDomainRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain to create. All domain names in an Amazon Web Services Region that are in the same Amazon Web Services account must be unique. The domain name is used as the prefix in DNS hostnames. Do not use sensitive information in a domain name because it is publicly discoverable. </p>"""
+    encryption_key: NotRequired["capo_codeartifact.types.arn.Arn"]
+    r"""<p> The encryption key for the domain. This is used to encrypt content stored in a domain. An encryption key can be a key ID, a key Amazon Resource Name (ARN), a key alias, or a key alias ARN. To specify an <code>encryptionKey</code>, your IAM role must have <code>kms:DescribeKey</code> and <code>kms:CreateGrant</code> permissions on the encryption key that is used. For more information, see <a href=\"https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestSyntax\">DescribeKey</a> in the <i>Key Management Service API Reference</i> and <a href=\"https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html\">Key Management Service API Permissions Reference</a> in the <i>Key Management Service Developer Guide</i>. </p> <important> <p> CodeArtifact supports only symmetric CMKs. Do not associate an asymmetric CMK with your domain. For more information, see <a href=\"https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html\">Using symmetric and asymmetric keys</a> in the <i>Key Management Service Developer Guide</i>. </p> </important>"""
+    tags: NotRequired["capo_codeartifact.types.tag_list.TagList"]
+    """<p>One or more tag key-value pairs for the domain.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateDomainRequest) -> dict:
+    out: dict = {}
+    if "encryption_key" in value:
+        out["encryptionKey"] = value["encryption_key"]
+    if "tags" in value:
+        import capo_codeartifact.types.tag_list
+
+        out["tags"] = capo_codeartifact.types.tag_list.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> CreateDomainRequest:
+    out: CreateDomainRequest = {}  # type: ignore[typeddict-item]
+    if data.get("encryptionKey") is not None:
+        out["encryption_key"] = data["encryptionKey"]
+    if data.get("tags") is not None:
+        import capo_codeartifact.types.tag_list
+
+        out["tags"] = capo_codeartifact.types.tag_list.deserialize_json(data["tags"])
+    return out

capo_codeartifact/types/create_domain_result.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#CreateDomainResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.domain_description
+
+
+class CreateDomainResult(TypedDict, closed=True):
+    domain: NotRequired["capo_codeartifact.types.domain_description.DomainDescription"]
+    """<p> Contains information about the created domain after processing the request. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateDomainResult) -> dict:
+    out: dict = {}
+    if "domain" in value:
+        import capo_codeartifact.types.domain_description
+
+        out["domain"] = capo_codeartifact.types.domain_description.serialize_json(
+            value["domain"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> CreateDomainResult:
+    out: CreateDomainResult = {}  # type: ignore[typeddict-item]
+    if data.get("domain") is not None:
+        import capo_codeartifact.types.domain_description
+
+        out["domain"] = capo_codeartifact.types.domain_description.deserialize_json(
+            data["domain"]
+        )
+    return out

capo_codeartifact/types/create_package_group_request.py

@@ -0,0 +1,64 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#CreatePackageGroupRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codeartifact.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.description
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.package_group_contact_info
+    import capo_codeartifact.types.package_group_pattern
+    import capo_codeartifact.types.tag_list
+
+
+class CreatePackageGroupRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain in which you want to create a 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>"""
+    package_group: "capo_codeartifact.types.package_group_pattern.PackageGroupPattern"
+    """<p>The pattern of the package group to create. The pattern is also the identifier of the package group. </p>"""
+    contact_info: NotRequired[
+        "capo_codeartifact.types.package_group_contact_info.PackageGroupContactInfo"
+    ]
+    """<p> The contact information for the created package group. </p>"""
+    description: NotRequired["capo_codeartifact.types.description.Description"]
+    """<p> A description of the package group. </p>"""
+    tags: NotRequired["capo_codeartifact.types.tag_list.TagList"]
+    """<p>One or more tag key-value pairs for the package group.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreatePackageGroupRequest) -> dict:
+    out: dict = {}
+    out["packageGroup"] = value["package_group"]
+    if "contact_info" in value:
+        out["contactInfo"] = value["contact_info"]
+    if "description" in value:
+        out["description"] = value["description"]
+    if "tags" in value:
+        import capo_codeartifact.types.tag_list
+
+        out["tags"] = capo_codeartifact.types.tag_list.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> CreatePackageGroupRequest:
+    out: CreatePackageGroupRequest = {}  # type: ignore[typeddict-item]
+    if data.get("packageGroup") is not None:
+        out["package_group"] = data["packageGroup"]
+    else:
+        raise DeserializationError("CreatePackageGroupRequest.package_group required")
+    if data.get("contactInfo") is not None:
+        out["contact_info"] = data["contactInfo"]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("tags") is not None:
+        import capo_codeartifact.types.tag_list
+
+        out["tags"] = capo_codeartifact.types.tag_list.deserialize_json(data["tags"])
+    return out