capo-devops-agent 0.1.0__py3-none-any.whl

capo_devops_agent/types/service_now_service_details.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ServiceNowServiceDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.service_now_instance_url
+    import capo_devops_agent.types.service_now_service_authorization_config
+
+
+class ServiceNowServiceDetails(TypedDict, closed=True):
+    instance_url: (
+        "capo_devops_agent.types.service_now_instance_url.ServiceNowInstanceUrl"
+    )
+    """<p>ServiceNow instance URL.</p>"""
+    authorization_config: NotRequired[
+        "capo_devops_agent.types.service_now_service_authorization_config.ServiceNowServiceAuthorizationConfig"
+    ]
+    """<p>ServiceNow OAuth client credentials configuration. Use this when registering with OAuth client credentials flow.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ServiceNowServiceDetails) -> dict:
+    out: dict = {}
+    out["instanceUrl"] = value["instance_url"]
+    if "authorization_config" in value:
+        import capo_devops_agent.types.service_now_service_authorization_config
+
+        out["authorizationConfig"] = (
+            capo_devops_agent.types.service_now_service_authorization_config.serialize_json(
+                value["authorization_config"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ServiceNowServiceDetails:
+    out: ServiceNowServiceDetails = {}  # type: ignore[typeddict-item]
+    if data.get("instanceUrl") is not None:
+        out["instance_url"] = data["instanceUrl"]
+    else:
+        raise DeserializationError("ServiceNowServiceDetails.instance_url required")
+    if data.get("authorizationConfig") is not None:
+        import capo_devops_agent.types.service_now_service_authorization_config
+
+        out["authorization_config"] = (
+            capo_devops_agent.types.service_now_service_authorization_config.deserialize_json(
+                data["authorizationConfig"]
+            )
+        )
+    return out

capo_devops_agent/types/sig_v4_region.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#SigV4Region``."""
+
+from typing import TypeAlias
+
+"""<p>AWS region identifier or wildcard (*) for SigV4a multi-region signing.</p>"""
+SigV4Region: TypeAlias = str

capo_devops_agent/types/slack_channel.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#SlackChannel``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+
+class SlackChannel(TypedDict, closed=True):
+    channel_name: NotRequired["str"]
+    """<p>Slack channel name</p>"""
+    channel_id: "str"
+    """<p>Slack channel ID</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SlackChannel) -> dict:
+    out: dict = {}
+    if "channel_name" in value:
+        out["channelName"] = value["channel_name"]
+    out["channelId"] = value["channel_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> SlackChannel:
+    out: SlackChannel = {}  # type: ignore[typeddict-item]
+    if data.get("channelName") is not None:
+        out["channel_name"] = data["channelName"]
+    if data.get("channelId") is not None:
+        out["channel_id"] = data["channelId"]
+    else:
+        raise DeserializationError("SlackChannel.channel_id required")
+    return out

capo_devops_agent/types/slack_configuration.py

@@ -0,0 +1,59 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#SlackConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.slack_transmission_target
+
+
+class SlackConfiguration(TypedDict, closed=True):
+    workspace_id: "str"
+    """<p>Associated Slack workspace ID</p>"""
+    workspace_name: "str"
+    """<p>Associated Slack workspace name</p>"""
+    transmission_target: (
+        "capo_devops_agent.types.slack_transmission_target.SlackTransmissionTarget"
+    )
+    """<p>Transmission targets for agent notifications</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SlackConfiguration) -> dict:
+    out: dict = {}
+    out["workspaceId"] = value["workspace_id"]
+    out["workspaceName"] = value["workspace_name"]
+    import capo_devops_agent.types.slack_transmission_target
+
+    out["transmissionTarget"] = (
+        capo_devops_agent.types.slack_transmission_target.serialize_json(
+            value["transmission_target"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> SlackConfiguration:
+    out: SlackConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("workspaceId") is not None:
+        out["workspace_id"] = data["workspaceId"]
+    else:
+        raise DeserializationError("SlackConfiguration.workspace_id required")
+    if data.get("workspaceName") is not None:
+        out["workspace_name"] = data["workspaceName"]
+    else:
+        raise DeserializationError("SlackConfiguration.workspace_name required")
+    if data.get("transmissionTarget") is not None:
+        import capo_devops_agent.types.slack_transmission_target
+
+        out["transmission_target"] = (
+            capo_devops_agent.types.slack_transmission_target.deserialize_json(
+                data["transmissionTarget"]
+            )
+        )
+    else:
+        raise DeserializationError("SlackConfiguration.transmission_target required")
+    return out

capo_devops_agent/types/slack_transmission_target.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#SlackTransmissionTarget``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.slack_channel
+
+
+class SlackTransmissionTarget(TypedDict, closed=True):
+    ops_oncall_target: "capo_devops_agent.types.slack_channel.SlackChannel"
+    """<p>Destination for On-call Agent (Ops1)</p>"""
+    ops_sre_target: NotRequired["capo_devops_agent.types.slack_channel.SlackChannel"]
+    """<p>Destination for SRE Agent (Ops1.5)</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SlackTransmissionTarget) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.slack_channel
+
+    out["opsOncallTarget"] = capo_devops_agent.types.slack_channel.serialize_json(
+        value["ops_oncall_target"]
+    )
+    if "ops_sre_target" in value:
+        import capo_devops_agent.types.slack_channel
+
+        out["opsSRETarget"] = capo_devops_agent.types.slack_channel.serialize_json(
+            value["ops_sre_target"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SlackTransmissionTarget:
+    out: SlackTransmissionTarget = {}  # type: ignore[typeddict-item]
+    if data.get("opsOncallTarget") is not None:
+        import capo_devops_agent.types.slack_channel
+
+        out["ops_oncall_target"] = (
+            capo_devops_agent.types.slack_channel.deserialize_json(
+                data["opsOncallTarget"]
+            )
+        )
+    else:
+        raise DeserializationError("SlackTransmissionTarget.ops_oncall_target required")
+    if data.get("opsSRETarget") is not None:
+        import capo_devops_agent.types.slack_channel
+
+        out["ops_sre_target"] = capo_devops_agent.types.slack_channel.deserialize_json(
+            data["opsSRETarget"]
+        )
+    return out

capo_devops_agent/types/source_account_type.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#SourceAccountType``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>AWS association type for source account.</p>"""
+SourceAccountType: TypeAlias = Literal["source",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SourceAccountType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> SourceAccountType:
+    return cast(SourceAccountType, data)

capo_devops_agent/types/source_aws_configuration.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#SourceAwsConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.role_arn
+    import capo_devops_agent.types.source_account_type
+
+
+class SourceAwsConfiguration(TypedDict, closed=True):
+    account_id: "str"
+    """<p>AWS Account Id corresponding to provided resources.</p>"""
+    account_type: "capo_devops_agent.types.source_account_type.SourceAccountType"
+    """<p>Account Type 'source' for AIDevOps monitoring.</p>"""
+    assumable_role_arn: "capo_devops_agent.types.role_arn.RoleArn"
+    """<p>Role ARN to be assumed by AIDevOps to operate on behalf of customer.</p>"""
+    external_id: NotRequired["str"]
+    """<p>External ID for additional security when assuming the role. Used to prevent the confused deputy problem.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SourceAwsConfiguration) -> dict:
+    out: dict = {}
+    out["accountId"] = value["account_id"]
+    import capo_devops_agent.types.source_account_type
+
+    out["accountType"] = capo_devops_agent.types.source_account_type.serialize_json(
+        value["account_type"]
+    )
+    out["assumableRoleArn"] = value["assumable_role_arn"]
+    if "external_id" in value:
+        out["externalId"] = value["external_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> SourceAwsConfiguration:
+    out: SourceAwsConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("accountId") is not None:
+        out["account_id"] = data["accountId"]
+    else:
+        raise DeserializationError("SourceAwsConfiguration.account_id required")
+    if data.get("accountType") is not None:
+        import capo_devops_agent.types.source_account_type
+
+        out["account_type"] = (
+            capo_devops_agent.types.source_account_type.deserialize_json(
+                data["accountType"]
+            )
+        )
+    else:
+        raise DeserializationError("SourceAwsConfiguration.account_type required")
+    if data.get("assumableRoleArn") is not None:
+        out["assumable_role_arn"] = data["assumableRoleArn"]
+    else:
+        raise DeserializationError("SourceAwsConfiguration.assumable_role_arn required")
+    if data.get("externalId") is not None:
+        out["external_id"] = data["externalId"]
+    return out

capo_devops_agent/types/subnet_id.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#SubnetId``."""
+
+from typing import TypeAlias
+
+"""<p>Subnet identifier.</p>"""
+SubnetId: TypeAlias = str

capo_devops_agent/types/tag_key.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#TagKey``."""
+
+from typing import TypeAlias
+
+"""<p>Tag key string.</p>"""
+TagKey: TypeAlias = str

capo_devops_agent/types/tag_key_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#TagKeyList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.tag_key
+
+TagKeyList: TypeAlias = list["capo_devops_agent.types.tag_key.TagKey"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagKeyList) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> TagKeyList:
+    return [item for item in data if item is not None]

capo_devops_agent/types/tag_resource_request.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#TagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.tags
+
+
+class TagResourceRequest(TypedDict, closed=True):
+    resource_arn: "str"
+    """<p>The ARN of the resource to tag.</p>"""
+    tags: "capo_devops_agent.types.tags.Tags"
+    """<p>Tags to add to the resource.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagResourceRequest) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.tags
+
+    out["tags"] = capo_devops_agent.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> TagResourceRequest:
+    out: TagResourceRequest = {}  # type: ignore[typeddict-item]
+    if data.get("tags") is not None:
+        import capo_devops_agent.types.tags
+
+        out["tags"] = capo_devops_agent.types.tags.deserialize_json(data["tags"])
+    else:
+        raise DeserializationError("TagResourceRequest.tags required")
+    return out

capo_devops_agent/types/tag_resource_response.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#TagResourceResponse``."""
+
+from typing_extensions import TypedDict
+
+
+class TagResourceResponse(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TagResourceResponse) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> TagResourceResponse:
+    out: TagResourceResponse = {}  # type: ignore[typeddict-item]
+    return out

capo_devops_agent/types/tag_value.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#TagValue``."""
+
+from typing import TypeAlias
+
+"""<p>Tag value string.</p>"""
+TagValue: TypeAlias = str

capo_devops_agent/types/tags.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#Tags``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.tag_key
+    import capo_devops_agent.types.tag_value
+
+Tags: TypeAlias = dict[
+    "capo_devops_agent.types.tag_key.TagKey",
+    "capo_devops_agent.types.tag_value.TagValue",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: Tags) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        out[key] = value
+    return out
+
+
+def deserialize_json(data: dict) -> Tags:
+    out: Tags = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        out[key] = value
+    return out

capo_devops_agent/types/task.py

@@ -0,0 +1,184 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#Task``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.back_log_timestamp
+    import capo_devops_agent.types.priority
+    import capo_devops_agent.types.reference_output
+    import capo_devops_agent.types.task_status
+    import capo_devops_agent.types.task_type
+
+
+class Task(TypedDict, closed=True):
+    agent_space_id: "str"
+    """<p>The unique identifier for the agent space containing this task</p>"""
+    task_id: "str"
+    """<p>The unique identifier for this task</p>"""
+    execution_id: NotRequired["str"]
+    """<p>The execution ID associated with this task, if any</p>"""
+    title: "str"
+    """<p>The title of the task</p>"""
+    description: NotRequired["str"]
+    """<p>Optional detailed description of the task</p>"""
+    reference: NotRequired["capo_devops_agent.types.reference_output.ReferenceOutput"]
+    """<p>Optional reference information linking this task to external systems</p>"""
+    task_type: "capo_devops_agent.types.task_type.TaskType"
+    """<p>The type of this task</p>"""
+    priority: "capo_devops_agent.types.priority.Priority"
+    """<p>The priority level of this task</p>"""
+    status: "capo_devops_agent.types.task_status.TaskStatus"
+    """<p>The current status of this task</p>"""
+    created_at: "capo_devops_agent.types.back_log_timestamp.BackLogTimestamp"
+    """<p>Timestamp when this task was created</p>"""
+    updated_at: "capo_devops_agent.types.back_log_timestamp.BackLogTimestamp"
+    """<p>Timestamp when this task was last updated</p>"""
+    version: "int"
+    """<p>Version number for optimistic locking</p>"""
+    support_metadata: NotRequired["object"]
+    """<p>Optional support metadata for the task</p>"""
+    metadata: NotRequired["object"]
+    """<p>Optional metadata for the task</p>"""
+    primary_task_id: NotRequired["str"]
+    """<p>The task ID of the primary investigation this task is linked to</p>"""
+    status_reason: NotRequired["str"]
+    """<p>Explanation for why the task status was changed (e.g., linked reason)</p>"""
+    has_linked_tasks: "bool"
+    """<p>Indicates if this task has other tasks linked to it</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Task) -> dict:
+    out: dict = {}
+    out["agentSpaceId"] = value["agent_space_id"]
+    out["taskId"] = value["task_id"]
+    if "execution_id" in value:
+        out["executionId"] = value["execution_id"]
+    out["title"] = value["title"]
+    if "description" in value:
+        out["description"] = value["description"]
+    if "reference" in value:
+        import capo_devops_agent.types.reference_output
+
+        out["reference"] = capo_devops_agent.types.reference_output.serialize_json(
+            value["reference"]
+        )
+    import capo_devops_agent.types.task_type
+
+    out["taskType"] = capo_devops_agent.types.task_type.serialize_json(
+        value["task_type"]
+    )
+    import capo_devops_agent.types.priority
+
+    out["priority"] = capo_devops_agent.types.priority.serialize_json(value["priority"])
+    import capo_devops_agent.types.task_status
+
+    out["status"] = capo_devops_agent.types.task_status.serialize_json(value["status"])
+    import capo_devops_agent.types.back_log_timestamp
+
+    out["createdAt"] = capo_devops_agent.types.back_log_timestamp.serialize_json(
+        value["created_at"]
+    )
+    import capo_devops_agent.types.back_log_timestamp
+
+    out["updatedAt"] = capo_devops_agent.types.back_log_timestamp.serialize_json(
+        value["updated_at"]
+    )
+    out["version"] = value["version"]
+    if "support_metadata" in value:
+        out["supportMetadata"] = value["support_metadata"]
+    if "metadata" in value:
+        out["metadata"] = value["metadata"]
+    if "primary_task_id" in value:
+        out["primaryTaskId"] = value["primary_task_id"]
+    if "status_reason" in value:
+        out["statusReason"] = value["status_reason"]
+    out["hasLinkedTasks"] = value.get("has_linked_tasks", False)
+    return out
+
+
+def deserialize_json(data: dict) -> Task:
+    out: Task = {}  # type: ignore[typeddict-item]
+    if data.get("agentSpaceId") is not None:
+        out["agent_space_id"] = data["agentSpaceId"]
+    else:
+        raise DeserializationError("Task.agent_space_id required")
+    if data.get("taskId") is not None:
+        out["task_id"] = data["taskId"]
+    else:
+        raise DeserializationError("Task.task_id required")
+    if data.get("executionId") is not None:
+        out["execution_id"] = data["executionId"]
+    if data.get("title") is not None:
+        out["title"] = data["title"]
+    else:
+        raise DeserializationError("Task.title required")
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("reference") is not None:
+        import capo_devops_agent.types.reference_output
+
+        out["reference"] = capo_devops_agent.types.reference_output.deserialize_json(
+            data["reference"]
+        )
+    if data.get("taskType") is not None:
+        import capo_devops_agent.types.task_type
+
+        out["task_type"] = capo_devops_agent.types.task_type.deserialize_json(
+            data["taskType"]
+        )
+    else:
+        raise DeserializationError("Task.task_type required")
+    if data.get("priority") is not None:
+        import capo_devops_agent.types.priority
+
+        out["priority"] = capo_devops_agent.types.priority.deserialize_json(
+            data["priority"]
+        )
+    else:
+        raise DeserializationError("Task.priority required")
+    if data.get("status") is not None:
+        import capo_devops_agent.types.task_status
+
+        out["status"] = capo_devops_agent.types.task_status.deserialize_json(
+            data["status"]
+        )
+    else:
+        raise DeserializationError("Task.status required")
+    if data.get("createdAt") is not None:
+        import capo_devops_agent.types.back_log_timestamp
+
+        out["created_at"] = capo_devops_agent.types.back_log_timestamp.deserialize_json(
+            data["createdAt"]
+        )
+    else:
+        raise DeserializationError("Task.created_at required")
+    if data.get("updatedAt") is not None:
+        import capo_devops_agent.types.back_log_timestamp
+
+        out["updated_at"] = capo_devops_agent.types.back_log_timestamp.deserialize_json(
+            data["updatedAt"]
+        )
+    else:
+        raise DeserializationError("Task.updated_at required")
+    if data.get("version") is not None:
+        out["version"] = data["version"]
+    else:
+        raise DeserializationError("Task.version required")
+    if data.get("supportMetadata") is not None:
+        out["support_metadata"] = data["supportMetadata"]
+    if data.get("metadata") is not None:
+        out["metadata"] = data["metadata"]
+    if data.get("primaryTaskId") is not None:
+        out["primary_task_id"] = data["primaryTaskId"]
+    if data.get("statusReason") is not None:
+        out["status_reason"] = data["statusReason"]
+    if data.get("hasLinkedTasks") is not None:
+        out["has_linked_tasks"] = data["hasLinkedTasks"]
+    else:
+        out["has_linked_tasks"] = False
+    return out