capo-codeartifact 0.1.0__py3-none-any.whl

capo_codeartifact/types/package_format.py

@@ -0,0 +1,23 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageFormat``."""
+
+from typing import Literal, TypeAlias, cast
+
+PackageFormat: TypeAlias = Literal[
+    "npm",
+    "pypi",
+    "maven",
+    "nuget",
+    "generic",
+    "ruby",
+    "swift",
+    "cargo",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageFormat) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> PackageFormat:
+    return cast(PackageFormat, data)

capo_codeartifact/types/package_group_allowed_repository.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageGroupAllowedRepository``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_group_origin_restriction_type
+    import capo_codeartifact.types.repository_name
+
+
+class PackageGroupAllowedRepository(TypedDict, closed=True):
+    repository_name: NotRequired[
+        "capo_codeartifact.types.repository_name.RepositoryName"
+    ]
+    """<p> The name of the allowed repository. </p>"""
+    origin_restriction_type: NotRequired[
+        "capo_codeartifact.types.package_group_origin_restriction_type.PackageGroupOriginRestrictionType"
+    ]
+    """<p>The origin configuration restriction type of the allowed repository.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageGroupAllowedRepository) -> dict:
+    out: dict = {}
+    if "repository_name" in value:
+        out["repositoryName"] = value["repository_name"]
+    if "origin_restriction_type" in value:
+        import capo_codeartifact.types.package_group_origin_restriction_type
+
+        out["originRestrictionType"] = (
+            capo_codeartifact.types.package_group_origin_restriction_type.serialize_json(
+                value["origin_restriction_type"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageGroupAllowedRepository:
+    out: PackageGroupAllowedRepository = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    if data.get("originRestrictionType") is not None:
+        import capo_codeartifact.types.package_group_origin_restriction_type
+
+        out["origin_restriction_type"] = (
+            capo_codeartifact.types.package_group_origin_restriction_type.deserialize_json(
+                data["originRestrictionType"]
+            )
+        )
+    return out

capo_codeartifact/types/package_group_allowed_repository_list.py

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

capo_codeartifact/types/package_group_allowed_repository_update.py

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

capo_codeartifact/types/package_group_allowed_repository_update_type.py

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

capo_codeartifact/types/package_group_allowed_repository_updates.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageGroupAllowedRepositoryUpdates``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_group_allowed_repository_update
+    import capo_codeartifact.types.package_group_origin_restriction_type
+
+PackageGroupAllowedRepositoryUpdates: TypeAlias = dict[
+    "capo_codeartifact.types.package_group_origin_restriction_type.PackageGroupOriginRestrictionType",
+    "capo_codeartifact.types.package_group_allowed_repository_update.PackageGroupAllowedRepositoryUpdate",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: PackageGroupAllowedRepositoryUpdates) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        import capo_codeartifact.types.package_group_allowed_repository_update
+        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_allowed_repository_update.serialize_json(
+            value
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageGroupAllowedRepositoryUpdates:
+    out: PackageGroupAllowedRepositoryUpdates = {}
+    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_allowed_repository_update
+
+        out[
+            capo_codeartifact.types.package_group_origin_restriction_type.deserialize_json(
+                key
+            )
+        ] = capo_codeartifact.types.package_group_allowed_repository_update.deserialize_json(
+            value
+        )
+    return out

capo_codeartifact/types/package_group_association_type.py

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

capo_codeartifact/types/package_group_contact_info.py

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

capo_codeartifact/types/package_group_description.py

@@ -0,0 +1,122 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageGroupDescription``."""
+
+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 PackageGroupDescription(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 name of 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 package group 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>The package group origin configuration that determines how package versions can enter repositories.</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: PackageGroupDescription) -> 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) -> PackageGroupDescription:
+    out: PackageGroupDescription = {}  # 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_origin_configuration.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageGroupOriginConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_group_origin_restrictions
+
+
+class PackageGroupOriginConfiguration(TypedDict, closed=True):
+    restrictions: NotRequired[
+        "capo_codeartifact.types.package_group_origin_restrictions.PackageGroupOriginRestrictions"
+    ]
+    """<p>The origin configuration settings that determine how package versions can enter repositories.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageGroupOriginConfiguration) -> dict:
+    out: dict = {}
+    if "restrictions" in value:
+        import capo_codeartifact.types.package_group_origin_restrictions
+
+        out["restrictions"] = (
+            capo_codeartifact.types.package_group_origin_restrictions.serialize_json(
+                value["restrictions"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageGroupOriginConfiguration:
+    out: PackageGroupOriginConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("restrictions") is not None:
+        import capo_codeartifact.types.package_group_origin_restrictions
+
+        out["restrictions"] = (
+            capo_codeartifact.types.package_group_origin_restrictions.deserialize_json(
+                data["restrictions"]
+            )
+        )
+    return out

capo_codeartifact/types/package_group_origin_restriction.py

@@ -0,0 +1,92 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageGroupOriginRestriction``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.long_optional
+    import capo_codeartifact.types.package_group_origin_restriction_mode
+    import capo_codeartifact.types.package_group_reference
+
+
+class PackageGroupOriginRestriction(TypedDict, closed=True):
+    mode: NotRequired[
+        "capo_codeartifact.types.package_group_origin_restriction_mode.PackageGroupOriginRestrictionMode"
+    ]
+    """<p>The package group origin restriction setting. If the value of <code>mode</code> is <code>ALLOW</code>, <code>ALLOW_SPECIFIC_REPOSITORIES</code>, or <code>BLOCK</code>, then the value of <code>effectiveMode</code> is the same. Otherwise, when the value is <code>INHERIT</code>, then the value of <code>effectiveMode</code> is the value of <code>mode</code> of the first parent group which does not have a value of <code>INHERIT</code>.</p>"""
+    effective_mode: NotRequired[
+        "capo_codeartifact.types.package_group_origin_restriction_mode.PackageGroupOriginRestrictionMode"
+    ]
+    """<p>The effective package group origin restriction setting. If the value of <code>mode</code> is <code>ALLOW</code>, <code>ALLOW_SPECIFIC_REPOSITORIES</code>, or <code>BLOCK</code>, then the value of <code>effectiveMode</code> is the same. Otherwise, when the value of <code>mode</code> is <code>INHERIT</code>, then the value of <code>effectiveMode</code> is the value of <code>mode</code> of the first parent group which does not have a value of <code>INHERIT</code>.</p>"""
+    inherited_from: NotRequired[
+        "capo_codeartifact.types.package_group_reference.PackageGroupReference"
+    ]
+    """<p>The parent package group that the package group origin restrictions are inherited from.</p>"""
+    repositories_count: NotRequired[
+        "capo_codeartifact.types.long_optional.LongOptional"
+    ]
+    """<p>The number of repositories in the allowed repository list.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageGroupOriginRestriction) -> dict:
+    out: dict = {}
+    if "mode" in value:
+        import capo_codeartifact.types.package_group_origin_restriction_mode
+
+        out["mode"] = (
+            capo_codeartifact.types.package_group_origin_restriction_mode.serialize_json(
+                value["mode"]
+            )
+        )
+    if "effective_mode" in value:
+        import capo_codeartifact.types.package_group_origin_restriction_mode
+
+        out["effectiveMode"] = (
+            capo_codeartifact.types.package_group_origin_restriction_mode.serialize_json(
+                value["effective_mode"]
+            )
+        )
+    if "inherited_from" in value:
+        import capo_codeartifact.types.package_group_reference
+
+        out["inheritedFrom"] = (
+            capo_codeartifact.types.package_group_reference.serialize_json(
+                value["inherited_from"]
+            )
+        )
+    if "repositories_count" in value:
+        out["repositoriesCount"] = value["repositories_count"]
+    return out
+
+
+def deserialize_json(data: dict) -> PackageGroupOriginRestriction:
+    out: PackageGroupOriginRestriction = {}  # type: ignore[typeddict-item]
+    if data.get("mode") is not None:
+        import capo_codeartifact.types.package_group_origin_restriction_mode
+
+        out["mode"] = (
+            capo_codeartifact.types.package_group_origin_restriction_mode.deserialize_json(
+                data["mode"]
+            )
+        )
+    if data.get("effectiveMode") is not None:
+        import capo_codeartifact.types.package_group_origin_restriction_mode
+
+        out["effective_mode"] = (
+            capo_codeartifact.types.package_group_origin_restriction_mode.deserialize_json(
+                data["effectiveMode"]
+            )
+        )
+    if data.get("inheritedFrom") is not None:
+        import capo_codeartifact.types.package_group_reference
+
+        out["inherited_from"] = (
+            capo_codeartifact.types.package_group_reference.deserialize_json(
+                data["inheritedFrom"]
+            )
+        )
+    if data.get("repositoriesCount") is not None:
+        out["repositories_count"] = data["repositoriesCount"]
+    return out

capo_codeartifact/types/package_group_origin_restriction_mode.py

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

capo_codeartifact/types/package_group_origin_restriction_type.py

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

capo_codeartifact/types/package_group_origin_restrictions.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageGroupOriginRestrictions``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.package_group_origin_restriction
+    import capo_codeartifact.types.package_group_origin_restriction_type
+
+PackageGroupOriginRestrictions: TypeAlias = dict[
+    "capo_codeartifact.types.package_group_origin_restriction_type.PackageGroupOriginRestrictionType",
+    "capo_codeartifact.types.package_group_origin_restriction.PackageGroupOriginRestriction",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: PackageGroupOriginRestrictions) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        import capo_codeartifact.types.package_group_origin_restriction
+        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.serialize_json(
+            value
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PackageGroupOriginRestrictions:
+    out: PackageGroupOriginRestrictions = {}
+    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
+
+        out[
+            capo_codeartifact.types.package_group_origin_restriction_type.deserialize_json(
+                key
+            )
+        ] = capo_codeartifact.types.package_group_origin_restriction.deserialize_json(
+            value
+        )
+    return out

capo_codeartifact/types/package_group_pattern.py

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

capo_codeartifact/types/package_group_pattern_prefix.py

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

capo_codeartifact/types/package_group_reference.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.codeartifact#PackageGroupReference``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeartifact.types.arn
+    import capo_codeartifact.types.package_group_pattern
+
+
+class PackageGroupReference(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, and is also the identifier of the package group. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PackageGroupReference) -> dict:
+    out: dict = {}
+    if "arn" in value:
+        out["arn"] = value["arn"]
+    if "pattern" in value:
+        out["pattern"] = value["pattern"]
+    return out
+
+
+def deserialize_json(data: dict) -> PackageGroupReference:
+    out: PackageGroupReference = {}  # 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"]
+    return out