capo-codeartifact 0.1.0__py3-none-any.whl

capo_codeartifact/types/package_group_summary.py

@@ -0,0 +1,122 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageGroupSummary``."""
+
+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.description
+    import capo_codeartifact.types.domain_name
+    import capo_codeartifact.types.package_group_contact_info
+    import capo_codeartifact.types.package_group_origin_configuration
+    import capo_codeartifact.types.package_group_pattern
+    import capo_codeartifact.types.package_group_reference
+    import capo_codeartifact.types.timestamp
+
+
+class PackageGroupSummary(TypedDict, closed=True):
+    arn: NotRequired["capo_codeartifact.types.arn.Arn"]
+    """<p> The ARN of the package group. </p>"""
+    pattern: NotRequired[
+        "capo_codeartifact.types.package_group_pattern.PackageGroupPattern"
+    ]
+    """<p> The pattern of the package group. The pattern determines which packages are associated with the package group. </p>"""
+    domain_name: NotRequired["capo_codeartifact.types.domain_name.DomainName"]
+    """<p> The domain that contains the 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>"""
+    created_time: NotRequired["capo_codeartifact.types.timestamp.Timestamp"]
+    """<p>A timestamp that represents the date and time the repository was created.</p>"""
+    contact_info: NotRequired[
+        "capo_codeartifact.types.package_group_contact_info.PackageGroupContactInfo"
+    ]
+    """<p> The contact information of the package group. </p>"""
+    description: NotRequired["capo_codeartifact.types.description.Description"]
+    """<p> The description of the package group. </p>"""
+    origin_configuration: NotRequired[
+        "capo_codeartifact.types.package_group_origin_configuration.PackageGroupOriginConfiguration"
+    ]
+    """<p>Details about the package origin configuration of a package group.</p>"""
+    parent: NotRequired[
+        "capo_codeartifact.types.package_group_reference.PackageGroupReference"
+    ]
+    """<p> The direct parent package group of the package group. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageGroupSummary) -> dict:
+    out: dict = {}
+    if "arn" in value:
+        out["arn"] = value["arn"]
+    if "pattern" in value:
+        out["pattern"] = value["pattern"]
+    if "domain_name" in value:
+        out["domainName"] = value["domain_name"]
+    if "domain_owner" in value:
+        out["domainOwner"] = value["domain_owner"]
+    if "created_time" in value:
+        import capo_codeartifact.types.timestamp
+
+        out["createdTime"] = capo_codeartifact.types.timestamp.serialize_json(
+            value["created_time"]
+        )
+    if "contact_info" in value:
+        out["contactInfo"] = value["contact_info"]
+    if "description" in value:
+        out["description"] = value["description"]
+    if "origin_configuration" in value:
+        import capo_codeartifact.types.package_group_origin_configuration
+
+        out["originConfiguration"] = (
+            capo_codeartifact.types.package_group_origin_configuration.serialize_json(
+                value["origin_configuration"]
+            )
+        )
+    if "parent" in value:
+        import capo_codeartifact.types.package_group_reference
+
+        out["parent"] = capo_codeartifact.types.package_group_reference.serialize_json(
+            value["parent"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageGroupSummary:
+    out: PackageGroupSummary = {}  # type: ignore[typeddict-item]
+    if data.get("arn") is not None:
+        out["arn"] = data["arn"]
+    if data.get("pattern") is not None:
+        out["pattern"] = data["pattern"]
+    if data.get("domainName") is not None:
+        out["domain_name"] = data["domainName"]
+    if data.get("domainOwner") is not None:
+        out["domain_owner"] = data["domainOwner"]
+    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("contactInfo") is not None:
+        out["contact_info"] = data["contactInfo"]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("originConfiguration") is not None:
+        import capo_codeartifact.types.package_group_origin_configuration
+
+        out["origin_configuration"] = (
+            capo_codeartifact.types.package_group_origin_configuration.deserialize_json(
+                data["originConfiguration"]
+            )
+        )
+    if data.get("parent") is not None:
+        import capo_codeartifact.types.package_group_reference
+
+        out["parent"] = (
+            capo_codeartifact.types.package_group_reference.deserialize_json(
+                data["parent"]
+            )
+        )
+    return out

capo_codeartifact/types/package_group_summary_list.py

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

capo_codeartifact/types/package_name.py

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

capo_codeartifact/types/package_namespace.py

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

capo_codeartifact/types/package_origin_configuration.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageOriginConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_origin_restrictions
+
+
+class PackageOriginConfiguration(TypedDict, closed=True):
+    restrictions: NotRequired[
+        "capo_codeartifact.types.package_origin_restrictions.PackageOriginRestrictions"
+    ]
+    """<p>A <code>PackageOriginRestrictions</code> object that contains information about the upstream and publish package origin configuration for the package.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageOriginConfiguration) -> dict:
+    out: dict = {}
+    if "restrictions" in value:
+        import capo_codeartifact.types.package_origin_restrictions
+
+        out["restrictions"] = (
+            capo_codeartifact.types.package_origin_restrictions.serialize_json(
+                value["restrictions"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageOriginConfiguration:
+    out: PackageOriginConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("restrictions") is not None:
+        import capo_codeartifact.types.package_origin_restrictions
+
+        out["restrictions"] = (
+            capo_codeartifact.types.package_origin_restrictions.deserialize_json(
+                data["restrictions"]
+            )
+        )
+    return out

capo_codeartifact/types/package_origin_restrictions.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageOriginRestrictions``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codeartifact.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.allow_publish
+    import capo_codeartifact.types.allow_upstream
+
+
+class PackageOriginRestrictions(TypedDict, closed=True):
+    publish: "capo_codeartifact.types.allow_publish.AllowPublish"
+    """<p>The package origin configuration that determines if new versions of the package can be published directly to the repository.</p>"""
+    upstream: "capo_codeartifact.types.allow_upstream.AllowUpstream"
+    """<p>The package origin configuration that determines if new versions of the package can be added to the repository from an external connection or upstream source.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageOriginRestrictions) -> dict:
+    out: dict = {}
+    import capo_codeartifact.types.allow_publish
+
+    out["publish"] = capo_codeartifact.types.allow_publish.serialize_json(
+        value["publish"]
+    )
+    import capo_codeartifact.types.allow_upstream
+
+    out["upstream"] = capo_codeartifact.types.allow_upstream.serialize_json(
+        value["upstream"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageOriginRestrictions:
+    out: PackageOriginRestrictions = {}  # type: ignore[typeddict-item]
+    if data.get("publish") is not None:
+        import capo_codeartifact.types.allow_publish
+
+        out["publish"] = capo_codeartifact.types.allow_publish.deserialize_json(
+            data["publish"]
+        )
+    else:
+        raise DeserializationError("PackageOriginRestrictions.publish required")
+    if data.get("upstream") is not None:
+        import capo_codeartifact.types.allow_upstream
+
+        out["upstream"] = capo_codeartifact.types.allow_upstream.deserialize_json(
+            data["upstream"]
+        )
+    else:
+        raise DeserializationError("PackageOriginRestrictions.upstream required")
+    return out

capo_codeartifact/types/package_summary.py

@@ -0,0 +1,71 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageSummary``."""
+
+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 PackageSummary(TypedDict, closed=True):
+    format: NotRequired["capo_codeartifact.types.package_format.PackageFormat"]
+    """<p> The format 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>"""
+    package: NotRequired["capo_codeartifact.types.package_name.PackageName"]
+    """<p> The name of the package. </p>"""
+    origin_configuration: NotRequired[
+        "capo_codeartifact.types.package_origin_configuration.PackageOriginConfiguration"
+    ]
+    r"""<p>A <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageOriginConfiguration.html\">PackageOriginConfiguration</a> object that contains a <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageOriginRestrictions.html\">PackageOriginRestrictions</a> object that contains information about the upstream and publish package origin restrictions.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageSummary) -> 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 "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) -> PackageSummary:
+    out: PackageSummary = {}  # 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("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

capo_codeartifact/types/package_summary_list.py

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

capo_codeartifact/types/package_version.py

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

capo_codeartifact/types/package_version_description.py

@@ -0,0 +1,156 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageVersionDescription``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.license_info_list
+    import capo_codeartifact.types.package_format
+    import capo_codeartifact.types.package_name
+    import capo_codeartifact.types.package_namespace
+    import capo_codeartifact.types.package_version
+    import capo_codeartifact.types.package_version_origin
+    import capo_codeartifact.types.package_version_revision
+    import capo_codeartifact.types.package_version_status
+    import capo_codeartifact.types.string
+    import capo_codeartifact.types.string255
+    import capo_codeartifact.types.timestamp
+
+
+class PackageVersionDescription(TypedDict, closed=True):
+    format: NotRequired["capo_codeartifact.types.package_format.PackageFormat"]
+    """<p> The format of the package version. </p>"""
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace of the package version. 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_name: NotRequired["capo_codeartifact.types.package_name.PackageName"]
+    """<p> The name of the requested package. </p>"""
+    display_name: NotRequired["capo_codeartifact.types.string255.String255"]
+    """<p> The name of the package that is displayed. The <code>displayName</code> varies depending on the package version's format. For example, if an npm package is named <code>ui</code>, is in the namespace <code>vue</code>, and has the format <code>npm</code>, then the <code>displayName</code> is <code>@vue/ui</code>. </p>"""
+    version: NotRequired["capo_codeartifact.types.package_version.PackageVersion"]
+    """<p> The version of the package. </p>"""
+    summary: NotRequired["capo_codeartifact.types.string.String"]
+    """<p> A summary of the package version. The summary is extracted from the package. The information in and detail level of the summary depends on the package version's format. </p>"""
+    home_page: NotRequired["capo_codeartifact.types.string.String"]
+    """<p> The homepage associated with the package. </p>"""
+    source_code_repository: NotRequired["capo_codeartifact.types.string.String"]
+    """<p> The repository for the source code in the package version, or the source code used to build it. </p>"""
+    published_time: NotRequired["capo_codeartifact.types.timestamp.Timestamp"]
+    """<p> A timestamp that contains the date and time the package version was published. </p>"""
+    licenses: NotRequired["capo_codeartifact.types.license_info_list.LicenseInfoList"]
+    """<p> Information about licenses associated with the package version. </p>"""
+    revision: NotRequired[
+        "capo_codeartifact.types.package_version_revision.PackageVersionRevision"
+    ]
+    """<p> The revision of the package version. </p>"""
+    status: NotRequired[
+        "capo_codeartifact.types.package_version_status.PackageVersionStatus"
+    ]
+    """<p> A string that contains the status of the package version. </p>"""
+    origin: NotRequired[
+        "capo_codeartifact.types.package_version_origin.PackageVersionOrigin"
+    ]
+    r"""<p>A <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageVersionOrigin.html\">PackageVersionOrigin</a> object that contains information about how the package version was added to the repository.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageVersionDescription) -> 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_name" in value:
+        out["packageName"] = value["package_name"]
+    if "display_name" in value:
+        out["displayName"] = value["display_name"]
+    if "version" in value:
+        out["version"] = value["version"]
+    if "summary" in value:
+        out["summary"] = value["summary"]
+    if "home_page" in value:
+        out["homePage"] = value["home_page"]
+    if "source_code_repository" in value:
+        out["sourceCodeRepository"] = value["source_code_repository"]
+    if "published_time" in value:
+        import capo_codeartifact.types.timestamp
+
+        out["publishedTime"] = capo_codeartifact.types.timestamp.serialize_json(
+            value["published_time"]
+        )
+    if "licenses" in value:
+        import capo_codeartifact.types.license_info_list
+
+        out["licenses"] = capo_codeartifact.types.license_info_list.serialize_json(
+            value["licenses"]
+        )
+    if "revision" in value:
+        out["revision"] = value["revision"]
+    if "status" in value:
+        import capo_codeartifact.types.package_version_status
+
+        out["status"] = capo_codeartifact.types.package_version_status.serialize_json(
+            value["status"]
+        )
+    if "origin" in value:
+        import capo_codeartifact.types.package_version_origin
+
+        out["origin"] = capo_codeartifact.types.package_version_origin.serialize_json(
+            value["origin"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageVersionDescription:
+    out: PackageVersionDescription = {}  # 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("packageName") is not None:
+        out["package_name"] = data["packageName"]
+    if data.get("displayName") is not None:
+        out["display_name"] = data["displayName"]
+    if data.get("version") is not None:
+        out["version"] = data["version"]
+    if data.get("summary") is not None:
+        out["summary"] = data["summary"]
+    if data.get("homePage") is not None:
+        out["home_page"] = data["homePage"]
+    if data.get("sourceCodeRepository") is not None:
+        out["source_code_repository"] = data["sourceCodeRepository"]
+    if data.get("publishedTime") is not None:
+        import capo_codeartifact.types.timestamp
+
+        out["published_time"] = capo_codeartifact.types.timestamp.deserialize_json(
+            data["publishedTime"]
+        )
+    if data.get("licenses") is not None:
+        import capo_codeartifact.types.license_info_list
+
+        out["licenses"] = capo_codeartifact.types.license_info_list.deserialize_json(
+            data["licenses"]
+        )
+    if data.get("revision") is not None:
+        out["revision"] = data["revision"]
+    if data.get("status") is not None:
+        import capo_codeartifact.types.package_version_status
+
+        out["status"] = capo_codeartifact.types.package_version_status.deserialize_json(
+            data["status"]
+        )
+    if data.get("origin") is not None:
+        import capo_codeartifact.types.package_version_origin
+
+        out["origin"] = capo_codeartifact.types.package_version_origin.deserialize_json(
+            data["origin"]
+        )
+    return out

capo_codeartifact/types/package_version_error.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageVersionError``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.error_message
+    import capo_codeartifact.types.package_version_error_code
+
+
+class PackageVersionError(TypedDict, closed=True):
+    error_code: NotRequired[
+        "capo_codeartifact.types.package_version_error_code.PackageVersionErrorCode"
+    ]
+    """<p> The error code associated with the error. Valid 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>"""
+    error_message: NotRequired["capo_codeartifact.types.error_message.ErrorMessage"]
+    """<p> The error message associated with the error. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageVersionError) -> dict:
+    out: dict = {}
+    if "error_code" in value:
+        import capo_codeartifact.types.package_version_error_code
+
+        out["errorCode"] = (
+            capo_codeartifact.types.package_version_error_code.serialize_json(
+                value["error_code"]
+            )
+        )
+    if "error_message" in value:
+        out["errorMessage"] = value["error_message"]
+    return out
+
+
+def deserialize_json(data: dict) -> PackageVersionError:
+    out: PackageVersionError = {}  # type: ignore[typeddict-item]
+    if data.get("errorCode") is not None:
+        import capo_codeartifact.types.package_version_error_code
+
+        out["error_code"] = (
+            capo_codeartifact.types.package_version_error_code.deserialize_json(
+                data["errorCode"]
+            )
+        )
+    if data.get("errorMessage") is not None:
+        out["error_message"] = data["errorMessage"]
+    return out

capo_codeartifact/types/package_version_error_code.py

@@ -0,0 +1,21 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageVersionErrorCode``."""
+
+from typing import Literal, TypeAlias, cast
+
+PackageVersionErrorCode: TypeAlias = Literal[
+    "ALREADY_EXISTS",
+    "MISMATCHED_REVISION",
+    "MISMATCHED_STATUS",
+    "NOT_ALLOWED",
+    "NOT_FOUND",
+    "SKIPPED",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageVersionErrorCode) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> PackageVersionErrorCode:
+    return cast(PackageVersionErrorCode, data)

capo_codeartifact/types/package_version_error_map.py

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

capo_codeartifact/types/package_version_list.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageVersionList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_version
+
+PackageVersionList: TypeAlias = list[
+    "capo_codeartifact.types.package_version.PackageVersion"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageVersionList) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> PackageVersionList:
+    return [item for item in data if item is not None]