incident_io_api 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bf9f1c5912e372c6d2c203c09ef2e9d21b734512db214f0d7e5a0eb21f176f1
-  data.tar.gz: 77f62d6fed7b3a19a6e60ade9be517c565cdf6d7a70cdb3ecb436329516066ea
+  metadata.gz: 9003db95fc14c284f3c0151ba851762cfa723d2a1203da13b790c0725dd427d1
+  data.tar.gz: 853db891c89a138907bd103472dcb04dc70338476096bc92bdbc5341b4731f8a
 SHA512:
-  metadata.gz: '02308c9db7f0125ab0a839de724fc37551230154b265257537a1041cb311ac315149858317b78d2dc568e4ba9c7f3fdc492577ef7da649c85298cc5c92482a61'
-  data.tar.gz: f56c5bf6541e09cc54f9acf7199d57eeed10103efb7e637733a3839a063d665830d76df6541fa092deea8f148245a2248c2dc714f503d13dd111b5790b39573e
+  metadata.gz: fa1ba663293ea1ef0eb476ac129fa30a5f7b0b3e5cf88f5ab8e512de5b62aa0ec2ca1ea4208ff930f1a64072e7b49e277e2bb706f7572c54d33bba82d60f8ad3
+  data.tar.gz: 56a7f943c835ac46a36fbe4e4fbba4c13af8ebe64da3b9e37f4ced1a7cdf29f7d46d0bb22903bfb272186c579bb55c7e57c382186db86b9c7f799f5d7391f48b

data/lib/incident_io/api/schedules_v2_api.rb

@@ -723,7 +723,7 @@ module IncidentIo
     end
 
     # ListScheduleEntries Schedules V2
-    # List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+    # List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
     # @param schedule_id [String] The ID of the schedule to get entries for.
     # @param [Hash] opts the optional parameters
     # @option opts [String] :entry_window_start The start of the window to get entries for. May also carry an opaque pagination cursor previously returned in `pagination_meta.after` — pass it back here unchanged to fetch the next page (leave `entry_window_end` unchanged from the original request).
@@ -735,7 +735,7 @@ module IncidentIo
     end
 
     # ListScheduleEntries Schedules V2
-    # List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+    # List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
     # @param schedule_id [String] The ID of the schedule to get entries for.
     # @param [Hash] opts the optional parameters
     # @option opts [String] :entry_window_start The start of the window to get entries for. May also carry an opaque pagination cursor previously returned in `pagination_meta.after` — pass it back here unchanged to fetch the next page (leave `entry_window_end` unchanged from the original request).

data/lib/incident_io/models/audit_logs_on_call_notification_pause_resumed_v1.rb

@@ -0,0 +1,326 @@
+=begin
+#incident.io
+
+#Ruby client for the incident.io API.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module IncidentIo
+  class AuditLogsOnCallNotificationPauseResumedV1 < ApiModelBase
+    # The type of log entry that this is
+    attr_accessor :action
+
+    attr_accessor :actor
+
+    attr_accessor :context
+
+    attr_accessor :metadata
+
+    # When the entry occurred
+    attr_accessor :occurred_at
+
+    # The custom field that was created
+    attr_accessor :targets
+
+    # Which version the event is
+    attr_accessor :version
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'action' => :'action',
+        :'actor' => :'actor',
+        :'context' => :'context',
+        :'metadata' => :'metadata',
+        :'occurred_at' => :'occurred_at',
+        :'targets' => :'targets',
+        :'version' => :'version'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'action' => :'String',
+        :'actor' => :'AuditLogActorV2',
+        :'context' => :'AuditLogEntryContextV2',
+        :'metadata' => :'AuditLogOnCallNotificationPauseMetadataV2',
+        :'occurred_at' => :'Time',
+        :'targets' => :'Array<AuditLogTargetV2>',
+        :'version' => :'Integer'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `IncidentIo::AuditLogsOnCallNotificationPauseResumedV1` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `IncidentIo::AuditLogsOnCallNotificationPauseResumedV1`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'action')
+        self.action = attributes[:'action']
+      else
+        self.action = nil
+      end
+
+      if attributes.key?(:'actor')
+        self.actor = attributes[:'actor']
+      else
+        self.actor = nil
+      end
+
+      if attributes.key?(:'context')
+        self.context = attributes[:'context']
+      else
+        self.context = nil
+      end
+
+      if attributes.key?(:'metadata')
+        self.metadata = attributes[:'metadata']
+      else
+        self.metadata = nil
+      end
+
+      if attributes.key?(:'occurred_at')
+        self.occurred_at = attributes[:'occurred_at']
+      else
+        self.occurred_at = nil
+      end
+
+      if attributes.key?(:'targets')
+        if (value = attributes[:'targets']).is_a?(Array)
+          self.targets = value
+        end
+      else
+        self.targets = nil
+      end
+
+      if attributes.key?(:'version')
+        self.version = attributes[:'version']
+      else
+        self.version = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @action.nil?
+        invalid_properties.push('invalid value for "action", action cannot be nil.')
+      end
+
+      if @actor.nil?
+        invalid_properties.push('invalid value for "actor", actor cannot be nil.')
+      end
+
+      if @context.nil?
+        invalid_properties.push('invalid value for "context", context cannot be nil.')
+      end
+
+      if @metadata.nil?
+        invalid_properties.push('invalid value for "metadata", metadata cannot be nil.')
+      end
+
+      if @occurred_at.nil?
+        invalid_properties.push('invalid value for "occurred_at", occurred_at cannot be nil.')
+      end
+
+      if @targets.nil?
+        invalid_properties.push('invalid value for "targets", targets cannot be nil.')
+      end
+
+      if @version.nil?
+        invalid_properties.push('invalid value for "version", version cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @action.nil?
+      return false if @actor.nil?
+      return false if @context.nil?
+      return false if @metadata.nil?
+      return false if @occurred_at.nil?
+      return false if @targets.nil?
+      return false if @version.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] action Value to be assigned
+    def action=(action)
+      if action.nil?
+        fail ArgumentError, 'action cannot be nil'
+      end
+
+      @action = action
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] actor Value to be assigned
+    def actor=(actor)
+      if actor.nil?
+        fail ArgumentError, 'actor cannot be nil'
+      end
+
+      @actor = actor
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] context Value to be assigned
+    def context=(context)
+      if context.nil?
+        fail ArgumentError, 'context cannot be nil'
+      end
+
+      @context = context
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] metadata Value to be assigned
+    def metadata=(metadata)
+      if metadata.nil?
+        fail ArgumentError, 'metadata cannot be nil'
+      end
+
+      @metadata = metadata
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] occurred_at Value to be assigned
+    def occurred_at=(occurred_at)
+      if occurred_at.nil?
+        fail ArgumentError, 'occurred_at cannot be nil'
+      end
+
+      @occurred_at = occurred_at
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] targets Value to be assigned
+    def targets=(targets)
+      if targets.nil?
+        fail ArgumentError, 'targets cannot be nil'
+      end
+
+      @targets = targets
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] version Value to be assigned
+    def version=(version)
+      if version.nil?
+        fail ArgumentError, 'version cannot be nil'
+      end
+
+      @version = version
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          action == o.action &&
+          actor == o.actor &&
+          context == o.context &&
+          metadata == o.metadata &&
+          occurred_at == o.occurred_at &&
+          targets == o.targets &&
+          version == o.version
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [action, actor, context, metadata, occurred_at, targets, version].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/incident_io/models/schedule_entry_v2.rb

@@ -14,7 +14,7 @@ require 'date'
 require 'time'
 
 module IncidentIo
-  # A single shift on a schedule, representing who is on-call between a start and end time. When present, `rotation_id` and `layer_id` tell you which rotation and which layer within that rotation the entry belongs to. A schedule may have multiple rotations (for example, a primary and a secondary rotation) and each rotation can be made up of several layers — entries are returned for every rotation and layer on the schedule.  Entries come from two places: they are either generated from a schedule's rotation configuration (the regular pattern of who is on-call) or created by an override (a one-off change that replaces the normal rotation for a period of time). When you call the List schedule entries endpoint we return both kinds separately, along with the merged `final` schedule that reflects what will actually happen.  `entry_id` is only populated for entries that correspond to a stored record. Scheduled entries are projections computed from the rotation rules on the fly and don't have a persisted ID, so `entry_id` will be absent for those. Use `fingerprint` if you need a stable identifier to deduplicate or diff a shift across requests.
+  # A single shift on a schedule, representing who is on-call between a start and end time. When present, `rotation_id` tells you which rotation the entry belongs to. A schedule may have multiple rotations (for example, a primary and a secondary rotation) and each rotation can be made up of several layers — entries are returned for every rotation and layer on the schedule.  Entries come from two places: they are either generated from a schedule's rotation configuration (the regular pattern of who is on-call) or created by an override (a one-off change that replaces the normal rotation for a period of time). When you call the List schedule entries endpoint we return both kinds separately, along with the merged `final` schedule that reflects what will actually happen.  `entry_id` is only populated for entries that correspond to a stored record. Scheduled entries are projections computed from the rotation rules on the fly and don't have a persisted ID, so `entry_id` will be absent for those. Use `fingerprint` if you need a stable identifier to deduplicate or diff a shift across requests.
   class ScheduleEntryV2 < ApiModelBase
     attr_accessor :end_at
 
@@ -24,9 +24,6 @@ module IncidentIo
     # A unique identifier for this entry, used to determine a unique shift
     attr_accessor :fingerprint
 
-    # If present, the layer this entry applies to on the rotation
-    attr_accessor :layer_id
-
     # If present, the rotation this entry applies to on the schedule
     attr_accessor :rotation_id
 
@@ -40,7 +37,6 @@ module IncidentIo
         :'end_at' => :'end_at',
         :'entry_id' => :'entry_id',
         :'fingerprint' => :'fingerprint',
-        :'layer_id' => :'layer_id',
         :'rotation_id' => :'rotation_id',
         :'start_at' => :'start_at',
         :'user' => :'user'
@@ -63,7 +59,6 @@ module IncidentIo
         :'end_at' => :'Time',
         :'entry_id' => :'String',
         :'fingerprint' => :'String',
-        :'layer_id' => :'String',
         :'rotation_id' => :'String',
         :'start_at' => :'Time',
         :'user' => :'UserV2'
@@ -106,10 +101,6 @@ module IncidentIo
         self.fingerprint = attributes[:'fingerprint']
       end
 
-      if attributes.key?(:'layer_id')
-        self.layer_id = attributes[:'layer_id']
-      end
-
       if attributes.key?(:'rotation_id')
         self.rotation_id = attributes[:'rotation_id']
       end
@@ -178,7 +169,6 @@ module IncidentIo
           end_at == o.end_at &&
           entry_id == o.entry_id &&
           fingerprint == o.fingerprint &&
-          layer_id == o.layer_id &&
           rotation_id == o.rotation_id &&
           start_at == o.start_at &&
           user == o.user
@@ -193,7 +183,7 @@ module IncidentIo
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [end_at, entry_id, fingerprint, layer_id, rotation_id, start_at, user].hash
+      [end_at, entry_id, fingerprint, rotation_id, start_at, user].hash
     end
 
     # Builds the object from hash

data/lib/incident_io/version.rb

@@ -4,5 +4,5 @@ module IncidentIo
   # The release workflow sets this before building, so it tracks whatever we
   # last published. Listed in .openapi-generator-ignore so regeneration can't
   # reset it.
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 end

data/lib/incident_io.rb

@@ -374,6 +374,7 @@ IncidentIo.autoload :AuditLogsOnCallNotificationPauseCreatedV1, 'incident_io/mod
 IncidentIo.autoload :AuditLogsOnCallNotificationPauseCreatedV2, 'incident_io/models/audit_logs_on_call_notification_pause_created_v2'
 IncidentIo.autoload :AuditLogsOnCallNotificationPauseDeletedV1, 'incident_io/models/audit_logs_on_call_notification_pause_deleted_v1'
 IncidentIo.autoload :AuditLogsOnCallNotificationPauseDeletedV2, 'incident_io/models/audit_logs_on_call_notification_pause_deleted_v2'
+IncidentIo.autoload :AuditLogsOnCallNotificationPauseResumedV1, 'incident_io/models/audit_logs_on_call_notification_pause_resumed_v1'
 IncidentIo.autoload :AuditLogsOnCallNotificationPauseUpdatedV1, 'incident_io/models/audit_logs_on_call_notification_pause_updated_v1'
 IncidentIo.autoload :AuditLogsOnCallNotificationPauseUpdatedV2, 'incident_io/models/audit_logs_on_call_notification_pause_updated_v2'
 IncidentIo.autoload :AuditLogsOnCallUpsellRequestedV1, 'incident_io/models/audit_logs_on_call_upsell_requested_v1'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: incident_io_api
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - incident.io
@@ -495,6 +495,7 @@ files:
 - lib/incident_io/models/audit_logs_on_call_notification_pause_created_v2.rb
 - lib/incident_io/models/audit_logs_on_call_notification_pause_deleted_v1.rb
 - lib/incident_io/models/audit_logs_on_call_notification_pause_deleted_v2.rb
+- lib/incident_io/models/audit_logs_on_call_notification_pause_resumed_v1.rb
 - lib/incident_io/models/audit_logs_on_call_notification_pause_updated_v1.rb
 - lib/incident_io/models/audit_logs_on_call_notification_pause_updated_v2.rb
 - lib/incident_io/models/audit_logs_on_call_upsell_requested_v1.rb