repo_name stringlengths 1 52 | repo_creator stringclasses 6
values | programming_language stringclasses 4
values | code stringlengths 0 9.68M | num_lines int64 1 234k |
|---|---|---|---|---|
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates Amazon QuickSight customizations for the current Amazon Web Services
// Region. Currently, you can add a custom default theme by using the
// CreateAccountCustomization or UpdateAccountCustomization API operation. To
// further customize Amazon QuickSight by removing Amazon QuickSight sample assets
// and videos for all new users, see Customizing Amazon QuickSight (https://docs.aws.amazon.com/quicksight/latest/user/customizing-quicksight.html)
// in the Amazon QuickSight User Guide. You can create customizations for your
// Amazon Web Services account or, if you specify a namespace, for a QuickSight
// namespace instead. Customizations that apply to a namespace always override
// customizations that apply to an Amazon Web Services account. To find out which
// customizations apply, use the DescribeAccountCustomization API operation.
// Before you use the CreateAccountCustomization API operation to add a theme as
// the namespace default, make sure that you first share the theme with the
// namespace. If you don't share it with the namespace, the theme isn't visible to
// your users even if you make it the default theme. To check if the theme is
// shared, view the current permissions by using the DescribeThemePermissions (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeThemePermissions.html)
// API operation. To share the theme, grant permissions by using the
// UpdateThemePermissions (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateThemePermissions.html)
// API operation.
func (c *Client) CreateAccountCustomization(ctx context.Context, params *CreateAccountCustomizationInput, optFns ...func(*Options)) (*CreateAccountCustomizationOutput, error) {
if params == nil {
params = &CreateAccountCustomizationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAccountCustomization", params, optFns, c.addOperationCreateAccountCustomizationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAccountCustomizationOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAccountCustomizationInput struct {
// The Amazon QuickSight customizations you're adding in the current Amazon Web
// Services Region. You can add these to an Amazon Web Services account and a
// QuickSight namespace. For example, you can add a default theme by setting
// AccountCustomization to the midnight theme: "AccountCustomization": {
// "DefaultTheme": "arn:aws:quicksight::aws:theme/MIDNIGHT" } . Or, you can add a
// custom theme by specifying "AccountCustomization": { "DefaultTheme":
// "arn:aws:quicksight:us-west-2:111122223333:theme/bdb844d0-0fe9-4d9d-b520-0fe602d93639"
// } .
//
// This member is required.
AccountCustomization *types.AccountCustomization
// The ID for the Amazon Web Services account that you want to customize Amazon
// QuickSight for.
//
// This member is required.
AwsAccountId *string
// The Amazon QuickSight namespace that you want to add customizations to.
Namespace *string
// A list of the tags that you want to attach to this resource.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateAccountCustomizationOutput struct {
// The Amazon QuickSight customizations you're adding in the current Amazon Web
// Services Region.
AccountCustomization *types.AccountCustomization
// The Amazon Resource Name (ARN) for the customization that you created for this
// Amazon Web Services account.
Arn *string
// The ID for the Amazon Web Services account that you want to customize Amazon
// QuickSight for.
AwsAccountId *string
// The namespace associated with the customization you're creating.
Namespace *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAccountCustomizationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateAccountCustomization{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateAccountCustomization{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateAccountCustomizationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAccountCustomization(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateAccountCustomization(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateAccountCustomization",
}
}
| 179 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Amazon QuickSight account, or subscribes to Amazon QuickSight Q. The
// Amazon Web Services Region for the account is derived from what is configured in
// the CLI or SDK. This operation isn't supported in the US East (Ohio) Region,
// South America (Sao Paulo) Region, or Asia Pacific (Singapore) Region. Before you
// use this operation, make sure that you can connect to an existing Amazon Web
// Services account. If you don't have an Amazon Web Services account, see Sign up
// for Amazon Web Services (https://docs.aws.amazon.com/quicksight/latest/user/setting-up-aws-sign-up.html)
// in the Amazon QuickSight User Guide. The person who signs up for Amazon
// QuickSight needs to have the correct Identity and Access Management (IAM)
// permissions. For more information, see IAM Policy Examples for Amazon QuickSight (https://docs.aws.amazon.com/quicksight/latest/user/iam-policy-examples.html)
// in the Amazon QuickSight User Guide. If your IAM policy includes both the
// Subscribe and CreateAccountSubscription actions, make sure that both actions
// are set to Allow . If either action is set to Deny , the Deny action prevails
// and your API call fails. You can't pass an existing IAM role to access other
// Amazon Web Services services using this API operation. To pass your existing IAM
// role to Amazon QuickSight, see Passing IAM roles to Amazon QuickSight (https://docs.aws.amazon.com/quicksight/latest/user/security_iam_service-with-iam.html#security-create-iam-role)
// in the Amazon QuickSight User Guide. You can't set default resource access on
// the new account from the Amazon QuickSight API. Instead, add default resource
// access from the Amazon QuickSight console. For more information about setting
// default resource access to Amazon Web Services services, see Setting default
// resource access to Amazon Web Services services (https://docs.aws.amazon.com/quicksight/latest/user/scoping-policies-defaults.html)
// in the Amazon QuickSight User Guide.
func (c *Client) CreateAccountSubscription(ctx context.Context, params *CreateAccountSubscriptionInput, optFns ...func(*Options)) (*CreateAccountSubscriptionOutput, error) {
if params == nil {
params = &CreateAccountSubscriptionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAccountSubscription", params, optFns, c.addOperationCreateAccountSubscriptionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAccountSubscriptionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAccountSubscriptionInput struct {
// The name of your Amazon QuickSight account. This name is unique over all of
// Amazon Web Services, and it appears only when users sign in. You can't change
// AccountName value after the Amazon QuickSight account is created.
//
// This member is required.
AccountName *string
// The method that you want to use to authenticate your Amazon QuickSight account.
// Currently, the valid values for this parameter are IAM_AND_QUICKSIGHT , IAM_ONLY
// , and ACTIVE_DIRECTORY . If you choose ACTIVE_DIRECTORY , provide an
// ActiveDirectoryName and an AdminGroup associated with your Active Directory.
//
// This member is required.
AuthenticationMethod types.AuthenticationMethodOption
// The Amazon Web Services account ID of the account that you're using to create
// your Amazon QuickSight account.
//
// This member is required.
AwsAccountId *string
// The edition of Amazon QuickSight that you want your account to have. Currently,
// you can choose from ENTERPRISE or ENTERPRISE_AND_Q . If you choose
// ENTERPRISE_AND_Q , the following parameters are required:
// - FirstName
// - LastName
// - EmailAddress
// - ContactNumber
//
// This member is required.
Edition types.Edition
// The email address that you want Amazon QuickSight to send notifications to
// regarding your Amazon QuickSight account or Amazon QuickSight subscription.
//
// This member is required.
NotificationEmail *string
// The name of your Active Directory. This field is required if ACTIVE_DIRECTORY
// is the selected authentication method of the new Amazon QuickSight account.
ActiveDirectoryName *string
// The admin group associated with your Active Directory. This field is required
// if ACTIVE_DIRECTORY is the selected authentication method of the new Amazon
// QuickSight account. For more information about using Active Directory in Amazon
// QuickSight, see Using Active Directory with Amazon QuickSight Enterprise Edition (https://docs.aws.amazon.com/quicksight/latest/user/aws-directory-service.html)
// in the Amazon QuickSight User Guide.
AdminGroup []string
// The author group associated with your Active Directory. For more information
// about using Active Directory in Amazon QuickSight, see Using Active Directory
// with Amazon QuickSight Enterprise Edition (https://docs.aws.amazon.com/quicksight/latest/user/aws-directory-service.html)
// in the Amazon QuickSight User Guide.
AuthorGroup []string
// A 10-digit phone number for the author of the Amazon QuickSight account to use
// for future communications. This field is required if ENTERPPRISE_AND_Q is the
// selected edition of the new Amazon QuickSight account.
ContactNumber *string
// The ID of the Active Directory that is associated with your Amazon QuickSight
// account.
DirectoryId *string
// The email address of the author of the Amazon QuickSight account to use for
// future communications. This field is required if ENTERPPRISE_AND_Q is the
// selected edition of the new Amazon QuickSight account.
EmailAddress *string
// The first name of the author of the Amazon QuickSight account to use for future
// communications. This field is required if ENTERPPRISE_AND_Q is the selected
// edition of the new Amazon QuickSight account.
FirstName *string
// The last name of the author of the Amazon QuickSight account to use for future
// communications. This field is required if ENTERPPRISE_AND_Q is the selected
// edition of the new Amazon QuickSight account.
LastName *string
// The reader group associated with your Active Direcrtory. For more information
// about using Active Directory in Amazon QuickSight, see Using Active Directory
// with Amazon QuickSight Enterprise Edition (https://docs.aws.amazon.com/quicksight/latest/user/aws-directory-service.html)
// in the Amazon QuickSight User Guide.
ReaderGroup []string
// The realm of the Active Directory that is associated with your Amazon
// QuickSight account. This field is required if ACTIVE_DIRECTORY is the selected
// authentication method of the new Amazon QuickSight account.
Realm *string
noSmithyDocumentSerde
}
type CreateAccountSubscriptionOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// A SignupResponse object that returns information about a newly created Amazon
// QuickSight account.
SignupResponse *types.SignupResponse
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAccountSubscriptionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateAccountSubscription{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateAccountSubscription{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateAccountSubscriptionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAccountSubscription(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateAccountSubscription(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateAccountSubscription",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an analysis in Amazon QuickSight. Analyses can be created either from a
// template or from an AnalysisDefinition .
func (c *Client) CreateAnalysis(ctx context.Context, params *CreateAnalysisInput, optFns ...func(*Options)) (*CreateAnalysisOutput, error) {
if params == nil {
params = &CreateAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAnalysis", params, optFns, c.addOperationCreateAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAnalysisInput struct {
// The ID for the analysis that you're creating. This ID displays in the URL of
// the analysis.
//
// This member is required.
AnalysisId *string
// The ID of the Amazon Web Services account where you are creating an analysis.
//
// This member is required.
AwsAccountId *string
// A descriptive name for the analysis that you're creating. This name displays
// for the analysis in the Amazon QuickSight console.
//
// This member is required.
Name *string
// The definition of an analysis. A definition is the data model of all features
// in a Dashboard, Template, or Analysis. Either a SourceEntity or a Definition
// must be provided in order for the request to be valid.
Definition *types.AnalysisDefinition
// The parameter names and override values that you want to use. An analysis can
// have any parameter type, and some parameters might accept multiple values.
Parameters *types.Parameters
// A structure that describes the principals and the resource-level permissions on
// an analysis. You can use the Permissions structure to grant permissions by
// providing a list of Identity and Access Management (IAM) action information for
// each principal listed by Amazon Resource Name (ARN). To specify no permissions,
// omit Permissions .
Permissions []types.ResourcePermission
// A source entity to use for the analysis that you're creating. This metadata
// structure contains details that describe a source template and one or more
// datasets. Either a SourceEntity or a Definition must be provided in order for
// the request to be valid.
SourceEntity *types.AnalysisSourceEntity
// Contains a map of the key-value pairs for the resource tag or tags assigned to
// the analysis.
Tags []types.Tag
// The ARN for the theme to apply to the analysis that you're creating. To see the
// theme in the Amazon QuickSight console, make sure that you have access to it.
ThemeArn *string
noSmithyDocumentSerde
}
type CreateAnalysisOutput struct {
// The ID of the analysis.
AnalysisId *string
// The ARN for the analysis.
Arn *string
// The status of the creation of the analysis.
CreationStatus types.ResourceStatus
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateAnalysis{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAnalysis(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateAnalysis",
}
}
| 180 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a dashboard from either a template or directly with a
// DashboardDefinition . To first create a template, see the CreateTemplate (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_CreateTemplate.html)
// API operation. A dashboard is an entity in Amazon QuickSight that identifies
// Amazon QuickSight reports, created from analyses. You can share Amazon
// QuickSight dashboards. With the right permissions, you can create scheduled
// email reports from them. If you have the correct permissions, you can create a
// dashboard from a template that exists in a different Amazon Web Services
// account.
func (c *Client) CreateDashboard(ctx context.Context, params *CreateDashboardInput, optFns ...func(*Options)) (*CreateDashboardOutput, error) {
if params == nil {
params = &CreateDashboardInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDashboard", params, optFns, c.addOperationCreateDashboardMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDashboardOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDashboardInput struct {
// The ID of the Amazon Web Services account where you want to create the
// dashboard.
//
// This member is required.
AwsAccountId *string
// The ID for the dashboard, also added to the IAM policy.
//
// This member is required.
DashboardId *string
// The display name of the dashboard.
//
// This member is required.
Name *string
// Options for publishing the dashboard when you create it:
// - AvailabilityStatus for AdHocFilteringOption - This status can be either
// ENABLED or DISABLED . When this is set to DISABLED , Amazon QuickSight
// disables the left filter pane on the published dashboard, which can be used for
// ad hoc (one-time) filtering. This option is ENABLED by default.
// - AvailabilityStatus for ExportToCSVOption - This status can be either ENABLED
// or DISABLED . The visual option to export data to .CSV format isn't enabled
// when this is set to DISABLED . This option is ENABLED by default.
// - VisibilityState for SheetControlsOption - This visibility state can be
// either COLLAPSED or EXPANDED . This option is COLLAPSED by default.
DashboardPublishOptions *types.DashboardPublishOptions
// The definition of a dashboard. A definition is the data model of all features
// in a Dashboard, Template, or Analysis. Either a SourceEntity or a Definition
// must be provided in order for the request to be valid.
Definition *types.DashboardVersionDefinition
// The parameters for the creation of the dashboard, which you want to use to
// override the default settings. A dashboard can have any type of parameters, and
// some parameters might accept multiple values.
Parameters *types.Parameters
// A structure that contains the permissions of the dashboard. You can use this
// structure for granting permissions by providing a list of IAM action information
// for each principal ARN. To specify no permissions, omit the permissions list.
Permissions []types.ResourcePermission
// The entity that you are using as a source when you create the dashboard. In
// SourceEntity , you specify the type of object you're using as source. You can
// only create a dashboard from a template, so you use a SourceTemplate entity. If
// you need to create a dashboard from an analysis, first convert the analysis to a
// template by using the CreateTemplate (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_CreateTemplate.html)
// API operation. For SourceTemplate , specify the Amazon Resource Name (ARN) of
// the source template. The SourceTemplate ARN can contain any Amazon Web Services
// account and any Amazon QuickSight-supported Amazon Web Services Region. Use the
// DataSetReferences entity within SourceTemplate to list the replacement datasets
// for the placeholders listed in the original. The schema in each dataset must
// match its placeholder. Either a SourceEntity or a Definition must be provided
// in order for the request to be valid.
SourceEntity *types.DashboardSourceEntity
// Contains a map of the key-value pairs for the resource tag or tags assigned to
// the dashboard.
Tags []types.Tag
// The Amazon Resource Name (ARN) of the theme that is being used for this
// dashboard. If you add a value for this field, it overrides the value that is
// used in the source entity. The theme ARN must exist in the same Amazon Web
// Services account where you create the dashboard.
ThemeArn *string
// A description for the first version of the dashboard being created.
VersionDescription *string
noSmithyDocumentSerde
}
type CreateDashboardOutput struct {
// The ARN of the dashboard.
Arn *string
// The status of the dashboard creation request.
CreationStatus types.ResourceStatus
// The ID for the dashboard.
DashboardId *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The ARN of the dashboard, including the version number of the first version
// that is created.
VersionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDashboardMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateDashboard{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateDashboard{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDashboardValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDashboard(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDashboard(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateDashboard",
}
}
| 213 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a dataset. This operation doesn't support datasets that include
// uploaded files as a source.
func (c *Client) CreateDataSet(ctx context.Context, params *CreateDataSetInput, optFns ...func(*Options)) (*CreateDataSetOutput, error) {
if params == nil {
params = &CreateDataSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDataSet", params, optFns, c.addOperationCreateDataSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDataSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDataSetInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// An ID for the dataset that you want to create. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
//
// This member is required.
DataSetId *string
// Indicates whether you want to import the data into SPICE.
//
// This member is required.
ImportMode types.DataSetImportMode
// The display name for the dataset.
//
// This member is required.
Name *string
// Declares the physical tables that are available in the underlying data sources.
//
// This member is required.
PhysicalTableMap map[string]types.PhysicalTable
// Groupings of columns that work together in certain Amazon QuickSight features.
// Currently, only geospatial hierarchy is supported.
ColumnGroups []types.ColumnGroup
// A set of one or more definitions of a ColumnLevelPermissionRule (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_ColumnLevelPermissionRule.html)
// .
ColumnLevelPermissionRules []types.ColumnLevelPermissionRule
// The usage configuration to apply to child datasets that reference this dataset
// as a source.
DataSetUsageConfiguration *types.DataSetUsageConfiguration
// The parameter declarations of the dataset.
DatasetParameters []types.DatasetParameter
// The folder that contains fields and nested subfolders for your dataset.
FieldFolders map[string]types.FieldFolder
// Configures the combination and transformation of the data from the physical
// tables.
LogicalTableMap map[string]types.LogicalTable
// A list of resource permissions on the dataset.
Permissions []types.ResourcePermission
// The row-level security configuration for the data that you want to create.
RowLevelPermissionDataSet *types.RowLevelPermissionDataSet
// The configuration of tags on a dataset to set row-level security. Row-level
// security tags are currently supported for anonymous embedding only.
RowLevelPermissionTagConfiguration *types.RowLevelPermissionTagConfiguration
// Contains a map of the key-value pairs for the resource tag or tags assigned to
// the dataset.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDataSetOutput struct {
// The Amazon Resource Name (ARN) of the dataset.
Arn *string
// The ID for the dataset that you want to create. This ID is unique per Amazon
// Web Services Region for each Amazon Web Services account.
DataSetId *string
// The ARN for the ingestion, which is triggered as a result of dataset creation
// if the import mode is SPICE.
IngestionArn *string
// The ID of the ingestion, which is triggered as a result of dataset creation if
// the import mode is SPICE.
IngestionId *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDataSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateDataSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateDataSet{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDataSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDataSet(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDataSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateDataSet",
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a data source.
func (c *Client) CreateDataSource(ctx context.Context, params *CreateDataSourceInput, optFns ...func(*Options)) (*CreateDataSourceOutput, error) {
if params == nil {
params = &CreateDataSourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDataSource", params, optFns, c.addOperationCreateDataSourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDataSourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDataSourceInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// An ID for the data source. This ID is unique per Amazon Web Services Region for
// each Amazon Web Services account.
//
// This member is required.
DataSourceId *string
// A display name for the data source.
//
// This member is required.
Name *string
// The type of the data source. To return a list of all data sources, use
// ListDataSources . Use AMAZON_ELASTICSEARCH for Amazon OpenSearch Service.
//
// This member is required.
Type types.DataSourceType
// The credentials Amazon QuickSight that uses to connect to your underlying
// source. Currently, only credentials based on user name and password are
// supported.
Credentials *types.DataSourceCredentials
// The parameters that Amazon QuickSight uses to connect to your underlying source.
DataSourceParameters types.DataSourceParameters
// A list of resource permissions on the data source.
Permissions []types.ResourcePermission
// Secure Socket Layer (SSL) properties that apply when Amazon QuickSight connects
// to your underlying source.
SslProperties *types.SslProperties
// Contains a map of the key-value pairs for the resource tag or tags assigned to
// the data source.
Tags []types.Tag
// Use this parameter only when you want Amazon QuickSight to use a VPC connection
// when connecting to your underlying source.
VpcConnectionProperties *types.VpcConnectionProperties
noSmithyDocumentSerde
}
type CreateDataSourceOutput struct {
// The Amazon Resource Name (ARN) of the data source.
Arn *string
// The status of creating the data source.
CreationStatus types.ResourceStatus
// The ID of the data source. This ID is unique per Amazon Web Services Region for
// each Amazon Web Services account.
DataSourceId *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDataSourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateDataSource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateDataSource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDataSourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDataSource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDataSource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateDataSource",
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an empty shared folder.
func (c *Client) CreateFolder(ctx context.Context, params *CreateFolderInput, optFns ...func(*Options)) (*CreateFolderOutput, error) {
if params == nil {
params = &CreateFolderInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFolder", params, optFns, c.addOperationCreateFolderMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFolderOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFolderInput struct {
// The ID for the Amazon Web Services account where you want to create the folder.
//
// This member is required.
AwsAccountId *string
// The ID of the folder.
//
// This member is required.
FolderId *string
// The type of folder. By default, folderType is SHARED .
FolderType types.FolderType
// The name of the folder.
Name *string
// The Amazon Resource Name (ARN) for the parent folder. ParentFolderArn can be
// null. An empty parentFolderArn creates a root-level folder.
ParentFolderArn *string
// A structure that describes the principals and the resource-level permissions of
// a folder. To specify no permissions, omit Permissions .
Permissions []types.ResourcePermission
// Tags for the folder.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateFolderOutput struct {
// The Amazon Resource Name (ARN) for the newly created folder.
Arn *string
// The folder ID for the newly created folder.
FolderId *string
// The request ID for the newly created folder.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateFolderMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateFolder{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateFolder{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateFolderValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateFolder(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateFolder(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateFolder",
}
}
| 156 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds an asset, such as a dashboard, analysis, or dataset into a folder.
func (c *Client) CreateFolderMembership(ctx context.Context, params *CreateFolderMembershipInput, optFns ...func(*Options)) (*CreateFolderMembershipOutput, error) {
if params == nil {
params = &CreateFolderMembershipInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFolderMembership", params, optFns, c.addOperationCreateFolderMembershipMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFolderMembershipOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFolderMembershipInput struct {
// The ID for the Amazon Web Services account that contains the folder.
//
// This member is required.
AwsAccountId *string
// The ID of the folder.
//
// This member is required.
FolderId *string
// The ID of the asset (the dashboard, analysis, or dataset).
//
// This member is required.
MemberId *string
// The type of the member, including DASHBOARD , ANALYSIS , and DATASET .
//
// This member is required.
MemberType types.MemberType
noSmithyDocumentSerde
}
type CreateFolderMembershipOutput struct {
// Information about the member in the folder.
FolderMember *types.FolderMember
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateFolderMembershipMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateFolderMembership{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateFolderMembership{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateFolderMembershipValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateFolderMembership(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateFolderMembership(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateFolderMembership",
}
}
| 146 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use the CreateGroup operation to create a group in Amazon QuickSight. You can
// create up to 10,000 groups in a namespace. If you want to create more than
// 10,000 groups in a namespace, contact AWS Support. The permissions resource is
// arn:aws:quicksight:::group/default/ . The response is a group object.
func (c *Client) CreateGroup(ctx context.Context, params *CreateGroupInput, optFns ...func(*Options)) (*CreateGroupOutput, error) {
if params == nil {
params = &CreateGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateGroup", params, optFns, c.addOperationCreateGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
// The request object for this operation.
type CreateGroupInput struct {
// The ID for the Amazon Web Services account that the group is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// A name for the group that you want to create.
//
// This member is required.
GroupName *string
// The namespace that you want the group to be a part of.
//
// This member is required.
Namespace *string
// A description for the group that you want to create.
Description *string
noSmithyDocumentSerde
}
// The response object for this operation.
type CreateGroupOutput struct {
// The name of the group.
Group *types.Group
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateGroup{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateGroup",
}
}
| 151 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds an Amazon QuickSight user to an Amazon QuickSight group.
func (c *Client) CreateGroupMembership(ctx context.Context, params *CreateGroupMembershipInput, optFns ...func(*Options)) (*CreateGroupMembershipOutput, error) {
if params == nil {
params = &CreateGroupMembershipInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateGroupMembership", params, optFns, c.addOperationCreateGroupMembershipMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateGroupMembershipOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateGroupMembershipInput struct {
// The ID for the Amazon Web Services account that the group is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The name of the group that you want to add the user to.
//
// This member is required.
GroupName *string
// The name of the user that you want to add to the group membership.
//
// This member is required.
MemberName *string
// The namespace that you want the user to be a part of.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type CreateGroupMembershipOutput struct {
// The group member.
GroupMember *types.GroupMember
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateGroupMembershipMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateGroupMembership{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateGroupMembership{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateGroupMembershipValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateGroupMembership(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateGroupMembership(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateGroupMembership",
}
}
| 148 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an assignment with one specified IAM policy, identified by its Amazon
// Resource Name (ARN). This policy assignment is attached to the specified groups
// or users of Amazon QuickSight. Assignment names are unique per Amazon Web
// Services account. To avoid overwriting rules in other namespaces, use assignment
// names that are unique.
func (c *Client) CreateIAMPolicyAssignment(ctx context.Context, params *CreateIAMPolicyAssignmentInput, optFns ...func(*Options)) (*CreateIAMPolicyAssignmentOutput, error) {
if params == nil {
params = &CreateIAMPolicyAssignmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateIAMPolicyAssignment", params, optFns, c.addOperationCreateIAMPolicyAssignmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateIAMPolicyAssignmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateIAMPolicyAssignmentInput struct {
// The name of the assignment, also called a rule. The name must be unique within
// the Amazon Web Services account.
//
// This member is required.
AssignmentName *string
// The status of the assignment. Possible values are as follows:
// - ENABLED - Anything specified in this assignment is used when creating the
// data source.
// - DISABLED - This assignment isn't used when creating the data source.
// - DRAFT - This assignment is an unfinished draft and isn't used when creating
// the data source.
//
// This member is required.
AssignmentStatus types.AssignmentStatus
// The ID of the Amazon Web Services account where you want to assign an IAM
// policy to Amazon QuickSight users or groups.
//
// This member is required.
AwsAccountId *string
// The namespace that contains the assignment.
//
// This member is required.
Namespace *string
// The Amazon QuickSight users, groups, or both that you want to assign the policy
// to.
Identities map[string][]string
// The ARN for the IAM policy to apply to the Amazon QuickSight users and groups
// specified in this assignment.
PolicyArn *string
noSmithyDocumentSerde
}
type CreateIAMPolicyAssignmentOutput struct {
// The ID for the assignment.
AssignmentId *string
// The name of the assignment. The name must be unique within the Amazon Web
// Services account.
AssignmentName *string
// The status of the assignment. Possible values are as follows:
// - ENABLED - Anything specified in this assignment is used when creating the
// data source.
// - DISABLED - This assignment isn't used when creating the data source.
// - DRAFT - This assignment is an unfinished draft and isn't used when creating
// the data source.
AssignmentStatus types.AssignmentStatus
// The Amazon QuickSight users, groups, or both that the IAM policy is assigned to.
Identities map[string][]string
// The ARN for the IAM policy that is applied to the Amazon QuickSight users and
// groups specified in this assignment.
PolicyArn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateIAMPolicyAssignmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateIAMPolicyAssignment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateIAMPolicyAssignment{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateIAMPolicyAssignmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateIAMPolicyAssignment(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateIAMPolicyAssignment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateIAMPolicyAssignment",
}
}
| 184 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates and starts a new SPICE ingestion for a dataset. You can manually
// refresh datasets in an Enterprise edition account 32 times in a 24-hour period.
// You can manually refresh datasets in a Standard edition account 8 times in a
// 24-hour period. Each 24-hour period is measured starting 24 hours before the
// current date and time. Any ingestions operating on tagged datasets inherit the
// same tags automatically for use in access control. For an example, see How do I
// create an IAM policy to control access to Amazon EC2 resources using tags? (http://aws.amazon.com/premiumsupport/knowledge-center/iam-ec2-resource-tags/)
// in the Amazon Web Services Knowledge Center. Tags are visible on the tagged
// dataset, but not on the ingestion resource.
func (c *Client) CreateIngestion(ctx context.Context, params *CreateIngestionInput, optFns ...func(*Options)) (*CreateIngestionOutput, error) {
if params == nil {
params = &CreateIngestionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateIngestion", params, optFns, c.addOperationCreateIngestionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateIngestionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateIngestionInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset used in the ingestion.
//
// This member is required.
DataSetId *string
// An ID for the ingestion.
//
// This member is required.
IngestionId *string
// The type of ingestion that you want to create.
IngestionType types.IngestionType
noSmithyDocumentSerde
}
type CreateIngestionOutput struct {
// The Amazon Resource Name (ARN) for the data ingestion.
Arn *string
// An ID for the ingestion.
IngestionId *string
// The ingestion status.
IngestionStatus types.IngestionStatus
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateIngestionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateIngestion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateIngestion{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateIngestionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateIngestion(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateIngestion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateIngestion",
}
}
| 158 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// (Enterprise edition only) Creates a new namespace for you to use with Amazon
// QuickSight. A namespace allows you to isolate the Amazon QuickSight users and
// groups that are registered for that namespace. Users that access the namespace
// can share assets only with other users or groups in the same namespace. They
// can't see users and groups in other namespaces. You can create a namespace after
// your Amazon Web Services account is subscribed to Amazon QuickSight. The
// namespace must be unique within the Amazon Web Services account. By default,
// there is a limit of 100 namespaces per Amazon Web Services account. To increase
// your limit, create a ticket with Amazon Web Services Support.
func (c *Client) CreateNamespace(ctx context.Context, params *CreateNamespaceInput, optFns ...func(*Options)) (*CreateNamespaceOutput, error) {
if params == nil {
params = &CreateNamespaceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateNamespace", params, optFns, c.addOperationCreateNamespaceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateNamespaceOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateNamespaceInput struct {
// The ID for the Amazon Web Services account that you want to create the Amazon
// QuickSight namespace in.
//
// This member is required.
AwsAccountId *string
// Specifies the type of your user identity directory. Currently, this supports
// users with an identity type of QUICKSIGHT .
//
// This member is required.
IdentityStore types.IdentityStore
// The name that you want to use to describe the new namespace.
//
// This member is required.
Namespace *string
// The tags that you want to associate with the namespace that you're creating.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateNamespaceOutput struct {
// The ARN of the Amazon QuickSight namespace you created.
Arn *string
// The Amazon Web Services Region; that you want to use for the free SPICE
// capacity for the new namespace. This is set to the region that you run
// CreateNamespace in.
CapacityRegion *string
// The status of the creation of the namespace. This is an asynchronous process. A
// status of CREATED means that your namespace is ready to use. If an error
// occurs, it indicates if the process is retryable or non-retryable . In the case
// of a non-retryable error, refer to the error message for follow-up tasks.
CreationStatus types.NamespaceStatus
// Specifies the type of your user identity directory. Currently, this supports
// users with an identity type of QUICKSIGHT .
IdentityStore types.IdentityStore
// The name of the new namespace that you created.
Name *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateNamespaceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateNamespace{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateNamespace{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateNamespaceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateNamespace(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateNamespace(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateNamespace",
}
}
| 172 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a refresh schedule for a dataset. You can create up to 5 different
// schedules for a single dataset.
func (c *Client) CreateRefreshSchedule(ctx context.Context, params *CreateRefreshScheduleInput, optFns ...func(*Options)) (*CreateRefreshScheduleOutput, error) {
if params == nil {
params = &CreateRefreshScheduleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateRefreshSchedule", params, optFns, c.addOperationCreateRefreshScheduleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateRefreshScheduleOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateRefreshScheduleInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset.
//
// This member is required.
DataSetId *string
// The refresh schedule.
//
// This member is required.
Schedule *types.RefreshSchedule
noSmithyDocumentSerde
}
type CreateRefreshScheduleOutput struct {
// The Amazon Resource Name (ARN) for the refresh schedule.
Arn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The ID of the refresh schedule.
ScheduleId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateRefreshScheduleMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateRefreshScheduleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateRefreshSchedule(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateRefreshSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateRefreshSchedule",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a template either from a TemplateDefinition or from an existing Amazon
// QuickSight analysis or template. You can use the resulting template to create
// additional dashboards, templates, or analyses. A template is an entity in Amazon
// QuickSight that encapsulates the metadata required to create an analysis and
// that you can use to create s dashboard. A template adds a layer of abstraction
// by using placeholders to replace the dataset associated with the analysis. You
// can use templates to create dashboards by replacing dataset placeholders with
// datasets that follow the same schema that was used to create the source analysis
// and template.
func (c *Client) CreateTemplate(ctx context.Context, params *CreateTemplateInput, optFns ...func(*Options)) (*CreateTemplateOutput, error) {
if params == nil {
params = &CreateTemplateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTemplate", params, optFns, c.addOperationCreateTemplateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateTemplateOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateTemplateInput struct {
// The ID for the Amazon Web Services account that the group is in. You use the ID
// for the Amazon Web Services account that contains your Amazon QuickSight
// account.
//
// This member is required.
AwsAccountId *string
// An ID for the template that you want to create. This template is unique per
// Amazon Web Services Region; in each Amazon Web Services account.
//
// This member is required.
TemplateId *string
// The definition of a template. A definition is the data model of all features in
// a Dashboard, Template, or Analysis. Either a SourceEntity or a Definition must
// be provided in order for the request to be valid.
Definition *types.TemplateVersionDefinition
// A display name for the template.
Name *string
// A list of resource permissions to be set on the template.
Permissions []types.ResourcePermission
// The entity that you are using as a source when you create the template. In
// SourceEntity , you specify the type of object you're using as source:
// SourceTemplate for a template or SourceAnalysis for an analysis. Both of these
// require an Amazon Resource Name (ARN). For SourceTemplate , specify the ARN of
// the source template. For SourceAnalysis , specify the ARN of the source
// analysis. The SourceTemplate ARN can contain any Amazon Web Services account
// and any Amazon QuickSight-supported Amazon Web Services Region. Use the
// DataSetReferences entity within SourceTemplate or SourceAnalysis to list the
// replacement datasets for the placeholders listed in the original. The schema in
// each dataset must match its placeholder. Either a SourceEntity or a Definition
// must be provided in order for the request to be valid.
SourceEntity *types.TemplateSourceEntity
// Contains a map of the key-value pairs for the resource tag or tags assigned to
// the resource.
Tags []types.Tag
// A description of the current template version being created. This API operation
// creates the first version of the template. Every time UpdateTemplate is called,
// a new version is created. Each version of the template maintains a description
// of the version in the VersionDescription field.
VersionDescription *string
noSmithyDocumentSerde
}
type CreateTemplateOutput struct {
// The ARN for the template.
Arn *string
// The template creation status.
CreationStatus types.ResourceStatus
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The ID of the template.
TemplateId *string
// The ARN for the template, including the version information of the first
// version.
VersionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateTemplateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateTemplate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateTemplate{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateTemplateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTemplate(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTemplate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateTemplate",
}
}
| 191 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a template alias for a template.
func (c *Client) CreateTemplateAlias(ctx context.Context, params *CreateTemplateAliasInput, optFns ...func(*Options)) (*CreateTemplateAliasOutput, error) {
if params == nil {
params = &CreateTemplateAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTemplateAlias", params, optFns, c.addOperationCreateTemplateAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateTemplateAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateTemplateAliasInput struct {
// The name that you want to give to the template alias that you're creating.
// Don't start the alias name with the $ character. Alias names that start with $
// are reserved by Amazon QuickSight.
//
// This member is required.
AliasName *string
// The ID of the Amazon Web Services account that contains the template that you
// creating an alias for.
//
// This member is required.
AwsAccountId *string
// An ID for the template.
//
// This member is required.
TemplateId *string
// The version number of the template.
//
// This member is required.
TemplateVersionNumber *int64
noSmithyDocumentSerde
}
type CreateTemplateAliasOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Information about the template alias.
TemplateAlias *types.TemplateAlias
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateTemplateAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateTemplateAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateTemplateAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateTemplateAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTemplateAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTemplateAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateTemplateAlias",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a theme. A theme is set of configuration options for color and layout.
// Themes apply to analyses and dashboards. For more information, see Using Themes
// in Amazon QuickSight (https://docs.aws.amazon.com/quicksight/latest/user/themes-in-quicksight.html)
// in the Amazon QuickSight User Guide.
func (c *Client) CreateTheme(ctx context.Context, params *CreateThemeInput, optFns ...func(*Options)) (*CreateThemeOutput, error) {
if params == nil {
params = &CreateThemeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTheme", params, optFns, c.addOperationCreateThemeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateThemeOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateThemeInput struct {
// The ID of the Amazon Web Services account where you want to store the new theme.
//
// This member is required.
AwsAccountId *string
// The ID of the theme that a custom theme will inherit from. All themes inherit
// from one of the starting themes defined by Amazon QuickSight. For a list of the
// starting themes, use ListThemes or choose Themes from within an analysis.
//
// This member is required.
BaseThemeId *string
// The theme configuration, which contains the theme display properties.
//
// This member is required.
Configuration *types.ThemeConfiguration
// A display name for the theme.
//
// This member is required.
Name *string
// An ID for the theme that you want to create. The theme ID is unique per Amazon
// Web Services Region in each Amazon Web Services account.
//
// This member is required.
ThemeId *string
// A valid grouping of resource permissions to apply to the new theme.
Permissions []types.ResourcePermission
// A map of the key-value pairs for the resource tag or tags that you want to add
// to the resource.
Tags []types.Tag
// A description of the first version of the theme that you're creating. Every
// time UpdateTheme is called, a new version is created. Each version of the theme
// has a description of the version in the VersionDescription field.
VersionDescription *string
noSmithyDocumentSerde
}
type CreateThemeOutput struct {
// The Amazon Resource Name (ARN) for the theme.
Arn *string
// The theme creation status.
CreationStatus types.ResourceStatus
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The ID of the theme.
ThemeId *string
// The Amazon Resource Name (ARN) for the new theme.
VersionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateThemeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateTheme{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateTheme{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateThemeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTheme(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTheme(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateTheme",
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a theme alias for a theme.
func (c *Client) CreateThemeAlias(ctx context.Context, params *CreateThemeAliasInput, optFns ...func(*Options)) (*CreateThemeAliasOutput, error) {
if params == nil {
params = &CreateThemeAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateThemeAlias", params, optFns, c.addOperationCreateThemeAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateThemeAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateThemeAliasInput struct {
// The name that you want to give to the theme alias that you are creating. The
// alias name can't begin with a $ . Alias names that start with $ are reserved by
// Amazon QuickSight.
//
// This member is required.
AliasName *string
// The ID of the Amazon Web Services account that contains the theme for the new
// theme alias.
//
// This member is required.
AwsAccountId *string
// An ID for the theme alias.
//
// This member is required.
ThemeId *string
// The version number of the theme.
//
// This member is required.
ThemeVersionNumber *int64
noSmithyDocumentSerde
}
type CreateThemeAliasOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Information about the theme alias.
ThemeAlias *types.ThemeAlias
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateThemeAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateThemeAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateThemeAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateThemeAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateThemeAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateThemeAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateThemeAlias",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new Q topic.
func (c *Client) CreateTopic(ctx context.Context, params *CreateTopicInput, optFns ...func(*Options)) (*CreateTopicOutput, error) {
if params == nil {
params = &CreateTopicInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTopic", params, optFns, c.addOperationCreateTopicMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateTopicOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateTopicInput struct {
// The ID of the Amazon Web Services account that you want to create a topic in.
//
// This member is required.
AwsAccountId *string
// The definition of a topic to create.
//
// This member is required.
Topic *types.TopicDetails
// The ID for the topic that you want to create. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
//
// This member is required.
TopicId *string
// Contains a map of the key-value pairs for the resource tag or tags that are
// assigned to the dataset.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateTopicOutput struct {
// The Amazon Resource Name (ARN) of the topic.
Arn *string
// The Amazon Resource Name (ARN) of the topic refresh.
RefreshArn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The ID for the topic that you want to create. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
TopicId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateTopicMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateTopic{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateTopic{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateTopicValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTopic(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTopic(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateTopic",
}
}
| 153 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a topic refresh schedule.
func (c *Client) CreateTopicRefreshSchedule(ctx context.Context, params *CreateTopicRefreshScheduleInput, optFns ...func(*Options)) (*CreateTopicRefreshScheduleOutput, error) {
if params == nil {
params = &CreateTopicRefreshScheduleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTopicRefreshSchedule", params, optFns, c.addOperationCreateTopicRefreshScheduleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateTopicRefreshScheduleOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateTopicRefreshScheduleInput struct {
// The ID of the Amazon Web Services account that contains the topic you're
// creating a refresh schedule for.
//
// This member is required.
AwsAccountId *string
// The Amazon Resource Name (ARN) of the dataset.
//
// This member is required.
DatasetArn *string
// The definition of a refresh schedule.
//
// This member is required.
RefreshSchedule *types.TopicRefreshSchedule
// The ID of the topic that you want to modify. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
//
// This member is required.
TopicId *string
// The name of the dataset.
DatasetName *string
noSmithyDocumentSerde
}
type CreateTopicRefreshScheduleOutput struct {
// The Amazon Resource Name (ARN) of the dataset.
DatasetArn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The Amazon Resource Name (ARN) of the topic.
TopicArn *string
// The ID of the topic that you want to modify. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
TopicId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateTopicRefreshScheduleMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateTopicRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateTopicRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateTopicRefreshScheduleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTopicRefreshSchedule(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTopicRefreshSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateTopicRefreshSchedule",
}
}
| 158 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new VPC connection.
func (c *Client) CreateVPCConnection(ctx context.Context, params *CreateVPCConnectionInput, optFns ...func(*Options)) (*CreateVPCConnectionOutput, error) {
if params == nil {
params = &CreateVPCConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateVPCConnection", params, optFns, c.addOperationCreateVPCConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateVPCConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateVPCConnectionInput struct {
// The Amazon Web Services account ID of the account where you want to create a
// new VPC connection.
//
// This member is required.
AwsAccountId *string
// The display name for the VPC connection.
//
// This member is required.
Name *string
// The IAM role to associate with the VPC connection.
//
// This member is required.
RoleArn *string
// A list of security group IDs for the VPC connection.
//
// This member is required.
SecurityGroupIds []string
// A list of subnet IDs for the VPC connection.
//
// This member is required.
SubnetIds []string
// The ID of the VPC connection that you're creating. This ID is a unique
// identifier for each Amazon Web Services Region in an Amazon Web Services
// account.
//
// This member is required.
VPCConnectionId *string
// A list of IP addresses of DNS resolver endpoints for the VPC connection.
DnsResolvers []string
// A map of the key-value pairs for the resource tag or tags assigned to the VPC
// connection.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateVPCConnectionOutput struct {
// The Amazon Resource Name (ARN) of the VPC connection.
Arn *string
// The availability status of the VPC connection.
AvailabilityStatus types.VPCConnectionAvailabilityStatus
// The status of the creation of the VPC connection.
CreationStatus types.VPCConnectionResourceStatus
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The ID for the VPC connection that you're creating. This ID is unique per
// Amazon Web Services Region for each Amazon Web Services account.
VPCConnectionId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateVPCConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateVPCConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateVPCConnection{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateVPCConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateVPCConnection(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateVPCConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "CreateVPCConnection",
}
}
| 176 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes all Amazon QuickSight customizations in this Amazon Web Services Region
// for the specified Amazon Web Services account and Amazon QuickSight namespace.
func (c *Client) DeleteAccountCustomization(ctx context.Context, params *DeleteAccountCustomizationInput, optFns ...func(*Options)) (*DeleteAccountCustomizationOutput, error) {
if params == nil {
params = &DeleteAccountCustomizationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAccountCustomization", params, optFns, c.addOperationDeleteAccountCustomizationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAccountCustomizationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAccountCustomizationInput struct {
// The ID for the Amazon Web Services account that you want to delete Amazon
// QuickSight customizations from in this Amazon Web Services Region.
//
// This member is required.
AwsAccountId *string
// The Amazon QuickSight namespace that you're deleting the customizations from.
Namespace *string
noSmithyDocumentSerde
}
type DeleteAccountCustomizationOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAccountCustomizationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteAccountCustomization{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteAccountCustomization{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteAccountCustomizationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAccountCustomization(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAccountCustomization(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteAccountCustomization",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use the DeleteAccountSubscription operation to delete an Amazon QuickSight
// account. This operation will result in an error message if you have configured
// your account termination protection settings to True . To change this setting
// and delete your account, call the UpdateAccountSettings API and set the value
// of the TerminationProtectionEnabled parameter to False , then make another call
// to the DeleteAccountSubscription API.
func (c *Client) DeleteAccountSubscription(ctx context.Context, params *DeleteAccountSubscriptionInput, optFns ...func(*Options)) (*DeleteAccountSubscriptionOutput, error) {
if params == nil {
params = &DeleteAccountSubscriptionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAccountSubscription", params, optFns, c.addOperationDeleteAccountSubscriptionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAccountSubscriptionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAccountSubscriptionInput struct {
// The Amazon Web Services account ID of the account that you want to delete.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DeleteAccountSubscriptionOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAccountSubscriptionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteAccountSubscription{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteAccountSubscription{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteAccountSubscriptionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAccountSubscription(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAccountSubscription(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteAccountSubscription",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Deletes an analysis from Amazon QuickSight. You can optionally include a
// recovery window during which you can restore the analysis. If you don't specify
// a recovery window value, the operation defaults to 30 days. Amazon QuickSight
// attaches a DeletionTime stamp to the response that specifies the end of the
// recovery window. At the end of the recovery window, Amazon QuickSight deletes
// the analysis permanently. At any time before recovery window ends, you can use
// the RestoreAnalysis API operation to remove the DeletionTime stamp and cancel
// the deletion of the analysis. The analysis remains visible in the API until it's
// deleted, so you can describe it but you can't make a template from it. An
// analysis that's scheduled for deletion isn't accessible in the Amazon QuickSight
// console. To access it in the console, restore it. Deleting an analysis doesn't
// delete the dashboards that you publish from it.
func (c *Client) DeleteAnalysis(ctx context.Context, params *DeleteAnalysisInput, optFns ...func(*Options)) (*DeleteAnalysisOutput, error) {
if params == nil {
params = &DeleteAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAnalysis", params, optFns, c.addOperationDeleteAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAnalysisInput struct {
// The ID of the analysis that you're deleting.
//
// This member is required.
AnalysisId *string
// The ID of the Amazon Web Services account where you want to delete an analysis.
//
// This member is required.
AwsAccountId *string
// This option defaults to the value NoForceDeleteWithoutRecovery . To immediately
// delete the analysis, add the ForceDeleteWithoutRecovery option. You can't
// restore an analysis after it's deleted.
ForceDeleteWithoutRecovery bool
// A value that specifies the number of days that Amazon QuickSight waits before
// it deletes the analysis. You can't use this parameter with the
// ForceDeleteWithoutRecovery option in the same API call. The default value is 30.
RecoveryWindowInDays *int64
noSmithyDocumentSerde
}
type DeleteAnalysisOutput struct {
// The ID of the deleted analysis.
AnalysisId *string
// The Amazon Resource Name (ARN) of the deleted analysis.
Arn *string
// The date and time that the analysis is scheduled to be deleted.
DeletionTime *time.Time
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteAnalysis{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAnalysis(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteAnalysis",
}
}
| 163 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a dashboard.
func (c *Client) DeleteDashboard(ctx context.Context, params *DeleteDashboardInput, optFns ...func(*Options)) (*DeleteDashboardOutput, error) {
if params == nil {
params = &DeleteDashboardInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDashboard", params, optFns, c.addOperationDeleteDashboardMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDashboardOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDashboardInput struct {
// The ID of the Amazon Web Services account that contains the dashboard that
// you're deleting.
//
// This member is required.
AwsAccountId *string
// The ID for the dashboard.
//
// This member is required.
DashboardId *string
// The version number of the dashboard. If the version number property is
// provided, only the specified version of the dashboard is deleted.
VersionNumber *int64
noSmithyDocumentSerde
}
type DeleteDashboardOutput struct {
// The Secure Socket Layer (SSL) properties that apply for the resource.
Arn *string
// The ID of the dashboard.
DashboardId *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDashboardMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteDashboard{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteDashboard{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDashboardValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDashboard(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDashboard(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteDashboard",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a dataset.
func (c *Client) DeleteDataSet(ctx context.Context, params *DeleteDataSetInput, optFns ...func(*Options)) (*DeleteDataSetOutput, error) {
if params == nil {
params = &DeleteDataSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDataSet", params, optFns, c.addOperationDeleteDataSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDataSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDataSetInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID for the dataset that you want to create. This ID is unique per Amazon
// Web Services Region for each Amazon Web Services account.
//
// This member is required.
DataSetId *string
noSmithyDocumentSerde
}
type DeleteDataSetOutput struct {
// The Amazon Resource Name (ARN) of the dataset.
Arn *string
// The ID for the dataset that you want to create. This ID is unique per Amazon
// Web Services Region for each Amazon Web Services account.
DataSetId *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDataSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteDataSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteDataSet{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDataSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDataSet(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDataSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteDataSet",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the dataset refresh properties of the dataset.
func (c *Client) DeleteDataSetRefreshProperties(ctx context.Context, params *DeleteDataSetRefreshPropertiesInput, optFns ...func(*Options)) (*DeleteDataSetRefreshPropertiesOutput, error) {
if params == nil {
params = &DeleteDataSetRefreshPropertiesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDataSetRefreshProperties", params, optFns, c.addOperationDeleteDataSetRefreshPropertiesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDataSetRefreshPropertiesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDataSetRefreshPropertiesInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset.
//
// This member is required.
DataSetId *string
noSmithyDocumentSerde
}
type DeleteDataSetRefreshPropertiesOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDataSetRefreshPropertiesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteDataSetRefreshProperties{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteDataSetRefreshProperties{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDataSetRefreshPropertiesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDataSetRefreshProperties(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDataSetRefreshProperties(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteDataSetRefreshProperties",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the data source permanently. This operation breaks all the datasets
// that reference the deleted data source.
func (c *Client) DeleteDataSource(ctx context.Context, params *DeleteDataSourceInput, optFns ...func(*Options)) (*DeleteDataSourceOutput, error) {
if params == nil {
params = &DeleteDataSourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDataSource", params, optFns, c.addOperationDeleteDataSourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDataSourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDataSourceInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the data source. This ID is unique per Amazon Web Services Region for
// each Amazon Web Services account.
//
// This member is required.
DataSourceId *string
noSmithyDocumentSerde
}
type DeleteDataSourceOutput struct {
// The Amazon Resource Name (ARN) of the data source that you deleted.
Arn *string
// The ID of the data source. This ID is unique per Amazon Web Services Region for
// each Amazon Web Services account.
DataSourceId *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDataSourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteDataSource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteDataSource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDataSourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDataSource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDataSource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteDataSource",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an empty folder.
func (c *Client) DeleteFolder(ctx context.Context, params *DeleteFolderInput, optFns ...func(*Options)) (*DeleteFolderOutput, error) {
if params == nil {
params = &DeleteFolderInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFolder", params, optFns, c.addOperationDeleteFolderMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFolderOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFolderInput struct {
// The ID for the Amazon Web Services account that contains the folder.
//
// This member is required.
AwsAccountId *string
// The ID of the folder.
//
// This member is required.
FolderId *string
noSmithyDocumentSerde
}
type DeleteFolderOutput struct {
// The Amazon Resource Name of the deleted folder.
Arn *string
// The ID of the folder.
FolderId *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFolderMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteFolder{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteFolder{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFolderValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFolder(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFolder(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteFolder",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes an asset, such as a dashboard, analysis, or dataset, from a folder.
func (c *Client) DeleteFolderMembership(ctx context.Context, params *DeleteFolderMembershipInput, optFns ...func(*Options)) (*DeleteFolderMembershipOutput, error) {
if params == nil {
params = &DeleteFolderMembershipInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFolderMembership", params, optFns, c.addOperationDeleteFolderMembershipMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFolderMembershipOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFolderMembershipInput struct {
// The ID for the Amazon Web Services account that contains the folder.
//
// This member is required.
AwsAccountId *string
// The Folder ID.
//
// This member is required.
FolderId *string
// The ID of the asset (the dashboard, analysis, or dataset) that you want to
// delete.
//
// This member is required.
MemberId *string
// The type of the member, including DASHBOARD , ANALYSIS , and DATASET
//
// This member is required.
MemberType types.MemberType
noSmithyDocumentSerde
}
type DeleteFolderMembershipOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFolderMembershipMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteFolderMembership{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteFolderMembership{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFolderMembershipValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFolderMembership(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFolderMembership(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteFolderMembership",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes a user group from Amazon QuickSight.
func (c *Client) DeleteGroup(ctx context.Context, params *DeleteGroupInput, optFns ...func(*Options)) (*DeleteGroupOutput, error) {
if params == nil {
params = &DeleteGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteGroup", params, optFns, c.addOperationDeleteGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteGroupInput struct {
// The ID for the Amazon Web Services account that the group is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The name of the group that you want to delete.
//
// This member is required.
GroupName *string
// The namespace of the group that you want to delete.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type DeleteGroupOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteGroup{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteGroup",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes a user from a group so that the user is no longer a member of the group.
func (c *Client) DeleteGroupMembership(ctx context.Context, params *DeleteGroupMembershipInput, optFns ...func(*Options)) (*DeleteGroupMembershipOutput, error) {
if params == nil {
params = &DeleteGroupMembershipInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteGroupMembership", params, optFns, c.addOperationDeleteGroupMembershipMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteGroupMembershipOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteGroupMembershipInput struct {
// The ID for the Amazon Web Services account that the group is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The name of the group that you want to delete the user from.
//
// This member is required.
GroupName *string
// The name of the user that you want to delete from the group membership.
//
// This member is required.
MemberName *string
// The namespace of the group that you want to remove a user from.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type DeleteGroupMembershipOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteGroupMembershipMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteGroupMembership{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteGroupMembership{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteGroupMembershipValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteGroupMembership(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteGroupMembership(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteGroupMembership",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing IAM policy assignment.
func (c *Client) DeleteIAMPolicyAssignment(ctx context.Context, params *DeleteIAMPolicyAssignmentInput, optFns ...func(*Options)) (*DeleteIAMPolicyAssignmentOutput, error) {
if params == nil {
params = &DeleteIAMPolicyAssignmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteIAMPolicyAssignment", params, optFns, c.addOperationDeleteIAMPolicyAssignmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteIAMPolicyAssignmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteIAMPolicyAssignmentInput struct {
// The name of the assignment.
//
// This member is required.
AssignmentName *string
// The Amazon Web Services account ID where you want to delete the IAM policy
// assignment.
//
// This member is required.
AwsAccountId *string
// The namespace that contains the assignment.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type DeleteIAMPolicyAssignmentOutput struct {
// The name of the assignment.
AssignmentName *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteIAMPolicyAssignmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteIAMPolicyAssignment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteIAMPolicyAssignment{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteIAMPolicyAssignmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteIAMPolicyAssignment(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteIAMPolicyAssignment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteIAMPolicyAssignment",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a namespace and the users and groups that are associated with the
// namespace. This is an asynchronous process. Assets including dashboards,
// analyses, datasets and data sources are not deleted. To delete these assets, you
// use the API operations for the relevant asset.
func (c *Client) DeleteNamespace(ctx context.Context, params *DeleteNamespaceInput, optFns ...func(*Options)) (*DeleteNamespaceOutput, error) {
if params == nil {
params = &DeleteNamespaceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteNamespace", params, optFns, c.addOperationDeleteNamespaceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteNamespaceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteNamespaceInput struct {
// The ID for the Amazon Web Services account that you want to delete the Amazon
// QuickSight namespace from.
//
// This member is required.
AwsAccountId *string
// The namespace that you want to delete.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type DeleteNamespaceOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteNamespaceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteNamespace{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteNamespace{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteNamespaceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteNamespace(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteNamespace(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteNamespace",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a refresh schedule from a dataset.
func (c *Client) DeleteRefreshSchedule(ctx context.Context, params *DeleteRefreshScheduleInput, optFns ...func(*Options)) (*DeleteRefreshScheduleOutput, error) {
if params == nil {
params = &DeleteRefreshScheduleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteRefreshSchedule", params, optFns, c.addOperationDeleteRefreshScheduleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteRefreshScheduleOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteRefreshScheduleInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset.
//
// This member is required.
DataSetId *string
// The ID of the refresh schedule.
//
// This member is required.
ScheduleId *string
noSmithyDocumentSerde
}
type DeleteRefreshScheduleOutput struct {
// The Amazon Resource Name (ARN) for the refresh schedule.
Arn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The ID of the refresh schedule.
ScheduleId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteRefreshScheduleMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteRefreshScheduleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteRefreshSchedule(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteRefreshSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteRefreshSchedule",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a template.
func (c *Client) DeleteTemplate(ctx context.Context, params *DeleteTemplateInput, optFns ...func(*Options)) (*DeleteTemplateOutput, error) {
if params == nil {
params = &DeleteTemplateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteTemplate", params, optFns, c.addOperationDeleteTemplateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteTemplateOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteTemplateInput struct {
// The ID of the Amazon Web Services account that contains the template that
// you're deleting.
//
// This member is required.
AwsAccountId *string
// An ID for the template you want to delete.
//
// This member is required.
TemplateId *string
// Specifies the version of the template that you want to delete. If you don't
// provide a version number, DeleteTemplate deletes all versions of the template.
VersionNumber *int64
noSmithyDocumentSerde
}
type DeleteTemplateOutput struct {
// The Amazon Resource Name (ARN) of the resource.
Arn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// An ID for the template.
TemplateId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteTemplateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteTemplate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteTemplate{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteTemplateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteTemplate(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTemplate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteTemplate",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the item that the specified template alias points to. If you provide a
// specific alias, you delete the version of the template that the alias points to.
func (c *Client) DeleteTemplateAlias(ctx context.Context, params *DeleteTemplateAliasInput, optFns ...func(*Options)) (*DeleteTemplateAliasOutput, error) {
if params == nil {
params = &DeleteTemplateAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteTemplateAlias", params, optFns, c.addOperationDeleteTemplateAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteTemplateAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteTemplateAliasInput struct {
// The name for the template alias. To delete a specific alias, you delete the
// version that the alias points to. You can specify the alias name, or specify the
// latest version of the template by providing the keyword $LATEST in the AliasName
// parameter.
//
// This member is required.
AliasName *string
// The ID of the Amazon Web Services account that contains the item to delete.
//
// This member is required.
AwsAccountId *string
// The ID for the template that the specified alias is for.
//
// This member is required.
TemplateId *string
noSmithyDocumentSerde
}
type DeleteTemplateAliasOutput struct {
// The name for the template alias.
AliasName *string
// The Amazon Resource Name (ARN) of the template you want to delete.
Arn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// An ID for the template associated with the deletion.
TemplateId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteTemplateAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteTemplateAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteTemplateAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteTemplateAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteTemplateAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTemplateAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteTemplateAlias",
}
}
| 150 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a theme.
func (c *Client) DeleteTheme(ctx context.Context, params *DeleteThemeInput, optFns ...func(*Options)) (*DeleteThemeOutput, error) {
if params == nil {
params = &DeleteThemeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteTheme", params, optFns, c.addOperationDeleteThemeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteThemeOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteThemeInput struct {
// The ID of the Amazon Web Services account that contains the theme that you're
// deleting.
//
// This member is required.
AwsAccountId *string
// An ID for the theme that you want to delete.
//
// This member is required.
ThemeId *string
// The version of the theme that you want to delete. Note: If you don't provide a
// version number, you're using this call to DeleteTheme to delete all versions of
// the theme.
VersionNumber *int64
noSmithyDocumentSerde
}
type DeleteThemeOutput struct {
// The Amazon Resource Name (ARN) of the resource.
Arn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// An ID for the theme.
ThemeId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteThemeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteTheme{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteTheme{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteThemeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteTheme(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTheme(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteTheme",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the version of the theme that the specified theme alias points to. If
// you provide a specific alias, you delete the version of the theme that the alias
// points to.
func (c *Client) DeleteThemeAlias(ctx context.Context, params *DeleteThemeAliasInput, optFns ...func(*Options)) (*DeleteThemeAliasOutput, error) {
if params == nil {
params = &DeleteThemeAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteThemeAlias", params, optFns, c.addOperationDeleteThemeAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteThemeAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteThemeAliasInput struct {
// The unique name for the theme alias to delete.
//
// This member is required.
AliasName *string
// The ID of the Amazon Web Services account that contains the theme alias to
// delete.
//
// This member is required.
AwsAccountId *string
// The ID for the theme that the specified alias is for.
//
// This member is required.
ThemeId *string
noSmithyDocumentSerde
}
type DeleteThemeAliasOutput struct {
// The name for the theme alias.
AliasName *string
// The Amazon Resource Name (ARN) of the theme resource using the deleted alias.
Arn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// An ID for the theme associated with the deletion.
ThemeId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteThemeAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteThemeAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteThemeAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteThemeAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteThemeAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteThemeAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteThemeAlias",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a topic.
func (c *Client) DeleteTopic(ctx context.Context, params *DeleteTopicInput, optFns ...func(*Options)) (*DeleteTopicOutput, error) {
if params == nil {
params = &DeleteTopicInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteTopic", params, optFns, c.addOperationDeleteTopicMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteTopicOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteTopicInput struct {
// The ID of the Amazon Web Services account that contains the topic that you want
// to delete.
//
// This member is required.
AwsAccountId *string
// The ID of the topic that you want to delete. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
//
// This member is required.
TopicId *string
noSmithyDocumentSerde
}
type DeleteTopicOutput struct {
// The Amazon Resource Name (ARN) of the topic.
Arn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The ID of the topic that you want to delete. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
TopicId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteTopicMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteTopic{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteTopic{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteTopicValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteTopic(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTopic(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteTopic",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a topic refresh schedule.
func (c *Client) DeleteTopicRefreshSchedule(ctx context.Context, params *DeleteTopicRefreshScheduleInput, optFns ...func(*Options)) (*DeleteTopicRefreshScheduleOutput, error) {
if params == nil {
params = &DeleteTopicRefreshScheduleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteTopicRefreshSchedule", params, optFns, c.addOperationDeleteTopicRefreshScheduleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteTopicRefreshScheduleOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteTopicRefreshScheduleInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset.
//
// This member is required.
DatasetId *string
// The ID of the topic that you want to modify. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
//
// This member is required.
TopicId *string
noSmithyDocumentSerde
}
type DeleteTopicRefreshScheduleOutput struct {
// The Amazon Resource Name (ARN) of the dataset.
DatasetArn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The Amazon Resource Name (ARN) of the topic.
TopicArn *string
// The ID of the topic that you want to modify. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
TopicId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteTopicRefreshScheduleMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteTopicRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteTopicRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteTopicRefreshScheduleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteTopicRefreshSchedule(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTopicRefreshSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteTopicRefreshSchedule",
}
}
| 148 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the Amazon QuickSight user that is associated with the identity of the
// IAM user or role that's making the call. The IAM user isn't deleted as a result
// of this call.
func (c *Client) DeleteUser(ctx context.Context, params *DeleteUserInput, optFns ...func(*Options)) (*DeleteUserOutput, error) {
if params == nil {
params = &DeleteUserInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteUser", params, optFns, c.addOperationDeleteUserMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteUserOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteUserInput struct {
// The ID for the Amazon Web Services account that the user is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The namespace. Currently, you should set this to default .
//
// This member is required.
Namespace *string
// The name of the user that you want to delete.
//
// This member is required.
UserName *string
noSmithyDocumentSerde
}
type DeleteUserOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteUserMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteUser{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteUser{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteUserValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteUser(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteUser(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteUser",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a user identified by its principal ID.
func (c *Client) DeleteUserByPrincipalId(ctx context.Context, params *DeleteUserByPrincipalIdInput, optFns ...func(*Options)) (*DeleteUserByPrincipalIdOutput, error) {
if params == nil {
params = &DeleteUserByPrincipalIdInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteUserByPrincipalId", params, optFns, c.addOperationDeleteUserByPrincipalIdMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteUserByPrincipalIdOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteUserByPrincipalIdInput struct {
// The ID for the Amazon Web Services account that the user is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The namespace. Currently, you should set this to default .
//
// This member is required.
Namespace *string
// The principal ID of the user.
//
// This member is required.
PrincipalId *string
noSmithyDocumentSerde
}
type DeleteUserByPrincipalIdOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteUserByPrincipalIdMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteUserByPrincipalId{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteUserByPrincipalId{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteUserByPrincipalIdValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteUserByPrincipalId(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteUserByPrincipalId(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteUserByPrincipalId",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a VPC connection.
func (c *Client) DeleteVPCConnection(ctx context.Context, params *DeleteVPCConnectionInput, optFns ...func(*Options)) (*DeleteVPCConnectionOutput, error) {
if params == nil {
params = &DeleteVPCConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteVPCConnection", params, optFns, c.addOperationDeleteVPCConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteVPCConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteVPCConnectionInput struct {
// The Amazon Web Services account ID of the account where you want to delete a
// VPC connection.
//
// This member is required.
AwsAccountId *string
// The ID of the VPC connection that you're creating. This ID is a unique
// identifier for each Amazon Web Services Region in an Amazon Web Services
// account.
//
// This member is required.
VPCConnectionId *string
noSmithyDocumentSerde
}
type DeleteVPCConnectionOutput struct {
// The Amazon Resource Name (ARN) of the deleted VPC connection.
Arn *string
// The availability status of the VPC connection.
AvailabilityStatus types.VPCConnectionAvailabilityStatus
// The deletion status of the VPC connection.
DeletionStatus types.VPCConnectionResourceStatus
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The ID of the VPC connection that you're creating. This ID is a unique
// identifier for each Amazon Web Services Region in an Amazon Web Services
// account.
VPCConnectionId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteVPCConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteVPCConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteVPCConnection{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteVPCConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteVPCConnection(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteVPCConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DeleteVPCConnection",
}
}
| 150 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the customizations associated with the provided Amazon Web Services
// account and Amazon Amazon QuickSight namespace in an Amazon Web Services Region.
// The Amazon QuickSight console evaluates which customizations to apply by running
// this API operation with the Resolved flag included. To determine what
// customizations display when you run this command, it can help to visualize the
// relationship of the entities involved.
// - Amazon Web Services account - The Amazon Web Services account exists at the
// top of the hierarchy. It has the potential to use all of the Amazon Web Services
// Regions and Amazon Web Services Services. When you subscribe to Amazon
// QuickSight, you choose one Amazon Web Services Region to use as your home
// Region. That's where your free SPICE capacity is located. You can use Amazon
// QuickSight in any supported Amazon Web Services Region.
// - Amazon Web Services Region - In each Amazon Web Services Region where you
// sign in to Amazon QuickSight at least once, Amazon QuickSight acts as a separate
// instance of the same service. If you have a user directory, it resides in
// us-east-1, which is the US East (N. Virginia). Generally speaking, these users
// have access to Amazon QuickSight in any Amazon Web Services Region, unless they
// are constrained to a namespace. To run the command in a different Amazon Web
// Services Region, you change your Region settings. If you're using the CLI, you
// can use one of the following options:
// - Use command line options (https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html)
// .
// - Use named profiles (https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html)
// .
// - Run aws configure to change your default Amazon Web Services Region. Use
// Enter to key the same settings for your keys. For more information, see
// Configuring the CLI (https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
// .
// - Namespace - A QuickSight namespace is a partition that contains users and
// assets (data sources, datasets, dashboards, and so on). To access assets that
// are in a specific namespace, users and groups must also be part of the same
// namespace. People who share a namespace are completely isolated from users and
// assets in other namespaces, even if they are in the same Amazon Web Services
// account and Amazon Web Services Region.
// - Applied customizations - Within an Amazon Web Services Region, a set of
// Amazon QuickSight customizations can apply to an Amazon Web Services account or
// to a namespace. Settings that you apply to a namespace override settings that
// you apply to an Amazon Web Services account. All settings are isolated to a
// single Amazon Web Services Region. To apply them in other Amazon Web Services
// Regions, run the CreateAccountCustomization command in each Amazon Web
// Services Region where you want to apply the same customizations.
func (c *Client) DescribeAccountCustomization(ctx context.Context, params *DescribeAccountCustomizationInput, optFns ...func(*Options)) (*DescribeAccountCustomizationOutput, error) {
if params == nil {
params = &DescribeAccountCustomizationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAccountCustomization", params, optFns, c.addOperationDescribeAccountCustomizationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAccountCustomizationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAccountCustomizationInput struct {
// The ID for the Amazon Web Services account that you want to describe Amazon
// QuickSight customizations for.
//
// This member is required.
AwsAccountId *string
// The Amazon QuickSight namespace that you want to describe Amazon QuickSight
// customizations for.
Namespace *string
// The Resolved flag works with the other parameters to determine which view of
// Amazon QuickSight customizations is returned. You can add this flag to your
// command to use the same view that Amazon QuickSight uses to identify which
// customizations to apply to the console. Omit this flag, or set it to no-resolved
// , to reveal customizations that are configured at different levels.
Resolved bool
noSmithyDocumentSerde
}
type DescribeAccountCustomizationOutput struct {
// The Amazon QuickSight customizations that exist in the current Amazon Web
// Services Region.
AccountCustomization *types.AccountCustomization
// The Amazon Resource Name (ARN) of the customization that's associated with this
// Amazon Web Services account.
Arn *string
// The ID for the Amazon Web Services account that you're describing.
AwsAccountId *string
// The Amazon QuickSight namespace that you're describing.
Namespace *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAccountCustomizationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAccountCustomization{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAccountCustomization{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAccountCustomizationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAccountCustomization(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAccountCustomization(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeAccountCustomization",
}
}
| 194 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the settings that were used when your Amazon QuickSight subscription
// was first created in this Amazon Web Services account.
func (c *Client) DescribeAccountSettings(ctx context.Context, params *DescribeAccountSettingsInput, optFns ...func(*Options)) (*DescribeAccountSettingsOutput, error) {
if params == nil {
params = &DescribeAccountSettingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAccountSettings", params, optFns, c.addOperationDescribeAccountSettingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAccountSettingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAccountSettingsInput struct {
// The ID for the Amazon Web Services account that contains the settings that you
// want to list.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DescribeAccountSettingsOutput struct {
// The Amazon QuickSight settings for this Amazon Web Services account. This
// information includes the edition of Amazon Amazon QuickSight that you subscribed
// to (Standard or Enterprise) and the notification email for the Amazon QuickSight
// subscription. In the QuickSight console, the Amazon QuickSight subscription is
// sometimes referred to as a QuickSight "account" even though it's technically not
// an account by itself. Instead, it's a subscription to the Amazon QuickSight
// service for your Amazon Web Services account. The edition that you subscribe to
// applies to Amazon QuickSight in every Amazon Web Services Region where you use
// it.
AccountSettings *types.AccountSettings
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAccountSettingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAccountSettings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAccountSettings{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAccountSettingsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAccountSettings(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAccountSettings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeAccountSettings",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use the DescribeAccountSubscription operation to receive a description of an
// Amazon QuickSight account's subscription. A successful API call returns an
// AccountInfo object that includes an account's name, subscription status,
// authentication type, edition, and notification email address.
func (c *Client) DescribeAccountSubscription(ctx context.Context, params *DescribeAccountSubscriptionInput, optFns ...func(*Options)) (*DescribeAccountSubscriptionOutput, error) {
if params == nil {
params = &DescribeAccountSubscriptionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAccountSubscription", params, optFns, c.addOperationDescribeAccountSubscriptionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAccountSubscriptionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAccountSubscriptionInput struct {
// The Amazon Web Services account ID associated with your Amazon QuickSight
// account.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DescribeAccountSubscriptionOutput struct {
// A structure that contains the following elements:
// - Your Amazon QuickSight account name.
// - The edition of Amazon QuickSight that your account is using.
// - The notification email address that is associated with the Amazon
// QuickSight account.
// - The authentication type of the Amazon QuickSight account.
// - The status of the Amazon QuickSight account's subscription.
AccountInfo *types.AccountInfo
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAccountSubscriptionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAccountSubscription{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAccountSubscription{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAccountSubscriptionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAccountSubscription(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAccountSubscription(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeAccountSubscription",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides a summary of the metadata for an analysis.
func (c *Client) DescribeAnalysis(ctx context.Context, params *DescribeAnalysisInput, optFns ...func(*Options)) (*DescribeAnalysisOutput, error) {
if params == nil {
params = &DescribeAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAnalysis", params, optFns, c.addOperationDescribeAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAnalysisInput struct {
// The ID of the analysis that you're describing. The ID is part of the URL of the
// analysis.
//
// This member is required.
AnalysisId *string
// The ID of the Amazon Web Services account that contains the analysis. You must
// be using the Amazon Web Services account that the analysis is in.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DescribeAnalysisOutput struct {
// A metadata structure that contains summary information for the analysis that
// you're describing.
Analysis *types.Analysis
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAnalysis{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAnalysis(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeAnalysis",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides a detailed description of the definition of an analysis. If you do not
// need to know details about the content of an Analysis, for instance if you are
// trying to check the status of a recently created or updated Analysis, use the
// DescribeAnalysis (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeAnalysis.html)
// instead.
func (c *Client) DescribeAnalysisDefinition(ctx context.Context, params *DescribeAnalysisDefinitionInput, optFns ...func(*Options)) (*DescribeAnalysisDefinitionOutput, error) {
if params == nil {
params = &DescribeAnalysisDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAnalysisDefinition", params, optFns, c.addOperationDescribeAnalysisDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAnalysisDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAnalysisDefinitionInput struct {
// The ID of the analysis that you're describing. The ID is part of the URL of the
// analysis.
//
// This member is required.
AnalysisId *string
// The ID of the Amazon Web Services account that contains the analysis. You must
// be using the Amazon Web Services account that the analysis is in.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DescribeAnalysisDefinitionOutput struct {
// The ID of the analysis described.
AnalysisId *string
// The definition of an analysis. A definition is the data model of all features
// in a Dashboard, Template, or Analysis.
Definition *types.AnalysisDefinition
// Errors associated with the analysis.
Errors []types.AnalysisError
// The descriptive name of the analysis.
Name *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// Status associated with the analysis.
// - CREATION_IN_PROGRESS
// - CREATION_SUCCESSFUL
// - CREATION_FAILED
// - UPDATE_IN_PROGRESS
// - UPDATE_SUCCESSFUL
// - UPDATE_FAILED
// - DELETED
ResourceStatus types.ResourceStatus
// The HTTP status of the request.
Status int32
// The ARN of the theme of the analysis.
ThemeArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAnalysisDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAnalysisDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAnalysisDefinition{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAnalysisDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAnalysisDefinition(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAnalysisDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeAnalysisDefinition",
}
}
| 165 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides the read and write permissions for an analysis.
func (c *Client) DescribeAnalysisPermissions(ctx context.Context, params *DescribeAnalysisPermissionsInput, optFns ...func(*Options)) (*DescribeAnalysisPermissionsOutput, error) {
if params == nil {
params = &DescribeAnalysisPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAnalysisPermissions", params, optFns, c.addOperationDescribeAnalysisPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAnalysisPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAnalysisPermissionsInput struct {
// The ID of the analysis whose permissions you're describing. The ID is part of
// the analysis URL.
//
// This member is required.
AnalysisId *string
// The ID of the Amazon Web Services account that contains the analysis whose
// permissions you're describing. You must be using the Amazon Web Services account
// that the analysis is in.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DescribeAnalysisPermissionsOutput struct {
// The Amazon Resource Name (ARN) of the analysis whose permissions you're
// describing.
AnalysisArn *string
// The ID of the analysis whose permissions you're describing.
AnalysisId *string
// A structure that describes the principals and the resource-level permissions on
// an analysis.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAnalysisPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAnalysisPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAnalysisPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAnalysisPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAnalysisPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAnalysisPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeAnalysisPermissions",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes an existing export job. Poll job descriptions after a job starts to
// know the status of the job. When a job succeeds, a URL is provided to download
// the exported assets' data from. Download URLs are valid for five minutes after
// they are generated. You can call the DescribeAssetBundleExportJob API for a new
// download URL as needed. Job descriptions are available for 14 days after the job
// starts.
func (c *Client) DescribeAssetBundleExportJob(ctx context.Context, params *DescribeAssetBundleExportJobInput, optFns ...func(*Options)) (*DescribeAssetBundleExportJobOutput, error) {
if params == nil {
params = &DescribeAssetBundleExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAssetBundleExportJob", params, optFns, c.addOperationDescribeAssetBundleExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAssetBundleExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAssetBundleExportJobInput struct {
// The ID of the job that you want described. The job ID is set when you start a
// new job with a StartAssetBundleExportJob API call.
//
// This member is required.
AssetBundleExportJobId *string
// The ID of the Amazon Web Services account the export job is executed in.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DescribeAssetBundleExportJobOutput struct {
// The Amazon Resource Name (ARN) for the export job.
Arn *string
// The ID of the job. The job ID is set when you start a new job with a
// StartAssetBundleExportJob API call.
AssetBundleExportJobId *string
// The ID of the Amazon Web Services account that the export job was executed in.
AwsAccountId *string
// The CloudFormation override property configuration for the export job.
CloudFormationOverridePropertyConfiguration *types.AssetBundleCloudFormationOverridePropertyConfiguration
// The time that the export job was created.
CreatedTime *time.Time
// The URL to download the exported asset bundle data from. This URL is available
// only after the job has succeeded. This URL is valid for 5 minutes after
// issuance. Call DescribeAssetBundleExportJob again for a fresh URL if needed.
// The downloaded asset bundle is a zip file named assetbundle-{jobId}.qs . The
// file has a .qs extension. This URL can't be used in a StartAssetBundleImportJob
// API call and should only be used for download purposes.
DownloadUrl *string
// An array of error records that describes any failures that occurred during the
// export job processing. Error records accumulate while the job runs. The complete
// set of error records is available after the job has completed and failed.
Errors []types.AssetBundleExportJobError
// The format of the export.
ExportFormat types.AssetBundleExportFormat
// The include dependencies flag.
IncludeAllDependencies bool
// Indicates the status of a job through its queuing and execution. Poll this
// DescribeAssetBundleExportApi until JobStatus is either SUCCESSFUL or FAILED .
JobStatus types.AssetBundleExportJobStatus
// The Amazon Web Services request ID for this operation.
RequestId *string
// A list of resource ARNs that exported with the job.
ResourceArns []string
// The HTTP status of the response.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAssetBundleExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAssetBundleExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAssetBundleExportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAssetBundleExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAssetBundleExportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAssetBundleExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeAssetBundleExportJob",
}
}
| 182 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes an existing import job. Poll job descriptions after starting a job to
// know when it has succeeded or failed. Job descriptions are available for 14 days
// after job starts.
func (c *Client) DescribeAssetBundleImportJob(ctx context.Context, params *DescribeAssetBundleImportJobInput, optFns ...func(*Options)) (*DescribeAssetBundleImportJobOutput, error) {
if params == nil {
params = &DescribeAssetBundleImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAssetBundleImportJob", params, optFns, c.addOperationDescribeAssetBundleImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAssetBundleImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAssetBundleImportJobInput struct {
// The ID of the job. The job ID is set when you start a new job with a
// StartAssetBundleImportJob API call.
//
// This member is required.
AssetBundleImportJobId *string
// The ID of the Amazon Web Services account the import job was executed in.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DescribeAssetBundleImportJobOutput struct {
// The Amazon Resource Name (ARN) for the import job.
Arn *string
// The ID of the job. The job ID is set when you start a new job with a
// StartAssetBundleImportJob API call.
AssetBundleImportJobId *string
// The source of the asset bundle zip file that contains the data that is imported
// by the job.
AssetBundleImportSource *types.AssetBundleImportSourceDescription
// The ID of the Amazon Web Services account the import job was executed in.
AwsAccountId *string
// The time that the import job was created.
CreatedTime *time.Time
// An array of error records that describes any failures that occurred during the
// export job processing. Error records accumulate while the job is still running.
// The complete set of error records is available after the job has completed and
// failed.
Errors []types.AssetBundleImportJobError
// The failure action for the import job.
FailureAction types.AssetBundleImportFailureAction
// Indicates the status of a job through its queuing and execution. Poll the
// DescribeAssetBundleImport API until JobStatus returns one of the following
// values:
// - SUCCESSFUL
// - FAILED
// - FAILED_ROLLBACK_COMPLETED
// - FAILED_ROLLBACK_ERROR
JobStatus types.AssetBundleImportJobStatus
// Optional overrides to be applied to the resource configuration before import.
OverrideParameters *types.AssetBundleImportJobOverrideParameters
// The Amazon Web Services request ID for this operation.
RequestId *string
// An array of error records that describes any failures that occurred while an
// import job was attempting a rollback. Error records accumulate while the job is
// still running. The complete set of error records is available after the job has
// completed and failed.
RollbackErrors []types.AssetBundleImportJobError
// The HTTP status of the response.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAssetBundleImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAssetBundleImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAssetBundleImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAssetBundleImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAssetBundleImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAssetBundleImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeAssetBundleImportJob",
}
}
| 181 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides a summary for a dashboard.
func (c *Client) DescribeDashboard(ctx context.Context, params *DescribeDashboardInput, optFns ...func(*Options)) (*DescribeDashboardOutput, error) {
if params == nil {
params = &DescribeDashboardInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDashboard", params, optFns, c.addOperationDescribeDashboardMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDashboardOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDashboardInput struct {
// The ID of the Amazon Web Services account that contains the dashboard that
// you're describing.
//
// This member is required.
AwsAccountId *string
// The ID for the dashboard.
//
// This member is required.
DashboardId *string
// The alias name.
AliasName *string
// The version number for the dashboard. If a version number isn't passed, the
// latest published dashboard version is described.
VersionNumber *int64
noSmithyDocumentSerde
}
type DescribeDashboardOutput struct {
// Information about the dashboard.
Dashboard *types.Dashboard
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of this request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDashboardMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDashboard{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDashboard{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDashboardValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDashboard(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDashboard(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeDashboard",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides a detailed description of the definition of a dashboard. If you do not
// need to know details about the content of a dashboard, for instance if you are
// trying to check the status of a recently created or updated dashboard, use the
// DescribeDashboard (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeDashboard.html)
// instead.
func (c *Client) DescribeDashboardDefinition(ctx context.Context, params *DescribeDashboardDefinitionInput, optFns ...func(*Options)) (*DescribeDashboardDefinitionOutput, error) {
if params == nil {
params = &DescribeDashboardDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDashboardDefinition", params, optFns, c.addOperationDescribeDashboardDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDashboardDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDashboardDefinitionInput struct {
// The ID of the Amazon Web Services account that contains the dashboard that
// you're describing.
//
// This member is required.
AwsAccountId *string
// The ID for the dashboard.
//
// This member is required.
DashboardId *string
// The alias name.
AliasName *string
// The version number for the dashboard. If a version number isn't passed, the
// latest published dashboard version is described.
VersionNumber *int64
noSmithyDocumentSerde
}
type DescribeDashboardDefinitionOutput struct {
// The ID of the dashboard described.
DashboardId *string
// Options for publishing the dashboard:
// - AvailabilityStatus for AdHocFilteringOption - This status can be either
// ENABLED or DISABLED . When this is set to DISABLED , Amazon QuickSight
// disables the left filter pane on the published dashboard, which can be used for
// ad hoc (one-time) filtering. This option is ENABLED by default.
// - AvailabilityStatus for ExportToCSVOption - This status can be either ENABLED
// or DISABLED . The visual option to export data to .CSV format isn't enabled
// when this is set to DISABLED . This option is ENABLED by default.
// - VisibilityState for SheetControlsOption - This visibility state can be
// either COLLAPSED or EXPANDED . This option is COLLAPSED by default.
DashboardPublishOptions *types.DashboardPublishOptions
// The definition of a dashboard. A definition is the data model of all features
// in a Dashboard, Template, or Analysis.
Definition *types.DashboardVersionDefinition
// Errors associated with this dashboard version.
Errors []types.DashboardError
// The display name of the dashboard.
Name *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// Status associated with the dashboard version.
// - CREATION_IN_PROGRESS
// - CREATION_SUCCESSFUL
// - CREATION_FAILED
// - UPDATE_IN_PROGRESS
// - UPDATE_SUCCESSFUL
// - UPDATE_FAILED
// - DELETED
ResourceStatus types.ResourceStatus
// The HTTP status of the request.
Status int32
// The ARN of the theme of the dashboard.
ThemeArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDashboardDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDashboardDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDashboardDefinition{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDashboardDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDashboardDefinition(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDashboardDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeDashboardDefinition",
}
}
| 183 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes read and write permissions for a dashboard.
func (c *Client) DescribeDashboardPermissions(ctx context.Context, params *DescribeDashboardPermissionsInput, optFns ...func(*Options)) (*DescribeDashboardPermissionsOutput, error) {
if params == nil {
params = &DescribeDashboardPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDashboardPermissions", params, optFns, c.addOperationDescribeDashboardPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDashboardPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDashboardPermissionsInput struct {
// The ID of the Amazon Web Services account that contains the dashboard that
// you're describing permissions for.
//
// This member is required.
AwsAccountId *string
// The ID for the dashboard, also added to the IAM policy.
//
// This member is required.
DashboardId *string
noSmithyDocumentSerde
}
type DescribeDashboardPermissionsOutput struct {
// The Amazon Resource Name (ARN) of the dashboard.
DashboardArn *string
// The ID for the dashboard.
DashboardId *string
// A structure that contains the configuration of a shareable link that grants
// access to the dashboard. Your users can use the link to view and interact with
// the dashboard, if the dashboard has been shared with them. For more information
// about sharing dashboards, see Sharing Dashboards (https://docs.aws.amazon.com/quicksight/latest/user/sharing-a-dashboard.html)
// .
LinkSharingConfiguration *types.LinkSharingConfiguration
// A structure that contains the permissions for the dashboard.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDashboardPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDashboardPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDashboardPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDashboardPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDashboardPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDashboardPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeDashboardPermissions",
}
}
| 150 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a dataset. This operation doesn't support datasets that include
// uploaded files as a source.
func (c *Client) DescribeDataSet(ctx context.Context, params *DescribeDataSetInput, optFns ...func(*Options)) (*DescribeDataSetOutput, error) {
if params == nil {
params = &DescribeDataSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDataSet", params, optFns, c.addOperationDescribeDataSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDataSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDataSetInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID for the dataset that you want to create. This ID is unique per Amazon
// Web Services Region for each Amazon Web Services account.
//
// This member is required.
DataSetId *string
noSmithyDocumentSerde
}
type DescribeDataSetOutput struct {
// Information on the dataset.
DataSet *types.DataSet
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDataSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDataSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDataSet{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDataSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDataSet(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDataSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeDataSet",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the permissions on a dataset. The permissions resource is
// arn:aws:quicksight:region:aws-account-id:dataset/data-set-id .
func (c *Client) DescribeDataSetPermissions(ctx context.Context, params *DescribeDataSetPermissionsInput, optFns ...func(*Options)) (*DescribeDataSetPermissionsOutput, error) {
if params == nil {
params = &DescribeDataSetPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDataSetPermissions", params, optFns, c.addOperationDescribeDataSetPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDataSetPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDataSetPermissionsInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID for the dataset that you want to create. This ID is unique per Amazon
// Web Services Region for each Amazon Web Services account.
//
// This member is required.
DataSetId *string
noSmithyDocumentSerde
}
type DescribeDataSetPermissionsOutput struct {
// The Amazon Resource Name (ARN) of the dataset.
DataSetArn *string
// The ID for the dataset that you want to create. This ID is unique per Amazon
// Web Services Region for each Amazon Web Services account.
DataSetId *string
// A list of resource permissions on the dataset.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDataSetPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDataSetPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDataSetPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDataSetPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDataSetPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDataSetPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeDataSetPermissions",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the refresh properties of a dataset.
func (c *Client) DescribeDataSetRefreshProperties(ctx context.Context, params *DescribeDataSetRefreshPropertiesInput, optFns ...func(*Options)) (*DescribeDataSetRefreshPropertiesOutput, error) {
if params == nil {
params = &DescribeDataSetRefreshPropertiesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDataSetRefreshProperties", params, optFns, c.addOperationDescribeDataSetRefreshPropertiesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDataSetRefreshPropertiesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDataSetRefreshPropertiesInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset.
//
// This member is required.
DataSetId *string
noSmithyDocumentSerde
}
type DescribeDataSetRefreshPropertiesOutput struct {
// The dataset refresh properties.
DataSetRefreshProperties *types.DataSetRefreshProperties
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDataSetRefreshPropertiesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDataSetRefreshProperties{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDataSetRefreshProperties{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDataSetRefreshPropertiesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDataSetRefreshProperties(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDataSetRefreshProperties(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeDataSetRefreshProperties",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a data source.
func (c *Client) DescribeDataSource(ctx context.Context, params *DescribeDataSourceInput, optFns ...func(*Options)) (*DescribeDataSourceOutput, error) {
if params == nil {
params = &DescribeDataSourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDataSource", params, optFns, c.addOperationDescribeDataSourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDataSourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDataSourceInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the data source. This ID is unique per Amazon Web Services Region for
// each Amazon Web Services account.
//
// This member is required.
DataSourceId *string
noSmithyDocumentSerde
}
type DescribeDataSourceOutput struct {
// The information on the data source.
DataSource *types.DataSource
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDataSourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDataSource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDataSource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDataSourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDataSource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDataSource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeDataSource",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the resource permissions for a data source.
func (c *Client) DescribeDataSourcePermissions(ctx context.Context, params *DescribeDataSourcePermissionsInput, optFns ...func(*Options)) (*DescribeDataSourcePermissionsOutput, error) {
if params == nil {
params = &DescribeDataSourcePermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDataSourcePermissions", params, optFns, c.addOperationDescribeDataSourcePermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDataSourcePermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDataSourcePermissionsInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the data source. This ID is unique per Amazon Web Services Region for
// each Amazon Web Services account.
//
// This member is required.
DataSourceId *string
noSmithyDocumentSerde
}
type DescribeDataSourcePermissionsOutput struct {
// The Amazon Resource Name (ARN) of the data source.
DataSourceArn *string
// The ID of the data source. This ID is unique per Amazon Web Services Region for
// each Amazon Web Services account.
DataSourceId *string
// A list of resource permissions on the data source.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDataSourcePermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDataSourcePermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDataSourcePermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDataSourcePermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDataSourcePermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDataSourcePermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeDataSourcePermissions",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a folder.
func (c *Client) DescribeFolder(ctx context.Context, params *DescribeFolderInput, optFns ...func(*Options)) (*DescribeFolderOutput, error) {
if params == nil {
params = &DescribeFolderInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFolder", params, optFns, c.addOperationDescribeFolderMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFolderOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFolderInput struct {
// The ID for the Amazon Web Services account that contains the folder.
//
// This member is required.
AwsAccountId *string
// The ID of the folder.
//
// This member is required.
FolderId *string
noSmithyDocumentSerde
}
type DescribeFolderOutput struct {
// Information about the folder.
Folder *types.Folder
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFolderMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeFolder{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeFolder{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeFolderValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFolder(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeFolder(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeFolder",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes permissions for a folder.
func (c *Client) DescribeFolderPermissions(ctx context.Context, params *DescribeFolderPermissionsInput, optFns ...func(*Options)) (*DescribeFolderPermissionsOutput, error) {
if params == nil {
params = &DescribeFolderPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFolderPermissions", params, optFns, c.addOperationDescribeFolderPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFolderPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFolderPermissionsInput struct {
// The ID for the Amazon Web Services account that contains the folder.
//
// This member is required.
AwsAccountId *string
// The ID of the folder.
//
// This member is required.
FolderId *string
noSmithyDocumentSerde
}
type DescribeFolderPermissionsOutput struct {
// The Amazon Resource Name (ARN) for the folder.
Arn *string
// The ID of the folder.
FolderId *string
// Information about the permissions on the folder.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFolderPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeFolderPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeFolderPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeFolderPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFolderPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeFolderPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeFolderPermissions",
}
}
| 142 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the folder resolved permissions. Permissions consists of both folder
// direct permissions and the inherited permissions from the ancestor folders.
func (c *Client) DescribeFolderResolvedPermissions(ctx context.Context, params *DescribeFolderResolvedPermissionsInput, optFns ...func(*Options)) (*DescribeFolderResolvedPermissionsOutput, error) {
if params == nil {
params = &DescribeFolderResolvedPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFolderResolvedPermissions", params, optFns, c.addOperationDescribeFolderResolvedPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFolderResolvedPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFolderResolvedPermissionsInput struct {
// The ID for the Amazon Web Services account that contains the folder.
//
// This member is required.
AwsAccountId *string
// The ID of the folder.
//
// This member is required.
FolderId *string
noSmithyDocumentSerde
}
type DescribeFolderResolvedPermissionsOutput struct {
// The Amazon Resource Name (ARN) of the folder.
Arn *string
// The ID of the folder.
FolderId *string
// Information about the permissions for the folder.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFolderResolvedPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeFolderResolvedPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeFolderResolvedPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeFolderResolvedPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFolderResolvedPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeFolderResolvedPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeFolderResolvedPermissions",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an Amazon QuickSight group's description and Amazon Resource Name (ARN).
func (c *Client) DescribeGroup(ctx context.Context, params *DescribeGroupInput, optFns ...func(*Options)) (*DescribeGroupOutput, error) {
if params == nil {
params = &DescribeGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGroup", params, optFns, c.addOperationDescribeGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGroupInput struct {
// The ID for the Amazon Web Services account that the group is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The name of the group that you want to describe.
//
// This member is required.
GroupName *string
// The namespace of the group that you want described.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type DescribeGroupOutput struct {
// The name of the group.
Group *types.Group
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeGroup{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeGroup",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use the DescribeGroupMembership operation to determine if a user is a member of
// the specified group. If the user exists and is a member of the specified group,
// an associated GroupMember object is returned.
func (c *Client) DescribeGroupMembership(ctx context.Context, params *DescribeGroupMembershipInput, optFns ...func(*Options)) (*DescribeGroupMembershipOutput, error) {
if params == nil {
params = &DescribeGroupMembershipInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGroupMembership", params, optFns, c.addOperationDescribeGroupMembershipMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGroupMembershipOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGroupMembershipInput struct {
// The ID for the Amazon Web Services account that the group is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The name of the group that you want to search.
//
// This member is required.
GroupName *string
// The user name of the user that you want to search for.
//
// This member is required.
MemberName *string
// The namespace that includes the group you are searching within.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type DescribeGroupMembershipOutput struct {
// A member of an Amazon QuickSight group. Currently, group members must be users.
// Groups can't be members of another group. .
GroupMember *types.GroupMember
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGroupMembershipMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeGroupMembership{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeGroupMembership{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeGroupMembershipValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeGroupMembership(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeGroupMembership(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeGroupMembership",
}
}
| 151 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes an existing IAM policy assignment, as specified by the assignment
// name.
func (c *Client) DescribeIAMPolicyAssignment(ctx context.Context, params *DescribeIAMPolicyAssignmentInput, optFns ...func(*Options)) (*DescribeIAMPolicyAssignmentOutput, error) {
if params == nil {
params = &DescribeIAMPolicyAssignmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeIAMPolicyAssignment", params, optFns, c.addOperationDescribeIAMPolicyAssignmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeIAMPolicyAssignmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeIAMPolicyAssignmentInput struct {
// The name of the assignment, also called a rule.
//
// This member is required.
AssignmentName *string
// The ID of the Amazon Web Services account that contains the assignment that you
// want to describe.
//
// This member is required.
AwsAccountId *string
// The namespace that contains the assignment.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type DescribeIAMPolicyAssignmentOutput struct {
// Information describing the IAM policy assignment.
IAMPolicyAssignment *types.IAMPolicyAssignment
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeIAMPolicyAssignmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeIAMPolicyAssignment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeIAMPolicyAssignment{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeIAMPolicyAssignmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeIAMPolicyAssignment(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeIAMPolicyAssignment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeIAMPolicyAssignment",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a SPICE ingestion.
func (c *Client) DescribeIngestion(ctx context.Context, params *DescribeIngestionInput, optFns ...func(*Options)) (*DescribeIngestionOutput, error) {
if params == nil {
params = &DescribeIngestionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeIngestion", params, optFns, c.addOperationDescribeIngestionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeIngestionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeIngestionInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset used in the ingestion.
//
// This member is required.
DataSetId *string
// An ID for the ingestion.
//
// This member is required.
IngestionId *string
noSmithyDocumentSerde
}
type DescribeIngestionOutput struct {
// Information about the ingestion.
Ingestion *types.Ingestion
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeIngestionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeIngestion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeIngestion{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeIngestionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeIngestion(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeIngestion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeIngestion",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides a summary and status of IP rules.
func (c *Client) DescribeIpRestriction(ctx context.Context, params *DescribeIpRestrictionInput, optFns ...func(*Options)) (*DescribeIpRestrictionOutput, error) {
if params == nil {
params = &DescribeIpRestrictionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeIpRestriction", params, optFns, c.addOperationDescribeIpRestrictionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeIpRestrictionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeIpRestrictionInput struct {
// The ID of the Amazon Web Services account that contains the IP rules.
//
// This member is required.
AwsAccountId *string
noSmithyDocumentSerde
}
type DescribeIpRestrictionOutput struct {
// The ID of the Amazon Web Services account that contains the IP rules.
AwsAccountId *string
// A value that specifies whether IP rules are turned on.
Enabled *bool
// A map that describes the IP rules with CIDR range and description.
IpRestrictionRuleMap map[string]string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeIpRestrictionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeIpRestriction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeIpRestriction{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeIpRestrictionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeIpRestriction(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeIpRestriction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeIpRestriction",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the current namespace.
func (c *Client) DescribeNamespace(ctx context.Context, params *DescribeNamespaceInput, optFns ...func(*Options)) (*DescribeNamespaceOutput, error) {
if params == nil {
params = &DescribeNamespaceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeNamespace", params, optFns, c.addOperationDescribeNamespaceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeNamespaceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeNamespaceInput struct {
// The ID for the Amazon Web Services account that contains the Amazon QuickSight
// namespace that you want to describe.
//
// This member is required.
AwsAccountId *string
// The namespace that you want to describe.
//
// This member is required.
Namespace *string
noSmithyDocumentSerde
}
type DescribeNamespaceOutput struct {
// The information about the namespace that you're describing. The response
// includes the namespace ARN, name, Amazon Web Services Region, creation status,
// and identity store. DescribeNamespace also works for namespaces that are in the
// process of being created. For incomplete namespaces, this API operation lists
// the namespace error types and messages associated with the creation process.
Namespace *types.NamespaceInfoV2
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeNamespaceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeNamespace{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeNamespace{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeNamespaceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeNamespace(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeNamespace(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeNamespace",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides a summary of a refresh schedule.
func (c *Client) DescribeRefreshSchedule(ctx context.Context, params *DescribeRefreshScheduleInput, optFns ...func(*Options)) (*DescribeRefreshScheduleOutput, error) {
if params == nil {
params = &DescribeRefreshScheduleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeRefreshSchedule", params, optFns, c.addOperationDescribeRefreshScheduleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeRefreshScheduleOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeRefreshScheduleInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset.
//
// This member is required.
DataSetId *string
// The ID of the refresh schedule.
//
// This member is required.
ScheduleId *string
noSmithyDocumentSerde
}
type DescribeRefreshScheduleOutput struct {
// The Amazon Resource Name (ARN) for the refresh schedule.
Arn *string
// The refresh schedule.
RefreshSchedule *types.RefreshSchedule
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeRefreshScheduleMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeRefreshScheduleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeRefreshSchedule(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeRefreshSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeRefreshSchedule",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a template's metadata.
func (c *Client) DescribeTemplate(ctx context.Context, params *DescribeTemplateInput, optFns ...func(*Options)) (*DescribeTemplateOutput, error) {
if params == nil {
params = &DescribeTemplateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTemplate", params, optFns, c.addOperationDescribeTemplateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTemplateOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTemplateInput struct {
// The ID of the Amazon Web Services account that contains the template that
// you're describing.
//
// This member is required.
AwsAccountId *string
// The ID for the template.
//
// This member is required.
TemplateId *string
// The alias of the template that you want to describe. If you name a specific
// alias, you describe the version that the alias points to. You can specify the
// latest version of the template by providing the keyword $LATEST in the AliasName
// parameter. The keyword $PUBLISHED doesn't apply to templates.
AliasName *string
// (Optional) The number for the version to describe. If a VersionNumber parameter
// value isn't provided, the latest version of the template is described.
VersionNumber *int64
noSmithyDocumentSerde
}
type DescribeTemplateOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The template structure for the object you want to describe.
Template *types.Template
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTemplateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTemplate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTemplate{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTemplateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTemplate(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTemplate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTemplate",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the template alias for a template.
func (c *Client) DescribeTemplateAlias(ctx context.Context, params *DescribeTemplateAliasInput, optFns ...func(*Options)) (*DescribeTemplateAliasOutput, error) {
if params == nil {
params = &DescribeTemplateAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTemplateAlias", params, optFns, c.addOperationDescribeTemplateAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTemplateAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTemplateAliasInput struct {
// The name of the template alias that you want to describe. If you name a
// specific alias, you describe the version that the alias points to. You can
// specify the latest version of the template by providing the keyword $LATEST in
// the AliasName parameter. The keyword $PUBLISHED doesn't apply to templates.
//
// This member is required.
AliasName *string
// The ID of the Amazon Web Services account that contains the template alias that
// you're describing.
//
// This member is required.
AwsAccountId *string
// The ID for the template.
//
// This member is required.
TemplateId *string
noSmithyDocumentSerde
}
type DescribeTemplateAliasOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Information about the template alias.
TemplateAlias *types.TemplateAlias
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTemplateAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTemplateAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTemplateAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTemplateAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTemplateAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTemplateAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTemplateAlias",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides a detailed description of the definition of a template. If you do not
// need to know details about the content of a template, for instance if you are
// trying to check the status of a recently created or updated template, use the
// DescribeTemplate (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeTemplate.html)
// instead.
func (c *Client) DescribeTemplateDefinition(ctx context.Context, params *DescribeTemplateDefinitionInput, optFns ...func(*Options)) (*DescribeTemplateDefinitionOutput, error) {
if params == nil {
params = &DescribeTemplateDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTemplateDefinition", params, optFns, c.addOperationDescribeTemplateDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTemplateDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTemplateDefinitionInput struct {
// The ID of the Amazon Web Services account that contains the template. You must
// be using the Amazon Web Services account that the template is in.
//
// This member is required.
AwsAccountId *string
// The ID of the template that you're describing.
//
// This member is required.
TemplateId *string
// The alias of the template that you want to describe. If you name a specific
// alias, you describe the version that the alias points to. You can specify the
// latest version of the template by providing the keyword $LATEST in the AliasName
// parameter. The keyword $PUBLISHED doesn't apply to templates.
AliasName *string
// The version number of the template.
VersionNumber *int64
noSmithyDocumentSerde
}
type DescribeTemplateDefinitionOutput struct {
// The definition of the template. A definition is the data model of all features
// in a Dashboard, Template, or Analysis.
Definition *types.TemplateVersionDefinition
// Errors associated with the template version.
Errors []types.TemplateError
// The descriptive name of the template.
Name *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// Status associated with the template.
// - CREATION_IN_PROGRESS
// - CREATION_SUCCESSFUL
// - CREATION_FAILED
// - UPDATE_IN_PROGRESS
// - UPDATE_SUCCESSFUL
// - UPDATE_FAILED
// - DELETED
ResourceStatus types.ResourceStatus
// The HTTP status of the request.
Status int32
// The ID of the template described.
TemplateId *string
// The ARN of the theme of the template.
ThemeArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTemplateDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTemplateDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTemplateDefinition{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTemplateDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTemplateDefinition(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTemplateDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTemplateDefinition",
}
}
| 173 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes read and write permissions on a template.
func (c *Client) DescribeTemplatePermissions(ctx context.Context, params *DescribeTemplatePermissionsInput, optFns ...func(*Options)) (*DescribeTemplatePermissionsOutput, error) {
if params == nil {
params = &DescribeTemplatePermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTemplatePermissions", params, optFns, c.addOperationDescribeTemplatePermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTemplatePermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTemplatePermissionsInput struct {
// The ID of the Amazon Web Services account that contains the template that
// you're describing.
//
// This member is required.
AwsAccountId *string
// The ID for the template.
//
// This member is required.
TemplateId *string
noSmithyDocumentSerde
}
type DescribeTemplatePermissionsOutput struct {
// A list of resource permissions to be set on the template.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The Amazon Resource Name (ARN) of the template.
TemplateArn *string
// The ID for the template.
TemplateId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTemplatePermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTemplatePermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTemplatePermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTemplatePermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTemplatePermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTemplatePermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTemplatePermissions",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a theme.
func (c *Client) DescribeTheme(ctx context.Context, params *DescribeThemeInput, optFns ...func(*Options)) (*DescribeThemeOutput, error) {
if params == nil {
params = &DescribeThemeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTheme", params, optFns, c.addOperationDescribeThemeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeThemeOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeThemeInput struct {
// The ID of the Amazon Web Services account that contains the theme that you're
// describing.
//
// This member is required.
AwsAccountId *string
// The ID for the theme.
//
// This member is required.
ThemeId *string
// The alias of the theme that you want to describe. If you name a specific alias,
// you describe the version that the alias points to. You can specify the latest
// version of the theme by providing the keyword $LATEST in the AliasName
// parameter. The keyword $PUBLISHED doesn't apply to themes.
AliasName *string
// The version number for the version to describe. If a VersionNumber parameter
// value isn't provided, the latest version of the theme is described.
VersionNumber *int64
noSmithyDocumentSerde
}
type DescribeThemeOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The information about the theme that you are describing.
Theme *types.Theme
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeThemeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTheme{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTheme{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeThemeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTheme(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTheme(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTheme",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the alias for a theme.
func (c *Client) DescribeThemeAlias(ctx context.Context, params *DescribeThemeAliasInput, optFns ...func(*Options)) (*DescribeThemeAliasOutput, error) {
if params == nil {
params = &DescribeThemeAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeThemeAlias", params, optFns, c.addOperationDescribeThemeAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeThemeAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeThemeAliasInput struct {
// The name of the theme alias that you want to describe.
//
// This member is required.
AliasName *string
// The ID of the Amazon Web Services account that contains the theme alias that
// you're describing.
//
// This member is required.
AwsAccountId *string
// The ID for the theme.
//
// This member is required.
ThemeId *string
noSmithyDocumentSerde
}
type DescribeThemeAliasOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Information about the theme alias.
ThemeAlias *types.ThemeAlias
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeThemeAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeThemeAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeThemeAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeThemeAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeThemeAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeThemeAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeThemeAlias",
}
}
| 142 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the read and write permissions for a theme.
func (c *Client) DescribeThemePermissions(ctx context.Context, params *DescribeThemePermissionsInput, optFns ...func(*Options)) (*DescribeThemePermissionsOutput, error) {
if params == nil {
params = &DescribeThemePermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeThemePermissions", params, optFns, c.addOperationDescribeThemePermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeThemePermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeThemePermissionsInput struct {
// The ID of the Amazon Web Services account that contains the theme that you're
// describing.
//
// This member is required.
AwsAccountId *string
// The ID for the theme that you want to describe permissions for.
//
// This member is required.
ThemeId *string
noSmithyDocumentSerde
}
type DescribeThemePermissionsOutput struct {
// A list of resource permissions set on the theme.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The Amazon Resource Name (ARN) of the theme.
ThemeArn *string
// The ID for the theme.
ThemeId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeThemePermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeThemePermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeThemePermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeThemePermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeThemePermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeThemePermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeThemePermissions",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a topic.
func (c *Client) DescribeTopic(ctx context.Context, params *DescribeTopicInput, optFns ...func(*Options)) (*DescribeTopicOutput, error) {
if params == nil {
params = &DescribeTopicInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTopic", params, optFns, c.addOperationDescribeTopicMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTopicOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTopicInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the topic that you want to describe. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
//
// This member is required.
TopicId *string
noSmithyDocumentSerde
}
type DescribeTopicOutput struct {
// The Amazon Resource Name (ARN) of the topic.
Arn *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The definition of a topic.
Topic *types.TopicDetails
// The ID of the topic that you want to describe. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
TopicId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTopicMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTopic{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTopic{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTopicValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTopic(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTopic(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTopic",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the permissions of a topic.
func (c *Client) DescribeTopicPermissions(ctx context.Context, params *DescribeTopicPermissionsInput, optFns ...func(*Options)) (*DescribeTopicPermissionsOutput, error) {
if params == nil {
params = &DescribeTopicPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTopicPermissions", params, optFns, c.addOperationDescribeTopicPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTopicPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTopicPermissionsInput struct {
// The ID of the Amazon Web Services account that contains the topic that you want
// described.
//
// This member is required.
AwsAccountId *string
// The ID of the topic that you want to describe. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
//
// This member is required.
TopicId *string
noSmithyDocumentSerde
}
type DescribeTopicPermissionsOutput struct {
// A list of resource permissions that are configured to the topic.
Permissions []types.ResourcePermission
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The Amazon Resource Name (ARN) of the topic.
TopicArn *string
// The ID of the topic that you want to describe. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
TopicId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTopicPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTopicPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTopicPermissions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTopicPermissionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTopicPermissions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTopicPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTopicPermissions",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the status of a topic refresh.
func (c *Client) DescribeTopicRefresh(ctx context.Context, params *DescribeTopicRefreshInput, optFns ...func(*Options)) (*DescribeTopicRefreshOutput, error) {
if params == nil {
params = &DescribeTopicRefreshInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTopicRefresh", params, optFns, c.addOperationDescribeTopicRefreshMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTopicRefreshOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTopicRefreshInput struct {
// The ID of the Amazon Web Services account that contains the topic whose refresh
// you want to describe.
//
// This member is required.
AwsAccountId *string
// The ID of the refresh, which is performed when the topic is created or updated.
//
// This member is required.
RefreshId *string
// The ID of the topic that you want to describe. This ID is unique per Amazon Web
// Services Region for each Amazon Web Services account.
//
// This member is required.
TopicId *string
noSmithyDocumentSerde
}
type DescribeTopicRefreshOutput struct {
// Details of the refresh, which is performed when the topic is created or updated.
RefreshDetails *types.TopicRefreshDetails
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTopicRefreshMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTopicRefresh{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTopicRefresh{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTopicRefreshValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTopicRefresh(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTopicRefresh(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTopicRefresh",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a topic refresh schedule.
func (c *Client) DescribeTopicRefreshSchedule(ctx context.Context, params *DescribeTopicRefreshScheduleInput, optFns ...func(*Options)) (*DescribeTopicRefreshScheduleOutput, error) {
if params == nil {
params = &DescribeTopicRefreshScheduleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTopicRefreshSchedule", params, optFns, c.addOperationDescribeTopicRefreshScheduleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTopicRefreshScheduleOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTopicRefreshScheduleInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The ID of the dataset.
//
// This member is required.
DatasetId *string
// The ID of the topic that contains the refresh schedule that you want to
// describe. This ID is unique per Amazon Web Services Region for each Amazon Web
// Services account.
//
// This member is required.
TopicId *string
noSmithyDocumentSerde
}
type DescribeTopicRefreshScheduleOutput struct {
// The Amazon Resource Name (ARN) of the dataset.
DatasetArn *string
// The definition of a refresh schedule.
RefreshSchedule *types.TopicRefreshSchedule
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The Amazon Resource Name (ARN) of the topic.
TopicArn *string
// The ID of the topic that contains the refresh schedule that you want to
// describe. This ID is unique per Amazon Web Services Region for each Amazon Web
// Services account.
TopicId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTopicRefreshScheduleMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeTopicRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeTopicRefreshSchedule{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeTopicRefreshScheduleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTopicRefreshSchedule(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeTopicRefreshSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeTopicRefreshSchedule",
}
}
| 154 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a user, given the user name.
func (c *Client) DescribeUser(ctx context.Context, params *DescribeUserInput, optFns ...func(*Options)) (*DescribeUserOutput, error) {
if params == nil {
params = &DescribeUserInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeUser", params, optFns, c.addOperationDescribeUserMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeUserOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeUserInput struct {
// The ID for the Amazon Web Services account that the user is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The namespace. Currently, you should set this to default .
//
// This member is required.
Namespace *string
// The name of the user that you want to describe.
//
// This member is required.
UserName *string
noSmithyDocumentSerde
}
type DescribeUserOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// The user name.
User *types.User
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeUserMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeUser{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeUser{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeUserValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeUser(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeUser(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeUser",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a VPC connection.
func (c *Client) DescribeVPCConnection(ctx context.Context, params *DescribeVPCConnectionInput, optFns ...func(*Options)) (*DescribeVPCConnectionOutput, error) {
if params == nil {
params = &DescribeVPCConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeVPCConnection", params, optFns, c.addOperationDescribeVPCConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeVPCConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeVPCConnectionInput struct {
// The Amazon Web Services account ID of the account that contains the VPC
// connection that you want described.
//
// This member is required.
AwsAccountId *string
// The ID of the VPC connection that you're creating. This ID is a unique
// identifier for each Amazon Web Services Region in an Amazon Web Services
// account.
//
// This member is required.
VPCConnectionId *string
noSmithyDocumentSerde
}
type DescribeVPCConnectionOutput struct {
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// A response object that provides information for the specified VPC connection.
VPCConnection *types.VPCConnection
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeVPCConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeVPCConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeVPCConnection{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeVPCConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeVPCConnection(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeVPCConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "DescribeVPCConnection",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Generates an embed URL that you can use to embed an Amazon QuickSight dashboard
// or visual in your website, without having to register any reader users. Before
// you use this action, make sure that you have configured the dashboards and
// permissions. The following rules apply to the generated URL:
// - It contains a temporary bearer token. It is valid for 5 minutes after it is
// generated. Once redeemed within this period, it cannot be re-used again.
// - The URL validity period should not be confused with the actual session
// lifetime that can be customized using the SessionLifetimeInMinutes (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html#QS-GenerateEmbedUrlForAnonymousUser-request-SessionLifetimeInMinutes)
// parameter. The resulting user session is valid for 15 minutes (minimum) to 10
// hours (maximum). The default session duration is 10 hours.
// - You are charged only when the URL is used or there is interaction with
// Amazon QuickSight.
//
// For more information, see Embedded Analytics (https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics.html)
// in the Amazon QuickSight User Guide. For more information about the high-level
// steps for embedding and for an interactive demo of the ways you can customize
// embedding, visit the Amazon QuickSight Developer Portal (https://docs.aws.amazon.com/quicksight/latest/user/quicksight-dev-portal.html)
// .
func (c *Client) GenerateEmbedUrlForAnonymousUser(ctx context.Context, params *GenerateEmbedUrlForAnonymousUserInput, optFns ...func(*Options)) (*GenerateEmbedUrlForAnonymousUserOutput, error) {
if params == nil {
params = &GenerateEmbedUrlForAnonymousUserInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GenerateEmbedUrlForAnonymousUser", params, optFns, c.addOperationGenerateEmbedUrlForAnonymousUserMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GenerateEmbedUrlForAnonymousUserOutput)
out.ResultMetadata = metadata
return out, nil
}
type GenerateEmbedUrlForAnonymousUserInput struct {
// The Amazon Resource Names (ARNs) for the Amazon QuickSight resources that the
// user is authorized to access during the lifetime of the session. If you choose
// Dashboard embedding experience, pass the list of dashboard ARNs in the account
// that you want the user to be able to view. Currently, you can pass up to 25
// dashboard ARNs in each API call.
//
// This member is required.
AuthorizedResourceArns []string
// The ID for the Amazon Web Services account that contains the dashboard that
// you're embedding.
//
// This member is required.
AwsAccountId *string
// The configuration of the experience that you are embedding.
//
// This member is required.
ExperienceConfiguration *types.AnonymousUserEmbeddingExperienceConfiguration
// The Amazon QuickSight namespace that the anonymous user virtually belongs to.
// If you are not using an Amazon QuickSight custom namespace, set this to default .
//
// This member is required.
Namespace *string
// The domains that you want to add to the allow list for access to the generated
// URL that is then embedded. This optional parameter overrides the static domains
// that are configured in the Manage QuickSight menu in the Amazon QuickSight
// console. Instead, it allows only the domains that you include in this parameter.
// You can list up to three domains or subdomains in each API call. To include all
// subdomains under a specific domain to the allow list, use * . For example,
// https://*.sapp.amazon.com includes all subdomains under https://sapp.amazon.com .
AllowedDomains []string
// How many minutes the session is valid. The session lifetime must be in [15-600]
// minutes range.
SessionLifetimeInMinutes *int64
// The session tags used for row-level security. Before you use this parameter,
// make sure that you have configured the relevant datasets using the
// DataSet$RowLevelPermissionTagConfiguration parameter so that session tags can be
// used to provide row-level security. These are not the tags used for the Amazon
// Web Services resource tagging feature. For more information, see Using
// Row-Level Security (RLS) with Tags (https://docs.aws.amazon.com/quicksight/latest/user/quicksight-dev-rls-tags.html)
// in the Amazon QuickSight User Guide.
SessionTags []types.SessionTag
noSmithyDocumentSerde
}
type GenerateEmbedUrlForAnonymousUserOutput struct {
// The Amazon Resource Name (ARN) to use for the anonymous Amazon QuickSight user.
//
// This member is required.
AnonymousUserArn *string
// The embed URL for the dashboard.
//
// This member is required.
EmbedUrl *string
// The Amazon Web Services request ID for this operation.
//
// This member is required.
RequestId *string
// The HTTP status of the request.
//
// This member is required.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGenerateEmbedUrlForAnonymousUserMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGenerateEmbedUrlForAnonymousUser{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGenerateEmbedUrlForAnonymousUser{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGenerateEmbedUrlForAnonymousUserValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGenerateEmbedUrlForAnonymousUser(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGenerateEmbedUrlForAnonymousUser(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "GenerateEmbedUrlForAnonymousUser",
}
}
| 202 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Generates an embed URL that you can use to embed an Amazon QuickSight
// experience in your website. This action can be used for any type of user
// registered in an Amazon QuickSight account. Before you use this action, make
// sure that you have configured the relevant Amazon QuickSight resource and
// permissions. The following rules apply to the generated URL:
// - It contains a temporary bearer token. It is valid for 5 minutes after it is
// generated. Once redeemed within this period, it cannot be re-used again.
// - The URL validity period should not be confused with the actual session
// lifetime that can be customized using the SessionLifetimeInMinutes (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html#QS-GenerateEmbedUrlForRegisteredUser-request-SessionLifetimeInMinutes)
// parameter. The resulting user session is valid for 15 minutes (minimum) to 10
// hours (maximum). The default session duration is 10 hours.
// - You are charged only when the URL is used or there is interaction with
// Amazon QuickSight.
//
// For more information, see Embedded Analytics (https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics.html)
// in the Amazon QuickSight User Guide. For more information about the high-level
// steps for embedding and for an interactive demo of the ways you can customize
// embedding, visit the Amazon QuickSight Developer Portal (https://docs.aws.amazon.com/quicksight/latest/user/quicksight-dev-portal.html)
// .
func (c *Client) GenerateEmbedUrlForRegisteredUser(ctx context.Context, params *GenerateEmbedUrlForRegisteredUserInput, optFns ...func(*Options)) (*GenerateEmbedUrlForRegisteredUserOutput, error) {
if params == nil {
params = &GenerateEmbedUrlForRegisteredUserInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GenerateEmbedUrlForRegisteredUser", params, optFns, c.addOperationGenerateEmbedUrlForRegisteredUserMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GenerateEmbedUrlForRegisteredUserOutput)
out.ResultMetadata = metadata
return out, nil
}
type GenerateEmbedUrlForRegisteredUserInput struct {
// The ID for the Amazon Web Services account that contains the dashboard that
// you're embedding.
//
// This member is required.
AwsAccountId *string
// The experience you are embedding. For registered users, you can embed Amazon
// QuickSight dashboards, Amazon QuickSight visuals, the Amazon QuickSight Q search
// bar, or the entire Amazon QuickSight console.
//
// This member is required.
ExperienceConfiguration *types.RegisteredUserEmbeddingExperienceConfiguration
// The Amazon Resource Name for the registered user.
//
// This member is required.
UserArn *string
// The domains that you want to add to the allow list for access to the generated
// URL that is then embedded. This optional parameter overrides the static domains
// that are configured in the Manage QuickSight menu in the Amazon QuickSight
// console. Instead, it allows only the domains that you include in this parameter.
// You can list up to three domains or subdomains in each API call. To include all
// subdomains under a specific domain to the allow list, use * . For example,
// https://*.sapp.amazon.com includes all subdomains under https://sapp.amazon.com .
AllowedDomains []string
// How many minutes the session is valid. The session lifetime must be in [15-600]
// minutes range.
SessionLifetimeInMinutes *int64
noSmithyDocumentSerde
}
type GenerateEmbedUrlForRegisteredUserOutput struct {
// The embed URL for the Amazon QuickSight dashboard, visual, Q search bar, or
// console.
//
// This member is required.
EmbedUrl *string
// The Amazon Web Services request ID for this operation.
//
// This member is required.
RequestId *string
// The HTTP status of the request.
//
// This member is required.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGenerateEmbedUrlForRegisteredUserMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGenerateEmbedUrlForRegisteredUser{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGenerateEmbedUrlForRegisteredUser{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGenerateEmbedUrlForRegisteredUserValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGenerateEmbedUrlForRegisteredUser(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGenerateEmbedUrlForRegisteredUser(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "GenerateEmbedUrlForRegisteredUser",
}
}
| 182 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Generates a temporary session URL and authorization code(bearer token) that you
// can use to embed an Amazon QuickSight read-only dashboard in your website or
// application. Before you use this command, make sure that you have configured the
// dashboards and permissions. Currently, you can use GetDashboardEmbedURL only
// from the server, not from the user's browser. The following rules apply to the
// generated URL:
// - They must be used together.
// - They can be used one time only.
// - They are valid for 5 minutes after you run this command.
// - You are charged only when the URL is used or there is interaction with
// Amazon QuickSight.
// - The resulting user session is valid for 15 minutes (default) up to 10 hours
// (maximum). You can use the optional SessionLifetimeInMinutes parameter to
// customize session duration.
//
// For more information, see Embedding Analytics Using GetDashboardEmbedUrl (https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html)
// in the Amazon QuickSight User Guide. For more information about the high-level
// steps for embedding and for an interactive demo of the ways you can customize
// embedding, visit the Amazon QuickSight Developer Portal (https://docs.aws.amazon.com/quicksight/latest/user/quicksight-dev-portal.html)
// .
func (c *Client) GetDashboardEmbedUrl(ctx context.Context, params *GetDashboardEmbedUrlInput, optFns ...func(*Options)) (*GetDashboardEmbedUrlOutput, error) {
if params == nil {
params = &GetDashboardEmbedUrlInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDashboardEmbedUrl", params, optFns, c.addOperationGetDashboardEmbedUrlMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDashboardEmbedUrlOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDashboardEmbedUrlInput struct {
// The ID for the Amazon Web Services account that contains the dashboard that
// you're embedding.
//
// This member is required.
AwsAccountId *string
// The ID for the dashboard, also added to the Identity and Access Management
// (IAM) policy.
//
// This member is required.
DashboardId *string
// The authentication method that the user uses to sign in.
//
// This member is required.
IdentityType types.EmbeddingIdentityType
// A list of one or more dashboard IDs that you want anonymous users to have
// tempporary access to. Currently, the IdentityType parameter must be set to
// ANONYMOUS because other identity types authenticate as Amazon QuickSight or IAM
// users. For example, if you set " --dashboard-id dash_id1 --dashboard-id dash_id2
// dash_id3 identity-type ANONYMOUS ", the session can access all three dashboards.
AdditionalDashboardIds []string
// The Amazon QuickSight namespace that contains the dashboard IDs in this
// request. If you're not using a custom namespace, set Namespace = default .
Namespace *string
// Remove the reset button on the embedded dashboard. The default is FALSE, which
// enables the reset button.
ResetDisabled bool
// How many minutes the session is valid. The session lifetime must be 15-600
// minutes.
SessionLifetimeInMinutes *int64
// Adds persistence of state for the user session in an embedded dashboard.
// Persistence applies to the sheet and the parameter settings. These are control
// settings that the dashboard subscriber (Amazon QuickSight reader) chooses while
// viewing the dashboard. If this is set to TRUE , the settings are the same when
// the subscriber reopens the same dashboard URL. The state is stored in Amazon
// QuickSight, not in a browser cookie. If this is set to FALSE, the state of the
// user session is not persisted. The default is FALSE .
StatePersistenceEnabled bool
// Remove the undo/redo button on the embedded dashboard. The default is FALSE,
// which enables the undo/redo button.
UndoRedoDisabled bool
// The Amazon QuickSight user's Amazon Resource Name (ARN), for use with QUICKSIGHT
// identity type. You can use this for any Amazon QuickSight users in your account
// (readers, authors, or admins) authenticated as one of the following:
// - Active Directory (AD) users or group members
// - Invited nonfederated users
// - IAM users and IAM role-based sessions authenticated through Federated
// Single Sign-On using SAML, OpenID Connect, or IAM federation.
// Omit this parameter for users in the third group – IAM users and IAM role-based
// sessions.
UserArn *string
noSmithyDocumentSerde
}
// Output returned from the GetDashboardEmbedUrl operation.
type GetDashboardEmbedUrlOutput struct {
// A single-use URL that you can put into your server-side webpage to embed your
// dashboard. This URL is valid for 5 minutes. The API operation provides the URL
// with an auth_code value that enables one (and only one) sign-on to a user
// session that is valid for 10 hours.
EmbedUrl *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDashboardEmbedUrlMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetDashboardEmbedUrl{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetDashboardEmbedUrl{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetDashboardEmbedUrlValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetDashboardEmbedUrl(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetDashboardEmbedUrl(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "GetDashboardEmbedUrl",
}
}
| 209 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Generates a session URL and authorization code that you can use to embed the
// Amazon Amazon QuickSight console in your web server code. Use GetSessionEmbedUrl
// where you want to provide an authoring portal that allows users to create data
// sources, datasets, analyses, and dashboards. The users who access an embedded
// Amazon QuickSight console need belong to the author or admin security cohort. If
// you want to restrict permissions to some of these features, add a custom
// permissions profile to the user with the UpdateUser (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateUser.html)
// API operation. Use RegisterUser (https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)
// API operation to add a new user with a custom permission profile attached. For
// more information, see the following sections in the Amazon QuickSight User
// Guide:
// - Embedding Analytics (https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics.html)
// - Customizing Access to the Amazon QuickSight Console (https://docs.aws.amazon.com/quicksight/latest/user/customizing-permissions-to-the-quicksight-console.html)
func (c *Client) GetSessionEmbedUrl(ctx context.Context, params *GetSessionEmbedUrlInput, optFns ...func(*Options)) (*GetSessionEmbedUrlOutput, error) {
if params == nil {
params = &GetSessionEmbedUrlInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSessionEmbedUrl", params, optFns, c.addOperationGetSessionEmbedUrlMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSessionEmbedUrlOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSessionEmbedUrlInput struct {
// The ID for the Amazon Web Services account associated with your Amazon
// QuickSight subscription.
//
// This member is required.
AwsAccountId *string
// The URL you use to access the embedded session. The entry point URL is
// constrained to the following paths:
// - /start
// - /start/analyses
// - /start/dashboards
// - /start/favorites
// - /dashboards/DashboardId - where DashboardId is the actual ID key from the
// Amazon QuickSight console URL of the dashboard
// - /analyses/AnalysisId - where AnalysisId is the actual ID key from the Amazon
// QuickSight console URL of the analysis
EntryPoint *string
// How many minutes the session is valid. The session lifetime must be 15-600
// minutes.
SessionLifetimeInMinutes *int64
// The Amazon QuickSight user's Amazon Resource Name (ARN), for use with QUICKSIGHT
// identity type. You can use this for any type of Amazon QuickSight users in your
// account (readers, authors, or admins). They need to be authenticated as one of
// the following:
// - Active Directory (AD) users or group members
// - Invited nonfederated users
// - IAM users and IAM role-based sessions authenticated through Federated
// Single Sign-On using SAML, OpenID Connect, or IAM federation
// Omit this parameter for users in the third group, IAM users and IAM role-based
// sessions.
UserArn *string
noSmithyDocumentSerde
}
type GetSessionEmbedUrlOutput struct {
// A single-use URL that you can put into your server-side web page to embed your
// Amazon QuickSight session. This URL is valid for 5 minutes. The API operation
// provides the URL with an auth_code value that enables one (and only one)
// sign-on to a user session that is valid for 10 hours.
EmbedUrl *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSessionEmbedUrlMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetSessionEmbedUrl{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetSessionEmbedUrl{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetSessionEmbedUrlValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSessionEmbedUrl(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetSessionEmbedUrl(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "GetSessionEmbedUrl",
}
}
| 174 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists Amazon QuickSight analyses that exist in the specified Amazon Web
// Services account.
func (c *Client) ListAnalyses(ctx context.Context, params *ListAnalysesInput, optFns ...func(*Options)) (*ListAnalysesOutput, error) {
if params == nil {
params = &ListAnalysesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAnalyses", params, optFns, c.addOperationListAnalysesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAnalysesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAnalysesInput struct {
// The ID of the Amazon Web Services account that contains the analyses.
//
// This member is required.
AwsAccountId *string
// The maximum number of results to return.
MaxResults *int32
// A pagination token that can be used in a subsequent request.
NextToken *string
noSmithyDocumentSerde
}
type ListAnalysesOutput struct {
// Metadata describing each of the analyses that are listed.
AnalysisSummaryList []types.AnalysisSummary
// A pagination token that can be used in a subsequent request.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAnalysesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAnalyses{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAnalyses{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListAnalysesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAnalyses(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListAnalysesAPIClient is a client that implements the ListAnalyses operation.
type ListAnalysesAPIClient interface {
ListAnalyses(context.Context, *ListAnalysesInput, ...func(*Options)) (*ListAnalysesOutput, error)
}
var _ ListAnalysesAPIClient = (*Client)(nil)
// ListAnalysesPaginatorOptions is the paginator options for ListAnalyses
type ListAnalysesPaginatorOptions struct {
// The maximum number of results to return.
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
}
// ListAnalysesPaginator is a paginator for ListAnalyses
type ListAnalysesPaginator struct {
options ListAnalysesPaginatorOptions
client ListAnalysesAPIClient
params *ListAnalysesInput
nextToken *string
firstPage bool
}
// NewListAnalysesPaginator returns a new ListAnalysesPaginator
func NewListAnalysesPaginator(client ListAnalysesAPIClient, params *ListAnalysesInput, optFns ...func(*ListAnalysesPaginatorOptions)) *ListAnalysesPaginator {
if params == nil {
params = &ListAnalysesInput{}
}
options := ListAnalysesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAnalysesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAnalysesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAnalyses page.
func (p *ListAnalysesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAnalysesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListAnalyses(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListAnalyses(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListAnalyses",
}
}
| 231 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all asset bundle export jobs that have been taken place in the last 14
// days. Jobs created more than 14 days ago are deleted forever and are not
// returned. If you are using the same job ID for multiple jobs,
// ListAssetBundleExportJobs only returns the most recent job that uses the
// repeated job ID.
func (c *Client) ListAssetBundleExportJobs(ctx context.Context, params *ListAssetBundleExportJobsInput, optFns ...func(*Options)) (*ListAssetBundleExportJobsOutput, error) {
if params == nil {
params = &ListAssetBundleExportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAssetBundleExportJobs", params, optFns, c.addOperationListAssetBundleExportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAssetBundleExportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAssetBundleExportJobsInput struct {
// The ID of the Amazon Web Services account that the export jobs were executed in.
//
// This member is required.
AwsAccountId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListAssetBundleExportJobsOutput struct {
// A list of export job summaries.
AssetBundleExportJobSummaryList []types.AssetBundleExportJobSummary
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAssetBundleExportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAssetBundleExportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAssetBundleExportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListAssetBundleExportJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAssetBundleExportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListAssetBundleExportJobsAPIClient is a client that implements the
// ListAssetBundleExportJobs operation.
type ListAssetBundleExportJobsAPIClient interface {
ListAssetBundleExportJobs(context.Context, *ListAssetBundleExportJobsInput, ...func(*Options)) (*ListAssetBundleExportJobsOutput, error)
}
var _ ListAssetBundleExportJobsAPIClient = (*Client)(nil)
// ListAssetBundleExportJobsPaginatorOptions is the paginator options for
// ListAssetBundleExportJobs
type ListAssetBundleExportJobsPaginatorOptions struct {
// The maximum number of results to be returned per request.
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
}
// ListAssetBundleExportJobsPaginator is a paginator for ListAssetBundleExportJobs
type ListAssetBundleExportJobsPaginator struct {
options ListAssetBundleExportJobsPaginatorOptions
client ListAssetBundleExportJobsAPIClient
params *ListAssetBundleExportJobsInput
nextToken *string
firstPage bool
}
// NewListAssetBundleExportJobsPaginator returns a new
// ListAssetBundleExportJobsPaginator
func NewListAssetBundleExportJobsPaginator(client ListAssetBundleExportJobsAPIClient, params *ListAssetBundleExportJobsInput, optFns ...func(*ListAssetBundleExportJobsPaginatorOptions)) *ListAssetBundleExportJobsPaginator {
if params == nil {
params = &ListAssetBundleExportJobsInput{}
}
options := ListAssetBundleExportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAssetBundleExportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAssetBundleExportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAssetBundleExportJobs page.
func (p *ListAssetBundleExportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAssetBundleExportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListAssetBundleExportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListAssetBundleExportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListAssetBundleExportJobs",
}
}
| 237 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all asset bundle import jobs that have taken place in the last 14 days.
// Jobs created more than 14 days ago are deleted forever and are not returned. If
// you are using the same job ID for multiple jobs, ListAssetBundleImportJobs only
// returns the most recent job that uses the repeated job ID.
func (c *Client) ListAssetBundleImportJobs(ctx context.Context, params *ListAssetBundleImportJobsInput, optFns ...func(*Options)) (*ListAssetBundleImportJobsOutput, error) {
if params == nil {
params = &ListAssetBundleImportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAssetBundleImportJobs", params, optFns, c.addOperationListAssetBundleImportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAssetBundleImportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAssetBundleImportJobsInput struct {
// The ID of the Amazon Web Services account that the import jobs were executed in.
//
// This member is required.
AwsAccountId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListAssetBundleImportJobsOutput struct {
// A list of import job summaries.
AssetBundleImportJobSummaryList []types.AssetBundleImportJobSummary
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the response.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAssetBundleImportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAssetBundleImportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAssetBundleImportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListAssetBundleImportJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAssetBundleImportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListAssetBundleImportJobsAPIClient is a client that implements the
// ListAssetBundleImportJobs operation.
type ListAssetBundleImportJobsAPIClient interface {
ListAssetBundleImportJobs(context.Context, *ListAssetBundleImportJobsInput, ...func(*Options)) (*ListAssetBundleImportJobsOutput, error)
}
var _ ListAssetBundleImportJobsAPIClient = (*Client)(nil)
// ListAssetBundleImportJobsPaginatorOptions is the paginator options for
// ListAssetBundleImportJobs
type ListAssetBundleImportJobsPaginatorOptions struct {
// The maximum number of results to be returned per request.
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
}
// ListAssetBundleImportJobsPaginator is a paginator for ListAssetBundleImportJobs
type ListAssetBundleImportJobsPaginator struct {
options ListAssetBundleImportJobsPaginatorOptions
client ListAssetBundleImportJobsAPIClient
params *ListAssetBundleImportJobsInput
nextToken *string
firstPage bool
}
// NewListAssetBundleImportJobsPaginator returns a new
// ListAssetBundleImportJobsPaginator
func NewListAssetBundleImportJobsPaginator(client ListAssetBundleImportJobsAPIClient, params *ListAssetBundleImportJobsInput, optFns ...func(*ListAssetBundleImportJobsPaginatorOptions)) *ListAssetBundleImportJobsPaginator {
if params == nil {
params = &ListAssetBundleImportJobsInput{}
}
options := ListAssetBundleImportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAssetBundleImportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAssetBundleImportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAssetBundleImportJobs page.
func (p *ListAssetBundleImportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAssetBundleImportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListAssetBundleImportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListAssetBundleImportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListAssetBundleImportJobs",
}
}
| 236 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists dashboards in an Amazon Web Services account.
func (c *Client) ListDashboards(ctx context.Context, params *ListDashboardsInput, optFns ...func(*Options)) (*ListDashboardsOutput, error) {
if params == nil {
params = &ListDashboardsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDashboards", params, optFns, c.addOperationListDashboardsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDashboardsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDashboardsInput struct {
// The ID of the Amazon Web Services account that contains the dashboards that
// you're listing.
//
// This member is required.
AwsAccountId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListDashboardsOutput struct {
// A structure that contains all of the dashboards in your Amazon Web Services
// account. This structure provides basic information about the dashboards.
DashboardSummaryList []types.DashboardSummary
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDashboardsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDashboards{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDashboards{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListDashboardsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDashboards(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDashboardsAPIClient is a client that implements the ListDashboards
// operation.
type ListDashboardsAPIClient interface {
ListDashboards(context.Context, *ListDashboardsInput, ...func(*Options)) (*ListDashboardsOutput, error)
}
var _ ListDashboardsAPIClient = (*Client)(nil)
// ListDashboardsPaginatorOptions is the paginator options for ListDashboards
type ListDashboardsPaginatorOptions struct {
// The maximum number of results to be returned per request.
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
}
// ListDashboardsPaginator is a paginator for ListDashboards
type ListDashboardsPaginator struct {
options ListDashboardsPaginatorOptions
client ListDashboardsAPIClient
params *ListDashboardsInput
nextToken *string
firstPage bool
}
// NewListDashboardsPaginator returns a new ListDashboardsPaginator
func NewListDashboardsPaginator(client ListDashboardsAPIClient, params *ListDashboardsInput, optFns ...func(*ListDashboardsPaginatorOptions)) *ListDashboardsPaginator {
if params == nil {
params = &ListDashboardsInput{}
}
options := ListDashboardsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDashboardsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDashboardsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDashboards page.
func (p *ListDashboardsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDashboardsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDashboards(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDashboards(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListDashboards",
}
}
| 233 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all the versions of the dashboards in the Amazon QuickSight subscription.
func (c *Client) ListDashboardVersions(ctx context.Context, params *ListDashboardVersionsInput, optFns ...func(*Options)) (*ListDashboardVersionsOutput, error) {
if params == nil {
params = &ListDashboardVersionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDashboardVersions", params, optFns, c.addOperationListDashboardVersionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDashboardVersionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDashboardVersionsInput struct {
// The ID of the Amazon Web Services account that contains the dashboard that
// you're listing versions for.
//
// This member is required.
AwsAccountId *string
// The ID for the dashboard.
//
// This member is required.
DashboardId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListDashboardVersionsOutput struct {
// A structure that contains information about each version of the dashboard.
DashboardVersionSummaryList []types.DashboardVersionSummary
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDashboardVersionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDashboardVersions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDashboardVersions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListDashboardVersionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDashboardVersions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDashboardVersionsAPIClient is a client that implements the
// ListDashboardVersions operation.
type ListDashboardVersionsAPIClient interface {
ListDashboardVersions(context.Context, *ListDashboardVersionsInput, ...func(*Options)) (*ListDashboardVersionsOutput, error)
}
var _ ListDashboardVersionsAPIClient = (*Client)(nil)
// ListDashboardVersionsPaginatorOptions is the paginator options for
// ListDashboardVersions
type ListDashboardVersionsPaginatorOptions struct {
// The maximum number of results to be returned per request.
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
}
// ListDashboardVersionsPaginator is a paginator for ListDashboardVersions
type ListDashboardVersionsPaginator struct {
options ListDashboardVersionsPaginatorOptions
client ListDashboardVersionsAPIClient
params *ListDashboardVersionsInput
nextToken *string
firstPage bool
}
// NewListDashboardVersionsPaginator returns a new ListDashboardVersionsPaginator
func NewListDashboardVersionsPaginator(client ListDashboardVersionsAPIClient, params *ListDashboardVersionsInput, optFns ...func(*ListDashboardVersionsPaginatorOptions)) *ListDashboardVersionsPaginator {
if params == nil {
params = &ListDashboardVersionsInput{}
}
options := ListDashboardVersionsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDashboardVersionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDashboardVersionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDashboardVersions page.
func (p *ListDashboardVersionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDashboardVersionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDashboardVersions(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDashboardVersions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListDashboardVersions",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all of the datasets belonging to the current Amazon Web Services account
// in an Amazon Web Services Region. The permissions resource is
// arn:aws:quicksight:region:aws-account-id:dataset/* .
func (c *Client) ListDataSets(ctx context.Context, params *ListDataSetsInput, optFns ...func(*Options)) (*ListDataSetsOutput, error) {
if params == nil {
params = &ListDataSetsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDataSets", params, optFns, c.addOperationListDataSetsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDataSetsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDataSetsInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListDataSetsOutput struct {
// The list of dataset summaries.
DataSetSummaries []types.DataSetSummary
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDataSetsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDataSets{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDataSets{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListDataSetsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDataSets(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDataSetsAPIClient is a client that implements the ListDataSets operation.
type ListDataSetsAPIClient interface {
ListDataSets(context.Context, *ListDataSetsInput, ...func(*Options)) (*ListDataSetsOutput, error)
}
var _ ListDataSetsAPIClient = (*Client)(nil)
// ListDataSetsPaginatorOptions is the paginator options for ListDataSets
type ListDataSetsPaginatorOptions struct {
// The maximum number of results to be returned per request.
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
}
// ListDataSetsPaginator is a paginator for ListDataSets
type ListDataSetsPaginator struct {
options ListDataSetsPaginatorOptions
client ListDataSetsAPIClient
params *ListDataSetsInput
nextToken *string
firstPage bool
}
// NewListDataSetsPaginator returns a new ListDataSetsPaginator
func NewListDataSetsPaginator(client ListDataSetsAPIClient, params *ListDataSetsInput, optFns ...func(*ListDataSetsPaginatorOptions)) *ListDataSetsPaginator {
if params == nil {
params = &ListDataSetsInput{}
}
options := ListDataSetsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDataSetsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDataSetsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDataSets page.
func (p *ListDataSetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDataSetsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDataSets(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDataSets(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListDataSets",
}
}
| 232 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists data sources in current Amazon Web Services Region that belong to this
// Amazon Web Services account.
func (c *Client) ListDataSources(ctx context.Context, params *ListDataSourcesInput, optFns ...func(*Options)) (*ListDataSourcesOutput, error) {
if params == nil {
params = &ListDataSourcesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDataSources", params, optFns, c.addOperationListDataSourcesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDataSourcesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDataSourcesInput struct {
// The Amazon Web Services account ID.
//
// This member is required.
AwsAccountId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListDataSourcesOutput struct {
// A list of data sources.
DataSources []types.DataSource
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDataSourcesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDataSources{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDataSources{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListDataSourcesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDataSources(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDataSourcesAPIClient is a client that implements the ListDataSources
// operation.
type ListDataSourcesAPIClient interface {
ListDataSources(context.Context, *ListDataSourcesInput, ...func(*Options)) (*ListDataSourcesOutput, error)
}
var _ ListDataSourcesAPIClient = (*Client)(nil)
// ListDataSourcesPaginatorOptions is the paginator options for ListDataSources
type ListDataSourcesPaginatorOptions struct {
// The maximum number of results to be returned per request.
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
}
// ListDataSourcesPaginator is a paginator for ListDataSources
type ListDataSourcesPaginator struct {
options ListDataSourcesPaginatorOptions
client ListDataSourcesAPIClient
params *ListDataSourcesInput
nextToken *string
firstPage bool
}
// NewListDataSourcesPaginator returns a new ListDataSourcesPaginator
func NewListDataSourcesPaginator(client ListDataSourcesAPIClient, params *ListDataSourcesInput, optFns ...func(*ListDataSourcesPaginatorOptions)) *ListDataSourcesPaginator {
if params == nil {
params = &ListDataSourcesInput{}
}
options := ListDataSourcesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDataSourcesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDataSourcesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDataSources page.
func (p *ListDataSourcesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDataSourcesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDataSources(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDataSources(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListDataSources",
}
}
| 232 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List all assets ( DASHBOARD , ANALYSIS , and DATASET ) in a folder.
func (c *Client) ListFolderMembers(ctx context.Context, params *ListFolderMembersInput, optFns ...func(*Options)) (*ListFolderMembersOutput, error) {
if params == nil {
params = &ListFolderMembersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListFolderMembers", params, optFns, c.addOperationListFolderMembersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListFolderMembersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListFolderMembersInput struct {
// The ID for the Amazon Web Services account that contains the folder.
//
// This member is required.
AwsAccountId *string
// The ID of the folder.
//
// This member is required.
FolderId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListFolderMembersOutput struct {
// A structure that contains all of the folder members (dashboards, analyses, and
// datasets) in the folder.
FolderMemberList []types.MemberIdArnPair
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListFolderMembersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListFolderMembers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListFolderMembers{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListFolderMembersValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListFolderMembers(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opListFolderMembers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListFolderMembers",
}
}
| 146 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all folders in an account.
func (c *Client) ListFolders(ctx context.Context, params *ListFoldersInput, optFns ...func(*Options)) (*ListFoldersOutput, error) {
if params == nil {
params = &ListFoldersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListFolders", params, optFns, c.addOperationListFoldersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListFoldersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListFoldersInput struct {
// The ID for the Amazon Web Services account that contains the folder.
//
// This member is required.
AwsAccountId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListFoldersOutput struct {
// A structure that contains all of the folders in the Amazon Web Services
// account. This structure provides basic information about the folders.
FolderSummaryList []types.FolderSummary
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListFoldersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListFolders{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListFolders{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListFoldersValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListFolders(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opListFolders(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListFolders",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists member users in a group.
func (c *Client) ListGroupMemberships(ctx context.Context, params *ListGroupMembershipsInput, optFns ...func(*Options)) (*ListGroupMembershipsOutput, error) {
if params == nil {
params = &ListGroupMembershipsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListGroupMemberships", params, optFns, c.addOperationListGroupMembershipsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListGroupMembershipsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListGroupMembershipsInput struct {
// The ID for the Amazon Web Services account that the group is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The name of the group that you want to see a membership list of.
//
// This member is required.
GroupName *string
// The namespace of the group that you want a list of users from.
//
// This member is required.
Namespace *string
// The maximum number of results to return from this request.
MaxResults *int32
// A pagination token that can be used in a subsequent request.
NextToken *string
noSmithyDocumentSerde
}
type ListGroupMembershipsOutput struct {
// The list of the members of the group.
GroupMemberList []types.GroupMember
// A pagination token that can be used in a subsequent request.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListGroupMembershipsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListGroupMemberships{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListGroupMemberships{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListGroupMembershipsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListGroupMemberships(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opListGroupMemberships(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListGroupMemberships",
}
}
| 152 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all user groups in Amazon QuickSight.
func (c *Client) ListGroups(ctx context.Context, params *ListGroupsInput, optFns ...func(*Options)) (*ListGroupsOutput, error) {
if params == nil {
params = &ListGroupsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListGroups", params, optFns, c.addOperationListGroupsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListGroupsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListGroupsInput struct {
// The ID for the Amazon Web Services account that the group is in. Currently, you
// use the ID for the Amazon Web Services account that contains your Amazon
// QuickSight account.
//
// This member is required.
AwsAccountId *string
// The namespace that you want a list of groups from.
//
// This member is required.
Namespace *string
// The maximum number of results to return.
MaxResults *int32
// A pagination token that can be used in a subsequent request.
NextToken *string
noSmithyDocumentSerde
}
type ListGroupsOutput struct {
// The list of the groups.
GroupList []types.Group
// A pagination token that can be used in a subsequent request.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListGroups{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListGroups{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListGroupsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListGroups(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opListGroups(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListGroups",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the IAM policy assignments in the current Amazon QuickSight account.
func (c *Client) ListIAMPolicyAssignments(ctx context.Context, params *ListIAMPolicyAssignmentsInput, optFns ...func(*Options)) (*ListIAMPolicyAssignmentsOutput, error) {
if params == nil {
params = &ListIAMPolicyAssignmentsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListIAMPolicyAssignments", params, optFns, c.addOperationListIAMPolicyAssignmentsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListIAMPolicyAssignmentsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListIAMPolicyAssignmentsInput struct {
// The ID of the Amazon Web Services account that contains these IAM policy
// assignments.
//
// This member is required.
AwsAccountId *string
// The namespace for the assignments.
//
// This member is required.
Namespace *string
// The status of the assignments.
AssignmentStatus types.AssignmentStatus
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListIAMPolicyAssignmentsOutput struct {
// Information describing the IAM policy assignments.
IAMPolicyAssignments []types.IAMPolicyAssignmentSummary
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListIAMPolicyAssignmentsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListIAMPolicyAssignments{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListIAMPolicyAssignments{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListIAMPolicyAssignmentsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListIAMPolicyAssignments(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opListIAMPolicyAssignments(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListIAMPolicyAssignments",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package quicksight
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all of the IAM policy assignments, including the Amazon Resource Names
// (ARNs), for the IAM policies assigned to the specified user and group, or groups
// that the user belongs to.
func (c *Client) ListIAMPolicyAssignmentsForUser(ctx context.Context, params *ListIAMPolicyAssignmentsForUserInput, optFns ...func(*Options)) (*ListIAMPolicyAssignmentsForUserOutput, error) {
if params == nil {
params = &ListIAMPolicyAssignmentsForUserInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListIAMPolicyAssignmentsForUser", params, optFns, c.addOperationListIAMPolicyAssignmentsForUserMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListIAMPolicyAssignmentsForUserOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListIAMPolicyAssignmentsForUserInput struct {
// The ID of the Amazon Web Services account that contains the assignments.
//
// This member is required.
AwsAccountId *string
// The namespace of the assignment.
//
// This member is required.
Namespace *string
// The name of the user.
//
// This member is required.
UserName *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token for the next set of results, or null if there are no more results.
NextToken *string
noSmithyDocumentSerde
}
type ListIAMPolicyAssignmentsForUserOutput struct {
// The active assignments for this user.
ActiveAssignments []types.ActiveIAMPolicyAssignment
// The token for the next set of results, or null if there are no more results.
NextToken *string
// The Amazon Web Services request ID for this operation.
RequestId *string
// The HTTP status of the request.
Status int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListIAMPolicyAssignmentsForUserMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListIAMPolicyAssignmentsForUser{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListIAMPolicyAssignmentsForUser{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListIAMPolicyAssignmentsForUserValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListIAMPolicyAssignmentsForUser(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opListIAMPolicyAssignmentsForUser(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "quicksight",
OperationName: "ListIAMPolicyAssignmentsForUser",
}
}
| 152 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.