securitylake

package module
v1.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 5, 2023 License: Apache-2.0 Imports: 32 Imported by: 9

Documentation

Overview

Package securitylake provides the API client, operations, and parameter types for Amazon Security Lake.

Amazon Security Lake is in preview release. Your use of the Security Lake preview is subject to Section 2 of the Amazon Web Services Service Terms (http://aws.amazon.com/service-terms/)("Betas and Previews"). Amazon Security Lake is a fully managed security data lake service. You can use Security Lake to automatically centralize security data from cloud, on-premises, and custom sources into a data lake that's stored in your Amazon Web Servicesaccount. Amazon Web Services Organizations is an account management service that lets you consolidate multiple Amazon Web Services accounts into an organization that you create and centrally manage. With Organizations, you can create member accounts and invite existing accounts to join your organization. Security Lake helps you analyze security data for a more complete understanding of your security posture across the entire organization. It can also help you improve the protection of your workloads, applications, and data. The data lake is backed by Amazon Simple Storage Service (Amazon S3) buckets, and you retain ownership over your data. Amazon Security Lake integrates with CloudTrail, a service that provides a record of actions taken by a user, role, or an Amazon Web Services service in Security Lake CloudTrail captures API calls for Security Lake as events. The calls captured include calls from the Security Lake console and code calls to the Security Lake API operations. If you create a trail, you can enable continuous delivery of CloudTrail events to an Amazon S3 bucket, including events for Security Lake. If you don't configure a trail, you can still view the most recent events in the CloudTrail console in Event history. Using the information collected by CloudTrail you can determine the request that was made to Security Lake, the IP address from which the request was made, who made the request, when it was made, and additional details. To learn more about Security Lake information in CloudTrail, see the Amazon Security Lake User Guide (https://docs.aws.amazon.com/security-lake/latest/userguide/securitylake-cloudtrail.html). Security Lake automates the collection of security-related log and event data from integrated Amazon Web Services and third-party services. It also helps you manage the lifecycle of data with customizable retention and replication settings. Security Lake converts ingested data into Apache Parquet format and a standard open-source schema called the Open Cybersecurity Schema Framework (OCSF). Other Amazon Web Services and third-party services can subscribe to the data that's stored in Security Lake for incident response and security data analytics.

Index

Constants

View Source 
const ServiceAPIVersion = "2018-05-10"
View Source 
const ServiceID = "SecurityLake"

Variables

This section is empty.

Functions

func NewDefaultEndpointResolver 

func NewDefaultEndpointResolver() *internalendpoints.Resolver

NewDefaultEndpointResolver constructs a new service endpoint resolver

func WithAPIOptions 

func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

WithAPIOptions returns a functional option for setting the Client's APIOptions option.

func WithEndpointResolver 

func WithEndpointResolver(v EndpointResolver) func(*Options)

WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

Types

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client provides the API client to make operations call for Amazon Security Lake.

func New 

func New(options Options, optFns ...func(*Options)) *Client

New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

func NewFromConfig 

func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

NewFromConfig returns a new client from the provided config.

func (*Client) CreateAwsLogSource 

func (c *Client) CreateAwsLogSource(ctx context.Context, params *CreateAwsLogSourceInput, optFns ...func(*Options)) (*CreateAwsLogSourceOutput, error)

Adds a natively supported Amazon Web Service as an Amazon Security Lake source. Enables source types for member accounts in required Amazon Web Services Regions, based on the parameters you specify. You can choose any source type in any Region for either accounts that are part of a trusted organization or standalone accounts. At least one of the three dimensions is a mandatory input to this API. However, you can supply any combination of the three dimensions to this API. By default, a dimension refers to the entire set. When you don't provide a dimension, Security Lake assumes that the missing dimension refers to the entire set. This is overridden when you supply any one of the inputs. For instance, when you do not specify members, the API enables all Security Lake member accounts for all sources. Similarly, when you do not specify Regions, Security Lake is enabled for all the Regions where Security Lake is available as a service. You can use this API only to enable natively supported Amazon Web Services as a source. Use CreateCustomLogSource to enable data collection from a custom source.

func (*Client) CreateCustomLogSource 

func (c *Client) CreateCustomLogSource(ctx context.Context, params *CreateCustomLogSourceInput, optFns ...func(*Options)) (*CreateCustomLogSourceOutput, error)

Adds a third-party custom source in Amazon Security Lake, from the Amazon Web Services Region where you want to create a custom source. Security Lake can collect logs and events from third-party custom sources. After creating the appropriate IAM role to invoke Glue crawler, use this API to add a custom source name in Security Lake. This operation creates a partition in the Amazon S3 bucket for Security Lake as the target location for log files from the custom source in addition to an associated Glue table and an Glue crawler.

func (*Client) CreateDatalake 

func (c *Client) CreateDatalake(ctx context.Context, params *CreateDatalakeInput, optFns ...func(*Options)) (*CreateDatalakeOutput, error)

Initializes an Amazon Security Lake instance with the provided (or default) configuration. You can enable Security Lake in Amazon Web Services Regions with customized settings before enabling log collection in Regions. You can either use the enableAll parameter to specify all Regions or specify the Regions where you want to enable Security Lake. To specify particular Regions, use the Regions parameter and then configure these Regions using the configurations parameter. If you have already enabled Security Lake in a Region when you call this command, the command will update the Region if you provide new configuration parameters. If you have not already enabled Security Lake in the Region when you call this API, it will set up the data lake in the Region with the specified configurations. When you enable Security Lake, it starts ingesting security data after the CreateAwsLogSource call. This includes ingesting security data from sources, storing data, and making data accessible to subscribers. Security Lake also enables all the existing settings and resources that it stores or maintains for your Amazon Web Services account in the current Region, including security log and event data. For more information, see the Amazon Security Lake User Guide (https://docs.aws.amazon.com/security-lake/latest/userguide/what-is-security-lake.html).

func (*Client) CreateDatalakeAutoEnable 

func (c *Client) CreateDatalakeAutoEnable(ctx context.Context, params *CreateDatalakeAutoEnableInput, optFns ...func(*Options)) (*CreateDatalakeAutoEnableOutput, error)

Automatically enables Amazon Security Lake for new member accounts in your organization. Security Lake is not automatically enabled for any existing member accounts in your organization.

func (*Client) CreateDatalakeDelegatedAdmin 

func (c *Client) CreateDatalakeDelegatedAdmin(ctx context.Context, params *CreateDatalakeDelegatedAdminInput, optFns ...func(*Options)) (*CreateDatalakeDelegatedAdminOutput, error)

Designates the Amazon Security Lake delegated administrator account for the organization. This API can only be called by the organization management account. The organization management account cannot be the delegated administrator account.

func (*Client) CreateDatalakeExceptionsSubscription 

func (c *Client) CreateDatalakeExceptionsSubscription(ctx context.Context, params *CreateDatalakeExceptionsSubscriptionInput, optFns ...func(*Options)) (*CreateDatalakeExceptionsSubscriptionOutput, error)

Creates the specified notification subscription in Amazon Security Lake for the organization you specify.

func (*Client) CreateSubscriber 

func (c *Client) CreateSubscriber(ctx context.Context, params *CreateSubscriberInput, optFns ...func(*Options)) (*CreateSubscriberOutput, error)

Creates a subscription permission for accounts that are already enabled in Amazon Security Lake. You can create a subscriber with access to data in the current Amazon Web Services Region.

func (*Client) CreateSubscriptionNotificationConfiguration 

func (c *Client) CreateSubscriptionNotificationConfiguration(ctx context.Context, params *CreateSubscriptionNotificationConfigurationInput, optFns ...func(*Options)) (*CreateSubscriptionNotificationConfigurationOutput, error)

Notifies the subscriber when new data is written to the data lake for the sources that the subscriber consumes in Security Lake.

func (*Client) DeleteAwsLogSource 

func (c *Client) DeleteAwsLogSource(ctx context.Context, params *DeleteAwsLogSourceInput, optFns ...func(*Options)) (*DeleteAwsLogSourceOutput, error)

Removes a natively supported Amazon Web Service as an Amazon Security Lake source. When you remove the source, Security Lake stops collecting data from that source, and subscribers can no longer consume new data from the source. Subscribers can still consume data that Security Lake collected from the source before disablement. You can choose any source type in any Amazon Web Services Region for either accounts that are part of a trusted organization or standalone accounts. At least one of the three dimensions is a mandatory input to this API. However, you can supply any combination of the three dimensions to this API. By default, a dimension refers to the entire set. This is overridden when you supply any one of the inputs. For instance, when you do not specify members, the API disables all Security Lake member accounts for sources. Similarly, when you do not specify Regions, Security Lake is disabled for all the Regions where Security Lake is available as a service. When you don't provide a dimension, Security Lake assumes that the missing dimension refers to the entire set. For example, if you don't provide specific accounts, the API applies to the entire set of accounts in your organization.

func (*Client) DeleteCustomLogSource 

func (c *Client) DeleteCustomLogSource(ctx context.Context, params *DeleteCustomLogSourceInput, optFns ...func(*Options)) (*DeleteCustomLogSourceOutput, error)

Removes a custom log source from Amazon Security Lake.

func (*Client) DeleteDatalake 

func (c *Client) DeleteDatalake(ctx context.Context, params *DeleteDatalakeInput, optFns ...func(*Options)) (*DeleteDatalakeOutput, error)

When you delete Amazon Security Lake from your account, Security Lake is disabled in all Amazon Web Services Regions. Also, this API automatically takes steps to remove the account from Security Lake . This operation disables security data collection from sources, deletes data stored, and stops making data accessible to subscribers. Security Lake also deletes all the existing settings and resources that it stores or maintains for your Amazon Web Services account in the current Region, including security log and event data. The DeleteDatalake operation does not delete the Amazon S3 bucket, which is owned by your Amazon Web Services account. For more information, see the Amazon Security Lake User Guide (https://docs.aws.amazon.com/security-lake/latest/userguide/disable-security-lake.html).

func (*Client) DeleteDatalakeAutoEnable 

func (c *Client) DeleteDatalakeAutoEnable(ctx context.Context, params *DeleteDatalakeAutoEnableInput, optFns ...func(*Options)) (*DeleteDatalakeAutoEnableOutput, error)

Automatically deletes Amazon Security Lake to stop collecting security data. When you delete Amazon Security Lake from your account, Security Lake is disabled in all Regions. Also, this API automatically takes steps to remove the account from Security Lake . This operation disables security data collection from sources, deletes data stored, and stops making data accessible to subscribers. Security Lake also deletes all the existing settings and resources that it stores or maintains for your Amazon Web Services account in the current Region, including security log and event data. The DeleteDatalake operation does not delete the Amazon S3 bucket, which is owned by your Amazon Web Services account. For more information, see the Amazon Security Lake User Guide (https://docs.aws.amazon.com/security-lake/latest/userguide/disable-security-lake.html).

func (*Client) DeleteDatalakeDelegatedAdmin 

func (c *Client) DeleteDatalakeDelegatedAdmin(ctx context.Context, params *DeleteDatalakeDelegatedAdminInput, optFns ...func(*Options)) (*DeleteDatalakeDelegatedAdminOutput, error)

Deletes the Amazon Security Lake delegated administrator account for the organization. This API can only be called by the organization management account. The organization management account cannot be the delegated administrator account.

func (*Client) DeleteDatalakeExceptionsSubscription 

func (c *Client) DeleteDatalakeExceptionsSubscription(ctx context.Context, params *DeleteDatalakeExceptionsSubscriptionInput, optFns ...func(*Options)) (*DeleteDatalakeExceptionsSubscriptionOutput, error)

Deletes the specified notification subscription in Amazon Security Lake for the organization you specify.

func (*Client) DeleteSubscriber 

func (c *Client) DeleteSubscriber(ctx context.Context, params *DeleteSubscriberInput, optFns ...func(*Options)) (*DeleteSubscriberOutput, error)

Deletes the subscription permission for accounts that are already enabled in Amazon Security Lake. You can delete a subscriber and remove access to data in the current Amazon Web Services Region.

func (*Client) DeleteSubscriptionNotificationConfiguration 

func (c *Client) DeleteSubscriptionNotificationConfiguration(ctx context.Context, params *DeleteSubscriptionNotificationConfigurationInput, optFns ...func(*Options)) (*DeleteSubscriptionNotificationConfigurationOutput, error)

Deletes the specified notification subscription in Amazon Security Lake for the organization you specify.

func (*Client) GetDatalake 

func (c *Client) GetDatalake(ctx context.Context, params *GetDatalakeInput, optFns ...func(*Options)) (*GetDatalakeOutput, error)

Retrieves the Amazon Security Lake configuration object for the specified Amazon Web Services account ID. You can use the GetDatalake API to know whether Security Lake is enabled for the current Region. This API does not take input parameters.

func (*Client) GetDatalakeAutoEnable 

func (c *Client) GetDatalakeAutoEnable(ctx context.Context, params *GetDatalakeAutoEnableInput, optFns ...func(*Options)) (*GetDatalakeAutoEnableOutput, error)

Retrieves the configuration that will be automatically set up for accounts added to the organization after the organization has onboarded to Amazon Security Lake. This API does not take input parameters.

func (*Client) GetDatalakeExceptionsExpiry 

func (c *Client) GetDatalakeExceptionsExpiry(ctx context.Context, params *GetDatalakeExceptionsExpiryInput, optFns ...func(*Options)) (*GetDatalakeExceptionsExpiryOutput, error)

Retrieves the expiration period and time-to-live (TTL) for which the exception message will remain. Exceptions are stored by default, for 2 weeks from when a record was created in Amazon Security Lake. This API does not take input parameters.

func (*Client) GetDatalakeExceptionsSubscription 

func (c *Client) GetDatalakeExceptionsSubscription(ctx context.Context, params *GetDatalakeExceptionsSubscriptionInput, optFns ...func(*Options)) (*GetDatalakeExceptionsSubscriptionOutput, error)

Retrieves the details of exception notifications for the account in Amazon Security Lake.

func (*Client) GetDatalakeStatus 

func (c *Client) GetDatalakeStatus(ctx context.Context, params *GetDatalakeStatusInput, optFns ...func(*Options)) (*GetDatalakeStatusOutput, error)

Retrieves a snapshot of the current Region, including whether Amazon Security Lake is enabled for those accounts and which sources Security Lake is collecting data from.

func (*Client) GetSubscriber 

func (c *Client) GetSubscriber(ctx context.Context, params *GetSubscriberInput, optFns ...func(*Options)) (*GetSubscriberOutput, error)

Retrieves the subscription information for the specified subscription ID. You can get information about a specific subscriber.

func (*Client) ListDatalakeExceptions 

func (c *Client) ListDatalakeExceptions(ctx context.Context, params *ListDatalakeExceptionsInput, optFns ...func(*Options)) (*ListDatalakeExceptionsOutput, error)

Lists the Amazon Security Lake exceptions that you can use to find the source of problems and fix them.

func (*Client) ListLogSources 

func (c *Client) ListLogSources(ctx context.Context, params *ListLogSourcesInput, optFns ...func(*Options)) (*ListLogSourcesOutput, error)

Retrieves the log sources in the current Amazon Web Services Region.

func (*Client) ListSubscribers 

func (c *Client) ListSubscribers(ctx context.Context, params *ListSubscribersInput, optFns ...func(*Options)) (*ListSubscribersOutput, error)

List all subscribers for the specific Amazon Security Lake account ID. You can retrieve a list of subscriptions associated with a specific organization or Amazon Web Services account.

func (*Client) UpdateDatalake 

func (c *Client) UpdateDatalake(ctx context.Context, params *UpdateDatalakeInput, optFns ...func(*Options)) (*UpdateDatalakeOutput, error)

Specifies where to store your security data and for how long. You can add a rollup Region to consolidate data from multiple Amazon Web Services Regions.

func (*Client) UpdateDatalakeExceptionsExpiry 

func (c *Client) UpdateDatalakeExceptionsExpiry(ctx context.Context, params *UpdateDatalakeExceptionsExpiryInput, optFns ...func(*Options)) (*UpdateDatalakeExceptionsExpiryOutput, error)

Update the expiration period for the exception message to your preferred time, and control the time-to-live (TTL) for the exception message to remain. Exceptions are stored by default for 2 weeks from when a record was created in Amazon Security Lake.

func (*Client) UpdateDatalakeExceptionsSubscription 

func (c *Client) UpdateDatalakeExceptionsSubscription(ctx context.Context, params *UpdateDatalakeExceptionsSubscriptionInput, optFns ...func(*Options)) (*UpdateDatalakeExceptionsSubscriptionOutput, error)

Updates the specified notification subscription in Amazon Security Lake for the organization you specify.

func (*Client) UpdateSubscriber 

func (c *Client) UpdateSubscriber(ctx context.Context, params *UpdateSubscriberInput, optFns ...func(*Options)) (*UpdateSubscriberOutput, error)

Updates an existing subscription for the given Amazon Security Lake account ID. You can update a subscriber by changing the sources that the subscriber consumes data from.

func (*Client) UpdateSubscriptionNotificationConfiguration 

func (c *Client) UpdateSubscriptionNotificationConfiguration(ctx context.Context, params *UpdateSubscriptionNotificationConfigurationInput, optFns ...func(*Options)) (*UpdateSubscriptionNotificationConfigurationOutput, error)

Creates a new subscription notification or adds the existing subscription notification setting for the specified subscription ID.

type CreateAwsLogSourceInput 

type CreateAwsLogSourceInput struct {

	// Specifies the input order to enable dimensions in Security Lake, namely Region,
	// source type, and member account.
	//
	// This member is required.
	InputOrder []types.Dimension

	// Enables data collection from specific Amazon Web Services sources in all
	// specific accounts and specific Regions.
	EnableAllDimensions map[string]map[string][]string

	// Enables data collection from all Amazon Web Services sources in specific
	// accounts or Regions.
	EnableSingleDimension []string

	// Enables data collection from specific Amazon Web Services sources in specific
	// accounts or Regions.
	EnableTwoDimensions map[string][]string
	// contains filtered or unexported fields
}

type CreateAwsLogSourceOutput 

type CreateAwsLogSourceOutput struct {

	// Lists all accounts in which enabling a natively supported Amazon Web Service as
	// a Security Lake source failed. The failure occurred as these accounts are not
	// part of an organization.
	Failed []string

	// Lists the accounts that are in the process of enabling a natively supported
	// Amazon Web Service as a Security Lake source.
	Processing []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateCustomLogSourceInput 

type CreateCustomLogSourceInput struct {

	// The name for a third-party custom source. This must be a Regionally unique
	// value.
	//
	// This member is required.
	CustomSourceName *string

	// The Open Cybersecurity Schema Framework (OCSF) event class which describes the
	// type of data that the custom source will send to Security Lake.
	//
	// This member is required.
	EventClass types.OcsfEventClass

	// The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role
	// to be used by the Glue crawler. The recommended IAM policies are:
	//
	// * The managed
	// policy AWSGlueServiceRole
	//
	// * A custom policy granting access to your Amazon S3
	// Data Lake
	//
	// This member is required.
	GlueInvocationRoleArn *string

	// The Amazon Web Services account ID of the custom source that will write logs and
	// events into the Amazon S3 Data Lake.
	//
	// This member is required.
	LogProviderAccountId *string
	// contains filtered or unexported fields
}

type CreateCustomLogSourceOutput 

type CreateCustomLogSourceOutput struct {

	// The location of the partition in the Amazon S3 bucket for Security Lake.
	//
	// This member is required.
	CustomDataLocation *string

	// The name of the Glue crawler.
	//
	// This member is required.
	GlueCrawlerName *string

	// The Glue database where results are written, such as:
	// arn:aws:daylight:us-east-1::database/sometable/*.
	//
	// This member is required.
	GlueDatabaseName *string

	// The table name of the Glue crawler.
	//
	// This member is required.
	GlueTableName *string

	// The ARN of the IAM role to be used by the entity putting logs into your custom
	// source partition. Security Lake will apply the correct access policies to this
	// role, but you must first manually create the trust policy for this role. The IAM
	// role name must start with the text 'Security Lake'. The IAM role must trust the
	// logProviderAccountId to assume the role.
	//
	// This member is required.
	LogProviderAccessRoleArn *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateDatalakeAutoEnableInput 

type CreateDatalakeAutoEnableInput struct {

	// Enable Security Lake with the specified configuration settings to begin
	// collecting security data for new accounts in your organization.
	//
	// This member is required.
	ConfigurationForNewAccounts []types.AutoEnableNewRegionConfiguration
	// contains filtered or unexported fields
}

type CreateDatalakeAutoEnableOutput 

type CreateDatalakeAutoEnableOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateDatalakeDelegatedAdminInput 

type CreateDatalakeDelegatedAdminInput struct {

	// The Amazon Web Services account ID of the Security Lake delegated administrator.
	//
	// This member is required.
	Account *string
	// contains filtered or unexported fields
}

type CreateDatalakeDelegatedAdminOutput 

type CreateDatalakeDelegatedAdminOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateDatalakeExceptionsSubscriptionInput 

type CreateDatalakeExceptionsSubscriptionInput struct {

	// The Amazon Web Services account where you want to receive exception
	// notifications.
	//
	// This member is required.
	NotificationEndpoint *string

	// The subscription protocol to which exception notifications are posted.
	//
	// This member is required.
	SubscriptionProtocol types.SubscriptionProtocolType
	// contains filtered or unexported fields
}

type CreateDatalakeExceptionsSubscriptionOutput 

type CreateDatalakeExceptionsSubscriptionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateDatalakeInput 

type CreateDatalakeInput struct {

	// Specify the Region or Regions that will contribute data to the rollup region.
	Configurations map[string]types.LakeConfigurationRequest

	// Enable Security Lake in all Regions.
	EnableAll *bool

	// The Amazon Resource Name (ARN) used to create and update the Glue table. This
	// table contains partitions generated by the ingestion and normalization of Amazon
	// Web Services log sources and custom sources.
	MetaStoreManagerRoleArn *string

	// Enable Security Lake in the specified Regions. To enable Security Lake in
	// specific Amazon Web Services Regions, such as us-east-1 or ap-northeast-3,
	// provide the Region codes. For a list of Region codes, see Amazon Security Lake
	// endpoints (https://docs.aws.amazon.com/general/latest/gr/securitylake.html) in
	// the Amazon Web Services General Reference.
	Regions []types.Region
	// contains filtered or unexported fields
}

type CreateDatalakeOutput 

type CreateDatalakeOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateSubscriberInput 

type CreateSubscriberInput struct {

	// The Amazon Web Services account ID used to access your data.
	//
	// This member is required.
	AccountId *string

	// The external ID of the subscriber. This lets the user that is assuming the role
	// assert the circumstances in which they are operating. It also provides a way for
	// the account owner to permit the role to be assumed only under specific
	// circumstances.
	//
	// This member is required.
	ExternalId *string

	// The supported Amazon Web Services from which logs and events are collected.
	// Security Lake supports log and event collection for natively supported Amazon
	// Web Services.
	//
	// This member is required.
	SourceTypes []types.SourceType

	// The name of your Security Lake subscriber account.
	//
	// This member is required.
	SubscriberName *string

	// The Amazon S3 or Lake Formation access type.
	AccessTypes []types.AccessType

	// The description for your subscriber account in Security Lake.
	SubscriberDescription *string
	// contains filtered or unexported fields
}

type CreateSubscriberOutput 

type CreateSubscriberOutput struct {

	// The subscriptionId created by the CreateSubscriber API call.
	//
	// This member is required.
	SubscriptionId *string

	// The Amazon Resource Name (ARN) created by you to provide to the subscriber. For
	// more information about ARNs and how to use them in policies, see IAM identifiers
	// in the Identity and Access Management (IAM) User Guide
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html). .
	RoleArn *string

	// The ARN for the Amazon S3 bucket.
	S3BucketArn *string

	// The ARN for the Amazon Simple Notification Service.
	SnsArn *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateSubscriptionNotificationConfigurationInput 

type CreateSubscriptionNotificationConfigurationInput struct {

	// The subscription ID for the notification subscription/
	//
	// This member is required.
	SubscriptionId *string

	// Create an Amazon Simple Queue Service queue.
	CreateSqs *bool

	// The key name for the notification subscription.
	HttpsApiKeyName *string

	// The key value for the notification subscription.
	HttpsApiKeyValue *string

	// The HTTPS method used for the notification subscription.
	HttpsMethod types.HttpsMethod

	// The Amazon Resource Name (ARN) of the EventBridge API destinations IAM role that
	// you created.
	RoleArn *string

	// The subscription endpoint in Security Lake. If you prefer notification with an
	// HTTPs endpoint, populate this field.
	SubscriptionEndpoint *string
	// contains filtered or unexported fields
}

type CreateSubscriptionNotificationConfigurationOutput 

type CreateSubscriptionNotificationConfigurationOutput struct {

	// Returns the Amazon Resource Name (ARN) of the queue.
	QueueArn *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteAwsLogSourceInput 

type DeleteAwsLogSourceInput struct {

	// This is a mandatory input. Specify the input order to disable dimensions in
	// Security Lake, namely Region (Amazon Web Services Region code, source type, and
	// member (account ID of a specific Amazon Web Services account).
	//
	// This member is required.
	InputOrder []types.Dimension

	// Removes the specific Amazon Web Services sources from specific accounts and
	// specific Regions.
	DisableAllDimensions map[string]map[string][]string

	// Removes all Amazon Web Services sources from specific accounts or Regions.
	DisableSingleDimension []string

	// Remove a specific Amazon Web Services source from specific accounts or Regions.
	DisableTwoDimensions map[string][]string
	// contains filtered or unexported fields
}

type DeleteAwsLogSourceOutput 

type DeleteAwsLogSourceOutput struct {

	// Deletion of the Amazon Web Services sources failed as the account is not a part
	// of the organization.
	Failed []string

	// Deletion of the Amazon Web Services sources is in progress.
	Processing []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteCustomLogSourceInput 

type DeleteCustomLogSourceInput struct {

	// The custom source name for the custom log source.
	//
	// This member is required.
	CustomSourceName *string
	// contains filtered or unexported fields
}

type DeleteCustomLogSourceOutput 

type DeleteCustomLogSourceOutput struct {

	// The location of the partition in the Amazon S3 bucket for Security Lake.
	//
	// This member is required.
	CustomDataLocation *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteDatalakeAutoEnableInput 

type DeleteDatalakeAutoEnableInput struct {

	// Delete Amazon Security Lake with the specified configuration settings to stop
	// ingesting security data for new accounts in Security Lake.
	//
	// This member is required.
	RemoveFromConfigurationForNewAccounts []types.AutoEnableNewRegionConfiguration
	// contains filtered or unexported fields
}

type DeleteDatalakeAutoEnableOutput 

type DeleteDatalakeAutoEnableOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteDatalakeDelegatedAdminInput 

type DeleteDatalakeDelegatedAdminInput struct {

	// The account ID the Security Lake delegated administrator.
	//
	// This member is required.
	Account *string
	// contains filtered or unexported fields
}

type DeleteDatalakeDelegatedAdminOutput 

type DeleteDatalakeDelegatedAdminOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteDatalakeExceptionsSubscriptionInput 

type DeleteDatalakeExceptionsSubscriptionInput struct {
	// contains filtered or unexported fields
}

type DeleteDatalakeExceptionsSubscriptionOutput 

type DeleteDatalakeExceptionsSubscriptionOutput struct {

	// Retrieves the status of the delete Security Lake operation for an account.
	//
	// This member is required.
	Status *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteDatalakeInput 

type DeleteDatalakeInput struct {
	// contains filtered or unexported fields
}

type DeleteDatalakeOutput 

type DeleteDatalakeOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteSubscriberInput 

type DeleteSubscriberInput struct {

	// A value created by Security Lake that uniquely identifies your DeleteSubscriber
	// API request.
	//
	// This member is required.
	Id *string
	// contains filtered or unexported fields
}

type DeleteSubscriberOutput 

type DeleteSubscriberOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteSubscriptionNotificationConfigurationInput 

type DeleteSubscriptionNotificationConfigurationInput struct {

	// The ID of the Security Lake subscriber account.
	//
	// This member is required.
	SubscriptionId *string
	// contains filtered or unexported fields
}

type DeleteSubscriptionNotificationConfigurationOutput 

type DeleteSubscriptionNotificationConfigurationOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type EndpointResolver 

type EndpointResolver interface {
	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}

EndpointResolver interface for resolving service endpoints.

func EndpointResolverFromURL 

func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

type EndpointResolverFunc 

type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

func (EndpointResolverFunc) ResolveEndpoint 

func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

type EndpointResolverOptions 

type EndpointResolverOptions = internalendpoints.Options

EndpointResolverOptions is the service endpoint resolver options

type GetDatalakeAutoEnableInput 

type GetDatalakeAutoEnableInput struct {
	// contains filtered or unexported fields
}

type GetDatalakeAutoEnableOutput 

type GetDatalakeAutoEnableOutput struct {

	// The configuration for new accounts.
	//
	// This member is required.
	AutoEnableNewAccounts []types.AutoEnableNewRegionConfiguration

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetDatalakeExceptionsExpiryInput 

type GetDatalakeExceptionsExpiryInput struct {
	// contains filtered or unexported fields
}

type GetDatalakeExceptionsExpiryOutput 

type GetDatalakeExceptionsExpiryOutput struct {

	// The expiration period and time-to-live (TTL).
	//
	// This member is required.
	ExceptionMessageExpiry *int64

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetDatalakeExceptionsSubscriptionInput 

type GetDatalakeExceptionsSubscriptionInput struct {
	// contains filtered or unexported fields
}

type GetDatalakeExceptionsSubscriptionOutput 

type GetDatalakeExceptionsSubscriptionOutput struct {

	// Retrieves the exception notification subscription information.
	//
	// This member is required.
	ProtocolAndNotificationEndpoint *types.ProtocolAndNotificationEndpoint

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetDatalakeInput 

type GetDatalakeInput struct {
	// contains filtered or unexported fields
}

type GetDatalakeOutput 

type GetDatalakeOutput struct {

	// Retrieves the Security Lake configuration object.
	//
	// This member is required.
	Configurations map[string]types.LakeConfigurationResponse

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetDatalakeStatusAPIClient 

type GetDatalakeStatusAPIClient interface {
	GetDatalakeStatus(context.Context, *GetDatalakeStatusInput, ...func(*Options)) (*GetDatalakeStatusOutput, error)
}

GetDatalakeStatusAPIClient is a client that implements the GetDatalakeStatus operation.

type GetDatalakeStatusInput 

type GetDatalakeStatusInput struct {

	// The Amazon Web Services account ID for which a static snapshot of the current
	// Amazon Web Services Region, including enabled accounts and log sources, is
	// retrieved.
	AccountSet []string

	// The maximum limit of accounts for which the static snapshot of the current
	// Region, including enabled accounts and log sources, is retrieved.
	MaxAccountResults *int32

	// Lists if there are more results available. The value of nextToken is a unique
	// pagination token for each page. Repeat the call using the returned token to
	// retrieve the next page. Keep all other arguments unchanged. Each pagination
	// token expires after 24 hours. Using an expired pagination token will return an
	// HTTP 400 InvalidToken error.
	NextToken *string
	// contains filtered or unexported fields
}

type GetDatalakeStatusOutput 

type GetDatalakeStatusOutput struct {

	// The list of enabled accounts and enabled sources.
	//
	// This member is required.
	AccountSourcesList []types.AccountSources

	// Lists if there are more results available. The value of nextToken is a unique
	// pagination token for each page. Repeat the call using the returned token to
	// retrieve the next page. Keep all other arguments unchanged. Each pagination
	// token expires after 24 hours. Using an expired pagination token will return an
	// HTTP 400 InvalidToken error.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetDatalakeStatusPaginator 

type GetDatalakeStatusPaginator struct {
	// contains filtered or unexported fields
}

GetDatalakeStatusPaginator is a paginator for GetDatalakeStatus

func NewGetDatalakeStatusPaginator 

func NewGetDatalakeStatusPaginator(client GetDatalakeStatusAPIClient, params *GetDatalakeStatusInput, optFns ...func(*GetDatalakeStatusPaginatorOptions)) *GetDatalakeStatusPaginator

NewGetDatalakeStatusPaginator returns a new GetDatalakeStatusPaginator

func (*GetDatalakeStatusPaginator) HasMorePages 

func (p *GetDatalakeStatusPaginator) HasMorePages() bool

HasMorePages returns a boolean indicating whether more pages are available

func (*GetDatalakeStatusPaginator) NextPage 

func (p *GetDatalakeStatusPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetDatalakeStatusOutput, error)

NextPage retrieves the next GetDatalakeStatus page.

type GetDatalakeStatusPaginatorOptions 

type GetDatalakeStatusPaginatorOptions struct {
	// The maximum limit of accounts for which the static snapshot of the current
	// Region, including enabled accounts and log sources, is retrieved.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

GetDatalakeStatusPaginatorOptions is the paginator options for GetDatalakeStatus

type GetSubscriberInput 

type GetSubscriberInput struct {

	// A value created by Amazon Security Lake that uniquely identifies your
	// GetSubscriber API request.
	//
	// This member is required.
	Id *string
	// contains filtered or unexported fields
}

type GetSubscriberOutput 

type GetSubscriberOutput struct {

	// The subscription information for the specified subscription ID.
	Subscriber *types.SubscriberResource

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type HTTPClient 

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}

type ListDatalakeExceptionsAPIClient 

type ListDatalakeExceptionsAPIClient interface {
	ListDatalakeExceptions(context.Context, *ListDatalakeExceptionsInput, ...func(*Options)) (*ListDatalakeExceptionsOutput, error)
}

ListDatalakeExceptionsAPIClient is a client that implements the ListDatalakeExceptions operation.

type ListDatalakeExceptionsInput 

type ListDatalakeExceptionsInput struct {

	// List the maximum number of failures in Security Lake.
	MaxFailures *int32

	// List if there are more results available. The value of nextToken is a unique
	// pagination token for each page. Repeat the call using the returned token to
	// retrieve the next page. Keep all other arguments unchanged. Each pagination
	// token expires after 24 hours. Using an expired pagination token will return an
	// HTTP 400 InvalidToken error.
	NextToken *string

	// List the Amazon Web Services Regions from which exceptions are retrieved.
	RegionSet []types.Region
	// contains filtered or unexported fields
}

type ListDatalakeExceptionsOutput 

type ListDatalakeExceptionsOutput struct {

	// Lists the failures that cannot be retried in the current Region.
	//
	// This member is required.
	NonRetryableFailures []types.FailuresResponse

	// List if there are more results available. The value of nextToken is a unique
	// pagination token for each page. Repeat the call using the returned token to
	// retrieve the next page. Keep all other arguments unchanged. Each pagination
	// token expires after 24 hours. Using an expired pagination token will return an
	// HTTP 400 InvalidToken error.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListDatalakeExceptionsPaginator 

type ListDatalakeExceptionsPaginator struct {
	// contains filtered or unexported fields
}

ListDatalakeExceptionsPaginator is a paginator for ListDatalakeExceptions

func NewListDatalakeExceptionsPaginator 

func NewListDatalakeExceptionsPaginator(client ListDatalakeExceptionsAPIClient, params *ListDatalakeExceptionsInput, optFns ...func(*ListDatalakeExceptionsPaginatorOptions)) *ListDatalakeExceptionsPaginator

NewListDatalakeExceptionsPaginator returns a new ListDatalakeExceptionsPaginator

func (*ListDatalakeExceptionsPaginator) HasMorePages 

func (p *ListDatalakeExceptionsPaginator) HasMorePages() bool

HasMorePages returns a boolean indicating whether more pages are available

func (*ListDatalakeExceptionsPaginator) NextPage 

func (p *ListDatalakeExceptionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatalakeExceptionsOutput, error)

NextPage retrieves the next ListDatalakeExceptions page.

type ListDatalakeExceptionsPaginatorOptions 

type ListDatalakeExceptionsPaginatorOptions struct {
	// List the maximum number of failures in Security Lake.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

ListDatalakeExceptionsPaginatorOptions is the paginator options for ListDatalakeExceptions

type ListLogSourcesAPIClient 

type ListLogSourcesAPIClient interface {
	ListLogSources(context.Context, *ListLogSourcesInput, ...func(*Options)) (*ListLogSourcesOutput, error)
}

ListLogSourcesAPIClient is a client that implements the ListLogSources operation.

type ListLogSourcesInput 

type ListLogSourcesInput struct {

	// Lists the log sources in input order, namely Region, source type, and member
	// account.
	InputOrder []types.Dimension

	// List the view of log sources for enabled Amazon Security Lake accounts for
	// specific Amazon Web Services sources from specific accounts and specific
	// Regions.
	ListAllDimensions map[string]map[string][]string

	// List the view of log sources for enabled Security Lake accounts for all Amazon
	// Web Services sources from specific accounts or specific Regions.
	ListSingleDimension []string

	// Lists the view of log sources for enabled Security Lake accounts for specific
	// Amazon Web Services sources from specific accounts or specific Regions.
	ListTwoDimensions map[string][]string

	// The maximum number of accounts for which the log sources are displayed.
	MaxResults *int32

	// If nextToken is returned, there are more results available. You can repeat the
	// call using the returned token to retrieve the next page.
	NextToken *string
	// contains filtered or unexported fields
}

type ListLogSourcesOutput 

type ListLogSourcesOutput struct {

	// Lists the log sources by Regions for enabled Security Lake accounts.
	//
	// This member is required.
	RegionSourceTypesAccountsList []map[string]map[string][]string

	// If nextToken is returned, there are more results available. You can repeat the
	// call using the returned token to retrieve the next page.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListLogSourcesPaginator 

type ListLogSourcesPaginator struct {
	// contains filtered or unexported fields
}

ListLogSourcesPaginator is a paginator for ListLogSources

func NewListLogSourcesPaginator 

func NewListLogSourcesPaginator(client ListLogSourcesAPIClient, params *ListLogSourcesInput, optFns ...func(*ListLogSourcesPaginatorOptions)) *ListLogSourcesPaginator

NewListLogSourcesPaginator returns a new ListLogSourcesPaginator

func (*ListLogSourcesPaginator) HasMorePages 

func (p *ListLogSourcesPaginator) HasMorePages() bool

HasMorePages returns a boolean indicating whether more pages are available

func (*ListLogSourcesPaginator) NextPage 

func (p *ListLogSourcesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListLogSourcesOutput, error)

NextPage retrieves the next ListLogSources page.

type ListLogSourcesPaginatorOptions 

type ListLogSourcesPaginatorOptions struct {
	// The maximum number of accounts for which the log sources are displayed.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

ListLogSourcesPaginatorOptions is the paginator options for ListLogSources

type ListSubscribersAPIClient 

type ListSubscribersAPIClient interface {
	ListSubscribers(context.Context, *ListSubscribersInput, ...func(*Options)) (*ListSubscribersOutput, error)
}

ListSubscribersAPIClient is a client that implements the ListSubscribers operation.

type ListSubscribersInput 

type ListSubscribersInput struct {

	// The maximum number of accounts for which the configuration is displayed.
	MaxResults *int32

	// If nextToken is returned, there are more results available. You can repeat the
	// call using the returned token to retrieve the next page.
	NextToken *string
	// contains filtered or unexported fields
}

type ListSubscribersOutput 

type ListSubscribersOutput struct {

	// The subscribers available for the specified Security Lake account ID.
	//
	// This member is required.
	Subscribers []types.SubscriberResource

	// If nextToken is returned, there are more results available. You can repeat the
	// call using the returned token to retrieve the next page.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListSubscribersPaginator 

type ListSubscribersPaginator struct {
	// contains filtered or unexported fields
}

ListSubscribersPaginator is a paginator for ListSubscribers

func NewListSubscribersPaginator 

func NewListSubscribersPaginator(client ListSubscribersAPIClient, params *ListSubscribersInput, optFns ...func(*ListSubscribersPaginatorOptions)) *ListSubscribersPaginator

NewListSubscribersPaginator returns a new ListSubscribersPaginator

func (*ListSubscribersPaginator) HasMorePages 

func (p *ListSubscribersPaginator) HasMorePages() bool

HasMorePages returns a boolean indicating whether more pages are available

func (*ListSubscribersPaginator) NextPage 

func (p *ListSubscribersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSubscribersOutput, error)

NextPage retrieves the next ListSubscribers page.

type ListSubscribersPaginatorOptions 

type ListSubscribersPaginatorOptions struct {
	// The maximum number of accounts for which the configuration is displayed.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

ListSubscribersPaginatorOptions is the paginator options for ListSubscribers

type Options 

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// Configures the events that will be sent to the configured logger.
	ClientLogMode aws.ClientLogMode

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The configuration DefaultsMode that the SDK should use when constructing the
	// clients initial default settings.
	DefaultsMode aws.DefaultsMode

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions EndpointResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// The logger writer interface to write logging messages to.
	Logger logging.Logger

	// The region to send requests to. (Required)
	Region string

	// RetryMaxAttempts specifies the maximum number attempts an API client will call
	// an operation that fails with a retryable error. A value of 0 is ignored, and
	// will not be used to configure the API client created default retryer, or modify
	// per operation call's retry max attempts. When creating a new API Clients this
	// member will only be used if the Retryer Options member is nil. This value will
	// be ignored if Retryer is not nil. If specified in an operation call's functional
	// options with a value that is different than the constructed client's Options,
	// the Client's Retryer will be wrapped to use the operation's specific
	// RetryMaxAttempts value.
	RetryMaxAttempts int

	// RetryMode specifies the retry mode the API client will be created with, if
	// Retryer option is not also specified. When creating a new API Clients this
	// member will only be used if the Retryer Options member is nil. This value will
	// be ignored if Retryer is not nil. Currently does not support per operation call
	// overrides, may in the future.
	RetryMode aws.RetryMode

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer. The kind of
	// default retry created by the API client can be changed with the RetryMode
	// option.
	Retryer aws.Retryer

	// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
	// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig. You
	// should not populate this structure programmatically, or rely on the values here
	// within your applications.
	RuntimeEnvironment aws.RuntimeEnvironment

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
	// contains filtered or unexported fields
}

func (Options) Copy 

func (o Options) Copy() Options

Copy creates a clone where the APIOptions list is deep copied.

type ResolveEndpoint 

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  EndpointResolverOptions
}

func (*ResolveEndpoint) HandleSerialize 

func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
)

func (*ResolveEndpoint) ID 

func (*ResolveEndpoint) ID() string

type UpdateDatalakeExceptionsExpiryInput 

type UpdateDatalakeExceptionsExpiryInput struct {

	// The time-to-live (TTL) for the exception message to remain.
	//
	// This member is required.
	ExceptionMessageExpiry *int64
	// contains filtered or unexported fields
}

type UpdateDatalakeExceptionsExpiryOutput 

type UpdateDatalakeExceptionsExpiryOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateDatalakeExceptionsSubscriptionInput 

type UpdateDatalakeExceptionsSubscriptionInput struct {

	// The account that is subscribed to receive exception notifications.
	//
	// This member is required.
	NotificationEndpoint *string

	// The subscription protocol to which exception messages are posted.
	//
	// This member is required.
	SubscriptionProtocol types.SubscriptionProtocolType
	// contains filtered or unexported fields
}

type UpdateDatalakeExceptionsSubscriptionOutput 

type UpdateDatalakeExceptionsSubscriptionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateDatalakeInput 

type UpdateDatalakeInput struct {

	// Specify the Region or Regions that will contribute data to the rollup region.
	//
	// This member is required.
	Configurations map[string]types.LakeConfigurationRequest
	// contains filtered or unexported fields
}

type UpdateDatalakeOutput 

type UpdateDatalakeOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateSubscriberInput 

type UpdateSubscriberInput struct {

	// A value created by Security Lake that uniquely identifies your subscription.
	//
	// This member is required.
	Id *string

	// The supported Amazon Web Services from which logs and events are collected. For
	// the list of supported Amazon Web Services, see the Amazon Security Lake User
	// Guide
	// (https://docs.aws.amazon.com/security-lake/latest/userguide/internal-sources.html).
	//
	// This member is required.
	SourceTypes []types.SourceType

	// The external ID of the Security Lake account.
	ExternalId *string

	// The description of the Security Lake account subscriber.
	SubscriberDescription *string

	// The name of the Security Lake account subscriber.
	SubscriberName *string
	// contains filtered or unexported fields
}

type UpdateSubscriberOutput 

type UpdateSubscriberOutput struct {

	// The account of the subscriber.
	Subscriber *types.SubscriberResource

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateSubscriptionNotificationConfigurationInput 

type UpdateSubscriptionNotificationConfigurationInput struct {

	// The subscription ID for which the subscription notification is specified.
	//
	// This member is required.
	SubscriptionId *string

	// Create a new subscription notification for the specified subscription ID in
	// Amazon Security Lake.
	CreateSqs *bool

	// The key name for the subscription notification.
	HttpsApiKeyName *string

	// The key value for the subscription notification.
	HttpsApiKeyValue *string

	// The HTTPS method used for the subscription notification.
	HttpsMethod types.HttpsMethod

	// The Amazon Resource Name (ARN) specifying the role of the subscriber.
	RoleArn *string

	// The subscription endpoint in Security Lake.
	SubscriptionEndpoint *string
	// contains filtered or unexported fields
}

type UpdateSubscriptionNotificationConfigurationOutput 

type UpdateSubscriptionNotificationConfigurationOutput struct {

	// Returns the ARN of the queue.
	QueueArn *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

Source Files

View all Source files

Directories

Path Synopsis
internal
endpoints

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.