api.go

// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package budgets

import (
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/internal/awsutil"
)

const opCreateBudget = "CreateBudget"

// CreateBudgetRequest is a API request type for the CreateBudget API operation.
type CreateBudgetRequest struct {
	*aws.Request
	Input *CreateBudgetInput
	Copy  func(*CreateBudgetInput) CreateBudgetRequest
}

// Send marshals and sends the CreateBudget API request.
func (r CreateBudgetRequest) Send() (*CreateBudgetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateBudgetOutput), nil
}

// CreateBudgetRequest returns a request value for making API operation for
// AWS Budgets.
//
// Creates a budget and, if included, notifications and subscribers.
//
//    // Example sending a request using the CreateBudgetRequest method.
//    req := client.CreateBudgetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) CreateBudgetRequest(input *CreateBudgetInput) CreateBudgetRequest {
	op := &aws.Operation{
		Name:       opCreateBudget,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateBudgetInput{}
	}

	output := &CreateBudgetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateBudgetRequest{Request: req, Input: input, Copy: c.CreateBudgetRequest}
}

const opCreateNotification = "CreateNotification"

// CreateNotificationRequest is a API request type for the CreateNotification API operation.
type CreateNotificationRequest struct {
	*aws.Request
	Input *CreateNotificationInput
	Copy  func(*CreateNotificationInput) CreateNotificationRequest
}

// Send marshals and sends the CreateNotification API request.
func (r CreateNotificationRequest) Send() (*CreateNotificationOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateNotificationOutput), nil
}

// CreateNotificationRequest returns a request value for making API operation for
// AWS Budgets.
//
// Creates a notification. You must create the budget before you create the
// associated notification.
//
//    // Example sending a request using the CreateNotificationRequest method.
//    req := client.CreateNotificationRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) CreateNotificationRequest(input *CreateNotificationInput) CreateNotificationRequest {
	op := &aws.Operation{
		Name:       opCreateNotification,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateNotificationInput{}
	}

	output := &CreateNotificationOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateNotificationRequest{Request: req, Input: input, Copy: c.CreateNotificationRequest}
}

const opCreateSubscriber = "CreateSubscriber"

// CreateSubscriberRequest is a API request type for the CreateSubscriber API operation.
type CreateSubscriberRequest struct {
	*aws.Request
	Input *CreateSubscriberInput
	Copy  func(*CreateSubscriberInput) CreateSubscriberRequest
}

// Send marshals and sends the CreateSubscriber API request.
func (r CreateSubscriberRequest) Send() (*CreateSubscriberOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateSubscriberOutput), nil
}

// CreateSubscriberRequest returns a request value for making API operation for
// AWS Budgets.
//
// Creates a subscriber. You must create the associated budget and notification
// before you create the subscriber.
//
//    // Example sending a request using the CreateSubscriberRequest method.
//    req := client.CreateSubscriberRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) CreateSubscriberRequest(input *CreateSubscriberInput) CreateSubscriberRequest {
	op := &aws.Operation{
		Name:       opCreateSubscriber,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateSubscriberInput{}
	}

	output := &CreateSubscriberOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateSubscriberRequest{Request: req, Input: input, Copy: c.CreateSubscriberRequest}
}

const opDeleteBudget = "DeleteBudget"

// DeleteBudgetRequest is a API request type for the DeleteBudget API operation.
type DeleteBudgetRequest struct {
	*aws.Request
	Input *DeleteBudgetInput
	Copy  func(*DeleteBudgetInput) DeleteBudgetRequest
}

// Send marshals and sends the DeleteBudget API request.
func (r DeleteBudgetRequest) Send() (*DeleteBudgetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteBudgetOutput), nil
}

// DeleteBudgetRequest returns a request value for making API operation for
// AWS Budgets.
//
// Deletes a budget. You can delete your budget at any time.
//
// Deleting a budget also deletes the notifications and subscribers associated
// with that budget.
//
//    // Example sending a request using the DeleteBudgetRequest method.
//    req := client.DeleteBudgetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) DeleteBudgetRequest(input *DeleteBudgetInput) DeleteBudgetRequest {
	op := &aws.Operation{
		Name:       opDeleteBudget,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteBudgetInput{}
	}

	output := &DeleteBudgetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteBudgetRequest{Request: req, Input: input, Copy: c.DeleteBudgetRequest}
}

const opDeleteNotification = "DeleteNotification"

// DeleteNotificationRequest is a API request type for the DeleteNotification API operation.
type DeleteNotificationRequest struct {
	*aws.Request
	Input *DeleteNotificationInput
	Copy  func(*DeleteNotificationInput) DeleteNotificationRequest
}

// Send marshals and sends the DeleteNotification API request.
func (r DeleteNotificationRequest) Send() (*DeleteNotificationOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteNotificationOutput), nil
}

// DeleteNotificationRequest returns a request value for making API operation for
// AWS Budgets.
//
// Deletes a notification.
//
// Deleting a notification also deletes the subscribers associated with the
// notification.
//
//    // Example sending a request using the DeleteNotificationRequest method.
//    req := client.DeleteNotificationRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) DeleteNotificationRequest(input *DeleteNotificationInput) DeleteNotificationRequest {
	op := &aws.Operation{
		Name:       opDeleteNotification,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteNotificationInput{}
	}

	output := &DeleteNotificationOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteNotificationRequest{Request: req, Input: input, Copy: c.DeleteNotificationRequest}
}

const opDeleteSubscriber = "DeleteSubscriber"

// DeleteSubscriberRequest is a API request type for the DeleteSubscriber API operation.
type DeleteSubscriberRequest struct {
	*aws.Request
	Input *DeleteSubscriberInput
	Copy  func(*DeleteSubscriberInput) DeleteSubscriberRequest
}

// Send marshals and sends the DeleteSubscriber API request.
func (r DeleteSubscriberRequest) Send() (*DeleteSubscriberOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteSubscriberOutput), nil
}

// DeleteSubscriberRequest returns a request value for making API operation for
// AWS Budgets.
//
// Deletes a subscriber.
//
// Deleting the last subscriber to a notification also deletes the notification.
//
//    // Example sending a request using the DeleteSubscriberRequest method.
//    req := client.DeleteSubscriberRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) DeleteSubscriberRequest(input *DeleteSubscriberInput) DeleteSubscriberRequest {
	op := &aws.Operation{
		Name:       opDeleteSubscriber,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteSubscriberInput{}
	}

	output := &DeleteSubscriberOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteSubscriberRequest{Request: req, Input: input, Copy: c.DeleteSubscriberRequest}
}

const opDescribeBudget = "DescribeBudget"

// DescribeBudgetRequest is a API request type for the DescribeBudget API operation.
type DescribeBudgetRequest struct {
	*aws.Request
	Input *DescribeBudgetInput
	Copy  func(*DescribeBudgetInput) DescribeBudgetRequest
}

// Send marshals and sends the DescribeBudget API request.
func (r DescribeBudgetRequest) Send() (*DescribeBudgetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeBudgetOutput), nil
}

// DescribeBudgetRequest returns a request value for making API operation for
// AWS Budgets.
//
// Describes a budget.
//
//    // Example sending a request using the DescribeBudgetRequest method.
//    req := client.DescribeBudgetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) DescribeBudgetRequest(input *DescribeBudgetInput) DescribeBudgetRequest {
	op := &aws.Operation{
		Name:       opDescribeBudget,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeBudgetInput{}
	}

	output := &DescribeBudgetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeBudgetRequest{Request: req, Input: input, Copy: c.DescribeBudgetRequest}
}

const opDescribeBudgets = "DescribeBudgets"

// DescribeBudgetsRequest is a API request type for the DescribeBudgets API operation.
type DescribeBudgetsRequest struct {
	*aws.Request
	Input *DescribeBudgetsInput
	Copy  func(*DescribeBudgetsInput) DescribeBudgetsRequest
}

// Send marshals and sends the DescribeBudgets API request.
func (r DescribeBudgetsRequest) Send() (*DescribeBudgetsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeBudgetsOutput), nil
}

// DescribeBudgetsRequest returns a request value for making API operation for
// AWS Budgets.
//
// Lists the budgets associated with an account.
//
//    // Example sending a request using the DescribeBudgetsRequest method.
//    req := client.DescribeBudgetsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) DescribeBudgetsRequest(input *DescribeBudgetsInput) DescribeBudgetsRequest {
	op := &aws.Operation{
		Name:       opDescribeBudgets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeBudgetsInput{}
	}

	output := &DescribeBudgetsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeBudgetsRequest{Request: req, Input: input, Copy: c.DescribeBudgetsRequest}
}

const opDescribeNotificationsForBudget = "DescribeNotificationsForBudget"

// DescribeNotificationsForBudgetRequest is a API request type for the DescribeNotificationsForBudget API operation.
type DescribeNotificationsForBudgetRequest struct {
	*aws.Request
	Input *DescribeNotificationsForBudgetInput
	Copy  func(*DescribeNotificationsForBudgetInput) DescribeNotificationsForBudgetRequest
}

// Send marshals and sends the DescribeNotificationsForBudget API request.
func (r DescribeNotificationsForBudgetRequest) Send() (*DescribeNotificationsForBudgetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeNotificationsForBudgetOutput), nil
}

// DescribeNotificationsForBudgetRequest returns a request value for making API operation for
// AWS Budgets.
//
// Lists the notifications associated with a budget.
//
//    // Example sending a request using the DescribeNotificationsForBudgetRequest method.
//    req := client.DescribeNotificationsForBudgetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) DescribeNotificationsForBudgetRequest(input *DescribeNotificationsForBudgetInput) DescribeNotificationsForBudgetRequest {
	op := &aws.Operation{
		Name:       opDescribeNotificationsForBudget,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeNotificationsForBudgetInput{}
	}

	output := &DescribeNotificationsForBudgetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeNotificationsForBudgetRequest{Request: req, Input: input, Copy: c.DescribeNotificationsForBudgetRequest}
}

const opDescribeSubscribersForNotification = "DescribeSubscribersForNotification"

// DescribeSubscribersForNotificationRequest is a API request type for the DescribeSubscribersForNotification API operation.
type DescribeSubscribersForNotificationRequest struct {
	*aws.Request
	Input *DescribeSubscribersForNotificationInput
	Copy  func(*DescribeSubscribersForNotificationInput) DescribeSubscribersForNotificationRequest
}

// Send marshals and sends the DescribeSubscribersForNotification API request.
func (r DescribeSubscribersForNotificationRequest) Send() (*DescribeSubscribersForNotificationOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeSubscribersForNotificationOutput), nil
}

// DescribeSubscribersForNotificationRequest returns a request value for making API operation for
// AWS Budgets.
//
// Lists the subscribers associated with a notification.
//
//    // Example sending a request using the DescribeSubscribersForNotificationRequest method.
//    req := client.DescribeSubscribersForNotificationRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) DescribeSubscribersForNotificationRequest(input *DescribeSubscribersForNotificationInput) DescribeSubscribersForNotificationRequest {
	op := &aws.Operation{
		Name:       opDescribeSubscribersForNotification,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeSubscribersForNotificationInput{}
	}

	output := &DescribeSubscribersForNotificationOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeSubscribersForNotificationRequest{Request: req, Input: input, Copy: c.DescribeSubscribersForNotificationRequest}
}

const opUpdateBudget = "UpdateBudget"

// UpdateBudgetRequest is a API request type for the UpdateBudget API operation.
type UpdateBudgetRequest struct {
	*aws.Request
	Input *UpdateBudgetInput
	Copy  func(*UpdateBudgetInput) UpdateBudgetRequest
}

// Send marshals and sends the UpdateBudget API request.
func (r UpdateBudgetRequest) Send() (*UpdateBudgetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateBudgetOutput), nil
}

// UpdateBudgetRequest returns a request value for making API operation for
// AWS Budgets.
//
// Updates a budget. You can change every part of a budget except for the budgetName
// and the calculatedSpend. When a budget is modified, the calculatedSpend drops
// to zero until AWS has new usage data to use for forecasting.
//
//    // Example sending a request using the UpdateBudgetRequest method.
//    req := client.UpdateBudgetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) UpdateBudgetRequest(input *UpdateBudgetInput) UpdateBudgetRequest {
	op := &aws.Operation{
		Name:       opUpdateBudget,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateBudgetInput{}
	}

	output := &UpdateBudgetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateBudgetRequest{Request: req, Input: input, Copy: c.UpdateBudgetRequest}
}

const opUpdateNotification = "UpdateNotification"

// UpdateNotificationRequest is a API request type for the UpdateNotification API operation.
type UpdateNotificationRequest struct {
	*aws.Request
	Input *UpdateNotificationInput
	Copy  func(*UpdateNotificationInput) UpdateNotificationRequest
}

// Send marshals and sends the UpdateNotification API request.
func (r UpdateNotificationRequest) Send() (*UpdateNotificationOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateNotificationOutput), nil
}

// UpdateNotificationRequest returns a request value for making API operation for
// AWS Budgets.
//
// Updates a notification.
//
//    // Example sending a request using the UpdateNotificationRequest method.
//    req := client.UpdateNotificationRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) UpdateNotificationRequest(input *UpdateNotificationInput) UpdateNotificationRequest {
	op := &aws.Operation{
		Name:       opUpdateNotification,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateNotificationInput{}
	}

	output := &UpdateNotificationOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateNotificationRequest{Request: req, Input: input, Copy: c.UpdateNotificationRequest}
}

const opUpdateSubscriber = "UpdateSubscriber"

// UpdateSubscriberRequest is a API request type for the UpdateSubscriber API operation.
type UpdateSubscriberRequest struct {
	*aws.Request
	Input *UpdateSubscriberInput
	Copy  func(*UpdateSubscriberInput) UpdateSubscriberRequest
}

// Send marshals and sends the UpdateSubscriber API request.
func (r UpdateSubscriberRequest) Send() (*UpdateSubscriberOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateSubscriberOutput), nil
}

// UpdateSubscriberRequest returns a request value for making API operation for
// AWS Budgets.
//
// Updates a subscriber.
//
//    // Example sending a request using the UpdateSubscriberRequest method.
//    req := client.UpdateSubscriberRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
func (c *Budgets) UpdateSubscriberRequest(input *UpdateSubscriberInput) UpdateSubscriberRequest {
	op := &aws.Operation{
		Name:       opUpdateSubscriber,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateSubscriberInput{}
	}

	output := &UpdateSubscriberOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateSubscriberRequest{Request: req, Input: input, Copy: c.UpdateSubscriberRequest}
}

// Represents the output of the CreateBudget operation. The content consists
// of the detailed metadata and data file information, and the current status
// of the budget.
//
// The ARN pattern for a budget is: arn:aws:budgetservice::AccountId:budget/budgetName
type Budget struct {
	_ struct{} `type:"structure"`

	// The total amount of cost, usage, or RI utilization that you want to track
	// with your budget.
	//
	// BudgetLimit is required for cost or usage budgets, but optional for RI utilization
	// budgets. RI utilization budgets default to the only valid value for RI utilization
	// budgets, which is 100.
	BudgetLimit *Spend `type:"structure"`

	// The name of a budget. Unique within accounts. : and \ characters are not
	// allowed in the BudgetName.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// Whether this budget tracks monetary costs, usage, or RI utilization.
	//
	// BudgetType is a required field
	BudgetType BudgetType `type:"string" required:"true" enum:"true"`

	// The actual and forecasted cost or usage being tracked by a budget.
	CalculatedSpend *CalculatedSpend `type:"structure"`

	// The cost filters applied to a budget, such as service or region.
	CostFilters map[string][]string `type:"map"`

	// The types of costs included in this budget.
	CostTypes *CostTypes `type:"structure"`

	// The period of time covered by a budget. Has a start date and an end date.
	// The start date must come before the end date. There are no restrictions on
	// the end date.
	//
	// If you created your budget and didn't specify a start date, AWS defaults
	// to the start of your chosen time period (i.e. DAILY, MONTHLY, QUARTERLY,
	// ANNUALLY). For example, if you created your budget on January 24th 2018,
	// chose DAILY, and didn't set a start date, AWS set your start date to 01/24/18
	// 00:00 UTC. If you chose MONTHLY, AWS set your start date to 01/01/18 00:00
	// UTC. If you didn't specify an end date, AWS set your end date to 06/15/87
	// 00:00 UTC. The defaults are the same for the AWS Billing and Cost Management
	// console and the API.
	//
	// You can change either date with the UpdateBudget operation.
	//
	// After the end date, AWS deletes the budget and all associated notifications
	// and subscribers.
	TimePeriod *TimePeriod `type:"structure"`

	// The length of time until a budget resets the actual and forecasted spend.
	//
	// TimeUnit is a required field
	TimeUnit TimeUnit `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s Budget) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Budget) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Budget) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Budget"}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}
	if len(s.BudgetType) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("BudgetType"))
	}
	if len(s.TimeUnit) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("TimeUnit"))
	}
	if s.BudgetLimit != nil {
		if err := s.BudgetLimit.Validate(); err != nil {
			invalidParams.AddNested("BudgetLimit", err.(aws.ErrInvalidParams))
		}
	}
	if s.CalculatedSpend != nil {
		if err := s.CalculatedSpend.Validate(); err != nil {
			invalidParams.AddNested("CalculatedSpend", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The spend objects associated with this budget. The actualSpend tracks how
// much you've used, cost, usage, or RI units, and the forecastedSpend tracks
// how much you are predicted to spend if your current usage remains steady.
//
// For example, if it is the 20th of the month and you have spent 50 dollars
// on Amazon EC2, your actualSpend is 50 USD, and your forecastedSpend is 75
// USD.
type CalculatedSpend struct {
	_ struct{} `type:"structure"`

	// The amount of cost, usage, or RI units that you have used.
	//
	// ActualSpend is a required field
	ActualSpend *Spend `type:"structure" required:"true"`

	// The amount of cost, usage, or RI units that you are forecasted to use.
	ForecastedSpend *Spend `type:"structure"`
}

// String returns the string representation
func (s CalculatedSpend) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CalculatedSpend) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CalculatedSpend) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CalculatedSpend"}

	if s.ActualSpend == nil {
		invalidParams.Add(aws.NewErrParamRequired("ActualSpend"))
	}
	if s.ActualSpend != nil {
		if err := s.ActualSpend.Validate(); err != nil {
			invalidParams.AddNested("ActualSpend", err.(aws.ErrInvalidParams))
		}
	}
	if s.ForecastedSpend != nil {
		if err := s.ForecastedSpend.Validate(); err != nil {
			invalidParams.AddNested("ForecastedSpend", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The types of cost included in a budget, such as tax and subscriptions.
type CostTypes struct {
	_ struct{} `type:"structure"`

	// Specifies whether a budget includes credits.
	//
	// The default value is true.
	IncludeCredit *bool `type:"boolean"`

	// Specifies whether a budget includes discounts.
	//
	// The default value is true.
	IncludeDiscount *bool `type:"boolean"`

	// Specifies whether a budget includes non-RI subscription costs.
	//
	// The default value is true.
	IncludeOtherSubscription *bool `type:"boolean"`

	// Specifies whether a budget includes recurring fees such as monthly RI fees.
	//
	// The default value is true.
	IncludeRecurring *bool `type:"boolean"`

	// Specifies whether a budget includes refunds.
	//
	// The default value is true.
	IncludeRefund *bool `type:"boolean"`

	// Specifies whether a budget includes subscriptions.
	//
	// The default value is true.
	IncludeSubscription *bool `type:"boolean"`

	// Specifies whether a budget includes support subscription fees.
	//
	// The default value is true.
	IncludeSupport *bool `type:"boolean"`

	// Specifies whether a budget includes taxes.
	//
	// The default value is true.
	IncludeTax *bool `type:"boolean"`

	// Specifies whether a budget includes upfront RI costs.
	//
	// The default value is true.
	IncludeUpfront *bool `type:"boolean"`

	// Specifies whether a budget uses the amortized rate.
	//
	// The default value is false.
	UseAmortized *bool `type:"boolean"`

	// Specifies whether a budget uses blended rate.
	//
	// The default value is false.
	UseBlended *bool `type:"boolean"`
}

// String returns the string representation
func (s CostTypes) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CostTypes) GoString() string {
	return s.String()
}

// Request of CreateBudget
type CreateBudgetInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The budget object that you want to create.
	//
	// Budget is a required field
	Budget *Budget `type:"structure" required:"true"`

	// A notification that you want to associate with a budget. A budget can have
	// up to five notifications, and each notification can have one SNS subscriber
	// and up to ten email subscribers. If you include notifications and subscribers
	// in your CreateBudget call, AWS creates the notifications and subscribers
	// for you.
	NotificationsWithSubscribers []NotificationWithSubscribers `type:"list"`
}

// String returns the string representation
func (s CreateBudgetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateBudgetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateBudgetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateBudgetInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.Budget == nil {
		invalidParams.Add(aws.NewErrParamRequired("Budget"))
	}
	if s.Budget != nil {
		if err := s.Budget.Validate(); err != nil {
			invalidParams.AddNested("Budget", err.(aws.ErrInvalidParams))
		}
	}
	if s.NotificationsWithSubscribers != nil {
		for i, v := range s.NotificationsWithSubscribers {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "NotificationsWithSubscribers", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of CreateBudget
type CreateBudgetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s CreateBudgetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateBudgetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateBudgetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of CreateNotification
type CreateNotificationInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget that you want to create
	// a notification for.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget that you want AWS to notified you about. Budget names
	// must be unique within an account.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// The notification that you want to create.
	//
	// Notification is a required field
	Notification *Notification `type:"structure" required:"true"`

	// A list of subscribers that you want to associate with the notification. Each
	// notification can have one SNS subscriber and up to ten email subscribers.
	//
	// Subscribers is a required field
	Subscribers []Subscriber `min:"1" type:"list" required:"true"`
}

// String returns the string representation
func (s CreateNotificationInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateNotificationInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateNotificationInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateNotificationInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}

	if s.Notification == nil {
		invalidParams.Add(aws.NewErrParamRequired("Notification"))
	}

	if s.Subscribers == nil {
		invalidParams.Add(aws.NewErrParamRequired("Subscribers"))
	}
	if s.Subscribers != nil && len(s.Subscribers) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Subscribers", 1))
	}
	if s.Notification != nil {
		if err := s.Notification.Validate(); err != nil {
			invalidParams.AddNested("Notification", err.(aws.ErrInvalidParams))
		}
	}
	if s.Subscribers != nil {
		for i, v := range s.Subscribers {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Subscribers", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of CreateNotification
type CreateNotificationOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s CreateNotificationOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateNotificationOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateNotificationOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of CreateSubscriber
type CreateSubscriberInput struct {
	_ struct{} `type:"structure"`

	// The accountId associated with the budget that you want to create a subscriber
	// for.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget that you want to subscribe to. Budget names must be
	// unique within an account.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// The notification that you want to create a subscriber for.
	//
	// Notification is a required field
	Notification *Notification `type:"structure" required:"true"`

	// The subscriber that you want to associate with a budget notification.
	//
	// Subscriber is a required field
	Subscriber *Subscriber `type:"structure" required:"true"`
}

// String returns the string representation
func (s CreateSubscriberInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateSubscriberInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateSubscriberInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateSubscriberInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}

	if s.Notification == nil {
		invalidParams.Add(aws.NewErrParamRequired("Notification"))
	}

	if s.Subscriber == nil {
		invalidParams.Add(aws.NewErrParamRequired("Subscriber"))
	}
	if s.Notification != nil {
		if err := s.Notification.Validate(); err != nil {
			invalidParams.AddNested("Notification", err.(aws.ErrInvalidParams))
		}
	}
	if s.Subscriber != nil {
		if err := s.Subscriber.Validate(); err != nil {
			invalidParams.AddNested("Subscriber", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of CreateSubscriber
type CreateSubscriberOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s CreateSubscriberOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateSubscriberOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateSubscriberOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of DeleteBudget
type DeleteBudgetInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget that you want to delete.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget that you want to delete.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteBudgetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteBudgetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteBudgetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteBudgetInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of DeleteBudget
type DeleteBudgetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteBudgetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteBudgetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteBudgetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of DeleteNotification
type DeleteNotificationInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget whose notification you want
	// to delete.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget whose notification you want to delete.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// The notification that you want to delete.
	//
	// Notification is a required field
	Notification *Notification `type:"structure" required:"true"`
}

// String returns the string representation
func (s DeleteNotificationInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteNotificationInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteNotificationInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteNotificationInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}

	if s.Notification == nil {
		invalidParams.Add(aws.NewErrParamRequired("Notification"))
	}
	if s.Notification != nil {
		if err := s.Notification.Validate(); err != nil {
			invalidParams.AddNested("Notification", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of DeleteNotification
type DeleteNotificationOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteNotificationOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteNotificationOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteNotificationOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of DeleteSubscriber
type DeleteSubscriberInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget whose subscriber you want
	// to delete.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget whose subscriber you want to delete.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// The notification whose subscriber you want to delete.
	//
	// Notification is a required field
	Notification *Notification `type:"structure" required:"true"`

	// The subscriber that you want to delete.
	//
	// Subscriber is a required field
	Subscriber *Subscriber `type:"structure" required:"true"`
}

// String returns the string representation
func (s DeleteSubscriberInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteSubscriberInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteSubscriberInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteSubscriberInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}

	if s.Notification == nil {
		invalidParams.Add(aws.NewErrParamRequired("Notification"))
	}

	if s.Subscriber == nil {
		invalidParams.Add(aws.NewErrParamRequired("Subscriber"))
	}
	if s.Notification != nil {
		if err := s.Notification.Validate(); err != nil {
			invalidParams.AddNested("Notification", err.(aws.ErrInvalidParams))
		}
	}
	if s.Subscriber != nil {
		if err := s.Subscriber.Validate(); err != nil {
			invalidParams.AddNested("Subscriber", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of DeleteSubscriber
type DeleteSubscriberOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteSubscriberOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteSubscriberOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteSubscriberOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of DescribeBudget
type DescribeBudgetInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget that you want a description
	// of.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget that you want a description of.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeBudgetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeBudgetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeBudgetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeBudgetInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of DescribeBudget
type DescribeBudgetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The description of the budget.
	Budget *Budget `type:"structure"`
}

// String returns the string representation
func (s DescribeBudgetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeBudgetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeBudgetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of DescribeBudgets
type DescribeBudgetsInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budgets that you want descriptions
	// of.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// Optional integer. Specifies the maximum number of results to return in response.
	MaxResults *int64 `min:"1" type:"integer"`

	// The pagination token that indicates the next set of results to retrieve.
	NextToken *string `type:"string"`
}

// String returns the string representation
func (s DescribeBudgetsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeBudgetsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeBudgetsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeBudgetsInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of DescribeBudgets
type DescribeBudgetsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A list of budgets.
	Budgets []Budget `type:"list"`

	// The pagination token that indicates the next set of results that you can
	// retrieve.
	NextToken *string `type:"string"`
}

// String returns the string representation
func (s DescribeBudgetsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeBudgetsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeBudgetsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of DescribeNotificationsForBudget
type DescribeNotificationsForBudgetInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget whose notifications you
	// want descriptions of.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget whose notifications you want descriptions of.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// Optional integer. Specifies the maximum number of results to return in response.
	MaxResults *int64 `min:"1" type:"integer"`

	// The pagination token that indicates the next set of results to retrieve.
	NextToken *string `type:"string"`
}

// String returns the string representation
func (s DescribeNotificationsForBudgetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeNotificationsForBudgetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeNotificationsForBudgetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeNotificationsForBudgetInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of GetNotificationsForBudget
type DescribeNotificationsForBudgetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The pagination token that indicates the next set of results that you can
	// retrieve.
	NextToken *string `type:"string"`

	// A list of notifications associated with a budget.
	Notifications []Notification `type:"list"`
}

// String returns the string representation
func (s DescribeNotificationsForBudgetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeNotificationsForBudgetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeNotificationsForBudgetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of DescribeSubscribersForNotification
type DescribeSubscribersForNotificationInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget whose subscribers you want
	// descriptions of.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget whose subscribers you want descriptions of.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// Optional integer. Specifies the maximum number of results to return in response.
	MaxResults *int64 `min:"1" type:"integer"`

	// The pagination token that indicates the next set of results to retrieve.
	NextToken *string `type:"string"`

	// The notification whose subscribers you want to list.
	//
	// Notification is a required field
	Notification *Notification `type:"structure" required:"true"`
}

// String returns the string representation
func (s DescribeSubscribersForNotificationInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeSubscribersForNotificationInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeSubscribersForNotificationInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeSubscribersForNotificationInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}

	if s.Notification == nil {
		invalidParams.Add(aws.NewErrParamRequired("Notification"))
	}
	if s.Notification != nil {
		if err := s.Notification.Validate(); err != nil {
			invalidParams.AddNested("Notification", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of DescribeSubscribersForNotification
type DescribeSubscribersForNotificationOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The pagination token that indicates the next set of results that you can
	// retrieve.
	NextToken *string `type:"string"`

	// A list of subscribers associated with a notification.
	Subscribers []Subscriber `min:"1" type:"list"`
}

// String returns the string representation
func (s DescribeSubscribersForNotificationOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeSubscribersForNotificationOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeSubscribersForNotificationOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// A notification associated with a budget. A budget can have up to five notifications.
//
// Each notification must have at least one subscriber. A notification can have
// one SNS subscriber and up to ten email subscribers, for a total of 11 subscribers.
//
// For example, if you have a budget for 200 dollars and you want to be notified
// when you go over 160 dollars, create a notification with the following parameters:
//
//    * A notificationType of ACTUAL
//
//    * A comparisonOperator of GREATER_THAN
//
//    * A notification threshold of 80
type Notification struct {
	_ struct{} `type:"structure"`

	// The comparison used for this notification.
	//
	// ComparisonOperator is a required field
	ComparisonOperator ComparisonOperator `type:"string" required:"true" enum:"true"`

	// Whether the notification is for how much you have spent (ACTUAL) or for how
	// much you are forecasted to spend (FORECASTED).
	//
	// NotificationType is a required field
	NotificationType NotificationType `type:"string" required:"true" enum:"true"`

	// The threshold associated with a notification. Thresholds are always a percentage.
	//
	// Threshold is a required field
	Threshold *float64 `min:"0.1" type:"double" required:"true"`

	// The type of threshold for a notification. For ACTUAL thresholds, AWS notifies
	// you when you go over the threshold, and for FORECASTED thresholds AWS notifies
	// you when you are forecasted to go over the threshold.
	ThresholdType ThresholdType `type:"string" enum:"true"`
}

// String returns the string representation
func (s Notification) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Notification) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Notification) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Notification"}
	if len(s.ComparisonOperator) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("ComparisonOperator"))
	}
	if len(s.NotificationType) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("NotificationType"))
	}

	if s.Threshold == nil {
		invalidParams.Add(aws.NewErrParamRequired("Threshold"))
	}
	if s.Threshold != nil && *s.Threshold < 0.1 {
		invalidParams.Add(aws.NewErrParamMinValue("Threshold", 0.1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// A notification with subscribers. A notification can have one SNS subscriber
// and up to ten email subscribers, for a total of 11 subscribers.
type NotificationWithSubscribers struct {
	_ struct{} `type:"structure"`

	// The notification associated with a budget.
	//
	// Notification is a required field
	Notification *Notification `type:"structure" required:"true"`

	// A list of subscribers who are subscribed to this notification.
	//
	// Subscribers is a required field
	Subscribers []Subscriber `min:"1" type:"list" required:"true"`
}

// String returns the string representation
func (s NotificationWithSubscribers) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s NotificationWithSubscribers) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *NotificationWithSubscribers) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "NotificationWithSubscribers"}

	if s.Notification == nil {
		invalidParams.Add(aws.NewErrParamRequired("Notification"))
	}

	if s.Subscribers == nil {
		invalidParams.Add(aws.NewErrParamRequired("Subscribers"))
	}
	if s.Subscribers != nil && len(s.Subscribers) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Subscribers", 1))
	}
	if s.Notification != nil {
		if err := s.Notification.Validate(); err != nil {
			invalidParams.AddNested("Notification", err.(aws.ErrInvalidParams))
		}
	}
	if s.Subscribers != nil {
		for i, v := range s.Subscribers {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Subscribers", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The amount of cost or usage being measured for a budget.
//
// For example, a Spend for 3 GB of S3 usage would have the following parameters:
//
//    * An Amount of 3
//
//    * A unit of GB
type Spend struct {
	_ struct{} `type:"structure"`

	// The cost or usage amount associated with a budget forecast, actual spend,
	// or budget threshold.
	//
	// Amount is a required field
	Amount *string `type:"string" required:"true"`

	// The unit of measurement used for the budget forecast, actual spend, or budget
	// threshold, such as dollars or GB.
	//
	// Unit is a required field
	Unit *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s Spend) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Spend) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Spend) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Spend"}

	if s.Amount == nil {
		invalidParams.Add(aws.NewErrParamRequired("Amount"))
	}

	if s.Unit == nil {
		invalidParams.Add(aws.NewErrParamRequired("Unit"))
	}
	if s.Unit != nil && len(*s.Unit) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Unit", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The subscriber to a budget notification. The subscriber consists of a subscription
// type and either an Amazon Simple Notification Service topic or an email address.
//
// For example, an email subscriber would have the following parameters:
//
//    * A subscriptionType of EMAIL
//
//    * An address of example@example.com
type Subscriber struct {
	_ struct{} `type:"structure"`

	// The address that AWS sends budget notifications to, either an SNS topic or
	// an email.
	//
	// Address is a required field
	Address *string `min:"1" type:"string" required:"true"`

	// The type of notification that AWS sends to a subscriber.
	//
	// SubscriptionType is a required field
	SubscriptionType SubscriptionType `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s Subscriber) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Subscriber) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Subscriber) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Subscriber"}

	if s.Address == nil {
		invalidParams.Add(aws.NewErrParamRequired("Address"))
	}
	if s.Address != nil && len(*s.Address) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Address", 1))
	}
	if len(s.SubscriptionType) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("SubscriptionType"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// The period of time covered by a budget. Has a start date and an end date.
// The start date must come before the end date. There are no restrictions on
// the end date.
type TimePeriod struct {
	_ struct{} `type:"structure"`

	// The end date for a budget. If you didn't specify an end date, AWS set your
	// end date to 06/15/87 00:00 UTC. The defaults are the same for the AWS Billing
	// and Cost Management console and the API.
	//
	// After the end date, AWS deletes the budget and all associated notifications
	// and subscribers. You can change your end date with the UpdateBudget operation.
	End *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The start date for a budget. If you created your budget and didn't specify
	// a start date, AWS defaults to the start of your chosen time period (i.e.
	// DAILY, MONTHLY, QUARTERLY, ANNUALLY). For example, if you created your budget
	// on January 24th 2018, chose DAILY, and didn't set a start date, AWS set your
	// start date to 01/24/18 00:00 UTC. If you chose MONTHLY, AWS set your start
	// date to 01/01/18 00:00 UTC. The defaults are the same for the AWS Billing
	// and Cost Management console and the API.
	//
	// You can change your start date with the UpdateBudget operation.
	Start *time.Time `type:"timestamp" timestampFormat:"unix"`
}

// String returns the string representation
func (s TimePeriod) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s TimePeriod) GoString() string {
	return s.String()
}

// Request of UpdateBudget
type UpdateBudgetInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget that you want to update.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The budget that you want to update your budget to.
	//
	// NewBudget is a required field
	NewBudget *Budget `type:"structure" required:"true"`
}

// String returns the string representation
func (s UpdateBudgetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateBudgetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateBudgetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateBudgetInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.NewBudget == nil {
		invalidParams.Add(aws.NewErrParamRequired("NewBudget"))
	}
	if s.NewBudget != nil {
		if err := s.NewBudget.Validate(); err != nil {
			invalidParams.AddNested("NewBudget", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of UpdateBudget
type UpdateBudgetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s UpdateBudgetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateBudgetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateBudgetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of UpdateNotification
type UpdateNotificationInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget whose notification you want
	// to update.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget whose notification you want to update.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// The updated notification to be associated with a budget.
	//
	// NewNotification is a required field
	NewNotification *Notification `type:"structure" required:"true"`

	// The previous notification associated with a budget.
	//
	// OldNotification is a required field
	OldNotification *Notification `type:"structure" required:"true"`
}

// String returns the string representation
func (s UpdateNotificationInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateNotificationInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateNotificationInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateNotificationInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}

	if s.NewNotification == nil {
		invalidParams.Add(aws.NewErrParamRequired("NewNotification"))
	}

	if s.OldNotification == nil {
		invalidParams.Add(aws.NewErrParamRequired("OldNotification"))
	}
	if s.NewNotification != nil {
		if err := s.NewNotification.Validate(); err != nil {
			invalidParams.AddNested("NewNotification", err.(aws.ErrInvalidParams))
		}
	}
	if s.OldNotification != nil {
		if err := s.OldNotification.Validate(); err != nil {
			invalidParams.AddNested("OldNotification", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of UpdateNotification
type UpdateNotificationOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s UpdateNotificationOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateNotificationOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateNotificationOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Request of UpdateSubscriber
type UpdateSubscriberInput struct {
	_ struct{} `type:"structure"`

	// The accountId that is associated with the budget whose subscriber you want
	// to update.
	//
	// AccountId is a required field
	AccountId *string `min:"12" type:"string" required:"true"`

	// The name of the budget whose subscriber you want to update.
	//
	// BudgetName is a required field
	BudgetName *string `type:"string" required:"true"`

	// The updated subscriber associated with a budget notification.
	//
	// NewSubscriber is a required field
	NewSubscriber *Subscriber `type:"structure" required:"true"`

	// The notification whose subscriber you want to update.
	//
	// Notification is a required field
	Notification *Notification `type:"structure" required:"true"`

	// The previous subscriber associated with a budget notification.
	//
	// OldSubscriber is a required field
	OldSubscriber *Subscriber `type:"structure" required:"true"`
}

// String returns the string representation
func (s UpdateSubscriberInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateSubscriberInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateSubscriberInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateSubscriberInput"}

	if s.AccountId == nil {
		invalidParams.Add(aws.NewErrParamRequired("AccountId"))
	}
	if s.AccountId != nil && len(*s.AccountId) < 12 {
		invalidParams.Add(aws.NewErrParamMinLen("AccountId", 12))
	}

	if s.BudgetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("BudgetName"))
	}

	if s.NewSubscriber == nil {
		invalidParams.Add(aws.NewErrParamRequired("NewSubscriber"))
	}

	if s.Notification == nil {
		invalidParams.Add(aws.NewErrParamRequired("Notification"))
	}

	if s.OldSubscriber == nil {
		invalidParams.Add(aws.NewErrParamRequired("OldSubscriber"))
	}
	if s.NewSubscriber != nil {
		if err := s.NewSubscriber.Validate(); err != nil {
			invalidParams.AddNested("NewSubscriber", err.(aws.ErrInvalidParams))
		}
	}
	if s.Notification != nil {
		if err := s.Notification.Validate(); err != nil {
			invalidParams.AddNested("Notification", err.(aws.ErrInvalidParams))
		}
	}
	if s.OldSubscriber != nil {
		if err := s.OldSubscriber.Validate(); err != nil {
			invalidParams.AddNested("OldSubscriber", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Response of UpdateSubscriber
type UpdateSubscriberOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s UpdateSubscriberOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateSubscriberOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateSubscriberOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// The type of a budget. It should be COST, USAGE, or RI_UTILIZATION.
type BudgetType string

// Enum values for BudgetType
const (
	BudgetTypeUsage         BudgetType = "USAGE"
	BudgetTypeCost          BudgetType = "COST"
	BudgetTypeRiUtilization BudgetType = "RI_UTILIZATION"
	BudgetTypeRiCoverage    BudgetType = "RI_COVERAGE"
)

func (enum BudgetType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BudgetType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The comparison operator of a notification. Currently we support less than,
// equal to and greater than.
type ComparisonOperator string

// Enum values for ComparisonOperator
const (
	ComparisonOperatorGreaterThan ComparisonOperator = "GREATER_THAN"
	ComparisonOperatorLessThan    ComparisonOperator = "LESS_THAN"
	ComparisonOperatorEqualTo     ComparisonOperator = "EQUAL_TO"
)

func (enum ComparisonOperator) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ComparisonOperator) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The type of a notification. It should be ACTUAL or FORECASTED.
type NotificationType string

// Enum values for NotificationType
const (
	NotificationTypeActual     NotificationType = "ACTUAL"
	NotificationTypeForecasted NotificationType = "FORECASTED"
)

func (enum NotificationType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotificationType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The subscription type of the subscriber. It can be SMS or EMAIL.
type SubscriptionType string

// Enum values for SubscriptionType
const (
	SubscriptionTypeSns   SubscriptionType = "SNS"
	SubscriptionTypeEmail SubscriptionType = "EMAIL"
)

func (enum SubscriptionType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SubscriptionType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The type of threshold for a notification. It can be PERCENTAGE or ABSOLUTE_VALUE.
type ThresholdType string

// Enum values for ThresholdType
const (
	ThresholdTypePercentage    ThresholdType = "PERCENTAGE"
	ThresholdTypeAbsoluteValue ThresholdType = "ABSOLUTE_VALUE"
)

func (enum ThresholdType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ThresholdType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The time unit of the budget. e.g. MONTHLY, QUARTERLY, etc.
type TimeUnit string

// Enum values for TimeUnit
const (
	TimeUnitDaily     TimeUnit = "DAILY"
	TimeUnitMonthly   TimeUnit = "MONTHLY"
	TimeUnitQuarterly TimeUnit = "QUARTERLY"
	TimeUnitAnnually  TimeUnit = "ANNUALLY"
)

func (enum TimeUnit) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TimeUnit) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}