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

capo_devops_agent/types/git_lab_configuration.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GitLabConfiguration``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+
+class GitLabConfiguration(TypedDict, closed=True):
+    project_id: "str"
+    """<p>GitLab numeric project ID.</p>"""
+    project_path: "str"
+    """<p>Full GitLab project path (e.g., namespace/project-name).</p>"""
+    instance_identifier: NotRequired["str"]
+    """<p>GitLab instance identifier (e.g., gitlab.com or e2e.gamma.dev.us-east-1.gitlab.falco.ai.aws.dev)</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GitLabConfiguration) -> dict:
+    out: dict = {}
+    out["projectId"] = value["project_id"]
+    out["projectPath"] = value["project_path"]
+    if "instance_identifier" in value:
+        out["instanceIdentifier"] = value["instance_identifier"]
+    return out
+
+
+def deserialize_json(data: dict) -> GitLabConfiguration:
+    out: GitLabConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("projectId") is not None:
+        out["project_id"] = data["projectId"]
+    else:
+        raise DeserializationError("GitLabConfiguration.project_id required")
+    if data.get("projectPath") is not None:
+        out["project_path"] = data["projectPath"]
+    else:
+        raise DeserializationError("GitLabConfiguration.project_path required")
+    if data.get("instanceIdentifier") is not None:
+        out["instance_identifier"] = data["instanceIdentifier"]
+    return out

capo_devops_agent/types/git_lab_details.py

@@ -0,0 +1,60 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GitLabDetails``."""
+
+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.git_lab_token_type
+    import capo_devops_agent.types.token_value
+
+
+class GitLabDetails(TypedDict, closed=True):
+    target_url: "str"
+    """<p>GitLab instance URL (e.g., https://gitlab.com or self-hosted instance).</p>"""
+    token_type: "capo_devops_agent.types.git_lab_token_type.GitLabTokenType"
+    """<p>Type of GitLab access token</p>"""
+    token_value: "capo_devops_agent.types.token_value.TokenValue"
+    """<p>GitLab access token value</p>"""
+    group_id: NotRequired["str"]
+    """<p>Optional GitLab group ID for group-level access tokens</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GitLabDetails) -> dict:
+    out: dict = {}
+    out["targetUrl"] = value["target_url"]
+    import capo_devops_agent.types.git_lab_token_type
+
+    out["tokenType"] = capo_devops_agent.types.git_lab_token_type.serialize_json(
+        value["token_type"]
+    )
+    out["tokenValue"] = value["token_value"]
+    if "group_id" in value:
+        out["groupId"] = value["group_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> GitLabDetails:
+    out: GitLabDetails = {}  # type: ignore[typeddict-item]
+    if data.get("targetUrl") is not None:
+        out["target_url"] = data["targetUrl"]
+    else:
+        raise DeserializationError("GitLabDetails.target_url required")
+    if data.get("tokenType") is not None:
+        import capo_devops_agent.types.git_lab_token_type
+
+        out["token_type"] = capo_devops_agent.types.git_lab_token_type.deserialize_json(
+            data["tokenType"]
+        )
+    else:
+        raise DeserializationError("GitLabDetails.token_type required")
+    if data.get("tokenValue") is not None:
+        out["token_value"] = data["tokenValue"]
+    else:
+        raise DeserializationError("GitLabDetails.token_value required")
+    if data.get("groupId") is not None:
+        out["group_id"] = data["groupId"]
+    return out

capo_devops_agent/types/git_lab_token_type.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GitLabTokenType``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>Type of GitLab access token.</p>"""
+GitLabTokenType: TypeAlias = Literal[
+    "personal",
+    "group",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GitLabTokenType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> GitLabTokenType:
+    return cast(GitLabTokenType, data)

capo_devops_agent/types/github_repo_owner_type.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GithubRepoOwnerType``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>Type of GitHub repository owner.</p>"""
+GithubRepoOwnerType: TypeAlias = Literal[
+    "organization",
+    "user",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GithubRepoOwnerType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> GithubRepoOwnerType:
+    return cast(GithubRepoOwnerType, data)

capo_devops_agent/types/goal.py

@@ -0,0 +1,181 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#Goal``."""
+
+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.goal_content
+    import capo_devops_agent.types.goal_schedule
+    import capo_devops_agent.types.goal_status
+    import capo_devops_agent.types.goal_type
+
+
+class Goal(TypedDict, closed=True):
+    agent_space_arn: "str"
+    """<p>The unique identifier for the agent space containing this goal</p>"""
+    goal_id: "str"
+    """<p>The unique identifier for this goal</p>"""
+    title: "str"
+    """<p>The title of the goal</p>"""
+    content: "capo_devops_agent.types.goal_content.GoalContent"
+    """<p>Content of the goal</p>"""
+    status: "capo_devops_agent.types.goal_status.GoalStatus"
+    """<p>Current status of the goal itself</p>"""
+    goal_type: "capo_devops_agent.types.goal_type.GoalType"
+    """<p>Type of goal based on its origin</p>"""
+    created_at: "capo_devops_agent.types.back_log_timestamp.BackLogTimestamp"
+    """<p>Timestamp when this goal was created</p>"""
+    updated_at: "capo_devops_agent.types.back_log_timestamp.BackLogTimestamp"
+    """<p>Timestamp when this goal was last updated</p>"""
+    last_evaluated_at: NotRequired[
+        "capo_devops_agent.types.back_log_timestamp.BackLogTimestamp"
+    ]
+    """<p>Timestamp when the goal was last evaluated</p>"""
+    last_task_id: NotRequired["str"]
+    """<p>ID of the most recent task associated with this goal</p>"""
+    last_successful_task_id: NotRequired["str"]
+    """<p>ID of the most recent successful task associated with this goal</p>"""
+    version: "int"
+    """<p>Version number for optimistic locking</p>"""
+    evaluation_schedule: NotRequired[
+        "capo_devops_agent.types.goal_schedule.GoalSchedule"
+    ]
+    """<p>Goal Schedule. Allows to schedule the goal to run periodically, as well as disable a goal temporarily</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Goal) -> dict:
+    out: dict = {}
+    out["agentSpaceArn"] = value["agent_space_arn"]
+    out["goalId"] = value["goal_id"]
+    out["title"] = value["title"]
+    import capo_devops_agent.types.goal_content
+
+    out["content"] = capo_devops_agent.types.goal_content.serialize_json(
+        value["content"]
+    )
+    import capo_devops_agent.types.goal_status
+
+    out["status"] = capo_devops_agent.types.goal_status.serialize_json(value["status"])
+    import capo_devops_agent.types.goal_type
+
+    out["goalType"] = capo_devops_agent.types.goal_type.serialize_json(
+        value.get("goal_type", "ONCALL_REPORT")
+    )
+    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"]
+    )
+    if "last_evaluated_at" in value:
+        import capo_devops_agent.types.back_log_timestamp
+
+        out["lastEvaluatedAt"] = (
+            capo_devops_agent.types.back_log_timestamp.serialize_json(
+                value["last_evaluated_at"]
+            )
+        )
+    if "last_task_id" in value:
+        out["lastTaskId"] = value["last_task_id"]
+    if "last_successful_task_id" in value:
+        out["lastSuccessfulTaskId"] = value["last_successful_task_id"]
+    out["version"] = value["version"]
+    if "evaluation_schedule" in value:
+        import capo_devops_agent.types.goal_schedule
+
+        out["evaluationSchedule"] = (
+            capo_devops_agent.types.goal_schedule.serialize_json(
+                value["evaluation_schedule"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> Goal:
+    out: Goal = {}  # type: ignore[typeddict-item]
+    if data.get("agentSpaceArn") is not None:
+        out["agent_space_arn"] = data["agentSpaceArn"]
+    else:
+        raise DeserializationError("Goal.agent_space_arn required")
+    if data.get("goalId") is not None:
+        out["goal_id"] = data["goalId"]
+    else:
+        raise DeserializationError("Goal.goal_id required")
+    if data.get("title") is not None:
+        out["title"] = data["title"]
+    else:
+        raise DeserializationError("Goal.title required")
+    if data.get("content") is not None:
+        import capo_devops_agent.types.goal_content
+
+        out["content"] = capo_devops_agent.types.goal_content.deserialize_json(
+            data["content"]
+        )
+    else:
+        raise DeserializationError("Goal.content required")
+    if data.get("status") is not None:
+        import capo_devops_agent.types.goal_status
+
+        out["status"] = capo_devops_agent.types.goal_status.deserialize_json(
+            data["status"]
+        )
+    else:
+        raise DeserializationError("Goal.status required")
+    if data.get("goalType") is not None:
+        import capo_devops_agent.types.goal_type
+
+        out["goal_type"] = capo_devops_agent.types.goal_type.deserialize_json(
+            data["goalType"]
+        )
+    else:
+        out["goal_type"] = "ONCALL_REPORT"
+    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("Goal.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("Goal.updated_at required")
+    if data.get("lastEvaluatedAt") is not None:
+        import capo_devops_agent.types.back_log_timestamp
+
+        out["last_evaluated_at"] = (
+            capo_devops_agent.types.back_log_timestamp.deserialize_json(
+                data["lastEvaluatedAt"]
+            )
+        )
+    if data.get("lastTaskId") is not None:
+        out["last_task_id"] = data["lastTaskId"]
+    if data.get("lastSuccessfulTaskId") is not None:
+        out["last_successful_task_id"] = data["lastSuccessfulTaskId"]
+    if data.get("version") is not None:
+        out["version"] = data["version"]
+    else:
+        raise DeserializationError("Goal.version required")
+    if data.get("evaluationSchedule") is not None:
+        import capo_devops_agent.types.goal_schedule
+
+        out["evaluation_schedule"] = (
+            capo_devops_agent.types.goal_schedule.deserialize_json(
+                data["evaluationSchedule"]
+            )
+        )
+    return out

capo_devops_agent/types/goal_content.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GoalContent``."""
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+
+class GoalContent(TypedDict, closed=True):
+    description: "str"
+    """<p>A detailed description of the goal.</p>"""
+    objectives: "str"
+    """<p>The objectives to be achieved for this goal.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GoalContent) -> dict:
+    out: dict = {}
+    out["description"] = value["description"]
+    out["objectives"] = value["objectives"]
+    return out
+
+
+def deserialize_json(data: dict) -> GoalContent:
+    out: GoalContent = {}  # type: ignore[typeddict-item]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    else:
+        raise DeserializationError("GoalContent.description required")
+    if data.get("objectives") is not None:
+        out["objectives"] = data["objectives"]
+    else:
+        raise DeserializationError("GoalContent.objectives required")
+    return out

capo_devops_agent/types/goal_list.py

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

capo_devops_agent/types/goal_schedule.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GoalSchedule``."""
+
+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.scheduler_state
+
+
+class GoalSchedule(TypedDict, closed=True):
+    state: "capo_devops_agent.types.scheduler_state.SchedulerState"
+    """<p>Whether the schedule is enabled or disabled</p>"""
+    expression: NotRequired["str"]
+    """<p>Schedule expression (e.g., 'rate(7 days)')</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GoalSchedule) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.scheduler_state
+
+    out["state"] = capo_devops_agent.types.scheduler_state.serialize_json(
+        value["state"]
+    )
+    if "expression" in value:
+        out["expression"] = value["expression"]
+    return out
+
+
+def deserialize_json(data: dict) -> GoalSchedule:
+    out: GoalSchedule = {}  # type: ignore[typeddict-item]
+    if data.get("state") is not None:
+        import capo_devops_agent.types.scheduler_state
+
+        out["state"] = capo_devops_agent.types.scheduler_state.deserialize_json(
+            data["state"]
+        )
+    else:
+        raise DeserializationError("GoalSchedule.state required")
+    if data.get("expression") is not None:
+        out["expression"] = data["expression"]
+    return out

capo_devops_agent/types/goal_schedule_input.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GoalScheduleInput``."""
+
+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.scheduler_state
+
+
+class GoalScheduleInput(TypedDict, closed=True):
+    state: "capo_devops_agent.types.scheduler_state.SchedulerState"
+    """<p>Whether the schedule is enabled or disabled</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GoalScheduleInput) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.scheduler_state
+
+    out["state"] = capo_devops_agent.types.scheduler_state.serialize_json(
+        value["state"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GoalScheduleInput:
+    out: GoalScheduleInput = {}  # type: ignore[typeddict-item]
+    if data.get("state") is not None:
+        import capo_devops_agent.types.scheduler_state
+
+        out["state"] = capo_devops_agent.types.scheduler_state.deserialize_json(
+            data["state"]
+        )
+    else:
+        raise DeserializationError("GoalScheduleInput.state required")
+    return out

capo_devops_agent/types/goal_status.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GoalStatus``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>Possible states of a goal throughout its lifecycle</p>"""
+GoalStatus: TypeAlias = Literal[
+    "ACTIVE",
+    "PAUSED",
+    "COMPLETE",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GoalStatus) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> GoalStatus:
+    return cast(GoalStatus, data)

capo_devops_agent/types/goal_type.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GoalType``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>Type of goal based on its origin</p>"""
+GoalType: TypeAlias = Literal[
+    "CUSTOMER_DEFINED",
+    "ONCALL_REPORT",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GoalType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> GoalType:
+    return cast(GoalType, data)

capo_devops_agent/types/grafana_service_details.py

@@ -0,0 +1,68 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GrafanaServiceDetails``."""
+
+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.description
+    import capo_devops_agent.types.mcp_server_authorization_config
+    import capo_devops_agent.types.mcp_server_endpoint
+    import capo_devops_agent.types.mcp_server_name
+
+
+class GrafanaServiceDetails(TypedDict, closed=True):
+    name: "capo_devops_agent.types.mcp_server_name.MCPServerName"
+    """<p>MCP server name.</p>"""
+    endpoint: "capo_devops_agent.types.mcp_server_endpoint.MCPServerEndpoint"
+    """<p>MCP server endpoint URL.</p>"""
+    description: NotRequired["capo_devops_agent.types.description.Description"]
+    """<p>Optional description for the MCP server.</p>"""
+    authorization_config: "capo_devops_agent.types.mcp_server_authorization_config.MCPServerAuthorizationConfig"
+    """<p>Grafana MCP server authorization configuration (experimental).</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GrafanaServiceDetails) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    out["endpoint"] = value["endpoint"]
+    if "description" in value:
+        out["description"] = value["description"]
+    import capo_devops_agent.types.mcp_server_authorization_config
+
+    out["authorizationConfig"] = (
+        capo_devops_agent.types.mcp_server_authorization_config.serialize_json(
+            value["authorization_config"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GrafanaServiceDetails:
+    out: GrafanaServiceDetails = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("GrafanaServiceDetails.name required")
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("GrafanaServiceDetails.endpoint required")
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("authorizationConfig") is not None:
+        import capo_devops_agent.types.mcp_server_authorization_config
+
+        out["authorization_config"] = (
+            capo_devops_agent.types.mcp_server_authorization_config.deserialize_json(
+                data["authorizationConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GrafanaServiceDetails.authorization_config required"
+        )
+    return out

capo_devops_agent/types/guid.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#Guid``."""
+
+from typing import TypeAlias
+
+"""<p>Globally Unique Identifier (GUID) in standard format.</p>"""
+Guid: TypeAlias = str

capo_devops_agent/types/iam_auth_configuration.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#IamAuthConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import datetime
+
+
+class IamAuthConfiguration(TypedDict, closed=True):
+    operator_app_role_arn: "str"
+    """<p>The IAM role end users assume to access AIDevOps APIs</p>"""
+    created_at: "datetime.datetime"
+    """<p>The timestamp when the Operator App IAM auth flow was enabled.</p>"""
+    updated_at: NotRequired["datetime.datetime"]
+    """<p>The timestamp when the Operator App IAM auth flow was updated.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: IamAuthConfiguration) -> dict:
+    out: dict = {}
+    out["operatorAppRoleArn"] = value["operator_app_role_arn"]
+    import capo_devops_agent._protocol.serialize
+
+    out["createdAt"] = capo_devops_agent._protocol.serialize.fmt_date_time(
+        value["created_at"]
+    )
+    if "updated_at" in value:
+        import capo_devops_agent._protocol.serialize
+
+        out["updatedAt"] = capo_devops_agent._protocol.serialize.fmt_date_time(
+            value["updated_at"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> IamAuthConfiguration:
+    out: IamAuthConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("operatorAppRoleArn") is not None:
+        out["operator_app_role_arn"] = data["operatorAppRoleArn"]
+    else:
+        raise DeserializationError(
+            "IamAuthConfiguration.operator_app_role_arn required"
+        )
+    if data.get("createdAt") is not None:
+        import datetime
+
+        out["created_at"] = datetime.datetime.fromisoformat(
+            data["createdAt"].replace("Z", "+00:00")
+        )
+    else:
+        raise DeserializationError("IamAuthConfiguration.created_at required")
+    if data.get("updatedAt") is not None:
+        import datetime
+
+        out["updated_at"] = datetime.datetime.fromisoformat(
+            data["updatedAt"].replace("Z", "+00:00")
+        )
+    return out