type AccessDeniedException struct {
	Message *string
}

type Budget struct {

	// The types of costs that are included in this COST budget. USAGE, RI_UTILIZATION,
	// RI_COVERAGE, Savings_Plans_Utilization, and Savings_Plans_Coverage budgets do
	// not have CostTypes.
	CostTypes *CostTypes

	// The length of time until a budget resets the actual and forecasted spend. DAILY
	// is available only for RI_UTILIZATION, RI_COVERAGE, Savings_Plans_Utilization,
	// and Savings_Plans_Coverage budgets.
	//
	// This member is required.
	TimeUnit TimeUnit

	// The cost filters, such as service or tag, that are applied to a budget. AWS
	// Budgets supports the following services as a filter for RI budgets:
	//
	//     *
	// Amazon Elastic Compute Cloud - Compute
	//
	//     * Amazon Redshift
	//
	//     * Amazon
	// Relational Database Service
	//
	//     * Amazon ElastiCache
	//
	//     * Amazon
	// Elasticsearch Service
	CostFilters map[string][]*string

	// The actual and forecasted cost or usage that the budget tracks.
	CalculatedSpend *CalculatedSpend

	// The last time that you updated this budget.
	LastUpdatedTime *time.Time

	// A map containing multiple BudgetLimit, including current or future limits.
	// PlannedBudgetLimits is available for cost or usage budget and supports monthly
	// and quarterly TimeUnit. For monthly budgets, provide 12 months of
	// PlannedBudgetLimits values. This must start from the current month and include
	// the next 11 months. The key is the start of the month, UTC in epoch seconds. For
	// quarterly budgets, provide 4 quarters of PlannedBudgetLimits value entries in
	// standard calendar quarter increments. This must start from the current quarter
	// and include the next 3 quarters. The key is the start of the quarter, UTC in
	// epoch seconds. If the planned budget expires before 12 months for monthly or 4
	// quarters for quarterly, provide the PlannedBudgetLimits values only for the
	// remaining periods. If the budget begins at a date in the future, provide
	// PlannedBudgetLimits values from the start date of the budget. After all of the
	// BudgetLimit values in PlannedBudgetLimits are used, the budget continues to use
	// the last limit as the BudgetLimit. At that point, the planned budget provides
	// the same experience as a fixed budget. DescribeBudget and DescribeBudgets
	// response along with PlannedBudgetLimits will also contain BudgetLimit
	// representing the current month or quarter limit present in PlannedBudgetLimits.
	// This only applies to budgets created with PlannedBudgetLimits. Budgets created
	// without PlannedBudgetLimits will only contain BudgetLimit, and no
	// PlannedBudgetLimits.
	PlannedBudgetLimits map[string]*Spend

	// The name of a budget. The name must be unique within an account. The : and \
	// characters aren't allowed in BudgetName.
	//
	// This member is required.
	BudgetName *string

	// The total amount of cost, usage, RI utilization, RI coverage, Savings Plans
	// utilization, or Savings Plans coverage that you want to track with your budget.
	// BudgetLimit is required for cost or usage budgets, but optional for RI or
	// Savings Plans utilization or coverage budgets. RI and Savings Plans utilization
	// or coverage budgets default to 100, which is the only valid value for RI or
	// Savings Plans utilization or coverage budgets. You can't use BudgetLimit with
	// PlannedBudgetLimits for CreateBudget and UpdateBudget actions.
	BudgetLimit *Spend

	// The period of time that is covered by a budget. The period has a start date and
	// an end date. The start date must come before the end date. The end date must
	// come before 06/15/87 00:00 UTC. If you create your budget and don't specify a
	// start date, AWS defaults to the start of your chosen time period (DAILY,
	// MONTHLY, QUARTERLY, or ANNUALLY). For example, if you created your budget on
	// January 24, 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

	// Whether this budget tracks costs, usage, RI utilization, RI coverage, Savings
	// Plans utilization, or Savings Plans coverage.
	//
	// This member is required.
	BudgetType BudgetType
}

type BudgetPerformanceHistory struct {

	// A string that represents the budget name. The ":" and "\" characters aren't
	// allowed.
	BudgetName *string

	// A list of amounts of cost or usage that you created budgets for, compared to
	// your actual costs or usage.
	BudgetedAndActualAmountsList []*BudgetedAndActualAmounts

	// The time unit of the budget, such as MONTHLY or QUARTERLY.
	TimeUnit TimeUnit

	// The history of the cost filters for a budget during the specified time period.
	CostFilters map[string][]*string

	// The history of the cost types for a budget during the specified time period.
	CostTypes *CostTypes

	// The type of a budget. It must be one of the following types: COST, USAGE,
	// RI_UTILIZATION, or RI_COVERAGE.
	BudgetType BudgetType
}

type BudgetType string

const (
	BudgetTypeUsage         BudgetType = "USAGE"
	BudgetTypeCost          BudgetType = "COST"
	BudgetTypeRiutilization BudgetType = "RI_UTILIZATION"
	BudgetTypeRicoverage    BudgetType = "RI_COVERAGE"
	BudgetTypeSputilization BudgetType = "SAVINGS_PLANS_UTILIZATION"
	BudgetTypeSpcoverage    BudgetType = "SAVINGS_PLANS_COVERAGE"
)

type BudgetedAndActualAmounts struct {

	// Your actual costs or usage for a budget period.
	ActualAmount *Spend

	// The amount of cost or usage that you created the budget for.
	BudgetedAmount *Spend

	// The time period covered by this budget comparison.
	TimePeriod *TimePeriod
}

type CalculatedSpend struct {

	// The amount of cost, usage, or RI units that you are forecasted to use.
	ForecastedSpend *Spend

	// The amount of cost, usage, or RI units that you have used.
	//
	// This member is required.
	ActualSpend *Spend
}

type ComparisonOperator string

const (
	ComparisonOperatorGreater_than ComparisonOperator = "GREATER_THAN"
	ComparisonOperatorLess_than    ComparisonOperator = "LESS_THAN"
	ComparisonOperatorEqual_to     ComparisonOperator = "EQUAL_TO"
)

type CostTypes struct {

	// Specifies whether a budget includes upfront RI costs. The default value is true.
	IncludeUpfront *bool

	// Specifies whether a budget includes subscriptions. The default value is true.
	IncludeSubscription *bool

	// Specifies whether a budget includes credits. The default value is true.
	IncludeCredit *bool

	// Specifies whether a budget includes discounts. The default value is true.
	IncludeDiscount *bool

	// Specifies whether a budget includes refunds. The default value is true.
	IncludeRefund *bool

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

	// Specifies whether a budget uses the amortized rate. The default value is false.
	UseAmortized *bool

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

	// Specifies whether a budget includes support subscription fees. The default value
	// is true.
	IncludeSupport *bool

	// Specifies whether a budget uses a blended rate. The default value is false.
	UseBlended *bool

	// Specifies whether a budget includes taxes. The default value is true.
	IncludeTax *bool
}

type CreationLimitExceededException struct {
	Message *string
}

type DuplicateRecordException struct {
	Message *string
}

type ExpiredNextTokenException struct {
	Message *string
}

type InternalErrorException struct {
	Message *string
}

type InvalidNextTokenException struct {
	Message *string
}

type InvalidParameterException struct {
	Message *string
}

type NotFoundException struct {
	Message *string
}

type Notification struct {

	// The comparison that is used for this notification.
	//
	// This member is required.
	ComparisonOperator ComparisonOperator

	// The type of threshold for a notification. For ABSOLUTE_VALUE thresholds, AWS
	// notifies you when you go over or are forecasted to go over your total cost
	// threshold. For PERCENTAGE thresholds, AWS notifies you when you go over or are
	// forecasted to go over a certain percentage of your forecasted spend. For
	// example, if you have a budget for 200 dollars and you have a PERCENTAGE
	// threshold of 80%, AWS notifies you when you go over 160 dollars.
	ThresholdType ThresholdType

	// Whether this notification is in alarm. If a budget notification is in the ALARM
	// state, you have passed the set threshold for the budget.
	NotificationState NotificationState

	// The threshold that is associated with a notification. Thresholds are always a
	// percentage.
	//
	// This member is required.
	Threshold *float64

	// Whether the notification is for how much you have spent (ACTUAL) or for how much
	// you're forecasted to spend (FORECASTED).
	//
	// This member is required.
	NotificationType NotificationType
}

type NotificationState string

const (
	NotificationStateOk    NotificationState = "OK"
	NotificationStateAlarm NotificationState = "ALARM"
)

type NotificationType string

const (
	NotificationTypeActual     NotificationType = "ACTUAL"
	NotificationTypeForecasted NotificationType = "FORECASTED"
)

type NotificationWithSubscribers struct {

	// The notification that is associated with a budget.
	//
	// This member is required.
	Notification *Notification

	// A list of subscribers who are subscribed to this notification.
	//
	// This member is required.
	Subscribers []*Subscriber
}

type Spend struct {

	// The cost or usage amount that is associated with a budget forecast, actual
	// spend, or budget threshold.
	//
	// This member is required.
	Amount *string

	// The unit of measurement that is used for the budget forecast, actual spend, or
	// budget threshold, such as dollars or GB.
	//
	// This member is required.
	Unit *string
}

type Subscriber struct {

	// The address that AWS sends budget notifications to, either an SNS topic or an
	// email. When you create a subscriber, the value of Address can't contain line
	// breaks.
	//
	// This member is required.
	Address *string

	// The type of notification that AWS sends to a subscriber.
	//
	// This member is required.
	SubscriptionType SubscriptionType
}

type SubscriptionType string

const (
	SubscriptionTypeSns   SubscriptionType = "SNS"
	SubscriptionTypeEmail SubscriptionType = "EMAIL"
)

type ThresholdType string

const (
	ThresholdTypePercentage     ThresholdType = "PERCENTAGE"
	ThresholdTypeAbsolute_value ThresholdType = "ABSOLUTE_VALUE"
)

type TimePeriod struct {

	// 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 (DAILY,
	// MONTHLY, QUARTERLY, or ANNUALLY). For example, if you created your budget on
	// January 24, 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

	// 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 TimeUnit string

const (
	TimeUnitDaily     TimeUnit = "DAILY"
	TimeUnitMonthly   TimeUnit = "MONTHLY"
	TimeUnitQuarterly TimeUnit = "QUARTERLY"
	TimeUnitAnnually  TimeUnit = "ANNUALLY"
)