secretsmanager

type CancelRotateSecretInput struct {
	// Specifies the secret to cancel a rotation request. You can specify either the
	// Amazon Resource Name (ARN) or the friendly name of the secret. If you specify an
	// ARN, we generally recommend that you specify a complete ARN. You can specify a
	// partial ARN too—for example, if you don’t include the final hyphen and six
	// random characters that Secrets Manager adds at the end of the ARN when you
	// created the secret. A partial ARN match can work as long as it uniquely matches
	// only one secret. However, if your secret has a name that ends in a hyphen
	// followed by six characters (before Secrets Manager adds the hyphen and six
	// characters to the ARN) and you try to use that as a partial ARN, then those
	// characters cause Secrets Manager to assume that you’re specifying a complete
	// ARN. This confusion can cause unexpected results. To avoid this situation, we
	// recommend that you don’t create secret names ending with a hyphen followed by
	// six characters. If you specify an incomplete ARN without the random suffix, and
	// instead provide the 'friendly name', you must not include the random suffix. If
	// you do include the random suffix added by Secrets Manager, you receive either a
	// ResourceNotFoundException or an AccessDeniedException error, depending on your
	// permissions.
	SecretId *string
}

type CancelRotateSecretOutput struct {
	// The unique identifier of the version of the secret created during the rotation.
	// This version might not be complete, and should be evaluated for possible
	// deletion. At the very least, you should remove the VersionStage value AWSPENDING
	// to enable this version to be deleted. Failing to clean up a cancelled rotation
	// can block you from successfully starting future rotations.
	VersionId *string
	// The ARN of the secret for which rotation was canceled.
	ARN *string
	// The friendly name of the secret for which rotation was canceled.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

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

type CreateSecretInput struct {
	// Specifies the friendly name of the new secret. The secret name must be ASCII
	// letters, digits, or the following characters : /_+=.@- Do not end your secret
	// name with a hyphen followed by six characters. If you do so, you risk confusion
	// and unexpected results when searching for a secret by partial ARN. Secrets
	// Manager automatically adds a hyphen and six random characters at the end of the
	// ARN.
	Name *string
	// (Optional) Specifies text data that you want to encrypt and store in this new
	// version of the secret. Either SecretString or SecretBinary must have a value,
	// but not both. They cannot both be empty. If you create a secret by using the
	// Secrets Manager console then Secrets Manager puts the protected secret text in
	// only the SecretString parameter. The Secrets Manager console stores the
	// information as a JSON structure of key/value pairs that the Lambda rotation
	// function knows how to parse. For storing multiple values, we recommend that you
	// use a JSON text string argument and specify key/value pairs. For information on
	// how to format a JSON parameter for the various command line tool environments,
	// see Using JSON for Parameters
	// (https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-json)
	// in the AWS CLI User Guide. For example:
	// {"username":"bob","password":"abc123xyz456"} If your command-line tool or SDK
	// requires quotation marks around the parameter, you should use single quotes to
	// avoid confusion with the double quotes required in the JSON text.
	SecretString *string
	// (Optional) Specifies a user-provided description of the secret.
	Description *string
	// (Optional) Specifies binary data that you want to encrypt and store in the new
	// version of the secret. To use this parameter in the command-line tools, we
	// recommend that you store your binary data in a file and then use the appropriate
	// technique for your tool to pass the contents of the file as a parameter. Either
	// SecretString or SecretBinary must have a value, but not both. They cannot both
	// be empty. This parameter is not available using the Secrets Manager console. It
	// can be accessed only by using the AWS CLI or one of the AWS SDKs.
	SecretBinary []byte
	// (Optional) If you include SecretString or SecretBinary, then an initial version
	// is created as part of the secret, and this parameter specifies a unique
	// identifier for the new version. If you use the AWS CLI or one of the AWS SDK to
	// call this operation, then you can leave this parameter empty. The CLI or SDK
	// generates a random UUID for you and includes it as the value for this parameter
	// in the request. If you don't use the SDK and instead generate a raw HTTP request
	// to the Secrets Manager service endpoint, then you must generate a
	// ClientRequestToken yourself for the new version and include the value in the
	// request. This value helps ensure idempotency. Secrets Manager uses this value to
	// prevent the accidental creation of duplicate versions if there are failures and
	// retries during a rotation. We recommend that you generate a UUID-type
	// (https://wikipedia.org/wiki/Universally_unique_identifier) value to ensure
	// uniqueness of your versions within the specified secret.
	//
	//     * If the
	// ClientRequestToken value isn't already associated with a version of the secret
	// then a new version of the secret is created.
	//
	//     * If a version with this value
	// already exists and the version SecretString and SecretBinary values are the same
	// as those in the request, then the request is ignored.
	//
	//     * If a version with
	// this value already exists and that version's SecretString and SecretBinary
	// values are different from those in the request then the request fails because
	// you cannot modify an existing version. Instead, use PutSecretValue () to create
	// a new version.
	//
	// This value becomes the VersionId of the new version.
	ClientRequestToken *string
	// (Optional) Specifies the ARN, Key ID, or alias of the AWS KMS customer master
	// key (CMK) to be used to encrypt the SecretString or SecretBinary values in the
	// versions stored in this secret. You can specify any of the supported ways to
	// identify a AWS KMS key ID. If you need to reference a CMK in a different
	// account, you can use only the key ARN or the alias ARN. If you don't specify
	// this value, then Secrets Manager defaults to using the AWS account's default CMK
	// (the one named aws/secretsmanager). If a AWS KMS CMK with that name doesn't yet
	// exist, then Secrets Manager creates it for you automatically the first time it
	// needs to encrypt a version's SecretString or SecretBinary fields. You can use
	// the account default CMK to encrypt and decrypt only if you call this operation
	// using credentials from the same account that owns the secret. If the secret
	// resides in a different account, then you must create a custom CMK and specify
	// the ARN in this field.
	KmsKeyId *string
	// (Optional) Specifies a list of user-defined tags that are attached to the
	// secret. Each tag is a "Key" and "Value" pair of strings. This operation only
	// appends tags to the existing list of tags. To remove tags, you must use
	// UntagResource ().
	//
	//     * Secrets Manager tag key names are case sensitive. A tag
	// with the key "ABC" is a different tag from one with key "abc".
	//
	//     * If you
	// check tags in IAM policy Condition elements as part of your security strategy,
	// then adding or removing a tag can change permissions. If the successful
	// completion of this operation would result in you losing your permissions for
	// this secret, then this operation is blocked and returns an Access Denied
	// error.
	//
	// This parameter requires a JSON text string argument. For information on
	// how to format a JSON parameter for the various command line tool environments,
	// see Using JSON for Parameters
	// (https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-json)
	// in the AWS CLI User Guide. For example:
	// [{"Key":"CostCenter","Value":"12345"},{"Key":"environment","Value":"production"}]
	// If your command-line tool or SDK requires quotation marks around the parameter,
	// you should use single quotes to avoid confusion with the double quotes required
	// in the JSON text. The following basic restrictions apply to tags:
	//
	//     * Maximum
	// number of tags per secret—50
	//
	//     * Maximum key length—127 Unicode characters in
	// UTF-8
	//
	//     * Maximum value length—255 Unicode characters in UTF-8
	//
	//     * Tag
	// keys and values are case sensitive.
	//
	//     * Do not use the aws: prefix in your
	// tag names or values because AWS reserves it for AWS use. You can't edit or
	// delete tag names or values with this prefix. Tags with this prefix do not count
	// against your tags per secret limit.
	//
	//     * If you use your tagging schema across
	// multiple services and resources, remember other services might have restrictions
	// on allowed characters. Generally allowed characters: letters, spaces, and
	// numbers representable in UTF-8, plus the following special characters: + - = . _
	// : / @.
	Tags []*types.Tag
}

type CreateSecretOutput struct {
	// The friendly name of the secret that you just created.
	Name *string
	// The unique identifier associated with the version of the secret you just
	// created.
	VersionId *string
	// The Amazon Resource Name (ARN) of the secret that you just created. Secrets
	// Manager automatically adds several random characters to the name at the end of
	// the ARN when you initially create a secret. This affects only the ARN and not
	// the actual friendly name. This ensures that if you create a new secret with the
	// same name as an old secret that you previously deleted, then users with access
	// to the old secret don't automatically get access to the new secret because the
	// ARNs are different.
	ARN *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteResourcePolicyInput struct {
	// Specifies the secret that you want to delete the attached resource-based policy
	// for. You can specify either the Amazon Resource Name (ARN) or the friendly name
	// of the secret. If you specify an ARN, we generally recommend that you specify a
	// complete ARN. You can specify a partial ARN too—for example, if you don’t
	// include the final hyphen and six random characters that Secrets Manager adds at
	// the end of the ARN when you created the secret. A partial ARN match can work as
	// long as it uniquely matches only one secret. However, if your secret has a name
	// that ends in a hyphen followed by six characters (before Secrets Manager adds
	// the hyphen and six characters to the ARN) and you try to use that as a partial
	// ARN, then those characters cause Secrets Manager to assume that you’re
	// specifying a complete ARN. This confusion can cause unexpected results. To avoid
	// this situation, we recommend that you don’t create secret names ending with a
	// hyphen followed by six characters. If you specify an incomplete ARN without the
	// random suffix, and instead provide the 'friendly name', you must not include the
	// random suffix. If you do include the random suffix added by Secrets Manager, you
	// receive either a ResourceNotFoundException or an AccessDeniedException error,
	// depending on your permissions.
	SecretId *string
}

type DeleteResourcePolicyOutput struct {
	// The friendly name of the secret that the resource-based policy was deleted for.
	Name *string
	// The ARN of the secret that the resource-based policy was deleted for.
	ARN *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteSecretInput struct {
	// (Optional) Specifies that the secret is to be deleted without any recovery
	// window. You can't use both this parameter and the RecoveryWindowInDays parameter
	// in the same API call. An asynchronous background process performs the actual
	// deletion, so there can be a short delay before the operation completes. If you
	// write code to delete and then immediately recreate a secret with the same name,
	// ensure that your code includes appropriate back off and retry logic. Use this
	// parameter with caution. This parameter causes the operation to skip the normal
	// waiting period before the permanent deletion that AWS would normally impose with
	// the RecoveryWindowInDays parameter. If you delete a secret with the
	// ForceDeleteWithouRecovery parameter, then you have no opportunity to recover the
	// secret. It is permanently lost.
	ForceDeleteWithoutRecovery *bool
	// Specifies the secret that you want to delete. You can specify either the Amazon
	// Resource Name (ARN) or the friendly name of the secret. If you specify an ARN,
	// we generally recommend that you specify a complete ARN. You can specify a
	// partial ARN too—for example, if you don’t include the final hyphen and six
	// random characters that Secrets Manager adds at the end of the ARN when you
	// created the secret. A partial ARN match can work as long as it uniquely matches
	// only one secret. However, if your secret has a name that ends in a hyphen
	// followed by six characters (before Secrets Manager adds the hyphen and six
	// characters to the ARN) and you try to use that as a partial ARN, then those
	// characters cause Secrets Manager to assume that you’re specifying a complete
	// ARN. This confusion can cause unexpected results. To avoid this situation, we
	// recommend that you don’t create secret names ending with a hyphen followed by
	// six characters. If you specify an incomplete ARN without the random suffix, and
	// instead provide the 'friendly name', you must not include the random suffix. If
	// you do include the random suffix added by Secrets Manager, you receive either a
	// ResourceNotFoundException or an AccessDeniedException error, depending on your
	// permissions.
	SecretId *string
	// (Optional) Specifies the number of days that Secrets Manager waits before it can
	// delete the secret. You can't use both this parameter and the
	// ForceDeleteWithoutRecovery parameter in the same API call. This value can range
	// from 7 to 30 days. The default value is 30.
	RecoveryWindowInDays *int64
}

type DeleteSecretOutput struct {
	// The ARN of the secret that is now scheduled for deletion.
	ARN *string
	// The friendly name of the secret that is now scheduled for deletion.
	Name *string
	// The date and time after which this secret can be deleted by Secrets Manager and
	// can no longer be restored. This value is the date and time of the delete request
	// plus the number of days specified in RecoveryWindowInDays.
	DeletionDate *time.Time

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeSecretInput struct {
	// The identifier of the secret whose details you want to retrieve. You can specify
	// either the Amazon Resource Name (ARN) or the friendly name of the secret. If you
	// specify an ARN, we generally recommend that you specify a complete ARN. You can
	// specify a partial ARN too—for example, if you don’t include the final hyphen and
	// six random characters that Secrets Manager adds at the end of the ARN when you
	// created the secret. A partial ARN match can work as long as it uniquely matches
	// only one secret. However, if your secret has a name that ends in a hyphen
	// followed by six characters (before Secrets Manager adds the hyphen and six
	// characters to the ARN) and you try to use that as a partial ARN, then those
	// characters cause Secrets Manager to assume that you’re specifying a complete
	// ARN. This confusion can cause unexpected results. To avoid this situation, we
	// recommend that you don’t create secret names ending with a hyphen followed by
	// six characters. If you specify an incomplete ARN without the random suffix, and
	// instead provide the 'friendly name', you must not include the random suffix. If
	// you do include the random suffix added by Secrets Manager, you receive either a
	// ResourceNotFoundException or an AccessDeniedException error, depending on your
	// permissions.
	SecretId *string
}

type DescribeSecretOutput struct {
	// The ARN of a Lambda function that's invoked by Secrets Manager to rotate the
	// secret either automatically per the schedule or manually by a call to
	// RotateSecret.
	RotationLambdaARN *string
	// The last date that this secret was accessed. This value is truncated to midnight
	// of the date and therefore shows only the date, not the time.
	LastAccessedDate *time.Time
	// The list of user-defined tags that are associated with the secret. To add tags
	// to a secret, use TagResource (). To remove tags, use UntagResource ().
	Tags []*types.Tag
	// Returns the name of the service that created this secret.
	OwningService *string
	// This value exists if the secret is scheduled for deletion. Some time after the
	// specified date and time, Secrets Manager deletes the secret and all of its
	// versions. If a secret is scheduled for deletion, then its details, including the
	// encrypted secret information, is not accessible. To cancel a scheduled deletion
	// and restore access, use RestoreSecret ().
	DeletedDate *time.Time
	// A list of all of the currently assigned VersionStage staging labels and the
	// VersionId that each is attached to. Staging labels are used to keep track of the
	// different versions during the rotation process. A version that does not have any
	// staging labels attached is considered deprecated and subject to deletion. Such
	// versions are not included in this list.
	VersionIdsToStages map[string][]*string
	// The ARN of the secret.
	ARN *string
	// The date that the secret was created.
	CreatedDate *time.Time
	// The most recent date and time that the Secrets Manager rotation process was
	// successfully completed. This value is null if the secret has never rotated.
	LastRotatedDate *time.Time
	// The user-provided friendly name of the secret.
	Name *string
	// The user-provided description of the secret.
	Description *string
	// A structure that contains the rotation configuration for this secret.
	RotationRules *types.RotationRulesType
	// Specifies whether automatic rotation is enabled for this secret. To enable
	// rotation, use RotateSecret () with AutomaticallyRotateAfterDays set to a value
	// greater than 0. To disable rotation, use CancelRotateSecret ().
	RotationEnabled *bool
	// The ARN or alias of the AWS KMS customer master key (CMK) that's used to encrypt
	// the SecretString or SecretBinary fields in each version of the secret. If you
	// don't provide a key, then Secrets Manager defaults to encrypting the secret
	// fields with the default AWS KMS CMK (the one named awssecretsmanager) for this
	// account.
	KmsKeyId *string
	// The last date and time that this secret was modified in any way.
	LastChangedDate *time.Time

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

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

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

type GetRandomPasswordInput struct {
	// A string that includes characters that should not be included in the generated
	// password. The default is that all characters from the included sets can be used.
	ExcludeCharacters *string
	// Specifies that the generated password should not include digits. The default if
	// you do not include this switch parameter is that digits can be included.
	ExcludeNumbers *bool
	// Specifies that the generated password should not include lowercase letters. The
	// default if you do not include this switch parameter is that lowercase letters
	// can be included.
	ExcludeLowercase *bool
	// A boolean value that specifies whether the generated password must include at
	// least one of every allowed character type. The default value is True and the
	// operation requires at least one of every character type.
	RequireEachIncludedType *bool
	// Specifies that the generated password should not include uppercase letters. The
	// default if you do not include this switch parameter is that uppercase letters
	// can be included.
	ExcludeUppercase *bool
	// Specifies that the generated password should not include punctuation characters.
	// The default if you do not include this switch parameter is that punctuation
	// characters can be included. The following are the punctuation characters that
	// can be included in the generated password if you don't explicitly exclude them
	// with ExcludeCharacters or ExcludePunctuation: ! " # $ % & ' ( ) * + , - . / : ;
	// < = > ? @ [ \ ] ^ _ ` { | } ~
	ExcludePunctuation *bool
	// Specifies that the generated password can include the space character. The
	// default if you do not include this switch parameter is that the space character
	// is not included.
	IncludeSpace *bool
	// The desired length of the generated password. The default value if you do not
	// include this parameter is 32 characters.
	PasswordLength *int64
}

type GetRandomPasswordOutput struct {
	// A string with the generated password.
	RandomPassword *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetResourcePolicyInput struct {
	// Specifies the secret that you want to retrieve the attached resource-based
	// policy for. You can specify either the Amazon Resource Name (ARN) or the
	// friendly name of the secret. If you specify an ARN, we generally recommend that
	// you specify a complete ARN. You can specify a partial ARN too—for example, if
	// you don’t include the final hyphen and six random characters that Secrets
	// Manager adds at the end of the ARN when you created the secret. A partial ARN
	// match can work as long as it uniquely matches only one secret. However, if your
	// secret has a name that ends in a hyphen followed by six characters (before
	// Secrets Manager adds the hyphen and six characters to the ARN) and you try to
	// use that as a partial ARN, then those characters cause Secrets Manager to assume
	// that you’re specifying a complete ARN. This confusion can cause unexpected
	// results. To avoid this situation, we recommend that you don’t create secret
	// names ending with a hyphen followed by six characters. If you specify an
	// incomplete ARN without the random suffix, and instead provide the 'friendly
	// name', you must not include the random suffix. If you do include the random
	// suffix added by Secrets Manager, you receive either a ResourceNotFoundException
	// or an AccessDeniedException error, depending on your permissions.
	SecretId *string
}

type GetResourcePolicyOutput struct {
	// The ARN of the secret that the resource-based policy was retrieved for.
	ARN *string
	// A JSON-formatted string that describes the permissions that are associated with
	// the attached secret. These permissions are combined with any permissions that
	// are associated with the user or role that attempts to access this secret. The
	// combined permissions specify who can access the secret and what actions they can
	// perform. For more information, see Authentication and Access Control for AWS
	// Secrets Manager
	// (http://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access.html)
	// in the AWS Secrets Manager User Guide.
	ResourcePolicy *string
	// The friendly name of the secret that the resource-based policy was retrieved
	// for.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSecretValueInput struct {
	// Specifies the secret containing the version that you want to retrieve. You can
	// specify either the Amazon Resource Name (ARN) or the friendly name of the
	// secret. If you specify an ARN, we generally recommend that you specify a
	// complete ARN. You can specify a partial ARN too—for example, if you don’t
	// include the final hyphen and six random characters that Secrets Manager adds at
	// the end of the ARN when you created the secret. A partial ARN match can work as
	// long as it uniquely matches only one secret. However, if your secret has a name
	// that ends in a hyphen followed by six characters (before Secrets Manager adds
	// the hyphen and six characters to the ARN) and you try to use that as a partial
	// ARN, then those characters cause Secrets Manager to assume that you’re
	// specifying a complete ARN. This confusion can cause unexpected results. To avoid
	// this situation, we recommend that you don’t create secret names ending with a
	// hyphen followed by six characters. If you specify an incomplete ARN without the
	// random suffix, and instead provide the 'friendly name', you must not include the
	// random suffix. If you do include the random suffix added by Secrets Manager, you
	// receive either a ResourceNotFoundException or an AccessDeniedException error,
	// depending on your permissions.
	SecretId *string
	// Specifies the unique identifier of the version of the secret that you want to
	// retrieve. If you specify this parameter then don't specify VersionStage. If you
	// don't specify either a VersionStage or VersionId then the default is to perform
	// the operation on the version with the VersionStage value of AWSCURRENT. This
	// value is typically a UUID-type
	// (https://wikipedia.org/wiki/Universally_unique_identifier) value with 32
	// hexadecimal digits.
	VersionId *string
	// Specifies the secret version that you want to retrieve by the staging label
	// attached to the version. Staging labels are used to keep track of different
	// versions during the rotation process. If you use this parameter then don't
	// specify VersionId. If you don't specify either a VersionStage or VersionId, then
	// the default is to perform the operation on the version with the VersionStage
	// value of AWSCURRENT.
	VersionStage *string
}

type GetSecretValueOutput struct {
	// The friendly name of the secret.
	Name *string
	// The date and time that this version of the secret was created.
	CreatedDate *time.Time
	// The decrypted part of the protected secret information that was originally
	// provided as binary data in the form of a byte array. The response parameter
	// represents the binary data as a base64-encoded
	// (https://tools.ietf.org/html/rfc4648#section-4) string. This parameter is not
	// used if the secret is created by the Secrets Manager console. If you store
	// custom information in this field of the secret, then you must code your Lambda
	// rotation function to parse and interpret whatever you store in the SecretString
	// or SecretBinary fields.
	SecretBinary []byte
	// The decrypted part of the protected secret information that was originally
	// provided as a string. If you create this secret by using the Secrets Manager
	// console then only the SecretString parameter contains data. Secrets Manager
	// stores the information as a JSON structure of key/value pairs that the Lambda
	// rotation function knows how to parse. If you store custom information in the
	// secret by using the CreateSecret (), UpdateSecret (), or PutSecretValue () API
	// operations instead of the Secrets Manager console, or by using the Other secret
	// type in the console, then you must code your Lambda rotation function to parse
	// and interpret those values.
	SecretString *string
	// The unique identifier of this version of the secret.
	VersionId *string
	// The ARN of the secret.
	ARN *string
	// A list of all of the staging labels currently attached to this version of the
	// secret.
	VersionStages []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

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

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

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

type ListSecretVersionIdsInput struct {
	// (Optional) Limits the number of results you want to include in the response. If
	// you don't include this parameter, it defaults to a value that's specific to the
	// operation. If additional items exist beyond the maximum you specify, the
	// NextToken response element is present and has a value (isn't null). Include that
	// value as the NextToken request parameter in the next call to the operation to
	// get the next part of the results. Note that Secrets Manager might return fewer
	// results than the maximum even when there are more results available. You should
	// check NextToken after every operation to ensure that you receive all of the
	// results.
	MaxResults *int32
	// (Optional) Specifies that you want the results to include versions that do not
	// have any staging labels attached to them. Such versions are considered
	// deprecated and are subject to deletion by Secrets Manager as needed.
	IncludeDeprecated *bool
	// The identifier for the secret containing the versions you want to list. You can
	// specify either the Amazon Resource Name (ARN) or the friendly name of the
	// secret. If you specify an ARN, we generally recommend that you specify a
	// complete ARN. You can specify a partial ARN too—for example, if you don’t
	// include the final hyphen and six random characters that Secrets Manager adds at
	// the end of the ARN when you created the secret. A partial ARN match can work as
	// long as it uniquely matches only one secret. However, if your secret has a name
	// that ends in a hyphen followed by six characters (before Secrets Manager adds
	// the hyphen and six characters to the ARN) and you try to use that as a partial
	// ARN, then those characters cause Secrets Manager to assume that you’re
	// specifying a complete ARN. This confusion can cause unexpected results. To avoid
	// this situation, we recommend that you don’t create secret names ending with a
	// hyphen followed by six characters. If you specify an incomplete ARN without the
	// random suffix, and instead provide the 'friendly name', you must not include the
	// random suffix. If you do include the random suffix added by Secrets Manager, you
	// receive either a ResourceNotFoundException or an AccessDeniedException error,
	// depending on your permissions.
	SecretId *string
	// (Optional) Use this parameter in a request if you receive a NextToken response
	// in a previous request indicating there's more output available. In a subsequent
	// call, set it to the value of the previous call NextToken response to indicate
	// where the output should continue from.
	NextToken *string
}

type ListSecretVersionIdsOutput struct {
	// The Amazon Resource Name (ARN) for the secret. Secrets Manager automatically
	// adds several random characters to the name at the end of the ARN when you
	// initially create a secret. This affects only the ARN and not the actual friendly
	// name. This ensures that if you create a new secret with the same name as an old
	// secret that you previously deleted, then users with access to the old secret
	// don't automatically get access to the new secret because the ARNs are different.
	ARN *string
	// The friendly name of the secret.
	Name *string
	// If present in the response, this value indicates that there's more output
	// available than included in the current response. This can occur even when the
	// response includes no values at all, such as when you ask for a filtered view of
	// a very long list. Use this value in the NextToken request parameter in a
	// subsequent call to the operation to continue processing and get the next part of
	// the output. You should repeat this until the NextToken response element comes
	// back empty (as null).
	NextToken *string
	// The list of the currently available versions of the specified secret.
	Versions []*types.SecretVersionsListEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListSecretsInput struct {
	// Lists the secret request filters.
	Filters []*types.Filter
	// (Optional) Limits the number of results you want to include in the response. If
	// you don't include this parameter, it defaults to a value that's specific to the
	// operation. If additional items exist beyond the maximum you specify, the
	// NextToken response element is present and has a value (isn't null). Include that
	// value as the NextToken request parameter in the next call to the operation to
	// get the next part of the results. Note that Secrets Manager might return fewer
	// results than the maximum even when there are more results available. You should
	// check NextToken after every operation to ensure that you receive all of the
	// results.
	MaxResults *int32
	// (Optional) Use this parameter in a request if you receive a NextToken response
	// in a previous request indicating there's more output available. In a subsequent
	// call, set it to the value of the previous call NextToken response to indicate
	// where the output should continue from.
	NextToken *string
	// Lists secrets in the requested order.
	SortOrder types.SortOrderType
}

type ListSecretsOutput struct {
	// If present in the response, this value indicates that there's more output
	// available than included in the current response. This can occur even when the
	// response includes no values at all, such as when you ask for a filtered view of
	// a very long list. Use this value in the NextToken request parameter in a
	// subsequent call to the operation to continue processing and get the next part of
	// the output. You should repeat this until the NextToken response element comes
	// back empty (as null).
	NextToken *string
	// A list of the secrets in the account.
	SecretList []*types.SecretListEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

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

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

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

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// Provides idempotency tokens values that will be automatically populated into
	// idempotent API operations.
	IdempotencyTokenProvider IdempotencyTokenProvider

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

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type PutResourcePolicyInput struct {
	// Makes an optional API call to Zelkova to validate the Resource Policy to prevent
	// broad access to your secret.
	BlockPublicPolicy *bool
	// A JSON-formatted string that's constructed according to the grammar and syntax
	// for an AWS resource-based policy. The policy in the string identifies who can
	// access or manage this secret and its versions. For information on how to format
	// a JSON parameter for the various command line tool environments, see Using JSON
	// for Parameters
	// (http://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-json)
	// in the AWS CLI User Guide.
	ResourcePolicy *string
	// Specifies the secret that you want to attach the resource-based policy to. You
	// can specify either the ARN or the friendly name of the secret. If you specify an
	// ARN, we generally recommend that you specify a complete ARN. You can specify a
	// partial ARN too—for example, if you don’t include the final hyphen and six
	// random characters that Secrets Manager adds at the end of the ARN when you
	// created the secret. A partial ARN match can work as long as it uniquely matches
	// only one secret. However, if your secret has a name that ends in a hyphen
	// followed by six characters (before Secrets Manager adds the hyphen and six
	// characters to the ARN) and you try to use that as a partial ARN, then those
	// characters cause Secrets Manager to assume that you’re specifying a complete
	// ARN. This confusion can cause unexpected results. To avoid this situation, we
	// recommend that you don’t create secret names ending with a hyphen followed by
	// six characters. If you specify an incomplete ARN without the random suffix, and
	// instead provide the 'friendly name', you must not include the random suffix. If
	// you do include the random suffix added by Secrets Manager, you receive either a
	// ResourceNotFoundException or an AccessDeniedException error, depending on your
	// permissions.
	SecretId *string
}

type PutResourcePolicyOutput struct {
	// The friendly name of the secret that the retrieved by the resource-based policy.
	Name *string
	// The ARN of the secret retrieved by the resource-based policy.
	ARN *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutSecretValueInput struct {
	// Specifies the secret to which you want to add a new version. You can specify
	// either the Amazon Resource Name (ARN) or the friendly name of the secret. The
	// secret must already exist. If you specify an ARN, we generally recommend that
	// you specify a complete ARN. You can specify a partial ARN too—for example, if
	// you don’t include the final hyphen and six random characters that Secrets
	// Manager adds at the end of the ARN when you created the secret. A partial ARN
	// match can work as long as it uniquely matches only one secret. However, if your
	// secret has a name that ends in a hyphen followed by six characters (before
	// Secrets Manager adds the hyphen and six characters to the ARN) and you try to
	// use that as a partial ARN, then those characters cause Secrets Manager to assume
	// that you’re specifying a complete ARN. This confusion can cause unexpected
	// results. To avoid this situation, we recommend that you don’t create secret
	// names ending with a hyphen followed by six characters. If you specify an
	// incomplete ARN without the random suffix, and instead provide the 'friendly
	// name', you must not include the random suffix. If you do include the random
	// suffix added by Secrets Manager, you receive either a ResourceNotFoundException
	// or an AccessDeniedException error, depending on your permissions.
	SecretId *string
	// (Optional) Specifies binary data that you want to encrypt and store in the new
	// version of the secret. To use this parameter in the command-line tools, we
	// recommend that you store your binary data in a file and then use the appropriate
	// technique for your tool to pass the contents of the file as a parameter. Either
	// SecretBinary or SecretString must have a value, but not both. They cannot both
	// be empty.  <p>This parameter is not accessible if the secret using the Secrets
	// Manager console.</p> <p></p>
	SecretBinary []byte
	// (Optional) Specifies text data that you want to encrypt and store in this new
	// version of the secret. Either SecretString or SecretBinary must have a value,
	// but not both. They cannot both be empty.  <p>If you create this secret by using
	// the Secrets Manager console then Secrets Manager puts the protected secret text
	// in only the <code>SecretString</code> parameter. The Secrets Manager console
	// stores the information as a JSON structure of key/value pairs that the default
	// Lambda rotation function knows how to parse.</p> <p>For storing multiple values,
	// we recommend that you use a JSON text string argument and specify key/value
	// pairs. For information on how to format a JSON parameter for the various command
	// line tool environments, see <a
	// href="https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-json">Using
	// JSON for Parameters</a> in the <i>AWS CLI User Guide</i>.</p> <p> For
	// example:</p> <p> <code>[{"username":"bob"},{"password":"abc123xyz456"}]</code>
	// </p> <p>If your command-line tool or SDK requires quotation marks around the
	// parameter, you should use single quotes to avoid confusion with the double
	// quotes required in the JSON text.</p>
	SecretString *string
	// (Optional) Specifies a unique identifier for the new version of the secret. If
	// you use the AWS CLI or one of the AWS SDK to call this operation, then you can
	// leave this parameter empty. The CLI or SDK generates a random UUID for you and
	// includes that in the request. If you don't use the SDK and instead generate a
	// raw HTTP request to the Secrets Manager service endpoint, then you must generate
	// a ClientRequestToken yourself for new versions and include that value in the
	// request. This value helps ensure idempotency. Secrets Manager uses this value to
	// prevent the accidental creation of duplicate versions if there are failures and
	// retries during the Lambda rotation function's processing. We recommend that you
	// generate a UUID-type (https://wikipedia.org/wiki/Universally_unique_identifier)
	// value to ensure uniqueness within the specified secret.
	//
	//     * If the
	// ClientRequestToken value isn't already associated with a version of the secret
	// then a new version of the secret is created.
	//
	//     * If a version with this value
	// already exists and that version's SecretString or SecretBinary values are the
	// same as those in the request then the request is ignored (the operation is
	// idempotent).
	//
	//     * If a version with this value already exists and the version
	// of the SecretString and SecretBinary values are different from those in the
	// request then the request fails because you cannot modify an existing secret
	// version. You can only create new versions to store new secret values.
	//
	// This
	// value becomes the VersionId of the new version.
	ClientRequestToken *string
	// (Optional) Specifies a list of staging labels that are attached to this version
	// of the secret. These staging labels are used to track the versions through the
	// rotation process by the Lambda rotation function. A staging label must be unique
	// to a single version of the secret. If you specify a staging label that's already
	// associated with a different version of the same secret then that staging label
	// is automatically removed from the other version and attached to this version. If
	// you do not specify a value for VersionStages then Secrets Manager automatically
	// moves the staging label AWSCURRENT to this new version.
	VersionStages []*string
}

type PutSecretValueOutput struct {
	// The unique identifier of the version of the secret you just created or updated.
	VersionId *string
	// The Amazon Resource Name (ARN) for the secret for which you just created a
	// version.
	ARN *string
	// The list of staging labels that are currently attached to this version of the
	// secret. Staging labels are used to track a version as it progresses through the
	// secret rotation process.
	VersionStages []*string
	// The friendly name of the secret for which you just created or updated a version.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type RestoreSecretInput struct {
	// Specifies the secret that you want to restore from a previously scheduled
	// deletion. You can specify either the Amazon Resource Name (ARN) or the friendly
	// name of the secret. If you specify an ARN, we generally recommend that you
	// specify a complete ARN. You can specify a partial ARN too—for example, if you
	// don’t include the final hyphen and six random characters that Secrets Manager
	// adds at the end of the ARN when you created the secret. A partial ARN match can
	// work as long as it uniquely matches only one secret. However, if your secret has
	// a name that ends in a hyphen followed by six characters (before Secrets Manager
	// adds the hyphen and six characters to the ARN) and you try to use that as a
	// partial ARN, then those characters cause Secrets Manager to assume that you’re
	// specifying a complete ARN. This confusion can cause unexpected results. To avoid
	// this situation, we recommend that you don’t create secret names ending with a
	// hyphen followed by six characters. If you specify an incomplete ARN without the
	// random suffix, and instead provide the 'friendly name', you must not include the
	// random suffix. If you do include the random suffix added by Secrets Manager, you
	// receive either a ResourceNotFoundException or an AccessDeniedException error,
	// depending on your permissions.
	SecretId *string
}

type RestoreSecretOutput struct {
	// The ARN of the secret that was restored.
	ARN *string
	// The friendly name of the secret that was restored.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RotateSecretInput struct {
	// (Optional) Specifies a unique identifier for the new version of the secret that
	// helps ensure idempotency. If you use the AWS CLI or one of the AWS SDK to call
	// this operation, then you can leave this parameter empty. The CLI or SDK
	// generates a random UUID for you and includes that in the request for this
	// parameter. If you don't use the SDK and instead generate a raw HTTP request to
	// the Secrets Manager service endpoint, then you must generate a
	// ClientRequestToken yourself for new versions and include that value in the
	// request. You only need to specify your own value if you implement your own retry
	// logic and want to ensure that a given secret is not created twice. We recommend
	// that you generate a UUID-type
	// (https://wikipedia.org/wiki/Universally_unique_identifier) value to ensure
	// uniqueness within the specified secret. Secrets Manager uses this value to
	// prevent the accidental creation of duplicate versions if there are failures and
	// retries during the function's processing. This value becomes the VersionId of
	// the new version.
	ClientRequestToken *string
	// (Optional) Specifies the ARN of the Lambda function that can rotate the secret.
	RotationLambdaARN *string
	// A structure that defines the rotation configuration for this secret.
	RotationRules *types.RotationRulesType
	// Specifies the secret that you want to rotate. You can specify either the Amazon
	// Resource Name (ARN) or the friendly name of the secret. If you specify an ARN,
	// we generally recommend that you specify a complete ARN. You can specify a
	// partial ARN too—for example, if you don’t include the final hyphen and six
	// random characters that Secrets Manager adds at the end of the ARN when you
	// created the secret. A partial ARN match can work as long as it uniquely matches
	// only one secret. However, if your secret has a name that ends in a hyphen
	// followed by six characters (before Secrets Manager adds the hyphen and six
	// characters to the ARN) and you try to use that as a partial ARN, then those
	// characters cause Secrets Manager to assume that you’re specifying a complete
	// ARN. This confusion can cause unexpected results. To avoid this situation, we
	// recommend that you don’t create secret names ending with a hyphen followed by
	// six characters. If you specify an incomplete ARN without the random suffix, and
	// instead provide the 'friendly name', you must not include the random suffix. If
	// you do include the random suffix added by Secrets Manager, you receive either a
	// ResourceNotFoundException or an AccessDeniedException error, depending on your
	// permissions.
	SecretId *string
}

type RotateSecretOutput struct {
	// The ID of the new version of the secret created by the rotation started by this
	// request.
	VersionId *string
	// The friendly name of the secret.
	Name *string
	// The ARN of the secret.
	ARN *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TagResourceInput struct {
	// The identifier for the secret that you want to attach tags to. You can specify
	// either the Amazon Resource Name (ARN) or the friendly name of the secret. If you
	// specify an ARN, we generally recommend that you specify a complete ARN. You can
	// specify a partial ARN too—for example, if you don’t include the final hyphen and
	// six random characters that Secrets Manager adds at the end of the ARN when you
	// created the secret. A partial ARN match can work as long as it uniquely matches
	// only one secret. However, if your secret has a name that ends in a hyphen
	// followed by six characters (before Secrets Manager adds the hyphen and six
	// characters to the ARN) and you try to use that as a partial ARN, then those
	// characters cause Secrets Manager to assume that you’re specifying a complete
	// ARN. This confusion can cause unexpected results. To avoid this situation, we
	// recommend that you don’t create secret names ending with a hyphen followed by
	// six characters. If you specify an incomplete ARN without the random suffix, and
	// instead provide the 'friendly name', you must not include the random suffix. If
	// you do include the random suffix added by Secrets Manager, you receive either a
	// ResourceNotFoundException or an AccessDeniedException error, depending on your
	// permissions.
	SecretId *string
	// The tags to attach to the secret. Each element in the list consists of a Key and
	// a Value. This parameter to the API requires a JSON text string argument. For
	// information on how to format a JSON parameter for the various command line tool
	// environments, see Using JSON for Parameters
	// (https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-json)
	// in the AWS CLI User Guide. For the AWS CLI, you can also use the syntax: --Tags
	// Key="Key1",Value="Value1",Key="Key2",Value="Value2"[,…]
	Tags []*types.Tag
}

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

type UntagResourceInput struct {
	// A list of tag key names to remove from the secret. You don't specify the value.
	// Both the key and its associated value are removed. This parameter to the API
	// requires a JSON text string argument. For information on how to format a JSON
	// parameter for the various command line tool environments, see Using JSON for
	// Parameters
	// (https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-json)
	// in the AWS CLI User Guide.
	TagKeys []*string
	// The identifier for the secret that you want to remove tags from. You can specify
	// either the Amazon Resource Name (ARN) or the friendly name of the secret. If you
	// specify an ARN, we generally recommend that you specify a complete ARN. You can
	// specify a partial ARN too—for example, if you don’t include the final hyphen and
	// six random characters that Secrets Manager adds at the end of the ARN when you
	// created the secret. A partial ARN match can work as long as it uniquely matches
	// only one secret. However, if your secret has a name that ends in a hyphen
	// followed by six characters (before Secrets Manager adds the hyphen and six
	// characters to the ARN) and you try to use that as a partial ARN, then those
	// characters cause Secrets Manager to assume that you’re specifying a complete
	// ARN. This confusion can cause unexpected results. To avoid this situation, we
	// recommend that you don’t create secret names ending with a hyphen followed by
	// six characters. If you specify an incomplete ARN without the random suffix, and
	// instead provide the 'friendly name', you must not include the random suffix. If
	// you do include the random suffix added by Secrets Manager, you receive either a
	// ResourceNotFoundException or an AccessDeniedException error, depending on your
	// permissions.
	SecretId *string
}

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

type UpdateSecretInput struct {
	// (Optional) Specifies updated binary data that you want to encrypt and store in
	// the new version of the secret. To use this parameter in the command-line tools,
	// we recommend that you store your binary data in a file and then use the
	// appropriate technique for your tool to pass the contents of the file as a
	// parameter. Either SecretBinary or SecretString must have a value, but not both.
	// They cannot both be empty. This parameter is not accessible using the Secrets
	// Manager console.
	SecretBinary []byte
	// (Optional) Specifies updated text data that you want to encrypt and store in
	// this new version of the secret. Either SecretBinary or SecretString must have a
	// value, but not both. They cannot both be empty. If you create this secret by
	// using the Secrets Manager console then Secrets Manager puts the protected secret
	// text in only the SecretString parameter. The Secrets Manager console stores the
	// information as a JSON structure of key/value pairs that the default Lambda
	// rotation function knows how to parse. For storing multiple values, we recommend
	// that you use a JSON text string argument and specify key/value pairs. For
	// information on how to format a JSON parameter for the various command line tool
	// environments, see Using JSON for Parameters
	// (https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-json)
	// in the AWS CLI User Guide. For example:
	// [{"username":"bob"},{"password":"abc123xyz456"}] If your command-line tool or
	// SDK requires quotation marks around the parameter, you should use single quotes
	// to avoid confusion with the double quotes required in the JSON text. You can
	// also 'escape' the double quote character in the embedded JSON text by prefacing
	// each with a backslash. For example, the following string is surrounded by
	// double-quotes. All of the embedded double quotes are escaped:
	// "[{\"username\":\"bob\"},{\"password\":\"abc123xyz456\"}]"
	SecretString *string
	// (Optional) Specifies an updated ARN or alias of the AWS KMS customer master key
	// (CMK) to be used to encrypt the protected text in new versions of this secret.
	// You can only use the account's default CMK to encrypt and decrypt if you call
	// this operation using credentials from the same account that owns the secret. If
	// the secret is in a different account, then you must create a custom CMK and
	// provide the ARN of that CMK in this field. The user making the call must have
	// permissions to both the secret and the CMK in their respective accounts.
	KmsKeyId *string
	// (Optional) Specifies an updated user-provided description of the secret.
	Description *string
	// Specifies the secret that you want to modify or to which you want to add a new
	// version. You can specify either the Amazon Resource Name (ARN) or the friendly
	// name of the secret. If you specify an ARN, we generally recommend that you
	// specify a complete ARN. You can specify a partial ARN too—for example, if you
	// don’t include the final hyphen and six random characters that Secrets Manager
	// adds at the end of the ARN when you created the secret. A partial ARN match can
	// work as long as it uniquely matches only one secret. However, if your secret has
	// a name that ends in a hyphen followed by six characters (before Secrets Manager
	// adds the hyphen and six characters to the ARN) and you try to use that as a
	// partial ARN, then those characters cause Secrets Manager to assume that you’re
	// specifying a complete ARN. This confusion can cause unexpected results. To avoid
	// this situation, we recommend that you don’t create secret names ending with a
	// hyphen followed by six characters. If you specify an incomplete ARN without the
	// random suffix, and instead provide the 'friendly name', you must not include the
	// random suffix. If you do include the random suffix added by Secrets Manager, you
	// receive either a ResourceNotFoundException or an AccessDeniedException error,
	// depending on your permissions.
	SecretId *string
	// (Optional) If you want to add a new version to the secret, this parameter
	// specifies a unique identifier for the new version that helps ensure idempotency.
	// If you use the AWS CLI or one of the AWS SDK to call this operation, then you
	// can leave this parameter empty. The CLI or SDK generates a random UUID for you
	// and includes that in the request. If you don't use the SDK and instead generate
	// a raw HTTP request to the Secrets Manager service endpoint, then you must
	// generate a ClientRequestToken yourself for new versions and include that value
	// in the request. You typically only need to interact with this value if you
	// implement your own retry logic and want to ensure that a given secret is not
	// created twice. We recommend that you generate a UUID-type
	// (https://wikipedia.org/wiki/Universally_unique_identifier) value to ensure
	// uniqueness within the specified secret. Secrets Manager uses this value to
	// prevent the accidental creation of duplicate versions if there are failures and
	// retries during the Lambda rotation function's processing.
	//
	//     * If the
	// ClientRequestToken value isn't already associated with a version of the secret
	// then a new version of the secret is created.
	//
	//     * If a version with this value
	// already exists and that version's SecretString and SecretBinary values are the
	// same as those in the request then the request is ignored (the operation is
	// idempotent).
	//
	//     * If a version with this value already exists and that
	// version's SecretString and SecretBinary values are different from the request
	// then an error occurs because you cannot modify an existing secret value.
	//
	// This
	// value becomes the VersionId of the new version.
	ClientRequestToken *string
}

type UpdateSecretOutput struct {
	// The ARN of the secret that was updated. Secrets Manager automatically adds
	// several random characters to the name at the end of the ARN when you initially
	// create a secret. This affects only the ARN and not the actual friendly name.
	// This ensures that if you create a new secret with the same name as an old secret
	// that you previously deleted, then users with access to the old secret don't
	// automatically get access to the new secret because the ARNs are different.
	ARN *string
	// If a new version of the secret was created by this operation, then VersionId
	// contains the unique identifier of the new version.
	VersionId *string
	// The friendly name of the secret that was updated.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateSecretVersionStageInput struct {
	// (Optional) The secret version ID that you want to add the staging label. If you
	// want to remove a label from a version, then do not specify this parameter. If
	// the staging label is already attached to a different version of the secret, then
	// you must also specify the RemoveFromVersionId parameter.
	MoveToVersionId *string
	// Specifies the secret with the version with the list of staging labels you want
	// to modify. You can specify either the Amazon Resource Name (ARN) or the friendly
	// name of the secret. If you specify an ARN, we generally recommend that you
	// specify a complete ARN. You can specify a partial ARN too—for example, if you
	// don’t include the final hyphen and six random characters that Secrets Manager
	// adds at the end of the ARN when you created the secret. A partial ARN match can
	// work as long as it uniquely matches only one secret. However, if your secret has
	// a name that ends in a hyphen followed by six characters (before Secrets Manager
	// adds the hyphen and six characters to the ARN) and you try to use that as a
	// partial ARN, then those characters cause Secrets Manager to assume that you’re
	// specifying a complete ARN. This confusion can cause unexpected results. To avoid
	// this situation, we recommend that you don’t create secret names ending with a
	// hyphen followed by six characters. If you specify an incomplete ARN without the
	// random suffix, and instead provide the 'friendly name', you must not include the
	// random suffix. If you do include the random suffix added by Secrets Manager, you
	// receive either a ResourceNotFoundException or an AccessDeniedException error,
	// depending on your permissions.
	SecretId *string
	// Specifies the secret version ID of the version that the staging label is to be
	// removed from. If the staging label you are trying to attach to one version is
	// already attached to a different version, then you must include this parameter
	// and specify the version that the label is to be removed from. If the label is
	// attached and you either do not specify this parameter, or the version ID does
	// not match, then the operation fails.
	RemoveFromVersionId *string
	// The staging label to add to this version.
	VersionStage *string
}

type UpdateSecretVersionStageOutput struct {
	// The ARN of the secret with the modified staging label.
	ARN *string
	// The friendly name of the secret with the modified staging label.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ValidateResourcePolicyInput struct {
	// The identifier for the secret that you want to validate a resource policy. You
	// can specify either the Amazon Resource Name (ARN) or the friendly name of the
	// secret. If you specify an ARN, we generally recommend that you specify a
	// complete ARN. You can specify a partial ARN too—for example, if you don’t
	// include the final hyphen and six random characters that Secrets Manager adds at
	// the end of the ARN when you created the secret. A partial ARN match can work as
	// long as it uniquely matches only one secret. However, if your secret has a name
	// that ends in a hyphen followed by six characters (before Secrets Manager adds
	// the hyphen and six characters to the ARN) and you try to use that as a partial
	// ARN, then those characters cause Secrets Manager to assume that you’re
	// specifying a complete ARN. This confusion can cause unexpected results. To avoid
	// this situation, we recommend that you don’t create secret names ending with a
	// hyphen followed by six characters. If you specify an incomplete ARN without the
	// random suffix, and instead provide the 'friendly name', you must not include the
	// random suffix. If you do include the random suffix added by Secrets Manager, you
	// receive either a ResourceNotFoundException or an AccessDeniedException error,
	// depending on your permissions.
	SecretId *string
	// Identifies the Resource Policy attached to the secret.
	ResourcePolicy *string
}

type ValidateResourcePolicyOutput struct {
	// Returns a message stating that your Reource Policy passed validation.
	PolicyValidationPassed *bool
	// Returns an error message if your policy doesn't pass validatation.
	ValidationErrors []*types.ValidationErrorsEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}