svix 1.13.0 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17b5d97f7e6c49e08bdd186ffc37d7df93e1ef4fee429a9ce546ea0fb3b0da18
-  data.tar.gz: aa249d2de965495213c584a96cae7400028dbd20b81920906aa2b5efb50dffaf
+  metadata.gz: d64085aefdf468273eede3dc68655f48abac3a682d01d7bb182e5abace37fbd3
+  data.tar.gz: e1bad67f258a28268b31f1d10418c593f8ef033cc91a5ea99006cb1eb72d7c2c
 SHA512:
-  metadata.gz: 3b3f7094ea9ed99dc168a1f23934c6a5ced2f36c08c032d90f573402603ac5d2f56b2c6d9841982eda6759baf42d7f8d08c4028686fe96bec3c0a8434e457857
-  data.tar.gz: 50c97cbb777efc0b1aa5d3eb6fd94d367ab1db413643e4ed3d9e108abe2b88f8748cf49beea6a358c5b32b2e214020cf871559b9919d89837f86ad35500deb3d
+  metadata.gz: 4d5d3697998262c85cb220125a5ba82798e0ea2163187816d23b4879a7e6268a17c04cc357766702822802cece5db1da0207f69cf9d889709b4ceac2e6a7b1c0
+  data.tar.gz: 485b6eb5fd8cb140e1c38e6baedf10f5c24c4b910fdc2ffd154900f927946ee10aded4d66cef9db3c88de06fb9ab291a88f3814d166d37c36512eef31d78e4bd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    svix (1.13.0)
+    svix (1.14.0)
       typhoeus (~> 1.0, >= 1.0.1)
 
 GEM

data/lib/svix/api/event_type_api.rb

@@ -162,6 +162,66 @@ module Svix
       return data, status_code, headers
     end
 
+    # Event Type Export From Openapi
+    # Exports event type definitions based on the OpenAPI schemas associated with each existing event type
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :idempotency_key The request's idempotency key
+    # @return [ExportEventTypeOut]
+    def v1_event_type_export_openapi(opts = {})
+      data, _status_code, _headers = v1_event_type_export_openapi_with_http_info(opts)
+      data
+    end
+
+    # Event Type Export From Openapi
+    # Exports event type definitions based on the OpenAPI schemas associated with each existing event type
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :idempotency_key The request's idempotency key
+    # @return [Array<(ExportEventTypeOut, Integer, Hash)>] ExportEventTypeOut data, response status code and response headers
+    def v1_event_type_export_openapi_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: EventTypeApi.v1_event_type_export_openapi ...'
+      end
+      # resource path
+      local_var_path = '/api/v1/event-type/export/openapi/'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      header_params[:'idempotency-key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ExportEventTypeOut'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"EventTypeApi.v1_event_type_export_openapi",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: EventTypeApi#v1_event_type_export_openapi\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # Generate Schema Example
     # Generates a fake example from the given JSONSchema
     # @param event_type_schema_in [EventTypeSchemaIn] 

data/lib/svix/api/statistics_api.rb

@@ -19,30 +19,30 @@ module Svix
     def initialize(api_client = ApiClient.default)
       @api_client = api_client
     end
-    # Calculate Aggregate App Stats
-    # Creates a background task to calculate the message destinations for all applications in the environment.
+    # Aggregate App Stats
+    # Creates a background task to calculate the message destinations for all applications in the environment.  Note that this endpoint is asynchronous. You will need to poll the `Get Background Task` endpoint to retrieve the results of the operation.
     # @param app_usage_stats_in [AppUsageStatsIn] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :idempotency_key The request's idempotency key
     # @return [AppUsageStatsOut]
-    def calculate_aggregate_app_stats(app_usage_stats_in, opts = {})
-      data, _status_code, _headers = calculate_aggregate_app_stats_with_http_info(app_usage_stats_in, opts)
+    def aggregate_app_stats(app_usage_stats_in, opts = {})
+      data, _status_code, _headers = aggregate_app_stats_with_http_info(app_usage_stats_in, opts)
       data
     end
 
-    # Calculate Aggregate App Stats
-    # Creates a background task to calculate the message destinations for all applications in the environment.
+    # Aggregate App Stats
+    # Creates a background task to calculate the message destinations for all applications in the environment.  Note that this endpoint is asynchronous. You will need to poll the `Get Background Task` endpoint to retrieve the results of the operation.
     # @param app_usage_stats_in [AppUsageStatsIn] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :idempotency_key The request's idempotency key
     # @return [Array<(AppUsageStatsOut, Integer, Hash)>] AppUsageStatsOut data, response status code and response headers
-    def calculate_aggregate_app_stats_with_http_info(app_usage_stats_in, opts = {})
+    def aggregate_app_stats_with_http_info(app_usage_stats_in, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: StatisticsApi.calculate_aggregate_app_stats ...'
+        @api_client.config.logger.debug 'Calling API: StatisticsApi.aggregate_app_stats ...'
       end
       # verify the required parameter 'app_usage_stats_in' is set
       if @api_client.config.client_side_validation && app_usage_stats_in.nil?
-        fail ArgumentError, "Missing the required parameter 'app_usage_stats_in' when calling StatisticsApi.calculate_aggregate_app_stats"
+        fail ArgumentError, "Missing the required parameter 'app_usage_stats_in' when calling StatisticsApi.aggregate_app_stats"
       end
       # resource path
       local_var_path = '/api/v1/stats/usage/app/'
@@ -71,7 +71,7 @@ module Svix
       auth_names = opts[:debug_auth_names] || ['HTTPBearer']
 
       new_options = opts.merge(
-        :operation => :"StatisticsApi.calculate_aggregate_app_stats",
+        :operation => :"StatisticsApi.aggregate_app_stats",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -82,7 +82,64 @@ module Svix
 
       data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: StatisticsApi#calculate_aggregate_app_stats\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: StatisticsApi#aggregate_app_stats\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Aggregate Event Types
+    # Creates a background task to calculate the listed event types for all apps in the organization.  Note that this endpoint is asynchronous. You will need to poll the `Get Background Task` endpoint to retrieve the results of the operation.
+    # @param [Hash] opts the optional parameters
+    # @return [AggregateEventTypesOut]
+    def aggregate_event_types(opts = {})
+      data, _status_code, _headers = aggregate_event_types_with_http_info(opts)
+      data
+    end
+
+    # Aggregate Event Types
+    # Creates a background task to calculate the listed event types for all apps in the organization.  Note that this endpoint is asynchronous. You will need to poll the &#x60;Get Background Task&#x60; endpoint to retrieve the results of the operation.
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(AggregateEventTypesOut, Integer, Hash)>] AggregateEventTypesOut data, response status code and response headers
+    def aggregate_event_types_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: StatisticsApi.aggregate_event_types ...'
+      end
+      # resource path
+      local_var_path = '/api/v1/stats/usage/event-types/'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'AggregateEventTypesOut'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"StatisticsApi.aggregate_event_types",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:PUT, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: StatisticsApi#aggregate_event_types\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end

data/lib/svix/api/transformation_template_api.rb

@@ -287,6 +287,142 @@ module Svix
       return data, status_code, headers
     end
 
+    # Authorize Discord
+    # Get Discord Incoming webhook URL
+    # @param oauth_payload_in [OauthPayloadIn] 
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :idempotency_key The request's idempotency key
+    # @return [OauthPayloadOut]
+    def v1_transformation_template_oauth_discord(oauth_payload_in, opts = {})
+      data, _status_code, _headers = v1_transformation_template_oauth_discord_with_http_info(oauth_payload_in, opts)
+      data
+    end
+
+    # Authorize Discord
+    # Get Discord Incoming webhook URL
+    # @param oauth_payload_in [OauthPayloadIn] 
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :idempotency_key The request's idempotency key
+    # @return [Array<(OauthPayloadOut, Integer, Hash)>] OauthPayloadOut data, response status code and response headers
+    def v1_transformation_template_oauth_discord_with_http_info(oauth_payload_in, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: TransformationTemplateApi.v1_transformation_template_oauth_discord ...'
+      end
+      # verify the required parameter 'oauth_payload_in' is set
+      if @api_client.config.client_side_validation && oauth_payload_in.nil?
+        fail ArgumentError, "Missing the required parameter 'oauth_payload_in' when calling TransformationTemplateApi.v1_transformation_template_oauth_discord"
+      end
+      # resource path
+      local_var_path = '/api/v1/transformation-template/oauth/discord'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])
+      header_params[:'idempotency-key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(oauth_payload_in)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'OauthPayloadOut'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"TransformationTemplateApi.v1_transformation_template_oauth_discord",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: TransformationTemplateApi#v1_transformation_template_oauth_discord\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Authorize Slack
+    # Get Slack Incoming webhook URL
+    # @param oauth_payload_in [OauthPayloadIn] 
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :idempotency_key The request&#39;s idempotency key
+    # @return [OauthPayloadOut]
+    def v1_transformation_template_oauth_slack(oauth_payload_in, opts = {})
+      data, _status_code, _headers = v1_transformation_template_oauth_slack_with_http_info(oauth_payload_in, opts)
+      data
+    end
+
+    # Authorize Slack
+    # Get Slack Incoming webhook URL
+    # @param oauth_payload_in [OauthPayloadIn] 
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :idempotency_key The request&#39;s idempotency key
+    # @return [Array<(OauthPayloadOut, Integer, Hash)>] OauthPayloadOut data, response status code and response headers
+    def v1_transformation_template_oauth_slack_with_http_info(oauth_payload_in, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: TransformationTemplateApi.v1_transformation_template_oauth_slack ...'
+      end
+      # verify the required parameter 'oauth_payload_in' is set
+      if @api_client.config.client_side_validation && oauth_payload_in.nil?
+        fail ArgumentError, "Missing the required parameter 'oauth_payload_in' when calling TransformationTemplateApi.v1_transformation_template_oauth_slack"
+      end
+      # resource path
+      local_var_path = '/api/v1/transformation-template/oauth/slack'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])
+      header_params[:'idempotency-key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(oauth_payload_in)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'OauthPayloadOut'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['HTTPBearer']
+
+      new_options = opts.merge(
+        :operation => :"TransformationTemplateApi.v1_transformation_template_oauth_slack",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: TransformationTemplateApi#v1_transformation_template_oauth_slack\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # Patch Transformation Template
     # Partially update a transformation template
     # @param transformation_template_id [String] 

data/lib/svix/message_api.rb

@@ -14,8 +14,8 @@ module Svix
       return @api.v1_message_create(app_id, message_in, options)
     end
 
-    def get(app_id, msg_id)
-      return @api.v1_message_get(app_id, msg_id)
+    def get(app_id, msg_id, options = {})
+      return @api.v1_message_get(app_id, msg_id, options)
     end
 
     def expunge_content(app_id, msg_id)

data/lib/svix/models/aggregate_event_types_out.rb

@@ -0,0 +1,251 @@
+=begin
+#Svix API
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 1.1.1
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.2.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Svix
+  class AggregateEventTypesOut
+    attr_accessor :id
+
+    attr_accessor :status
+
+    attr_accessor :task
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'id' => :'id',
+        :'status' => :'status',
+        :'task' => :'task'
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'id' => :'String',
+        :'status' => :'BackgroundTaskStatus',
+        :'task' => :'BackgroundTaskType'
+      }
+    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 `Svix::AggregateEventTypesOut` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!self.class.attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Svix::AggregateEventTypesOut`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'id')
+        self.id = attributes[:'id']
+      end
+
+      if attributes.key?(:'status')
+        self.status = attributes[:'status']
+      end
+
+      if attributes.key?(:'task')
+        self.task = attributes[:'task']
+      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
+      invalid_properties = Array.new
+      if @id.nil?
+        invalid_properties.push('invalid value for "id", id cannot be nil.')
+      end
+
+      if @status.nil?
+        invalid_properties.push('invalid value for "status", status cannot be nil.')
+      end
+
+      if @task.nil?
+        invalid_properties.push('invalid value for "task", task 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?
+      return false if @id.nil?
+      return false if @status.nil?
+      return false if @task.nil?
+      true
+    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 &&
+          id == o.id &&
+          status == o.status &&
+          task == o.task
+    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
+      [id, status, task].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)
+      new.build_from_hash(attributes)
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
+          self.send("#{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[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = Svix.const_get(type)
+        klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_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
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/lib/svix/models/background_task_type.rb

@@ -19,6 +19,8 @@ module Svix
     ENDPOINT_RECOVER = "endpoint.recover".freeze
     APPLICATION_STATS = "application.stats".freeze
     MESSAGE_BROADCAST = "message.broadcast".freeze
+    SDK_GENERATE = "sdk.generate".freeze
+    EVENT_TYPE_AGGREGATE = "event-type.aggregate".freeze
 
     # Builds the enum from string
     # @param [String] The enum value in the form of the string