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.

Category

Represents a category assigned to a security testing task.

CloudWatchLog

The Amazon CloudWatch Logs configuration for pentest job logging.

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.

CodeReviewSettings

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

CustomHeader

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

DeletePentestFailure

Contains information about a pentest 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.