capo-codeartifact 0.1.0__py3-none-any.whl

capo_codeartifact/types/list_packages_request.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListPackagesRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.allow_publish
+    import capo_codeartifact.types.allow_upstream
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.list_packages_max_results
+    import capo_codeartifact.types.package_format
+    import capo_codeartifact.types.package_name
+    import capo_codeartifact.types.package_namespace
+    import capo_codeartifact.types.pagination_token
+    import capo_codeartifact.types.repository_name
+
+
+class ListPackagesRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain that contains the repository that contains the requested packages. </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 that contains the requested packages. </p>"""
+    format: NotRequired["capo_codeartifact.types.package_format.PackageFormat"]
+    """<p>The format used to filter requested packages. Only packages from the provided format will be returned.</p>"""
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace prefix used to filter requested packages. Only packages with a namespace that starts with the provided string value are returned. Note that although this option is called <code>--namespace</code> and not <code>--namespace-prefix</code>, it has prefix-matching behavior.</p> <p>Each package format uses namespace as follows:</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_prefix: NotRequired["capo_codeartifact.types.package_name.PackageName"]
+    """<p> A prefix used to filter requested packages. Only packages with names that start with <code>packagePrefix</code> are returned. </p>"""
+    max_results: NotRequired[
+        "capo_codeartifact.types.list_packages_max_results.ListPackagesMaxResults"
+    ]
+    """<p> The maximum number of results to return per page. </p>"""
+    next_token: NotRequired["capo_codeartifact.types.pagination_token.PaginationToken"]
+    """<p> The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. </p>"""
+    publish: NotRequired["capo_codeartifact.types.allow_publish.AllowPublish"]
+    r"""<p>The value of the <code>Publish</code> package origin control restriction used to filter requested packages. Only packages with the provided restriction are returned. For more information, see <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageOriginRestrictions.html\">PackageOriginRestrictions</a>.</p>"""
+    upstream: NotRequired["capo_codeartifact.types.allow_upstream.AllowUpstream"]
+    r"""<p>The value of the <code>Upstream</code> package origin control restriction used to filter requested packages. Only packages with the provided restriction are returned. For more information, see <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageOriginRestrictions.html\">PackageOriginRestrictions</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListPackagesRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListPackagesRequest:
+    out: ListPackagesRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/list_packages_result.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListPackagesResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_summary_list
+    import capo_codeartifact.types.pagination_token
+
+
+class ListPackagesResult(TypedDict, closed=True):
+    packages: NotRequired[
+        "capo_codeartifact.types.package_summary_list.PackageSummaryList"
+    ]
+    r"""<p> The list of returned <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageSummary.html\">PackageSummary</a> objects. </p>"""
+    next_token: NotRequired["capo_codeartifact.types.pagination_token.PaginationToken"]
+    """<p> If there are additional results, this is the token for the next set of results. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListPackagesResult) -> dict:
+    out: dict = {}
+    if "packages" in value:
+        import capo_codeartifact.types.package_summary_list
+
+        out["packages"] = capo_codeartifact.types.package_summary_list.serialize_json(
+            value["packages"]
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListPackagesResult:
+    out: ListPackagesResult = {}  # type: ignore[typeddict-item]
+    if data.get("packages") is not None:
+        import capo_codeartifact.types.package_summary_list
+
+        out["packages"] = capo_codeartifact.types.package_summary_list.deserialize_json(
+            data["packages"]
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codeartifact/types/list_repositories_in_domain_max_results.py

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

capo_codeartifact/types/list_repositories_in_domain_request.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListRepositoriesInDomainRequest``."""
+
+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.list_repositories_in_domain_max_results
+    import capo_codeartifact.types.pagination_token
+    import capo_codeartifact.types.repository_name
+
+
+class ListRepositoriesInDomainRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain that contains the returned list of 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>"""
+    administrator_account: NotRequired["capo_codeartifact.types.account_id.AccountId"]
+    """<p> Filter the list of repositories to only include those that are managed by the Amazon Web Services account ID. </p>"""
+    repository_prefix: NotRequired[
+        "capo_codeartifact.types.repository_name.RepositoryName"
+    ]
+    """<p> A prefix used to filter returned repositories. Only repositories with names that start with <code>repositoryPrefix</code> are returned. </p>"""
+    max_results: NotRequired[
+        "capo_codeartifact.types.list_repositories_in_domain_max_results.ListRepositoriesInDomainMaxResults"
+    ]
+    """<p> The maximum number of results to return per page. </p>"""
+    next_token: NotRequired["capo_codeartifact.types.pagination_token.PaginationToken"]
+    """<p> The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListRepositoriesInDomainRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListRepositoriesInDomainRequest:
+    out: ListRepositoriesInDomainRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/list_repositories_in_domain_result.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListRepositoriesInDomainResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.pagination_token
+    import capo_codeartifact.types.repository_summary_list
+
+
+class ListRepositoriesInDomainResult(TypedDict, closed=True):
+    repositories: NotRequired[
+        "capo_codeartifact.types.repository_summary_list.RepositorySummaryList"
+    ]
+    """<p> The returned list of repositories. </p>"""
+    next_token: NotRequired["capo_codeartifact.types.pagination_token.PaginationToken"]
+    """<p> If there are additional results, this is the token for the next set of results. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListRepositoriesInDomainResult) -> dict:
+    out: dict = {}
+    if "repositories" in value:
+        import capo_codeartifact.types.repository_summary_list
+
+        out["repositories"] = (
+            capo_codeartifact.types.repository_summary_list.serialize_json(
+                value["repositories"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListRepositoriesInDomainResult:
+    out: ListRepositoriesInDomainResult = {}  # type: ignore[typeddict-item]
+    if data.get("repositories") is not None:
+        import capo_codeartifact.types.repository_summary_list
+
+        out["repositories"] = (
+            capo_codeartifact.types.repository_summary_list.deserialize_json(
+                data["repositories"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codeartifact/types/list_repositories_max_results.py

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

capo_codeartifact/types/list_repositories_request.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListRepositoriesRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.list_repositories_max_results
+    import capo_codeartifact.types.pagination_token
+    import capo_codeartifact.types.repository_name
+
+
+class ListRepositoriesRequest(TypedDict, closed=True):
+    repository_prefix: NotRequired[
+        "capo_codeartifact.types.repository_name.RepositoryName"
+    ]
+    """<p> A prefix used to filter returned repositories. Only repositories with names that start with <code>repositoryPrefix</code> are returned.</p>"""
+    max_results: NotRequired[
+        "capo_codeartifact.types.list_repositories_max_results.ListRepositoriesMaxResults"
+    ]
+    """<p> The maximum number of results to return per page. </p>"""
+    next_token: NotRequired["capo_codeartifact.types.pagination_token.PaginationToken"]
+    """<p> The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListRepositoriesRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListRepositoriesRequest:
+    out: ListRepositoriesRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/list_repositories_result.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListRepositoriesResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.pagination_token
+    import capo_codeartifact.types.repository_summary_list
+
+
+class ListRepositoriesResult(TypedDict, closed=True):
+    repositories: NotRequired[
+        "capo_codeartifact.types.repository_summary_list.RepositorySummaryList"
+    ]
+    r"""<p> The returned list of <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_RepositorySummary.html\">RepositorySummary</a> objects. </p>"""
+    next_token: NotRequired["capo_codeartifact.types.pagination_token.PaginationToken"]
+    """<p> If there are additional results, this is the token for the next set of results. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListRepositoriesResult) -> dict:
+    out: dict = {}
+    if "repositories" in value:
+        import capo_codeartifact.types.repository_summary_list
+
+        out["repositories"] = (
+            capo_codeartifact.types.repository_summary_list.serialize_json(
+                value["repositories"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListRepositoriesResult:
+    out: ListRepositoriesResult = {}  # type: ignore[typeddict-item]
+    if data.get("repositories") is not None:
+        import capo_codeartifact.types.repository_summary_list
+
+        out["repositories"] = (
+            capo_codeartifact.types.repository_summary_list.deserialize_json(
+                data["repositories"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codeartifact/types/list_sub_package_groups_request.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListSubPackageGroupsRequest``."""
+
+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.list_package_groups_max_results
+    import capo_codeartifact.types.package_group_pattern
+    import capo_codeartifact.types.pagination_token
+
+
+class ListSubPackageGroupsRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain which contains the package group from which to list sub package groups. </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 from which to list sub package groups. </p>"""
+    max_results: NotRequired[
+        "capo_codeartifact.types.list_package_groups_max_results.ListPackageGroupsMaxResults"
+    ]
+    """<p> The maximum number of results to return per page. </p>"""
+    next_token: NotRequired["capo_codeartifact.types.pagination_token.PaginationToken"]
+    """<p> The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSubPackageGroupsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListSubPackageGroupsRequest:
+    out: ListSubPackageGroupsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/list_sub_package_groups_result.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListSubPackageGroupsResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_group_summary_list
+    import capo_codeartifact.types.pagination_token
+
+
+class ListSubPackageGroupsResult(TypedDict, closed=True):
+    package_groups: NotRequired[
+        "capo_codeartifact.types.package_group_summary_list.PackageGroupSummaryList"
+    ]
+    """<p> A list of sub package groups for the requested package group. </p>"""
+    next_token: NotRequired["capo_codeartifact.types.pagination_token.PaginationToken"]
+    """<p> If there are additional results, this is the token for the next set of results. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSubPackageGroupsResult) -> dict:
+    out: dict = {}
+    if "package_groups" in value:
+        import capo_codeartifact.types.package_group_summary_list
+
+        out["packageGroups"] = (
+            capo_codeartifact.types.package_group_summary_list.serialize_json(
+                value["package_groups"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListSubPackageGroupsResult:
+    out: ListSubPackageGroupsResult = {}  # type: ignore[typeddict-item]
+    if data.get("packageGroups") is not None:
+        import capo_codeartifact.types.package_group_summary_list
+
+        out["package_groups"] = (
+            capo_codeartifact.types.package_group_summary_list.deserialize_json(
+                data["packageGroups"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codeartifact/types/list_tags_for_resource_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListTagsForResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.arn
+
+
+class ListTagsForResourceRequest(TypedDict, closed=True):
+    resource_arn: "capo_codeartifact.types.arn.Arn"
+    """<p>The Amazon Resource Name (ARN) of the resource to get tags for.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListTagsForResourceRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListTagsForResourceRequest:
+    out: ListTagsForResourceRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_codeartifact/types/list_tags_for_resource_result.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#ListTagsForResourceResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.tag_list
+
+
+class ListTagsForResourceResult(TypedDict, closed=True):
+    tags: NotRequired["capo_codeartifact.types.tag_list.TagList"]
+    """<p>A list of tag key and value pairs associated with the specified resource.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListTagsForResourceResult) -> dict:
+    out: dict = {}
+    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) -> ListTagsForResourceResult:
+    out: ListTagsForResourceResult = {}  # type: ignore[typeddict-item]
+    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/long.py

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

capo_codeartifact/types/long_optional.py

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

capo_codeartifact/types/origin_restrictions.py

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

capo_codeartifact/types/package_dependency.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageDependency``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_name
+    import capo_codeartifact.types.package_namespace
+    import capo_codeartifact.types.string
+
+
+class PackageDependency(TypedDict, closed=True):
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace of the package that this package depends on. 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 package that this package depends on. </p>"""
+    dependency_type: NotRequired["capo_codeartifact.types.string.String"]
+    """<p> The type of a package dependency. The possible values depend on the package type.</p> <ul> <li> <p>npm: <code>regular</code>, <code>dev</code>, <code>peer</code>, <code>optional</code> </p> </li> <li> <p>maven: <code>optional</code>, <code>parent</code>, <code>compile</code>, <code>runtime</code>, <code>test</code>, <code>system</code>, <code>provided</code>.</p> <note> <p>Note that <code>parent</code> is not a regular Maven dependency type; instead this is extracted from the <code><parent></code> element if one is defined in the package version's POM file.</p> </note> </li> <li> <p>nuget: The <code>dependencyType</code> field is never set for NuGet packages.</p> </li> <li> <p>pypi: <code>Requires-Dist</code> </p> </li> </ul>"""
+    version_requirement: NotRequired["capo_codeartifact.types.string.String"]
+    """<p> The required version, or version range, of the package that this package depends on. The version format is specific to the package type. For example, the following are possible valid required versions: <code>1.2.3</code>, <code>^2.3.4</code>, or <code>4.x</code>. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageDependency) -> dict:
+    out: dict = {}
+    if "namespace" in value:
+        out["namespace"] = value["namespace"]
+    if "package" in value:
+        out["package"] = value["package"]
+    if "dependency_type" in value:
+        out["dependencyType"] = value["dependency_type"]
+    if "version_requirement" in value:
+        out["versionRequirement"] = value["version_requirement"]
+    return out
+
+
+def deserialize_json(data: dict) -> PackageDependency:
+    out: PackageDependency = {}  # type: ignore[typeddict-item]
+    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("dependencyType") is not None:
+        out["dependency_type"] = data["dependencyType"]
+    if data.get("versionRequirement") is not None:
+        out["version_requirement"] = data["versionRequirement"]
+    return out

capo_codeartifact/types/package_dependency_list.py

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

capo_codeartifact/types/package_description.py

@@ -0,0 +1,71 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageDescription``."""
+
+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_name
+    import capo_codeartifact.types.package_namespace
+    import capo_codeartifact.types.package_origin_configuration
+
+
+class PackageDescription(TypedDict, closed=True):
+    format: NotRequired["capo_codeartifact.types.package_format.PackageFormat"]
+    """<p>A format that specifies the type of the package.</p>"""
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace of the 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>"""
+    name: NotRequired["capo_codeartifact.types.package_name.PackageName"]
+    """<p>The name of the package.</p>"""
+    origin_configuration: NotRequired[
+        "capo_codeartifact.types.package_origin_configuration.PackageOriginConfiguration"
+    ]
+    """<p>The package origin configuration for the package.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageDescription) -> 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 "name" in value:
+        out["name"] = value["name"]
+    if "origin_configuration" in value:
+        import capo_codeartifact.types.package_origin_configuration
+
+        out["originConfiguration"] = (
+            capo_codeartifact.types.package_origin_configuration.serialize_json(
+                value["origin_configuration"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageDescription:
+    out: PackageDescription = {}  # 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("name") is not None:
+        out["name"] = data["name"]
+    if data.get("originConfiguration") is not None:
+        import capo_codeartifact.types.package_origin_configuration
+
+        out["origin_configuration"] = (
+            capo_codeartifact.types.package_origin_configuration.deserialize_json(
+                data["originConfiguration"]
+            )
+        )
+    return out