Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS DevOps Agent Service can respond with.

Structs

AgentSpace

Represents a complete AgentSpace with all its properties, timestamps, encryption settings, and unique identifier.

Association

Represents a service association within an AgentSpace, defining how the agent interacts with external services.

AwsConfiguration

Configuration for AWS monitor account integration, allowing AIDevOps to monitor AWS resources.

AzureConfiguration

Configuration for Azure subscription integration.

AzureDevOpsConfiguration

Configuration for Azure DevOps project integration.

ChatExecution

A single chat execution summary

DatadogServiceDetails

Complete service details for Datadog MCP server integration.

DynatraceConfiguration

Configuration for Dynatrace monitoring integration.

DynatraceOAuthClientCredentialsConfig

OAuth client credentials configuration for Dynatrace.

DynatraceServiceDetails

Complete service details for Dynatrace integration.

EventChannelConfiguration

Configuration for Event Channel integration.

EventChannelDetails

Service details for Event Channel integration.

Execution

Represents an execution instance with its lifecycle information

GenericWebhook

Generic webhook configuration for services that support webhook notifications.

GitHubConfiguration

Configuration for GitHub repository integration.

GitLabConfiguration

Configuration for GitLab project integration.

GitLabDetails

Service details for GitLab integration.

Goal

Represents a goal with all its properties and metadata

GoalContent

Content of a goal

GoalSchedule

Schedule configuration for goal evaluations

GoalScheduleInput

Schedule configuration for updating goal evaluations

GrafanaServiceDetails

Complete service details for Grafana MCP server integration.

IamAuthConfiguration

Configuration for IAM-based authentication flow for the Operator App.

IdcAuthConfiguration

Configuration for AWS Identity Center (IdC) authentication flow for the Operator App.

IdpAuthConfiguration

Configuration for external Identity Provider OIDC authentication flow for the Operator App.

JournalRecord

Represents a journal record containing execution details and content

McpServerApiKeyConfig

API key configuration for MCP server.

McpServerAuthorizationDiscoveryConfig

Authorization discovery configuration for MCP server.

McpServerBearerTokenConfig

Bearer token configuration for MCP server (RFC 6750).

McpServerDetails

Complete service details for MCP server integration.

McpServerGrafanaConfiguration

Configuration for Grafana MCP server integration, used with an AWS-hosted MCP server.

McpServerNewRelicConfiguration

Mixin for webhook update support.

McpServerOAuth3LoConfig

OAuth 3-legged authorization configuration for MCP server.

McpServerOAuthClientCredentialsConfig

OAuth client credentials configuration for MCP server.

NewRelicApiKeyConfig

API key authentication configuration for New Relic service.

NewRelicServiceDetails

Complete service details for New Relic integration.

OAuthAdditionalStepDetails

Details for completing OAuth authorization step.

PagerDutyConfiguration

Configuration for Pagerduty integration.

PagerDutyDetails

Complete service details for PagerDuty integration

PagerDutyOAuthClientCredentialsConfig

OAuth client credentials configuration for PagerDuty.

PendingMessage

Represents a pending message in an agent execution.

PrivateConnectionSummary

Summary of a Private Connection.

Recommendation

Represents a recommendation with all its properties and metadata

RecommendationContent

Content of a recommendation

ReferenceInput

Reference information linking a task to external systems - for input with validation

ReferenceOutput

Reference information linking a task to external systems - for output without validation

RegisteredAzureDevOpsServiceDetails

Details specific to a registered Azure DevOps service.

RegisteredAzureIdentityDetails

Details specific to a registered Azure identity using AWS Outbound Identity Federation.

RegisteredGitLabServiceDetails

Details specific to a registered GitLab instance.

RegisteredGithubServiceDetails

Details specific to a registered GitHub service.

RegisteredGrafanaServerDetails

Details specific to a registered Grafana server, used by the built-in MCP server.

RegisteredMcpServerDetails

Details specific to a registered MCP (Model Context Protocol) server.

RegisteredNewRelicDetails

Details specific to a registered NewRelic instance.

RegisteredPagerDutyDetails

Details specific to a registered PagerDuty service.

RegisteredService

Represents a registered service with its configuration and accessible resources.

RegisteredServiceNowDetails

Details specific to a registered ServiceNow instance.

RegisteredSlackServiceDetails

Details specific to a registered Slack workspace.

SelfManagedInput

Configuration for a self-managed Private Connection.

SendMessageContentBlockDeltaEvent

Event emitted for each incremental content delta within a content block

SendMessageContentBlockStartEvent

Event emitted when a new content block starts

SendMessageContentBlockStopEvent

Event emitted when a content block is complete

SendMessageContext

Context object for additional message metadata

SendMessageHeartbeatEvent

Heartbeat event to keep connection alive

SendMessageJsonDelta

JSON delta containing partial JSON

SendMessageResponseCompletedEvent

Event emitted when the response completes successfully

SendMessageResponseCreatedEvent

Event emitted when the response is created

SendMessageResponseFailedEvent

Event emitted when the response fails

SendMessageResponseInProgressEvent

Event emitted while the response is being generated

SendMessageSummaryEvent

Event summarizing agent actions

SendMessageTextDelta

Text delta containing a text fragment

SendMessageUsageInfo

Token usage information

ServiceManagedInput

Configuration for a service-managed Private Connection.

ServiceNowConfiguration

Configuration for ServiceNow instance integration.

ServiceNowOAuthClientCredentialsConfig

OAuth client credentials configuration for ServiceNow.

ServiceNowServiceDetails

Complete service details for ServiceNow integration.

SlackChannel

Represents a Slack channel with its ID and optional name.

SlackConfiguration

Configuration for Slack workspace integration.

SlackTransmissionTarget

Defines Slack channels for different types of agent notifications.

SourceAwsConfiguration

Configuration for AWS source account integration. Note: passRole check on ‘assumableRoleArn’ is not supported.

Task

Represents a backlog task with all its properties and metadata

TaskFilter

Filter criteria for listing backlog tasks, supporting time range, priority, status, and type filters.

UsageMetric

Represents a usage metric with its configured limit and current usage value.

UserReference

Reference to a user in the system

ValidationExceptionField

Describes one specific validation failure for an input member.

Webhook

Represents a complete Webhook with all its properties, and unique identifier.

Enums

AdditionalServiceDetails

Union of service-specific details for different service types.

AdditionalServiceRegistrationStep

Additional steps required to complete service registration.

AssistantMessageBlock

A block of content in an assistant message.

AuthFlow

When writing a match expression against AuthFlow, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DatadogAuthorizationConfig

Authorization configuration for Datadog MCP server (uses authorization discovery only).

DynatraceServiceAuthorizationConfig

Authorization configuration options for Dynatrace service.

EventChannelType

When writing a match expression against EventChannelType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExecutionStatus

When writing a match expression against ExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GitLabTokenType

When writing a match expression against GitLabTokenType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GithubRepoOwnerType

When writing a match expression against GithubRepoOwnerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GoalStatus

When writing a match expression against GoalStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GoalType

When writing a match expression against GoalType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

IpAddressType

When writing a match expression against IpAddressType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

McpServerAuthorizationConfig

Authorization configuration options for MCP server, supporting OAuth, API key, bearer token, and authorization discovery methods.

McpServerAuthorizationMethod

When writing a match expression against McpServerAuthorizationMethod, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Message

A message in a conversation, either from the user or the assistant.

MonitorAccountType

When writing a match expression against MonitorAccountType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

NewRelicRegion

When writing a match expression against NewRelicRegion, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

NewRelicServiceAuthorizationConfig

Authorization configuration options for New Relic service.

OrderType

When writing a match expression against OrderType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PagerDutyAuthorizationConfig

Authorization configuration options for PagerDuty service.

PostRegisterServiceSupportedService

When writing a match expression against PostRegisterServiceSupportedService, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Priority

When writing a match expression against Priority, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PrivateConnectionMode

Private Connection mode — either service-managed or self-managed.

PrivateConnectionStatus

When writing a match expression against PrivateConnectionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PrivateConnectionType

When writing a match expression against PrivateConnectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecommendationPriority

When writing a match expression against RecommendationPriority, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecommendationStatus

When writing a match expression against RecommendationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SchedulerState

When writing a match expression against SchedulerState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SendMessageContentBlockDelta

Union of possible delta payloads within a content block delta event

SendMessageEvents

Event stream for chat message responses using the content block model. Events follow a lifecycle: responseCreated -> responseInProgress -> (contentBlockStart/contentBlockDelta/contentBlockStop events) -> responseCompleted|responseFailed SendMessage always uses content block mode — legacy per-field events (outputTextDelta, functionCallArgumentsDelta, etc.) are not emitted.

Service

When writing a match expression against Service, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ServiceConfiguration

Union of all supported service configuration types. Each service has its own specific configuration structure.

ServiceDetails

Union of service-specific configuration details for service registration.

ServiceNowServiceAuthorizationConfig

Authorization configuration options for ServiceNow service.

SourceAccountType

When writing a match expression against SourceAccountType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TaskSortField

When writing a match expression against TaskSortField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TaskSortOrder

When writing a match expression against TaskSortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TaskStatus

When writing a match expression against TaskStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TaskType

When writing a match expression against TaskType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UserMessageBlock

A block of content in a user message.

UserType

When writing a match expression against UserType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ValidationStatus

When writing a match expression against ValidationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

WebhookType

When writing a match expression against WebhookType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.