Documentation

Overview

    Package applicationdiscoveryservice provides the API client, operations, and parameter types for AWS Application Discovery Service.

    AWS Application Discovery Service AWS Application Discovery Service helps you plan application migration projects. It automatically identifies servers, virtual machines (VMs), and network dependencies in your on-premises data centers. For more information, see the AWS Application Discovery Service FAQ (http://aws.amazon.com/application-discovery/faqs/). Application Discovery Service offers three ways of performing discovery and collecting data about your on-premises servers:

    * Agentless discovery is recommended for environments that use VMware vCenter Server. This mode doesn't require you to install an agent on each host. It does not work in non-VMware environments.

    * Agentless discovery gathers server information regardless of the operating systems, which minimizes the time required for initial on-premises infrastructure assessment.

    * Agentless discovery doesn't collect information about network dependencies, only agent-based discovery collects that information.

    * Agent-based discovery collects a richer set of data than agentless discovery by using the AWS Application Discovery Agent, which you install on one or more hosts in your data center.

    * The agent captures infrastructure and application information, including an inventory of running processes, system performance information, resource utilization, and network dependencies.

    * The information collected by agents is secured at rest and in transit to the Application Discovery Service database in the cloud.

    * AWS Partner Network (APN) solutions integrate with Application Discovery Service, enabling you to import details of your on-premises environment directly into Migration Hub without using the discovery connector or discovery agent.

    * Third-party application discovery tools can query AWS Application Discovery Service, and they can write to the Application Discovery Service database using the public API.

    * In this way, you can import data into Migration Hub and view it, so that you can associate applications with servers and track migrations.

    Recommendations We recommend that you use agent-based discovery for non-VMware environments, and whenever you want to collect information about network dependencies. You can run agent-based and agentless discovery simultaneously. Use agentless discovery to complete the initial infrastructure assessment quickly, and then install agents on select hosts to collect additional information. Working With This Guide This API reference provides descriptions, syntax, and usage examples for each of the actions and data types for Application Discovery Service. The topic for each action shows the API request parameters and the response. Alternatively, you can use one of the AWS SDKs to access an API that is tailored to the programming language or platform that you're using. For more information, see AWS SDKs (http://aws.amazon.com/tools/#SDKs).

    * Remember that you must set your Migration Hub home region before you call any of these APIs.

    * You must make API calls for write actions (create, notify, associate, disassociate, import, or put) while in your home region, or a HomeRegionNotSetException error is returned.

    * API calls for read actions (list, describe, stop, and delete) are permitted outside of your home region.

    * Although it is unlikely, the Migration Hub home region could change. If you call APIs outside the home region, an InvalidInputException is returned.

    * You must call GetHomeRegion to obtain the latest Migration Hub home region.

    This guide is intended for use with the AWS Application Discovery Service User Guide (http://docs.aws.amazon.com/application-discovery/latest/userguide/). All data is handled according to the AWS Privacy Policy (http://aws.amazon.com/privacy/). You can operate Application Discovery Service offline to inspect collected data before it is shared with the service.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2015-11-01"
    View Source
    const ServiceID = "Application Discovery Service"

    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 AssociateConfigurationItemsToApplicationInput

          type AssociateConfigurationItemsToApplicationInput struct {
          
          	// The configuration ID of an application with which items are to be associated.
          	//
          	// This member is required.
          	ApplicationConfigurationId *string
          
          	// The ID of each configuration item to be associated with an application.
          	//
          	// This member is required.
          	ConfigurationIds []string
          }

          type AssociateConfigurationItemsToApplicationOutput

          type AssociateConfigurationItemsToApplicationOutput struct {
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type BatchDeleteImportDataInput

          type BatchDeleteImportDataInput struct {
          
          	// The IDs for the import tasks that you want to delete.
          	//
          	// This member is required.
          	ImportTaskIds []string
          }

          type BatchDeleteImportDataOutput

          type BatchDeleteImportDataOutput struct {
          
          	// Error messages returned for each import task that you deleted as a response for
          	// this command.
          	Errors []types.BatchDeleteImportDataError
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type Client

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

            Client provides the API client to make operations call for AWS Application Discovery Service.

            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) AssociateConfigurationItemsToApplication

                func (c *Client) AssociateConfigurationItemsToApplication(ctx context.Context, params *AssociateConfigurationItemsToApplicationInput, optFns ...func(*Options)) (*AssociateConfigurationItemsToApplicationOutput, error)

                  Associates one or more configuration items with an application.

                  func (*Client) BatchDeleteImportData

                  func (c *Client) BatchDeleteImportData(ctx context.Context, params *BatchDeleteImportDataInput, optFns ...func(*Options)) (*BatchDeleteImportDataOutput, error)

                    Deletes one or more import tasks, each identified by their import ID. Each import task has a number of records that can identify servers or applications. AWS Application Discovery Service has built-in matching logic that will identify when discovered servers match existing entries that you've previously discovered, the information for the already-existing discovered server is updated. When you delete an import task that contains records that were used to match, the information in those matched records that comes from the deleted records will also be deleted.

                    func (*Client) CreateApplication

                    func (c *Client) CreateApplication(ctx context.Context, params *CreateApplicationInput, optFns ...func(*Options)) (*CreateApplicationOutput, error)

                      Creates an application with the given name and description.

                      func (*Client) CreateTags

                      func (c *Client) CreateTags(ctx context.Context, params *CreateTagsInput, optFns ...func(*Options)) (*CreateTagsOutput, error)

                        Creates one or more tags for configuration items. Tags are metadata that help you categorize IT assets. This API accepts a list of multiple configuration items.

                        func (*Client) DeleteApplications

                        func (c *Client) DeleteApplications(ctx context.Context, params *DeleteApplicationsInput, optFns ...func(*Options)) (*DeleteApplicationsOutput, error)

                          Deletes a list of applications and their associations with configuration items.

                          func (*Client) DeleteTags

                          func (c *Client) DeleteTags(ctx context.Context, params *DeleteTagsInput, optFns ...func(*Options)) (*DeleteTagsOutput, error)

                            Deletes the association between configuration items and one or more tags. This API accepts a list of multiple configuration items.

                            func (*Client) DescribeAgents

                            func (c *Client) DescribeAgents(ctx context.Context, params *DescribeAgentsInput, optFns ...func(*Options)) (*DescribeAgentsOutput, error)

                              Lists agents or connectors as specified by ID or other filters. All agents/connectors associated with your user account can be listed if you call DescribeAgents as is without passing any parameters.

                              func (*Client) DescribeConfigurations

                              func (c *Client) DescribeConfigurations(ctx context.Context, params *DescribeConfigurationsInput, optFns ...func(*Options)) (*DescribeConfigurationsOutput, error)

                                Retrieves attributes for a list of configuration item IDs. All of the supplied IDs must be for the same asset type from one of the following:

                                * server

                                * application

                                * process

                                * connection

                                Output fields are specific to the asset type specified. For example, the output for a server configuration item includes a list of attributes about the server, such as host name, operating system, number of network cards, etc. For a complete list of outputs for each asset type, see Using the DescribeConfigurations Action (https://docs.aws.amazon.com/application-discovery/latest/userguide/discovery-api-queries.html#DescribeConfigurations) in the AWS Application Discovery Service User Guide.

                                func (*Client) DescribeContinuousExports

                                func (c *Client) DescribeContinuousExports(ctx context.Context, params *DescribeContinuousExportsInput, optFns ...func(*Options)) (*DescribeContinuousExportsOutput, error)

                                  Lists exports as specified by ID. All continuous exports associated with your user account can be listed if you call DescribeContinuousExports as is without passing any parameters.

                                  func (*Client) DescribeExportConfigurations

                                  func (c *Client) DescribeExportConfigurations(ctx context.Context, params *DescribeExportConfigurationsInput, optFns ...func(*Options)) (*DescribeExportConfigurationsOutput, error)

                                    DescribeExportConfigurations is deprecated. Use DescribeImportTasks (https://docs.aws.amazon.com/application-discovery/latest/APIReference/API_DescribeExportTasks.html), instead.

                                    Deprecated: This operation has been deprecated.

                                    func (*Client) DescribeExportTasks

                                    func (c *Client) DescribeExportTasks(ctx context.Context, params *DescribeExportTasksInput, optFns ...func(*Options)) (*DescribeExportTasksOutput, error)

                                      Retrieve status of one or more export tasks. You can retrieve the status of up to 100 export tasks.

                                      func (*Client) DescribeImportTasks

                                      func (c *Client) DescribeImportTasks(ctx context.Context, params *DescribeImportTasksInput, optFns ...func(*Options)) (*DescribeImportTasksOutput, error)

                                        Returns an array of import tasks for your account, including status information, times, IDs, the Amazon S3 Object URL for the import file, and more.

                                        func (*Client) DescribeTags

                                        func (c *Client) DescribeTags(ctx context.Context, params *DescribeTagsInput, optFns ...func(*Options)) (*DescribeTagsOutput, error)

                                          Retrieves a list of configuration items that have tags as specified by the key-value pairs, name and value, passed to the optional parameter filters. There are three valid tag filter names:

                                          * tagKey

                                          * tagValue

                                          * configurationId

                                          Also, all configuration items associated with your user account that have tags can be listed if you call DescribeTags as is without passing any parameters.

                                          func (*Client) DisassociateConfigurationItemsFromApplication

                                          func (c *Client) DisassociateConfigurationItemsFromApplication(ctx context.Context, params *DisassociateConfigurationItemsFromApplicationInput, optFns ...func(*Options)) (*DisassociateConfigurationItemsFromApplicationOutput, error)

                                            Disassociates one or more configuration items from an application.

                                            func (*Client) ExportConfigurations

                                            func (c *Client) ExportConfigurations(ctx context.Context, params *ExportConfigurationsInput, optFns ...func(*Options)) (*ExportConfigurationsOutput, error)

                                              Deprecated. Use StartExportTask instead. Exports all discovered configuration data to an Amazon S3 bucket or an application that enables you to view and evaluate the data. Data includes tags and tag associations, processes, connections, servers, and system performance. This API returns an export ID that you can query using the DescribeExportConfigurations API. The system imposes a limit of two configuration exports in six hours.

                                              Deprecated: This operation has been deprecated.

                                              func (*Client) GetDiscoverySummary

                                              func (c *Client) GetDiscoverySummary(ctx context.Context, params *GetDiscoverySummaryInput, optFns ...func(*Options)) (*GetDiscoverySummaryOutput, error)

                                                Retrieves a short summary of discovered assets. This API operation takes no request parameters and is called as is at the command prompt as shown in the example.

                                                func (*Client) ListConfigurations

                                                func (c *Client) ListConfigurations(ctx context.Context, params *ListConfigurationsInput, optFns ...func(*Options)) (*ListConfigurationsOutput, error)

                                                  Retrieves a list of configuration items as specified by the value passed to the required parameter configurationType. Optional filtering may be applied to refine search results.

                                                  func (*Client) ListServerNeighbors

                                                  func (c *Client) ListServerNeighbors(ctx context.Context, params *ListServerNeighborsInput, optFns ...func(*Options)) (*ListServerNeighborsOutput, error)

                                                    Retrieves a list of servers that are one network hop away from a specified server.

                                                    func (*Client) StartContinuousExport

                                                    func (c *Client) StartContinuousExport(ctx context.Context, params *StartContinuousExportInput, optFns ...func(*Options)) (*StartContinuousExportOutput, error)

                                                      Start the continuous flow of agent's discovered data into Amazon Athena.

                                                      func (*Client) StartDataCollectionByAgentIds

                                                      func (c *Client) StartDataCollectionByAgentIds(ctx context.Context, params *StartDataCollectionByAgentIdsInput, optFns ...func(*Options)) (*StartDataCollectionByAgentIdsOutput, error)

                                                        Instructs the specified agents or connectors to start collecting data.

                                                        func (*Client) StartExportTask

                                                        func (c *Client) StartExportTask(ctx context.Context, params *StartExportTaskInput, optFns ...func(*Options)) (*StartExportTaskOutput, error)

                                                          Begins the export of discovered data to an S3 bucket. If you specify agentIds in a filter, the task exports up to 72 hours of detailed data collected by the identified Application Discovery Agent, including network, process, and performance details. A time range for exported agent data may be set by using startTime and endTime. Export of detailed agent data is limited to five concurrently running exports. If you do not include an agentIds filter, summary data is exported that includes both AWS Agentless Discovery Connector data and summary data from AWS Discovery Agents. Export of summary data is limited to two exports per day.

                                                          func (*Client) StartImportTask

                                                          func (c *Client) StartImportTask(ctx context.Context, params *StartImportTaskInput, optFns ...func(*Options)) (*StartImportTaskOutput, error)

                                                            Starts an import task, which allows you to import details of your on-premises environment directly into AWS Migration Hub without having to use the Application Discovery Service (ADS) tools such as the Discovery Connector or Discovery Agent. This gives you the option to perform migration assessment and planning directly from your imported data, including the ability to group your devices as applications and track their migration status. To start an import request, do this:

                                                            * Download the specially formatted comma separated value (CSV) import template, which you can find here: https://s3-us-west-2.amazonaws.com/templates-7cffcf56-bd96-4b1c-b45b-a5b42f282e46/import_template.csv (https://s3-us-west-2.amazonaws.com/templates-7cffcf56-bd96-4b1c-b45b-a5b42f282e46/import_template.csv).

                                                            * Fill out the template with your server and application data.

                                                            * Upload your import file to an Amazon S3 bucket, and make a note of it's Object URL. Your import file must be in the CSV format.

                                                            * Use the console or the StartImportTask command with the AWS CLI or one of the AWS SDKs to import the records from your file.

                                                            For more information, including step-by-step procedures, see Migration Hub Import (https://docs.aws.amazon.com/application-discovery/latest/userguide/discovery-import.html) in the AWS Application Discovery Service User Guide. There are limits to the number of import tasks you can create (and delete) in an AWS account. For more information, see AWS Application Discovery Service Limits (https://docs.aws.amazon.com/application-discovery/latest/userguide/ads_service_limits.html) in the AWS Application Discovery Service User Guide.

                                                            func (*Client) StopContinuousExport

                                                            func (c *Client) StopContinuousExport(ctx context.Context, params *StopContinuousExportInput, optFns ...func(*Options)) (*StopContinuousExportOutput, error)

                                                              Stop the continuous flow of agent's discovered data into Amazon Athena.

                                                              func (*Client) StopDataCollectionByAgentIds

                                                              func (c *Client) StopDataCollectionByAgentIds(ctx context.Context, params *StopDataCollectionByAgentIdsInput, optFns ...func(*Options)) (*StopDataCollectionByAgentIdsOutput, error)

                                                                Instructs the specified agents or connectors to stop collecting data.

                                                                func (*Client) UpdateApplication

                                                                func (c *Client) UpdateApplication(ctx context.Context, params *UpdateApplicationInput, optFns ...func(*Options)) (*UpdateApplicationOutput, error)

                                                                  Updates metadata about an application.

                                                                  type CreateApplicationInput

                                                                  type CreateApplicationInput struct {
                                                                  
                                                                  	// Name of the application to be created.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Name *string
                                                                  
                                                                  	// Description of the application to be created.
                                                                  	Description *string
                                                                  }

                                                                  type CreateApplicationOutput

                                                                  type CreateApplicationOutput struct {
                                                                  
                                                                  	// Configuration ID of an application to be created.
                                                                  	ConfigurationId *string
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type CreateTagsInput

                                                                  type CreateTagsInput struct {
                                                                  
                                                                  	// A list of configuration items that you want to tag.
                                                                  	//
                                                                  	// This member is required.
                                                                  	ConfigurationIds []string
                                                                  
                                                                  	// Tags that you want to associate with one or more configuration items. Specify
                                                                  	// the tags that you want to create in a key-value format. For example: {"key":
                                                                  	// "serverType", "value": "webServer"}
                                                                  	//
                                                                  	// This member is required.
                                                                  	Tags []types.Tag
                                                                  }

                                                                  type CreateTagsOutput

                                                                  type CreateTagsOutput struct {
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type DeleteApplicationsInput

                                                                  type DeleteApplicationsInput struct {
                                                                  
                                                                  	// Configuration ID of an application to be deleted.
                                                                  	//
                                                                  	// This member is required.
                                                                  	ConfigurationIds []string
                                                                  }

                                                                  type DeleteApplicationsOutput

                                                                  type DeleteApplicationsOutput struct {
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type DeleteTagsInput

                                                                  type DeleteTagsInput struct {
                                                                  
                                                                  	// A list of configuration items with tags that you want to delete.
                                                                  	//
                                                                  	// This member is required.
                                                                  	ConfigurationIds []string
                                                                  
                                                                  	// Tags that you want to delete from one or more configuration items. Specify the
                                                                  	// tags that you want to delete in a key-value format. For example: {"key":
                                                                  	// "serverType", "value": "webServer"}
                                                                  	Tags []types.Tag
                                                                  }

                                                                  type DeleteTagsOutput

                                                                  type DeleteTagsOutput struct {
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type DescribeAgentsInput

                                                                  type DescribeAgentsInput struct {
                                                                  
                                                                  	// The agent or the Connector IDs for which you want information. If you specify no
                                                                  	// IDs, the system returns information about all agents/Connectors associated with
                                                                  	// your AWS user account.
                                                                  	AgentIds []string
                                                                  
                                                                  	// You can filter the request using various logical operators and a key-value
                                                                  	// format. For example: {"key": "collectionStatus", "value": "STARTED"}
                                                                  	Filters []types.Filter
                                                                  
                                                                  	// The total number of agents/Connectors to return in a single page of output. The
                                                                  	// maximum value is 100.
                                                                  	MaxResults int32
                                                                  
                                                                  	// Token to retrieve the next set of results. For example, if you previously
                                                                  	// specified 100 IDs for DescribeAgentsRequest$agentIds but set
                                                                  	// DescribeAgentsRequest$maxResults to 10, you received a set of 10 results along
                                                                  	// with a token. Use that token in this query to get the next set of 10.
                                                                  	NextToken *string
                                                                  }

                                                                  type DescribeAgentsOutput

                                                                  type DescribeAgentsOutput struct {
                                                                  
                                                                  	// Lists agents or the Connector by ID or lists all agents/Connectors associated
                                                                  	// with your user account if you did not specify an agent/Connector ID. The output
                                                                  	// includes agent/Connector IDs, IP addresses, media access control (MAC)
                                                                  	// addresses, agent/Connector health, host name where the agent/Connector resides,
                                                                  	// and the version number of each agent/Connector.
                                                                  	AgentsInfo []types.AgentInfo
                                                                  
                                                                  	// Token to retrieve the next set of results. For example, if you specified 100 IDs
                                                                  	// for DescribeAgentsRequest$agentIds but set DescribeAgentsRequest$maxResults to
                                                                  	// 10, you received a set of 10 results along with this token. Use this token in
                                                                  	// the next query to retrieve the next set of 10.
                                                                  	NextToken *string
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type DescribeConfigurationsInput

                                                                  type DescribeConfigurationsInput struct {
                                                                  
                                                                  	// One or more configuration IDs.
                                                                  	//
                                                                  	// This member is required.
                                                                  	ConfigurationIds []string
                                                                  }

                                                                  type DescribeConfigurationsOutput

                                                                  type DescribeConfigurationsOutput struct {
                                                                  
                                                                  	// A key in the response map. The value is an array of data.
                                                                  	Configurations []map[string]string
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type DescribeContinuousExportsAPIClient

                                                                  type DescribeContinuousExportsAPIClient interface {
                                                                  	DescribeContinuousExports(context.Context, *DescribeContinuousExportsInput, ...func(*Options)) (*DescribeContinuousExportsOutput, error)
                                                                  }

                                                                    DescribeContinuousExportsAPIClient is a client that implements the DescribeContinuousExports operation.

                                                                    type DescribeContinuousExportsInput

                                                                    type DescribeContinuousExportsInput struct {
                                                                    
                                                                    	// The unique IDs assigned to the exports.
                                                                    	ExportIds []string
                                                                    
                                                                    	// A number between 1 and 100 specifying the maximum number of continuous export
                                                                    	// descriptions returned.
                                                                    	MaxResults *int32
                                                                    
                                                                    	// The token from the previous call to DescribeExportTasks.
                                                                    	NextToken *string
                                                                    }

                                                                    type DescribeContinuousExportsOutput

                                                                    type DescribeContinuousExportsOutput struct {
                                                                    
                                                                    	// A list of continuous export descriptions.
                                                                    	Descriptions []types.ContinuousExportDescription
                                                                    
                                                                    	// The token from the previous call to DescribeExportTasks.
                                                                    	NextToken *string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DescribeContinuousExportsPaginator

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

                                                                      DescribeContinuousExportsPaginator is a paginator for DescribeContinuousExports

                                                                      func NewDescribeContinuousExportsPaginator

                                                                        NewDescribeContinuousExportsPaginator returns a new DescribeContinuousExportsPaginator

                                                                        func (*DescribeContinuousExportsPaginator) HasMorePages

                                                                        func (p *DescribeContinuousExportsPaginator) HasMorePages() bool

                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                          func (*DescribeContinuousExportsPaginator) NextPage

                                                                            NextPage retrieves the next DescribeContinuousExports page.

                                                                            type DescribeContinuousExportsPaginatorOptions

                                                                            type DescribeContinuousExportsPaginatorOptions struct {
                                                                            	// A number between 1 and 100 specifying the maximum number of continuous export
                                                                            	// descriptions returned.
                                                                            	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
                                                                            }

                                                                              DescribeContinuousExportsPaginatorOptions is the paginator options for DescribeContinuousExports

                                                                              type DescribeExportConfigurationsInput

                                                                              type DescribeExportConfigurationsInput struct {
                                                                              
                                                                              	// A list of continuous export IDs to search for.
                                                                              	ExportIds []string
                                                                              
                                                                              	// A number between 1 and 100 specifying the maximum number of continuous export
                                                                              	// descriptions returned.
                                                                              	MaxResults int32
                                                                              
                                                                              	// The token from the previous call to describe-export-tasks.
                                                                              	NextToken *string
                                                                              }

                                                                              type DescribeExportConfigurationsOutput

                                                                              type DescribeExportConfigurationsOutput struct {
                                                                              
                                                                              	//
                                                                              	ExportsInfo []types.ExportInfo
                                                                              
                                                                              	// The token from the previous call to describe-export-tasks.
                                                                              	NextToken *string
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type DescribeExportTasksInput

                                                                              type DescribeExportTasksInput struct {
                                                                              
                                                                              	// One or more unique identifiers used to query the status of an export request.
                                                                              	ExportIds []string
                                                                              
                                                                              	// One or more filters.
                                                                              	//
                                                                              	// * AgentId - ID of the agent whose collected data will be
                                                                              	// exported
                                                                              	Filters []types.ExportFilter
                                                                              
                                                                              	// The maximum number of volume results returned by DescribeExportTasks in
                                                                              	// paginated output. When this parameter is used, DescribeExportTasks only returns
                                                                              	// maxResults results in a single page along with a nextToken response element.
                                                                              	MaxResults int32
                                                                              
                                                                              	// The nextToken value returned from a previous paginated DescribeExportTasks
                                                                              	// request where maxResults was used and the results exceeded the value of that
                                                                              	// parameter. Pagination continues from the end of the previous results that
                                                                              	// returned the nextToken value. This value is null when there are no more results
                                                                              	// to return.
                                                                              	NextToken *string
                                                                              }

                                                                              type DescribeExportTasksOutput

                                                                              type DescribeExportTasksOutput struct {
                                                                              
                                                                              	// Contains one or more sets of export request details. When the status of a
                                                                              	// request is SUCCEEDED, the response includes a URL for an Amazon S3 bucket where
                                                                              	// you can view the data in a CSV file.
                                                                              	ExportsInfo []types.ExportInfo
                                                                              
                                                                              	// The nextToken value to include in a future DescribeExportTasks request. When the
                                                                              	// results of a DescribeExportTasks request exceed maxResults, this value can be
                                                                              	// used to retrieve the next page of results. This value is null when there are no
                                                                              	// more results to return.
                                                                              	NextToken *string
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type DescribeImportTasksAPIClient

                                                                              type DescribeImportTasksAPIClient interface {
                                                                              	DescribeImportTasks(context.Context, *DescribeImportTasksInput, ...func(*Options)) (*DescribeImportTasksOutput, error)
                                                                              }

                                                                                DescribeImportTasksAPIClient is a client that implements the DescribeImportTasks operation.

                                                                                type DescribeImportTasksInput

                                                                                type DescribeImportTasksInput struct {
                                                                                
                                                                                	// An array of name-value pairs that you provide to filter the results for the
                                                                                	// DescribeImportTask request to a specific subset of results. Currently, wildcard
                                                                                	// values aren't supported for filters.
                                                                                	Filters []types.ImportTaskFilter
                                                                                
                                                                                	// The maximum number of results that you want this request to return, up to 100.
                                                                                	MaxResults *int32
                                                                                
                                                                                	// The token to request a specific page of results.
                                                                                	NextToken *string
                                                                                }

                                                                                type DescribeImportTasksOutput

                                                                                type DescribeImportTasksOutput struct {
                                                                                
                                                                                	// The token to request the next page of results.
                                                                                	NextToken *string
                                                                                
                                                                                	// A returned array of import tasks that match any applied filters, up to the
                                                                                	// specified number of maximum results.
                                                                                	Tasks []types.ImportTask
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type DescribeImportTasksPaginator

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

                                                                                  DescribeImportTasksPaginator is a paginator for DescribeImportTasks

                                                                                  func NewDescribeImportTasksPaginator

                                                                                  func NewDescribeImportTasksPaginator(client DescribeImportTasksAPIClient, params *DescribeImportTasksInput, optFns ...func(*DescribeImportTasksPaginatorOptions)) *DescribeImportTasksPaginator

                                                                                    NewDescribeImportTasksPaginator returns a new DescribeImportTasksPaginator

                                                                                    func (*DescribeImportTasksPaginator) HasMorePages

                                                                                    func (p *DescribeImportTasksPaginator) HasMorePages() bool

                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                      func (*DescribeImportTasksPaginator) NextPage

                                                                                      func (p *DescribeImportTasksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeImportTasksOutput, error)

                                                                                        NextPage retrieves the next DescribeImportTasks page.

                                                                                        type DescribeImportTasksPaginatorOptions

                                                                                        type DescribeImportTasksPaginatorOptions struct {
                                                                                        	// The maximum number of results that you want this request to return, up to 100.
                                                                                        	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
                                                                                        }

                                                                                          DescribeImportTasksPaginatorOptions is the paginator options for DescribeImportTasks

                                                                                          type DescribeTagsInput

                                                                                          type DescribeTagsInput struct {
                                                                                          
                                                                                          	// You can filter the list using a key-value format. You can separate these items
                                                                                          	// by using logical operators. Allowed filters include tagKey, tagValue, and
                                                                                          	// configurationId.
                                                                                          	Filters []types.TagFilter
                                                                                          
                                                                                          	// The total number of items to return in a single page of output. The maximum
                                                                                          	// value is 100.
                                                                                          	MaxResults int32
                                                                                          
                                                                                          	// A token to start the list. Use this token to get the next set of results.
                                                                                          	NextToken *string
                                                                                          }

                                                                                          type DescribeTagsOutput

                                                                                          type DescribeTagsOutput struct {
                                                                                          
                                                                                          	// The call returns a token. Use this token to get the next set of results.
                                                                                          	NextToken *string
                                                                                          
                                                                                          	// Depending on the input, this is a list of configuration items tagged with a
                                                                                          	// specific tag, or a list of tags for a specific configuration item.
                                                                                          	Tags []types.ConfigurationTag
                                                                                          
                                                                                          	// Metadata pertaining to the operation's result.
                                                                                          	ResultMetadata middleware.Metadata
                                                                                          }

                                                                                          type DisassociateConfigurationItemsFromApplicationInput

                                                                                          type DisassociateConfigurationItemsFromApplicationInput struct {
                                                                                          
                                                                                          	// Configuration ID of an application from which each item is disassociated.
                                                                                          	//
                                                                                          	// This member is required.
                                                                                          	ApplicationConfigurationId *string
                                                                                          
                                                                                          	// Configuration ID of each item to be disassociated from an application.
                                                                                          	//
                                                                                          	// This member is required.
                                                                                          	ConfigurationIds []string
                                                                                          }

                                                                                          type DisassociateConfigurationItemsFromApplicationOutput

                                                                                          type DisassociateConfigurationItemsFromApplicationOutput struct {
                                                                                          	// Metadata pertaining to the operation's result.
                                                                                          	ResultMetadata middleware.Metadata
                                                                                          }

                                                                                          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 ExportConfigurationsInput

                                                                                                  type ExportConfigurationsInput struct {
                                                                                                  }

                                                                                                  type ExportConfigurationsOutput

                                                                                                  type ExportConfigurationsOutput struct {
                                                                                                  
                                                                                                  	// A unique identifier that you can use to query the export status.
                                                                                                  	ExportId *string
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  type GetDiscoverySummaryInput

                                                                                                  type GetDiscoverySummaryInput struct {
                                                                                                  }

                                                                                                  type GetDiscoverySummaryOutput

                                                                                                  type GetDiscoverySummaryOutput struct {
                                                                                                  
                                                                                                  	// Details about discovered agents, including agent status and health.
                                                                                                  	AgentSummary *types.CustomerAgentInfo
                                                                                                  
                                                                                                  	// The number of applications discovered.
                                                                                                  	Applications int64
                                                                                                  
                                                                                                  	// Details about discovered connectors, including connector status and health.
                                                                                                  	ConnectorSummary *types.CustomerConnectorInfo
                                                                                                  
                                                                                                  	// The number of servers discovered.
                                                                                                  	Servers int64
                                                                                                  
                                                                                                  	// The number of servers mapped to applications.
                                                                                                  	ServersMappedToApplications int64
                                                                                                  
                                                                                                  	// The number of servers mapped to tags.
                                                                                                  	ServersMappedtoTags int64
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  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 IdempotencyTokenProvider

                                                                                                  type IdempotencyTokenProvider interface {
                                                                                                  	GetIdempotencyToken() (string, error)
                                                                                                  }

                                                                                                    IdempotencyTokenProvider interface for providing idempotency token

                                                                                                    type ListConfigurationsInput

                                                                                                    type ListConfigurationsInput struct {
                                                                                                    
                                                                                                    	// A valid configuration identified by Application Discovery Service.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	ConfigurationType types.ConfigurationItemType
                                                                                                    
                                                                                                    	// You can filter the request using various logical operators and a key-value
                                                                                                    	// format. For example: {"key": "serverType", "value": "webServer"} For a complete
                                                                                                    	// list of filter options and guidance about using them with this action, see Using
                                                                                                    	// the ListConfigurations Action
                                                                                                    	// (https://docs.aws.amazon.com/application-discovery/latest/userguide/discovery-api-queries.html#ListConfigurations)
                                                                                                    	// in the AWS Application Discovery Service User Guide.
                                                                                                    	Filters []types.Filter
                                                                                                    
                                                                                                    	// The total number of items to return. The maximum value is 100.
                                                                                                    	MaxResults int32
                                                                                                    
                                                                                                    	// Token to retrieve the next set of results. For example, if a previous call to
                                                                                                    	// ListConfigurations returned 100 items, but you set
                                                                                                    	// ListConfigurationsRequest$maxResults to 10, you received a set of 10 results
                                                                                                    	// along with a token. Use that token in this query to get the next set of 10.
                                                                                                    	NextToken *string
                                                                                                    
                                                                                                    	// Certain filter criteria return output that can be sorted in ascending or
                                                                                                    	// descending order. For a list of output characteristics for each filter, see
                                                                                                    	// Using the ListConfigurations Action
                                                                                                    	// (https://docs.aws.amazon.com/application-discovery/latest/userguide/discovery-api-queries.html#ListConfigurations)
                                                                                                    	// in the AWS Application Discovery Service User Guide.
                                                                                                    	OrderBy []types.OrderByElement
                                                                                                    }

                                                                                                    type ListConfigurationsOutput

                                                                                                    type ListConfigurationsOutput struct {
                                                                                                    
                                                                                                    	// Returns configuration details, including the configuration ID, attribute names,
                                                                                                    	// and attribute values.
                                                                                                    	Configurations []map[string]string
                                                                                                    
                                                                                                    	// Token to retrieve the next set of results. For example, if your call to
                                                                                                    	// ListConfigurations returned 100 items, but you set
                                                                                                    	// ListConfigurationsRequest$maxResults to 10, you received a set of 10 results
                                                                                                    	// along with this token. Use this token in the next query to retrieve the next set
                                                                                                    	// of 10.
                                                                                                    	NextToken *string
                                                                                                    
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    type ListServerNeighborsInput

                                                                                                    type ListServerNeighborsInput struct {
                                                                                                    
                                                                                                    	// Configuration ID of the server for which neighbors are being listed.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	ConfigurationId *string
                                                                                                    
                                                                                                    	// Maximum number of results to return in a single page of output.
                                                                                                    	MaxResults int32
                                                                                                    
                                                                                                    	// List of configuration IDs to test for one-hop-away.
                                                                                                    	NeighborConfigurationIds []string
                                                                                                    
                                                                                                    	// Token to retrieve the next set of results. For example, if you previously
                                                                                                    	// specified 100 IDs for ListServerNeighborsRequest$neighborConfigurationIds but
                                                                                                    	// set ListServerNeighborsRequest$maxResults to 10, you received a set of 10
                                                                                                    	// results along with a token. Use that token in this query to get the next set of
                                                                                                    	// 10.
                                                                                                    	NextToken *string
                                                                                                    
                                                                                                    	// Flag to indicate if port and protocol information is needed as part of the
                                                                                                    	// response.
                                                                                                    	PortInformationNeeded bool
                                                                                                    }

                                                                                                    type ListServerNeighborsOutput

                                                                                                    type ListServerNeighborsOutput struct {
                                                                                                    
                                                                                                    	// List of distinct servers that are one hop away from the given server.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	Neighbors []types.NeighborConnectionDetail
                                                                                                    
                                                                                                    	// Count of distinct servers that are one hop away from the given server.
                                                                                                    	KnownDependencyCount int64
                                                                                                    
                                                                                                    	// Token to retrieve the next set of results. For example, if you specified 100 IDs
                                                                                                    	// for ListServerNeighborsRequest$neighborConfigurationIds but set
                                                                                                    	// ListServerNeighborsRequest$maxResults to 10, you received a set of 10 results
                                                                                                    	// along with this token. Use this token in the next query to retrieve the next set
                                                                                                    	// of 10.
                                                                                                    	NextToken *string
                                                                                                    
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                    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 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
                                                                                                    
                                                                                                    	// Provides idempotency tokens values that will be automatically populated into
                                                                                                    	// idempotent API operations.
                                                                                                    	IdempotencyTokenProvider IdempotencyTokenProvider
                                                                                                    
                                                                                                    	// The logger writer interface to write logging messages to.
                                                                                                    	Logger logging.Logger
                                                                                                    
                                                                                                    	// The region to send requests to. (Required)
                                                                                                    	Region string
                                                                                                    
                                                                                                    	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                    	// failures. When nil the API client will use a default retryer.
                                                                                                    	Retryer aws.Retryer
                                                                                                    
                                                                                                    	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                    	// implementation if nil.
                                                                                                    	HTTPClient HTTPClient
                                                                                                    }

                                                                                                    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 (*ResolveEndpoint) ID

                                                                                                      func (*ResolveEndpoint) ID() string

                                                                                                      type StartContinuousExportInput

                                                                                                      type StartContinuousExportInput struct {
                                                                                                      }

                                                                                                      type StartContinuousExportOutput

                                                                                                      type StartContinuousExportOutput struct {
                                                                                                      
                                                                                                      	// The type of data collector used to gather this data (currently only offered for
                                                                                                      	// AGENT).
                                                                                                      	DataSource types.DataSource
                                                                                                      
                                                                                                      	// The unique ID assigned to this export.
                                                                                                      	ExportId *string
                                                                                                      
                                                                                                      	// The name of the s3 bucket where the export data parquet files are stored.
                                                                                                      	S3Bucket *string
                                                                                                      
                                                                                                      	// A dictionary which describes how the data is stored.
                                                                                                      	//
                                                                                                      	// * databaseName - the name
                                                                                                      	// of the Glue database used to store the schema.
                                                                                                      	SchemaStorageConfig map[string]string
                                                                                                      
                                                                                                      	// The timestamp representing when the continuous export was started.
                                                                                                      	StartTime *time.Time
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type StartDataCollectionByAgentIdsInput

                                                                                                      type StartDataCollectionByAgentIdsInput struct {
                                                                                                      
                                                                                                      	// The IDs of the agents or connectors from which to start collecting data. If you
                                                                                                      	// send a request to an agent/connector ID that you do not have permission to
                                                                                                      	// contact, according to your AWS account, the service does not throw an exception.
                                                                                                      	// Instead, it returns the error in the Description field. If you send a request to
                                                                                                      	// multiple agents/connectors and you do not have permission to contact some of
                                                                                                      	// those agents/connectors, the system does not throw an exception. Instead, the
                                                                                                      	// system shows Failed in the Description field.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	AgentIds []string
                                                                                                      }

                                                                                                      type StartDataCollectionByAgentIdsOutput

                                                                                                      type StartDataCollectionByAgentIdsOutput struct {
                                                                                                      
                                                                                                      	// Information about agents or the connector that were instructed to start
                                                                                                      	// collecting data. Information includes the agent/connector ID, a description of
                                                                                                      	// the operation performed, and whether the agent/connector configuration was
                                                                                                      	// updated.
                                                                                                      	AgentsConfigurationStatus []types.AgentConfigurationStatus
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type StartExportTaskInput

                                                                                                      type StartExportTaskInput struct {
                                                                                                      
                                                                                                      	// The end timestamp for exported data from the single Application Discovery Agent
                                                                                                      	// selected in the filters. If no value is specified, exported data includes the
                                                                                                      	// most recent data collected by the agent.
                                                                                                      	EndTime *time.Time
                                                                                                      
                                                                                                      	// The file format for the returned export data. Default value is CSV. Note: The
                                                                                                      	// GRAPHML option has been deprecated.
                                                                                                      	ExportDataFormat []types.ExportDataFormat
                                                                                                      
                                                                                                      	// If a filter is present, it selects the single agentId of the Application
                                                                                                      	// Discovery Agent for which data is exported. The agentId can be found in the
                                                                                                      	// results of the DescribeAgents API or CLI. If no filter is present, startTime and
                                                                                                      	// endTime are ignored and exported data includes both Agentless Discovery
                                                                                                      	// Connector data and summary data from Application Discovery agents.
                                                                                                      	Filters []types.ExportFilter
                                                                                                      
                                                                                                      	// The start timestamp for exported data from the single Application Discovery
                                                                                                      	// Agent selected in the filters. If no value is specified, data is exported
                                                                                                      	// starting from the first data collected by the agent.
                                                                                                      	StartTime *time.Time
                                                                                                      }

                                                                                                      type StartExportTaskOutput

                                                                                                      type StartExportTaskOutput struct {
                                                                                                      
                                                                                                      	// A unique identifier used to query the status of an export request.
                                                                                                      	ExportId *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type StartImportTaskInput

                                                                                                      type StartImportTaskInput struct {
                                                                                                      
                                                                                                      	// The URL for your import file that you've uploaded to Amazon S3. If you're using
                                                                                                      	// the AWS CLI, this URL is structured as follows:
                                                                                                      	// s3://BucketName/ImportFileName.CSV
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ImportUrl *string
                                                                                                      
                                                                                                      	// A descriptive name for this request. You can use this name to filter future
                                                                                                      	// requests related to this import task, such as identifying applications and
                                                                                                      	// servers that were included in this import task. We recommend that you use a
                                                                                                      	// meaningful name for each import task.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// Optional. A unique token that you can provide to prevent the same import request
                                                                                                      	// from occurring more than once. If you don't provide a token, a token is
                                                                                                      	// automatically generated. Sending more than one StartImportTask request with the
                                                                                                      	// same client request token will return information about the original import task
                                                                                                      	// with that client request token.
                                                                                                      	ClientRequestToken *string
                                                                                                      }

                                                                                                      type StartImportTaskOutput

                                                                                                      type StartImportTaskOutput struct {
                                                                                                      
                                                                                                      	// An array of information related to the import task request including status
                                                                                                      	// information, times, IDs, the Amazon S3 Object URL for the import file, and more.
                                                                                                      	Task *types.ImportTask
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type StopContinuousExportInput

                                                                                                      type StopContinuousExportInput struct {
                                                                                                      
                                                                                                      	// The unique ID assigned to this export.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ExportId *string
                                                                                                      }

                                                                                                      type StopContinuousExportOutput

                                                                                                      type StopContinuousExportOutput struct {
                                                                                                      
                                                                                                      	// Timestamp that represents when this continuous export started collecting data.
                                                                                                      	StartTime *time.Time
                                                                                                      
                                                                                                      	// Timestamp that represents when this continuous export was stopped.
                                                                                                      	StopTime *time.Time
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type StopDataCollectionByAgentIdsInput

                                                                                                      type StopDataCollectionByAgentIdsInput struct {
                                                                                                      
                                                                                                      	// The IDs of the agents or connectors from which to stop collecting data.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	AgentIds []string
                                                                                                      }

                                                                                                      type StopDataCollectionByAgentIdsOutput

                                                                                                      type StopDataCollectionByAgentIdsOutput struct {
                                                                                                      
                                                                                                      	// Information about the agents or connector that were instructed to stop
                                                                                                      	// collecting data. Information includes the agent/connector ID, a description of
                                                                                                      	// the operation performed, and whether the agent/connector configuration was
                                                                                                      	// updated.
                                                                                                      	AgentsConfigurationStatus []types.AgentConfigurationStatus
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type UpdateApplicationInput

                                                                                                      type UpdateApplicationInput struct {
                                                                                                      
                                                                                                      	// Configuration ID of the application to be updated.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ConfigurationId *string
                                                                                                      
                                                                                                      	// New description of the application to be updated.
                                                                                                      	Description *string
                                                                                                      
                                                                                                      	// New name of the application to be updated.
                                                                                                      	Name *string
                                                                                                      }

                                                                                                      type UpdateApplicationOutput

                                                                                                      type UpdateApplicationOutput struct {
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      Directories

                                                                                                      Path Synopsis
                                                                                                      internal