Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS Security Agent can respond with.

Structs

Actor

Represents an actor used during penetration testing. An actor defines a user or entity that interacts with the target application, including authentication credentials and target URIs.

AgentSpace

Represents an agent space, which is a dedicated workspace for securing a specific application. An agent space contains the configuration, resources, and settings needed for security testing.

AgentSpaceSummary

Contains summary information about an agent space.

ApplicationSummary

Contains summary information about an application.

Artifact

Represents an artifact that provides context for security testing, such as documentation, diagrams, or configuration files.

ArtifactMetadataItem

Contains metadata about an artifact.

ArtifactSummary

Contains summary information about an artifact.

Assets

The collection of assets used in a pentest configuration, including endpoints, actors, documents, source code repositories, and integrated repositories.

Authentication

The authentication configuration for an actor, specifying the provider type and credentials.

AwsResources

The AWS resources associated with an agent space, including VPCs, log groups, S3 buckets, secrets, Lambda functions, and IAM roles.

BatchCreateSecurityRequirementResult

Contains information about a successfully created security requirement.

BatchGetSecurityRequirementResult

Contains information about a successfully retrieved security requirement.

BatchSecurityRequirementError

Contains information about an error that occurred for a specific security requirement during a batch operation.

BitbucketIntegrationInput

The configuration for creating a Bitbucket integration.

BitbucketRepositoryMetadata

Metadata for an integrated Bitbucket repository.

BitbucketRepositoryResource

A Bitbucket repository integrated as a resource.

BitbucketResourceCapabilities

Capabilities for an integrated Bitbucket repository.

Category

Represents a category assigned to a security testing task.

CloudWatchLog

The Amazon CloudWatch Logs configuration for pentest job logging.

CodeLocation

Represents a location in source code associated with a security finding.

CodeRemediationTask

Represents a code remediation task that was initiated to fix a security finding.

CodeRemediationTaskDetails

Contains details about a code remediation task, including links to the code diff and pull request.

CodeReview

Represents a code review configuration that defines the parameters for automated security-focused code analysis, including target assets and logging configuration.

CodeReviewJob

Represents a code review job, which is an execution instance of a code review. A code review job progresses through preflight, static analysis, and finalizing steps.

CodeReviewJobSummary

Contains summary information about a code review job.

CodeReviewJobTask

Represents an individual security test task within a code review job. Each task targets a specific risk type and executes independently.

CodeReviewJobTaskSummary

Contains summary information about a code review job task.

CodeReviewSettings

The code review settings for an agent space, controlling which types of scanning are enabled.

CodeReviewSummary

Contains summary information about a code review.

ConfluenceDocumentMetadata

Metadata for an integrated Confluence document.

ConfluenceDocumentResource

A Confluence document (page) integrated as a resource.

ConfluenceIntegrationInput

The configuration for creating a Confluence integration.

ConfluenceResourceCapabilities

Capabilities for an integrated Confluence space.

CreateSecurityRequirementEntry

Contains the details for a security requirement to create within a pack.

CustomHeader

A custom HTTP header to include in network traffic during penetration testing.

DeleteCodeReviewFailure

Contains information about a code review that failed to delete.

DeletePentestFailure

Contains information about a pentest that failed to delete.

DeleteThreatModelFailure

Contains information about a threat model that failed to delete.

DiscoveredEndpoint

Represents an endpoint discovered during a pentest job.

DnsVerification

Contains DNS verification details for a target domain, including the DNS record to create for domain ownership verification.

DocumentInfo

Represents a document that provides context for security testing.

Endpoint

Represents a target endpoint for penetration testing.

ErrorInformation

Contains error information for a pentest job that encountered an error.

ExecutionContext

Contains contextual information about the execution of a pentest job, such as errors, warnings, or informational messages.

Finding

Represents a security finding discovered during a pentest job. A finding contains details about a vulnerability, including its risk level, confidence, and remediation status.

FindingSummary

Contains summary information about a security finding.

GitHubIntegrationInput

The input required to create a GitHub integration, including the OAuth authorization code and CSRF state.

GitHubRepositoryMetadata

Contains metadata about a GitHub repository that is integrated with the service.

GitHubRepositoryResource

Represents a GitHub repository resource used in an integration.

GitHubResourceCapabilities

The capabilities enabled for a GitHub resource integration.

GitLabIntegrationInput

The configuration for creating a GitLab integration.

GitLabRepositoryMetadata

Metadata for an integrated GitLab repository.

GitLabRepositoryResource

A GitLab repository integrated as a resource.

GitLabResourceCapabilities

Capabilities for an integrated GitLab repository.

HttpVerification

Contains HTTP route verification details for a target domain, including the route path and token to serve for domain ownership verification.

IdCConfiguration

The IAM Identity Center configuration for an application.

IntegratedDocument

A reference to a document in a third-party provider, such as a Confluence page linked via an integration.

IntegratedRepository

Represents a code repository that is integrated with the service through a third-party provider.

IntegratedResourceInputItem

Represents an input item for updating integrated resources, including the resource and its capabilities.

IntegratedResourceSummary

Contains summary information about an integrated resource.

IntegrationSummary

Contains summary information about an integration.

ListSecurityRequirementPackFilter

Filter criteria for listing security requirement packs.

LogLocation

The log location for a task, specifying where task execution logs are stored.

MembershipSummary

Contains summary information about a membership.

NetworkTrafficConfig

The network traffic configuration for a pentest, including custom headers and traffic rules.

NetworkTrafficRule

A rule that controls network traffic during penetration testing by allowing or denying traffic to specific URL patterns.

Pentest

Represents a pentest configuration that defines the parameters for security testing, including target assets, risk type exclusions, and infrastructure settings.

PentestJob

Represents a pentest job, which is an execution instance of a pentest. A pentest job progresses through preflight, static analysis, pentest, and finalizing steps.

PentestJobSummary

Contains summary information about a pentest job.

PentestSummary

Contains summary information about a pentest.

PrivateConnectionSummary

Summarizes a private connection.

ReportDestination

Destination for publishing scan reports to an integrated document provider.

SecurityRequirementArtifact

A document used as source material for importing security requirements.

SecurityRequirementPackSummary

Contains summary information about a security requirement pack.

SecurityRequirementSummary

Contains summary information about a security requirement.

SelfManagedInput

The configuration for a self-managed private connection.

ServiceManagedInput

The configuration for a service-managed private connection.

SourceCodeRepository

Represents a source code repository used for security analysis during a pentest.

Step

Represents a step in the pentest job execution pipeline. Steps include preflight, static analysis, pentest, and finalizing.

TargetDomain

Represents a target domain registered for penetration testing. A target domain must be verified through DNS TXT or HTTP route verification before it can be used in pentests.

TargetDomainSummary

Contains summary information about a target domain.

Task

Represents an individual security test task within a pentest job. Each task targets a specific risk type or endpoint and executes independently.

TaskSummary

Contains summary information about a task.

Threat

Represents a threat identified during threat modeling.

ThreatAnchorShape

DFD element that a threat is anchored to.

ThreatEvidenceShape

Source code file supporting a threat.

ThreatModel

Represents a threat model configuration that defines the parameters for automated threat analysis, including target assets and logging configuration.

ThreatModelJob

Represents a threat model job, which is an execution instance of a threat model.

ThreatModelJobSummary

Contains summary information about a threat model job.

ThreatModelJobTask

Represents an individual task within a threat model job.

ThreatModelJobTaskSummary

Contains summary information about a threat model job task.

ThreatModelSummary

Contains summary information about a threat model.

ThreatSummary

Contains summary information about a threat.

UpdateSecurityRequirementEntry

Contains the details for updating an existing security requirement within a pack. The name is an immutable identifier used to locate the requirement and cannot be modified.

UserConfig

The configuration for a user membership, including the role assigned to the user within the agent space.

UserMetadata

Contains metadata about a user member, including the username and email address.

ValidationExceptionField

Describes one specific validation failure for an input member.

VerificationDetails

Contains the verification details for a target domain, including the verification method and provider-specific details.

VerificationScript

Contains metadata for a verification script that can be used to reproduce a security finding.

VerificationScriptEnvVar

Represents an environment variable required to run a verification script.

VpcConfig

The VPC configuration for a pentest, specifying the VPC, security groups, and subnets to use during testing.

Enums

AccessType

When writing a match expression against AccessType, 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.

ArtifactType

When writing a match expression against ArtifactType, 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.

AuthenticationProviderType

When writing a match expression against AuthenticationProviderType, 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.

CleanUpStrategy

When writing a match expression against CleanUpStrategy, 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.

CodeRemediationStrategy

When writing a match expression against CodeRemediationStrategy, 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.

CodeRemediationTaskStatus

When writing a match expression against CodeRemediationTaskStatus, 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.

ConfidenceLevel

When writing a match expression against ConfidenceLevel, 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.

ContextType

When writing a match expression against ContextType, 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.

DiffSource

Source of the diff for a differential code scan.

DnsRecordType

When writing a match expression against DnsRecordType, 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.

DomainVerificationMethod

When writing a match expression against DomainVerificationMethod, 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.

ErrorCode

When writing a match expression against ErrorCode, 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.

FindingStatus

When writing a match expression against FindingStatus, 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.

ImportSource

The source from which to import security requirements. Currently supports document uploads.

IntegratedResource

Represents an integrated resource from a third-party provider. This is a union type that contains provider-specific resource information.

IntegratedResourceMetadata

Contains metadata about an integrated resource. This is a union type that contains provider-specific metadata.

IntegrationFilter

A filter for listing integrations. This is a union type where you can filter by provider or provider type.

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.

JobStatus

When writing a match expression against JobStatus, 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.

LogType

When writing a match expression against LogType, 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.

ManagementType

When writing a match expression against ManagementType, 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.

MemberMetadata

Contains metadata about a member. This is a union type that contains member-type-specific metadata.

MembershipConfig

The configuration for a membership. This is a union type that contains member-type-specific configuration.

MembershipType

When writing a match expression against MembershipType, 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.

MembershipTypeFilter

When writing a match expression against MembershipTypeFilter, 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.

NetworkTrafficRuleEffect

When writing a match expression against NetworkTrafficRuleEffect, 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.

NetworkTrafficRuleType

When writing a match expression against NetworkTrafficRuleType, 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

The configuration for a private connection. Specify either a service-managed or a self-managed mode.

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.

Provider

When writing a match expression against Provider, 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.

ProviderInput

The provider-specific input for creating an integration. This is a union type that contains provider-specific configuration.

ProviderResourceCapabilities

The capabilities for an integrated resource from a third-party provider. This is a union type that contains provider-specific capabilities.

ProviderType

When writing a match expression against ProviderType, 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.

ResourceConfigDnsResolution

When writing a match expression against ResourceConfigDnsResolution, 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.

ResourceType

When writing a match expression against ResourceType, 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.

RiskLevel

When writing a match expression against RiskLevel, 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.

RiskType

When writing a match expression against RiskType, 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.

SecurityRequirementArtifactFormat

When writing a match expression against SecurityRequirementArtifactFormat, 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.

SecurityRequirementPackImportStatus

When writing a match expression against SecurityRequirementPackImportStatus, 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.

SecurityRequirementPackStatus

When writing a match expression against SecurityRequirementPackStatus, 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.

SkillType

When writing a match expression against SkillType, 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.

StepName

When writing a match expression against StepName, 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.

StepStatus

When writing a match expression against StepStatus, 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.

StrideCategory

When writing a match expression against StrideCategory, 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.

TargetDomainStatus

When writing a match expression against TargetDomainStatus, 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.

TaskExecutionStatus

When writing a match expression against TaskExecutionStatus, 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.

ThreatActor

When writing a match expression against ThreatActor, 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.

ThreatSeverity

When writing a match expression against ThreatSeverity, 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.

ThreatStatus

When writing a match expression against ThreatStatus, 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.

UserRole

When writing a match expression against UserRole, 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.

ValidationMode

When writing a match expression against ValidationMode, 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.