capo-codeartifact 0.1.0__py3-none-any.whl

capo_codeartifact/types/package_version_origin.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageVersionOrigin``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.domain_entry_point
+    import capo_codeartifact.types.package_version_origin_type
+
+
+class PackageVersionOrigin(TypedDict, closed=True):
+    domain_entry_point: NotRequired[
+        "capo_codeartifact.types.domain_entry_point.DomainEntryPoint"
+    ]
+    r"""<p>A <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DomainEntryPoint.html\">DomainEntryPoint</a> object that contains information about from which repository or external connection the package version was added to the domain.</p>"""
+    origin_type: NotRequired[
+        "capo_codeartifact.types.package_version_origin_type.PackageVersionOriginType"
+    ]
+    """<p>Describes how the package version was originally added to the domain. An <code>INTERNAL</code> origin type means the package version was published directly to a repository in the domain. An <code>EXTERNAL</code> origin type means the package version was ingested from an external connection.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageVersionOrigin) -> dict:
+    out: dict = {}
+    if "domain_entry_point" in value:
+        import capo_codeartifact.types.domain_entry_point
+
+        out["domainEntryPoint"] = (
+            capo_codeartifact.types.domain_entry_point.serialize_json(
+                value["domain_entry_point"]
+            )
+        )
+    if "origin_type" in value:
+        import capo_codeartifact.types.package_version_origin_type
+
+        out["originType"] = (
+            capo_codeartifact.types.package_version_origin_type.serialize_json(
+                value["origin_type"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageVersionOrigin:
+    out: PackageVersionOrigin = {}  # type: ignore[typeddict-item]
+    if data.get("domainEntryPoint") is not None:
+        import capo_codeartifact.types.domain_entry_point
+
+        out["domain_entry_point"] = (
+            capo_codeartifact.types.domain_entry_point.deserialize_json(
+                data["domainEntryPoint"]
+            )
+        )
+    if data.get("originType") is not None:
+        import capo_codeartifact.types.package_version_origin_type
+
+        out["origin_type"] = (
+            capo_codeartifact.types.package_version_origin_type.deserialize_json(
+                data["originType"]
+            )
+        )
+    return out

capo_codeartifact/types/package_version_origin_type.py

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

capo_codeartifact/types/package_version_revision.py

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

capo_codeartifact/types/package_version_revision_map.py

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

capo_codeartifact/types/package_version_sort_type.py

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

capo_codeartifact/types/package_version_status.py

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

capo_codeartifact/types/package_version_summary.py

@@ -0,0 +1,73 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageVersionSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codeartifact.errors import DeserializationError
+
+if TYPE_CHECKING:
+    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
+
+
+class PackageVersionSummary(TypedDict, closed=True):
+    version: "capo_codeartifact.types.package_version.PackageVersion"
+    """<p> Information about a package version. </p>"""
+    revision: NotRequired[
+        "capo_codeartifact.types.package_version_revision.PackageVersionRevision"
+    ]
+    """<p> The revision associated with a package version. </p>"""
+    status: "capo_codeartifact.types.package_version_status.PackageVersionStatus"
+    """<p> A string that contains the status of the package version. It can be one of the following: </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: PackageVersionSummary) -> dict:
+    out: dict = {}
+    out["version"] = value["version"]
+    if "revision" in value:
+        out["revision"] = value["revision"]
+    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) -> PackageVersionSummary:
+    out: PackageVersionSummary = {}  # type: ignore[typeddict-item]
+    if data.get("version") is not None:
+        out["version"] = data["version"]
+    else:
+        raise DeserializationError("PackageVersionSummary.version required")
+    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"]
+        )
+    else:
+        raise DeserializationError("PackageVersionSummary.status required")
+    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_summary_list.py

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

capo_codeartifact/types/pagination_token.py

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

capo_codeartifact/types/policy_document.py

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

capo_codeartifact/types/policy_revision.py

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

capo_codeartifact/types/publish_package_version_request.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PublishPackageVersionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.account_id
+    import capo_codeartifact.types.asset
+    import capo_codeartifact.types.asset_name
+    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
+    import capo_codeartifact.types.repository_name
+    import capo_codeartifact.types.sha256
+
+
+class PublishPackageVersionRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p>The name of the domain that contains the repository that contains the package version to publish.</p>"""
+    domain_owner: NotRequired["capo_codeartifact.types.account_id.AccountId"]
+    """<p>The 12-digit account number of the AWS 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 the package version will be published to.</p>"""
+    format: "capo_codeartifact.types.package_format.PackageFormat"
+    """<p>A format that specifies the type of the package version with the requested asset file.</p> <p>The only supported value is <code>generic</code>.</p>"""
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace of the package version to publish.</p>"""
+    package: "capo_codeartifact.types.package_name.PackageName"
+    """<p>The name of the package version to publish.</p>"""
+    package_version: "capo_codeartifact.types.package_version.PackageVersion"
+    """<p>The package version to publish (for example, <code>3.5.2</code>).</p>"""
+    asset_content: "capo_codeartifact.types.asset.Asset"
+    """<p>The content of the asset to publish.</p>"""
+    asset_name: "capo_codeartifact.types.asset_name.AssetName"
+    """<p>The name of the asset to publish. Asset names can include Unicode letters and numbers, and the following special characters: <code>~ ! @ ^ & ( ) - ` _ + [ ] { } ; , . `</code> </p>"""
+    asset_sha256: "capo_codeartifact.types.sha256.SHA256"
+    r"""<p>The SHA256 hash of the <code>assetContent</code> to publish. This value must be calculated by the caller and provided with the request (see <a href=\"https://docs.aws.amazon.com/codeartifact/latest/ug/using-generic.html#publishing-generic-packages\">Publishing a generic package</a> in the <i>CodeArtifact User Guide</i>).</p> <p>This value is used as an integrity check to verify that the <code>assetContent</code> has not changed after it was originally sent.</p>"""
+    unfinished: NotRequired["capo_codeartifact.types.boolean_optional.BooleanOptional"]
+    r"""<p>Specifies whether the package version should remain in the <code>unfinished</code> state. If omitted, the package version status will be set to <code>Published</code> (see <a href=\"https://docs.aws.amazon.com/codeartifact/latest/ug/packages-overview.html#package-version-status\">Package version status</a> in the <i>CodeArtifact User Guide</i>).</p> <p>Valid values: <code>unfinished</code> </p>"""

capo_codeartifact/types/publish_package_version_result.py

@@ -0,0 +1,98 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PublishPackageVersionResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.asset_summary
+    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_revision
+    import capo_codeartifact.types.package_version_status
+
+
+class PublishPackageVersionResult(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.</p>"""
+    package: NotRequired["capo_codeartifact.types.package_name.PackageName"]
+    """<p>The name of the package.</p>"""
+    version: NotRequired["capo_codeartifact.types.package_version.PackageVersion"]
+    """<p>The version of the package.</p>"""
+    version_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"
+    ]
+    r"""<p>A string that contains the status of the package version. For more information, see <a href=\"https://docs.aws.amazon.com/codeartifact/latest/ug/packages-overview.html#package-version-status.html#package-version-status\">Package version status</a> in the <i>CodeArtifact User Guide</i>.</p>"""
+    asset: NotRequired["capo_codeartifact.types.asset_summary.AssetSummary"]
+    r"""<p>An <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_AssetSummary.html\">AssetSummary</a> for the published asset.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PublishPackageVersionResult) -> 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 "version" in value:
+        out["version"] = value["version"]
+    if "version_revision" in value:
+        out["versionRevision"] = value["version_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 "asset" in value:
+        import capo_codeartifact.types.asset_summary
+
+        out["asset"] = capo_codeartifact.types.asset_summary.serialize_json(
+            value["asset"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PublishPackageVersionResult:
+    out: PublishPackageVersionResult = {}  # 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("version") is not None:
+        out["version"] = data["version"]
+    if data.get("versionRevision") is not None:
+        out["version_revision"] = data["versionRevision"]
+    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("asset") is not None:
+        import capo_codeartifact.types.asset_summary
+
+        out["asset"] = capo_codeartifact.types.asset_summary.deserialize_json(
+            data["asset"]
+        )
+    return out

capo_codeartifact/types/put_domain_permissions_policy_request.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PutDomainPermissionsPolicyRequest``."""
+
+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.domain_name
+    import capo_codeartifact.types.policy_document
+    import capo_codeartifact.types.policy_revision
+
+
+class PutDomainPermissionsPolicyRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p> The name of the domain on which to set the resource policy. </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>"""
+    policy_revision: NotRequired[
+        "capo_codeartifact.types.policy_revision.PolicyRevision"
+    ]
+    """<p> The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy. </p>"""
+    policy_document: "capo_codeartifact.types.policy_document.PolicyDocument"
+    """<p> A valid displayable JSON Aspen policy string to be set as the access control resource policy on the provided domain. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutDomainPermissionsPolicyRequest) -> dict:
+    out: dict = {}
+    out["domain"] = value["domain"]
+    if "domain_owner" in value:
+        out["domainOwner"] = value["domain_owner"]
+    if "policy_revision" in value:
+        out["policyRevision"] = value["policy_revision"]
+    out["policyDocument"] = value["policy_document"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutDomainPermissionsPolicyRequest:
+    out: PutDomainPermissionsPolicyRequest = {}  # type: ignore[typeddict-item]
+    if data.get("domain") is not None:
+        out["domain"] = data["domain"]
+    else:
+        raise DeserializationError("PutDomainPermissionsPolicyRequest.domain required")
+    if data.get("domainOwner") is not None:
+        out["domain_owner"] = data["domainOwner"]
+    if data.get("policyRevision") is not None:
+        out["policy_revision"] = data["policyRevision"]
+    if data.get("policyDocument") is not None:
+        out["policy_document"] = data["policyDocument"]
+    else:
+        raise DeserializationError(
+            "PutDomainPermissionsPolicyRequest.policy_document required"
+        )
+    return out

capo_codeartifact/types/put_domain_permissions_policy_result.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PutDomainPermissionsPolicyResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.resource_policy
+
+
+class PutDomainPermissionsPolicyResult(TypedDict, closed=True):
+    policy: NotRequired["capo_codeartifact.types.resource_policy.ResourcePolicy"]
+    """<p> The resource policy that was set after processing the request. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutDomainPermissionsPolicyResult) -> 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) -> PutDomainPermissionsPolicyResult:
+    out: PutDomainPermissionsPolicyResult = {}  # 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

capo_codeartifact/types/put_package_origin_configuration_request.py

@@ -0,0 +1,65 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PutPackageOriginConfigurationRequest``."""
+
+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.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_origin_restrictions
+    import capo_codeartifact.types.repository_name
+
+
+class PutPackageOriginConfigurationRequest(TypedDict, closed=True):
+    domain: "capo_codeartifact.types.domain_name.DomainName"
+    """<p>The name of the domain that contains the repository that contains the package.</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 package.</p>"""
+    format: "capo_codeartifact.types.package_format.PackageFormat"
+    """<p>A format that specifies the type of the package to be updated.</p>"""
+    namespace: NotRequired["capo_codeartifact.types.package_namespace.PackageNamespace"]
+    """<p>The namespace of the package to be updated. 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: "capo_codeartifact.types.package_name.PackageName"
+    """<p>The name of the package to be updated.</p>"""
+    restrictions: (
+        "capo_codeartifact.types.package_origin_restrictions.PackageOriginRestrictions"
+    )
+    r"""<p>A <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageOriginRestrictions.html\">PackageOriginRestrictions</a> object that contains information about the <code>upstream</code> and <code>publish</code> package origin restrictions. The <code>upstream</code> restriction determines if new package versions can be ingested or retained from external connections or upstream repositories. The <code>publish</code> restriction determines if new package versions can be published directly to the repository.</p> <p>You must include both the desired <code>upstream</code> and <code>publish</code> restrictions.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutPackageOriginConfigurationRequest) -> dict:
+    out: dict = {}
+    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) -> PutPackageOriginConfigurationRequest:
+    out: PutPackageOriginConfigurationRequest = {}  # 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"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "PutPackageOriginConfigurationRequest.restrictions required"
+        )
+    return out

capo_codeartifact/types/put_package_origin_configuration_result.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PutPackageOriginConfigurationResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_origin_configuration
+
+
+class PutPackageOriginConfigurationResult(TypedDict, closed=True):
+    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 describes the origin configuration set for the package. It contains a <a href=\"https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageOriginRestrictions.html\">PackageOriginRestrictions</a> object that describes how new versions of the package can be introduced to the repository.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutPackageOriginConfigurationResult) -> dict:
+    out: dict = {}
+    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) -> PutPackageOriginConfigurationResult:
+    out: PutPackageOriginConfigurationResult = {}  # type: ignore[typeddict-item]
+    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