aws-sdk-cloudwatch 1.32.0 → 1.33.0

data/lib/aws-sdk-cloudwatch/client_api.rb

@@ -20,6 +20,9 @@ module Aws::CloudWatch
     AlarmName = Shapes::StringShape.new(name: 'AlarmName')
     AlarmNamePrefix = Shapes::StringShape.new(name: 'AlarmNamePrefix')
     AlarmNames = Shapes::ListShape.new(name: 'AlarmNames')
+    AlarmRule = Shapes::StringShape.new(name: 'AlarmRule')
+    AlarmType = Shapes::StringShape.new(name: 'AlarmType')
+    AlarmTypes = Shapes::ListShape.new(name: 'AlarmTypes')
     AmazonResourceName = Shapes::StringShape.new(name: 'AmazonResourceName')
     AnomalyDetector = Shapes::StructureShape.new(name: 'AnomalyDetector')
     AnomalyDetectorConfiguration = Shapes::StructureShape.new(name: 'AnomalyDetectorConfiguration')
@@ -30,6 +33,8 @@ module Aws::CloudWatch
     AwsQueryErrorMessage = Shapes::StringShape.new(name: 'AwsQueryErrorMessage')
     BatchFailures = Shapes::ListShape.new(name: 'BatchFailures')
     ComparisonOperator = Shapes::StringShape.new(name: 'ComparisonOperator')
+    CompositeAlarm = Shapes::StructureShape.new(name: 'CompositeAlarm')
+    CompositeAlarms = Shapes::ListShape.new(name: 'CompositeAlarms')
     ConcurrentModificationException = Shapes::StructureShape.new(name: 'ConcurrentModificationException')
     Counts = Shapes::ListShape.new(name: 'Counts')
     DashboardArn = Shapes::StringShape.new(name: 'DashboardArn')
@@ -175,6 +180,7 @@ module Aws::CloudWatch
     Period = Shapes::IntegerShape.new(name: 'Period')
     PutAnomalyDetectorInput = Shapes::StructureShape.new(name: 'PutAnomalyDetectorInput')
     PutAnomalyDetectorOutput = Shapes::StructureShape.new(name: 'PutAnomalyDetectorOutput')
+    PutCompositeAlarmInput = Shapes::StructureShape.new(name: 'PutCompositeAlarmInput')
     PutDashboardInput = Shapes::StructureShape.new(name: 'PutDashboardInput')
     PutDashboardOutput = Shapes::StructureShape.new(name: 'PutDashboardOutput')
     PutInsightRuleInput = Shapes::StructureShape.new(name: 'PutInsightRuleInput')
@@ -218,6 +224,7 @@ module Aws::CloudWatch
     Values = Shapes::ListShape.new(name: 'Values')
 
     AlarmHistoryItem.add_member(:alarm_name, Shapes::ShapeRef.new(shape: AlarmName, location_name: "AlarmName"))
+    AlarmHistoryItem.add_member(:alarm_type, Shapes::ShapeRef.new(shape: AlarmType, location_name: "AlarmType"))
     AlarmHistoryItem.add_member(:timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "Timestamp"))
     AlarmHistoryItem.add_member(:history_item_type, Shapes::ShapeRef.new(shape: HistoryItemType, location_name: "HistoryItemType"))
     AlarmHistoryItem.add_member(:history_summary, Shapes::ShapeRef.new(shape: HistorySummary, location_name: "HistorySummary"))
@@ -228,6 +235,8 @@ module Aws::CloudWatch
 
     AlarmNames.member = Shapes::ShapeRef.new(shape: AlarmName)
 
+    AlarmTypes.member = Shapes::ShapeRef.new(shape: AlarmType)
+
     AnomalyDetector.add_member(:namespace, Shapes::ShapeRef.new(shape: Namespace, location_name: "Namespace"))
     AnomalyDetector.add_member(:metric_name, Shapes::ShapeRef.new(shape: MetricName, location_name: "MetricName"))
     AnomalyDetector.add_member(:dimensions, Shapes::ShapeRef.new(shape: Dimensions, location_name: "Dimensions"))
@@ -246,6 +255,25 @@ module Aws::CloudWatch
 
     BatchFailures.member = Shapes::ShapeRef.new(shape: PartialFailure)
 
+    CompositeAlarm.add_member(:actions_enabled, Shapes::ShapeRef.new(shape: ActionsEnabled, location_name: "ActionsEnabled"))
+    CompositeAlarm.add_member(:alarm_actions, Shapes::ShapeRef.new(shape: ResourceList, location_name: "AlarmActions"))
+    CompositeAlarm.add_member(:alarm_arn, Shapes::ShapeRef.new(shape: AlarmArn, location_name: "AlarmArn"))
+    CompositeAlarm.add_member(:alarm_configuration_updated_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "AlarmConfigurationUpdatedTimestamp"))
+    CompositeAlarm.add_member(:alarm_description, Shapes::ShapeRef.new(shape: AlarmDescription, location_name: "AlarmDescription"))
+    CompositeAlarm.add_member(:alarm_name, Shapes::ShapeRef.new(shape: AlarmName, location_name: "AlarmName"))
+    CompositeAlarm.add_member(:alarm_rule, Shapes::ShapeRef.new(shape: AlarmRule, location_name: "AlarmRule"))
+    CompositeAlarm.add_member(:insufficient_data_actions, Shapes::ShapeRef.new(shape: ResourceList, location_name: "InsufficientDataActions"))
+    CompositeAlarm.add_member(:ok_actions, Shapes::ShapeRef.new(shape: ResourceList, location_name: "OKActions"))
+    CompositeAlarm.add_member(:state_reason, Shapes::ShapeRef.new(shape: StateReason, location_name: "StateReason"))
+    CompositeAlarm.add_member(:state_reason_data, Shapes::ShapeRef.new(shape: StateReasonData, location_name: "StateReasonData"))
+    CompositeAlarm.add_member(:state_updated_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "StateUpdatedTimestamp"))
+    CompositeAlarm.add_member(:state_value, Shapes::ShapeRef.new(shape: StateValue, location_name: "StateValue"))
+    CompositeAlarm.struct_class = Types::CompositeAlarm
+
+    CompositeAlarms.member = Shapes::ShapeRef.new(shape: CompositeAlarm)
+
+    ConcurrentModificationException.struct_class = Types::ConcurrentModificationException
+
     Counts.member = Shapes::ShapeRef.new(shape: DatapointValue)
 
     DashboardEntries.member = Shapes::ShapeRef.new(shape: DashboardEntry)
@@ -311,11 +339,13 @@ module Aws::CloudWatch
     DeleteInsightRulesOutput.struct_class = Types::DeleteInsightRulesOutput
 
     DescribeAlarmHistoryInput.add_member(:alarm_name, Shapes::ShapeRef.new(shape: AlarmName, location_name: "AlarmName"))
+    DescribeAlarmHistoryInput.add_member(:alarm_types, Shapes::ShapeRef.new(shape: AlarmTypes, location_name: "AlarmTypes"))
     DescribeAlarmHistoryInput.add_member(:history_item_type, Shapes::ShapeRef.new(shape: HistoryItemType, location_name: "HistoryItemType"))
     DescribeAlarmHistoryInput.add_member(:start_date, Shapes::ShapeRef.new(shape: Timestamp, location_name: "StartDate"))
     DescribeAlarmHistoryInput.add_member(:end_date, Shapes::ShapeRef.new(shape: Timestamp, location_name: "EndDate"))
     DescribeAlarmHistoryInput.add_member(:max_records, Shapes::ShapeRef.new(shape: MaxRecords, location_name: "MaxRecords"))
     DescribeAlarmHistoryInput.add_member(:next_token, Shapes::ShapeRef.new(shape: NextToken, location_name: "NextToken"))
+    DescribeAlarmHistoryInput.add_member(:scan_by, Shapes::ShapeRef.new(shape: ScanBy, location_name: "ScanBy"))
     DescribeAlarmHistoryInput.struct_class = Types::DescribeAlarmHistoryInput
 
     DescribeAlarmHistoryOutput.add_member(:alarm_history_items, Shapes::ShapeRef.new(shape: AlarmHistoryItems, location_name: "AlarmHistoryItems"))
@@ -336,12 +366,16 @@ module Aws::CloudWatch
 
     DescribeAlarmsInput.add_member(:alarm_names, Shapes::ShapeRef.new(shape: AlarmNames, location_name: "AlarmNames"))
     DescribeAlarmsInput.add_member(:alarm_name_prefix, Shapes::ShapeRef.new(shape: AlarmNamePrefix, location_name: "AlarmNamePrefix"))
+    DescribeAlarmsInput.add_member(:alarm_types, Shapes::ShapeRef.new(shape: AlarmTypes, location_name: "AlarmTypes"))
+    DescribeAlarmsInput.add_member(:children_of_alarm_name, Shapes::ShapeRef.new(shape: AlarmName, location_name: "ChildrenOfAlarmName"))
+    DescribeAlarmsInput.add_member(:parents_of_alarm_name, Shapes::ShapeRef.new(shape: AlarmName, location_name: "ParentsOfAlarmName"))
     DescribeAlarmsInput.add_member(:state_value, Shapes::ShapeRef.new(shape: StateValue, location_name: "StateValue"))
     DescribeAlarmsInput.add_member(:action_prefix, Shapes::ShapeRef.new(shape: ActionPrefix, location_name: "ActionPrefix"))
     DescribeAlarmsInput.add_member(:max_records, Shapes::ShapeRef.new(shape: MaxRecords, location_name: "MaxRecords"))
     DescribeAlarmsInput.add_member(:next_token, Shapes::ShapeRef.new(shape: NextToken, location_name: "NextToken"))
     DescribeAlarmsInput.struct_class = Types::DescribeAlarmsInput
 
+    DescribeAlarmsOutput.add_member(:composite_alarms, Shapes::ShapeRef.new(shape: CompositeAlarms, location_name: "CompositeAlarms"))
     DescribeAlarmsOutput.add_member(:metric_alarms, Shapes::ShapeRef.new(shape: MetricAlarms, location_name: "MetricAlarms"))
     DescribeAlarmsOutput.add_member(:next_token, Shapes::ShapeRef.new(shape: NextToken, location_name: "NextToken"))
     DescribeAlarmsOutput.struct_class = Types::DescribeAlarmsOutput
@@ -513,6 +547,8 @@ module Aws::CloudWatch
     InvalidParameterValueException.add_member(:message, Shapes::ShapeRef.new(shape: AwsQueryErrorMessage, location_name: "message"))
     InvalidParameterValueException.struct_class = Types::InvalidParameterValueException
 
+    LimitExceededException.struct_class = Types::LimitExceededException
+
     LimitExceededFault.add_member(:message, Shapes::ShapeRef.new(shape: ErrorMessage, location_name: "message"))
     LimitExceededFault.struct_class = Types::LimitExceededFault
 
@@ -641,6 +677,16 @@ module Aws::CloudWatch
 
     PutAnomalyDetectorOutput.struct_class = Types::PutAnomalyDetectorOutput
 
+    PutCompositeAlarmInput.add_member(:actions_enabled, Shapes::ShapeRef.new(shape: ActionsEnabled, location_name: "ActionsEnabled"))
+    PutCompositeAlarmInput.add_member(:alarm_actions, Shapes::ShapeRef.new(shape: ResourceList, location_name: "AlarmActions"))
+    PutCompositeAlarmInput.add_member(:alarm_description, Shapes::ShapeRef.new(shape: AlarmDescription, location_name: "AlarmDescription"))
+    PutCompositeAlarmInput.add_member(:alarm_name, Shapes::ShapeRef.new(shape: AlarmName, required: true, location_name: "AlarmName"))
+    PutCompositeAlarmInput.add_member(:alarm_rule, Shapes::ShapeRef.new(shape: AlarmRule, required: true, location_name: "AlarmRule"))
+    PutCompositeAlarmInput.add_member(:insufficient_data_actions, Shapes::ShapeRef.new(shape: ResourceList, location_name: "InsufficientDataActions"))
+    PutCompositeAlarmInput.add_member(:ok_actions, Shapes::ShapeRef.new(shape: ResourceList, location_name: "OKActions"))
+    PutCompositeAlarmInput.add_member(:tags, Shapes::ShapeRef.new(shape: TagList, location_name: "Tags"))
+    PutCompositeAlarmInput.struct_class = Types::PutCompositeAlarmInput
+
     PutDashboardInput.add_member(:dashboard_name, Shapes::ShapeRef.new(shape: DashboardName, required: true, location_name: "DashboardName"))
     PutDashboardInput.add_member(:dashboard_body, Shapes::ShapeRef.new(shape: DashboardBody, required: true, location_name: "DashboardBody"))
     PutDashboardInput.struct_class = Types::PutDashboardInput
@@ -1005,6 +1051,15 @@ module Aws::CloudWatch
         o.errors << Shapes::ShapeRef.new(shape: MissingRequiredParameterException)
       end)
 
+      api.add_operation(:put_composite_alarm, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "PutCompositeAlarm"
+        o.http_method = "POST"
+        o.http_request_uri = "/"
+        o.input = Shapes::ShapeRef.new(shape: PutCompositeAlarmInput)
+        o.output = Shapes::ShapeRef.new(shape: Shapes::StructureShape.new(struct_class: Aws::EmptyStructure))
+        o.errors << Shapes::ShapeRef.new(shape: LimitExceededFault)
+      end)
+
       api.add_operation(:put_dashboard, Seahorse::Model::Operation.new.tap do |o|
         o.name = "PutDashboard"
         o.http_method = "POST"

data/lib/aws-sdk-cloudwatch/composite_alarm.rb

@@ -0,0 +1,472 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::CloudWatch
+  class CompositeAlarm
+
+    extend Aws::Deprecations
+
+    # @overload def initialize(name, options = {})
+    #   @param [String] name
+    #   @option options [Client] :client
+    # @overload def initialize(options = {})
+    #   @option options [required, String] :name
+    #   @option options [Client] :client
+    def initialize(*args)
+      options = Hash === args.last ? args.pop.dup : {}
+      @name = extract_name(args, options)
+      @data = options.delete(:data)
+      @client = options.delete(:client) || Client.new(options)
+      @waiter_block_warned = false
+    end
+
+    # @!group Read-Only Attributes
+
+    # @return [String]
+    def name
+      @name
+    end
+    alias :alarm_name :name
+
+    # Indicates whether actions should be executed during any changes to the
+    # alarm state.
+    # @return [Boolean]
+    def actions_enabled
+      data[:actions_enabled]
+    end
+
+    # The actions to execute when this alarm transitions to the ALARM state
+    # from any other state. Each action is specified as an Amazon Resource
+    # Name (ARN).
+    # @return [Array<String>]
+    def alarm_actions
+      data[:alarm_actions]
+    end
+
+    # The Amazon Resource Name (ARN) of the alarm.
+    # @return [String]
+    def alarm_arn
+      data[:alarm_arn]
+    end
+
+    # The time stamp of the last update to the alarm configuration.
+    # @return [Time]
+    def alarm_configuration_updated_timestamp
+      data[:alarm_configuration_updated_timestamp]
+    end
+
+    # The description of the alarm.
+    # @return [String]
+    def alarm_description
+      data[:alarm_description]
+    end
+
+    # The rule that this alarm uses to evaluate its alarm state.
+    # @return [String]
+    def alarm_rule
+      data[:alarm_rule]
+    end
+
+    # The actions to execute when this alarm transitions to the
+    # INSUFFICIENT\_DATA state from any other state. Each action is
+    # specified as an Amazon Resource Name (ARN).
+    # @return [Array<String>]
+    def insufficient_data_actions
+      data[:insufficient_data_actions]
+    end
+
+    # The actions to execute when this alarm transitions to the OK state
+    # from any other state. Each action is specified as an Amazon Resource
+    # Name (ARN).
+    # @return [Array<String>]
+    def ok_actions
+      data[:ok_actions]
+    end
+
+    # An explanation for the alarm state, in text format.
+    # @return [String]
+    def state_reason
+      data[:state_reason]
+    end
+
+    # An explanation for the alarm state, in JSON format.
+    # @return [String]
+    def state_reason_data
+      data[:state_reason_data]
+    end
+
+    # The time stamp of the last update to the alarm state.
+    # @return [Time]
+    def state_updated_timestamp
+      data[:state_updated_timestamp]
+    end
+
+    # The state value for the alarm.
+    # @return [String]
+    def state_value
+      data[:state_value]
+    end
+
+    # @!endgroup
+
+    # @return [Client]
+    def client
+      @client
+    end
+
+    # Loads, or reloads {#data} for the current {CompositeAlarm}.
+    # Returns `self` making it possible to chain methods.
+    #
+    #     composite_alarm.reload.data
+    #
+    # @return [self]
+    def load
+      resp = @client.describe_alarms(alarm_names: [@name])
+      @data = resp.composite_alarms[0]
+      self
+    end
+    alias :reload :load
+
+    # @return [Types::CompositeAlarm]
+    #   Returns the data for this {CompositeAlarm}. Calls
+    #   {Client#describe_alarms} if {#data_loaded?} is `false`.
+    def data
+      load unless @data
+      @data
+    end
+
+    # @return [Boolean]
+    #   Returns `true` if this resource is loaded.  Accessing attributes or
+    #   {#data} on an unloaded resource will trigger a call to {#load}.
+    def data_loaded?
+      !!@data
+    end
+
+    # @param [Hash] options ({})
+    # @return [Boolean]
+    #   Returns `true` if the CompositeAlarm exists.
+    def exists?(options = {})
+      begin
+        wait_until_exists(options.merge(max_attempts: 1))
+        true
+      rescue Aws::Waiters::Errors::UnexpectedError => e
+        raise e.error
+      rescue Aws::Waiters::Errors::WaiterFailed
+        false
+      end
+    end
+
+    # @param [Hash] options ({})
+    # @option options [Integer] :max_attempts (40)
+    # @option options [Float] :delay (5)
+    # @option options [Proc] :before_attempt
+    # @option options [Proc] :before_wait
+    # @return [CompositeAlarm]
+    def wait_until_exists(options = {}, &block)
+      options, params = separate_params_and_options(options)
+      waiter = Waiters::CompositeAlarmExists.new(options)
+      yield_waiter_and_warn(waiter, &block) if block_given?
+      waiter.wait(params.merge(alarm_names: [@name]))
+      CompositeAlarm.new({
+        name: @name,
+        client: @client
+      })
+    end
+
+    # @deprecated Use [Aws::CloudWatch::Client] #wait_until instead
+    #
+    # Waiter polls an API operation until a resource enters a desired
+    # state.
+    #
+    # @note The waiting operation is performed on a copy. The original resource remains unchanged
+    #
+    # ## Basic Usage
+    #
+    # Waiter will polls until it is successful, it fails by
+    # entering a terminal state, or until a maximum number of attempts
+    # are made.
+    #
+    #     # polls in a loop until condition is true
+    #     resource.wait_until(options) {|resource| condition}
+    #
+    # ## Example
+    #
+    #     instance.wait_until(max_attempts:10, delay:5) {|instance| instance.state.name == 'running' }
+    #
+    # ## Configuration
+    #
+    # You can configure the maximum number of polling attempts, and the
+    # delay (in seconds) between each polling attempt. The waiting condition is set
+    # by passing a block to {#wait_until}:
+    #
+    #     # poll for ~25 seconds
+    #     resource.wait_until(max_attempts:5,delay:5) {|resource|...}
+    #
+    # ## Callbacks
+    #
+    # You can be notified before each polling attempt and before each
+    # delay. If you throw `:success` or `:failure` from these callbacks,
+    # it will terminate the waiter.
+    #
+    #     started_at = Time.now
+    #     # poll for 1 hour, instead of a number of attempts
+    #     proc = Proc.new do |attempts, response|
+    #       throw :failure if Time.now - started_at > 3600
+    #     end
+    #
+    #       # disable max attempts
+    #     instance.wait_until(before_wait:proc, max_attempts:nil) {...}
+    #
+    # ## Handling Errors
+    #
+    # When a waiter is successful, it returns the Resource. When a waiter
+    # fails, it raises an error.
+    #
+    #     begin
+    #       resource.wait_until(...)
+    #     rescue Aws::Waiters::Errors::WaiterFailed
+    #       # resource did not enter the desired state in time
+    #     end
+    #
+    #
+    # @yield param [Resource] resource to be used in the waiting condition
+    #
+    # @raise [Aws::Waiters::Errors::FailureStateError] Raised when the waiter terminates
+    #   because the waiter has entered a state that it will not transition
+    #   out of, preventing success.
+    #
+    #   yet successful.
+    #
+    # @raise [Aws::Waiters::Errors::UnexpectedError] Raised when an error is encountered
+    #   while polling for a resource that is not expected.
+    #
+    # @raise [NotImplementedError] Raised when the resource does not
+    #
+    # @option options [Integer] :max_attempts (10) Maximum number of
+    # attempts
+    # @option options [Integer] :delay (10) Delay between each
+    # attempt in seconds
+    # @option options [Proc] :before_attempt (nil) Callback
+    # invoked before each attempt
+    # @option options [Proc] :before_wait (nil) Callback
+    # invoked before each wait
+    # @return [Resource] if the waiter was successful
+    def wait_until(options = {}, &block)
+      self_copy = self.dup
+      attempts = 0
+      options[:max_attempts] = 10 unless options.key?(:max_attempts)
+      options[:delay] ||= 10
+      options[:poller] = Proc.new do
+        attempts += 1
+        if block.call(self_copy)
+          [:success, self_copy]
+        else
+          self_copy.reload unless attempts == options[:max_attempts]
+          :retry
+        end
+      end
+      Aws::Waiters::Waiter.new(options).wait({})
+    end
+
+    # @!group Actions
+
+    # @example Request syntax with placeholder values
+    #
+    #   composite_alarm.delete()
+    # @param [Hash] options ({})
+    # @return [EmptyStructure]
+    def delete(options = {})
+      options = Aws::Util.deep_merge(options, alarm_names: [@name])
+      resp = @client.delete_alarms(options)
+      resp.data
+    end
+
+    # @example Request syntax with placeholder values
+    #
+    #   composite_alarm.describe_history({
+    #     alarm_types: ["CompositeAlarm"], # accepts CompositeAlarm, MetricAlarm
+    #     history_item_type: "ConfigurationUpdate", # accepts ConfigurationUpdate, StateUpdate, Action
+    #     start_date: Time.now,
+    #     end_date: Time.now,
+    #     max_records: 1,
+    #     next_token: "NextToken",
+    #     scan_by: "TimestampDescending", # accepts TimestampDescending, TimestampAscending
+    #   })
+    # @param [Hash] options ({})
+    # @option options [Array<String>] :alarm_types
+    #   Use this parameter to specify whether you want the operation to return
+    #   metric alarms or composite alarms. If you omit this parameter, only
+    #   metric alarms are returned.
+    # @option options [String] :history_item_type
+    #   The type of alarm histories to retrieve.
+    # @option options [Time,DateTime,Date,Integer,String] :start_date
+    #   The starting date to retrieve alarm history.
+    # @option options [Time,DateTime,Date,Integer,String] :end_date
+    #   The ending date to retrieve alarm history.
+    # @option options [Integer] :max_records
+    #   The maximum number of alarm history records to retrieve.
+    # @option options [String] :next_token
+    #   The token returned by a previous call to indicate that there is more
+    #   data available.
+    # @option options [String] :scan_by
+    #   Specified whether to return the newest or oldest alarm history first.
+    #   Specify `TimestampDescending` to have the newest event history
+    #   returned first, and specify `TimestampAscending` to have the oldest
+    #   history returned first.
+    # @return [Types::DescribeAlarmHistoryOutput]
+    def describe_history(options = {})
+      options = options.merge(alarm_name: @name)
+      resp = @client.describe_alarm_history(options)
+      resp.data
+    end
+
+    # @example Request syntax with placeholder values
+    #
+    #   composite_alarm.disable_actions()
+    # @param [Hash] options ({})
+    # @return [EmptyStructure]
+    def disable_actions(options = {})
+      options = Aws::Util.deep_merge(options, alarm_names: [@name])
+      resp = @client.disable_alarm_actions(options)
+      resp.data
+    end
+
+    # @example Request syntax with placeholder values
+    #
+    #   composite_alarm.enable_actions()
+    # @param [Hash] options ({})
+    # @return [EmptyStructure]
+    def enable_actions(options = {})
+      options = Aws::Util.deep_merge(options, alarm_names: [@name])
+      resp = @client.enable_alarm_actions(options)
+      resp.data
+    end
+
+    # @example Request syntax with placeholder values
+    #
+    #   composite_alarm.set_state({
+    #     state_value: "OK", # required, accepts OK, ALARM, INSUFFICIENT_DATA
+    #     state_reason: "StateReason", # required
+    #     state_reason_data: "StateReasonData",
+    #   })
+    # @param [Hash] options ({})
+    # @option options [required, String] :state_value
+    #   The value of the state.
+    # @option options [required, String] :state_reason
+    #   The reason that this alarm is set to this specific state, in text
+    #   format.
+    # @option options [String] :state_reason_data
+    #   The reason that this alarm is set to this specific state, in JSON
+    #   format.
+    #
+    #   For SNS or EC2 alarm actions, this is just informational. But for EC2
+    #   Auto Scaling or application Auto Scaling alarm actions, the Auto
+    #   Scaling policy uses the information in this field to take the correct
+    #   action.
+    # @return [EmptyStructure]
+    def set_state(options = {})
+      options = options.merge(alarm_name: @name)
+      resp = @client.set_alarm_state(options)
+      resp.data
+    end
+
+    # @deprecated
+    # @api private
+    def identifiers
+      { name: @name }
+    end
+    deprecated(:identifiers)
+
+    private
+
+    def extract_name(args, options)
+      value = args[0] || options.delete(:name)
+      case value
+      when String then value
+      when nil then raise ArgumentError, "missing required option :name"
+      else
+        msg = "expected :name to be a String, got #{value.class}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def yield_waiter_and_warn(waiter, &block)
+      if !@waiter_block_warned
+        msg = "pass options to configure the waiter; "
+        msg << "yielding the waiter is deprecated"
+        warn(msg)
+        @waiter_block_warned = true
+      end
+      yield(waiter.waiter)
+    end
+
+    def separate_params_and_options(options)
+      opts = Set.new([:client, :max_attempts, :delay, :before_attempt, :before_wait])
+      waiter_opts = {}
+      waiter_params = {}
+      options.each_pair do |key, value|
+        if opts.include?(key)
+          waiter_opts[key] = value
+        else
+          waiter_params[key] = value
+        end
+      end
+      waiter_opts[:client] ||= @client
+      [waiter_opts, waiter_params]
+    end
+
+    class Collection < Aws::Resources::Collection
+
+      # @!group Batch Actions
+
+      # @param options ({})
+      # @return [void]
+      def batch_delete!(options = {})
+        batch_enum.each do |batch|
+          params = Aws::Util.copy_hash(options)
+          params[:alarm_names] ||= []
+          batch.each do |item|
+            params[:alarm_names] << item.name
+          end
+          batch[0].client.delete_alarms(params)
+        end
+        nil
+      end
+
+      # @param options ({})
+      # @return [void]
+      def batch_disable_actions(options = {})
+        batch_enum.each do |batch|
+          params = Aws::Util.copy_hash(options)
+          params[:alarm_names] ||= []
+          batch.each do |item|
+            params[:alarm_names] << item.name
+          end
+          batch[0].client.disable_alarm_actions(params)
+        end
+        nil
+      end
+
+      # @param options ({})
+      # @return [void]
+      def batch_enable_actions(options = {})
+        batch_enum.each do |batch|
+          params = Aws::Util.copy_hash(options)
+          params[:alarm_names] ||= []
+          batch.each do |item|
+            params[:alarm_names] << item.name
+          end
+          batch[0].client.enable_alarm_actions(params)
+        end
+        nil
+      end
+
+      # @!endgroup
+
+    end
+  end
+end