hooksniff 0.1.0 → 1.0.0

data/lib/hooksniff/models/message_attempt_log.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  class MessageAttemptLog
+    # The Application's ID.
+    attr_accessor :app_id
+    # The Application's UID.
+    attr_accessor :app_uid
+    attr_accessor :attempt_count
+    attr_accessor :attempt_end
+    # The MessageAttempt's ID.
+    attr_accessor :attempt_id
+    attr_accessor :attempt_start
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    # The event type's name
+    attr_accessor :event_type
+    attr_accessor :http_times
+    attr_accessor :msg_created
+    # The Message's UID.
+    attr_accessor :msg_event_id
+    # The Message's ID.
+    attr_accessor :msg_id
+    # The Environment's ID.
+    attr_accessor :org_id
+    attr_accessor :response_status_code
+    attr_accessor :status
+
+    ALL_FIELD ||= [
+      "app_id",
+      "app_uid",
+      "attempt_count",
+      "attempt_end",
+      "attempt_id",
+      "attempt_start",
+      "endpoint_id",
+      "event_type",
+      "http_times",
+      "msg_created",
+      "msg_event_id",
+      "msg_id",
+      "org_id",
+      "response_status_code",
+      "status"
+    ].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `HookSniff::MessageAttemptLog` new method")
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageAttemptLog")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["app_id"] = attributes["appId"]
+      attrs["app_uid"] = attributes["appUid"]
+      attrs["attempt_count"] = attributes["attemptCount"]
+      attrs["attempt_end"] = DateTime.rfc3339(attributes["attemptEnd"]).to_time
+      attrs["attempt_id"] = attributes["attemptId"]
+      attrs["attempt_start"] = DateTime.rfc3339(attributes["attemptStart"]).to_time
+      attrs["endpoint_id"] = attributes["endpointId"]
+      attrs["event_type"] = attributes["eventType"]
+      attrs["http_times"] = HookSniff::HttpAttemptTimes.deserialize(attributes["httpTimes"]) if attributes["httpTimes"]
+      attrs["msg_created"] = DateTime.rfc3339(attributes["msgCreated"]).to_time
+      attrs["msg_event_id"] = attributes["msgEventId"]
+      attrs["msg_id"] = attributes["msgId"]
+      attrs["org_id"] = attributes["orgId"]
+      attrs["response_status_code"] = attributes["responseStatusCode"]
+      attrs["status"] = HookSniff::MessageStatus.deserialize(attributes["status"])
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["appId"] = HookSniff::serialize_primitive(@app_id) if @app_id
+      out["appUid"] = HookSniff::serialize_primitive(@app_uid) if @app_uid
+      out["attemptCount"] = HookSniff::serialize_primitive(@attempt_count) if @attempt_count
+      out["attemptEnd"] = HookSniff::serialize_primitive(@attempt_end) if @attempt_end
+      out["attemptId"] = HookSniff::serialize_primitive(@attempt_id) if @attempt_id
+      out["attemptStart"] = HookSniff::serialize_primitive(@attempt_start) if @attempt_start
+      out["endpointId"] = HookSniff::serialize_primitive(@endpoint_id) if @endpoint_id
+      out["eventType"] = HookSniff::serialize_primitive(@event_type) if @event_type
+      out["httpTimes"] = HookSniff::serialize_schema_ref(@http_times) if @http_times
+      out["msgCreated"] = HookSniff::serialize_primitive(@msg_created) if @msg_created
+      out["msgEventId"] = HookSniff::serialize_primitive(@msg_event_id) if @msg_event_id
+      out["msgId"] = HookSniff::serialize_primitive(@msg_id) if @msg_id
+      out["orgId"] = HookSniff::serialize_primitive(@org_id) if @org_id
+      out["responseStatusCode"] = HookSniff::serialize_primitive(@response_status_code) if @response_status_code
+      out["status"] = HookSniff::serialize_schema_ref(@status) if @status
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/message_attempt_log_event.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  # Sent after message attempts are made. Contains metadata about message attempts and their results. In order to reduce the frequency of webhooks, these are sent in batches periodically.
+  class MessageAttemptLogEvent
+    attr_accessor :data
+    attr_accessor :type
+
+    ALL_FIELD ||= ["data", "type"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `HookSniff::MessageAttemptLogEvent` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageAttemptLogEvent")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = attributes["data"].map { |v| HookSniff::MessageAttemptLog.deserialize(v) }
+      attrs["type"] = attributes["type"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = @data.map { |v| v.serialize } if @data
+      out["type"] = HookSniff::serialize_primitive(@type) if @type
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/message_attempt_out.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  class MessageAttemptOut
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    # The MessageAttempt's ID.
+    attr_accessor :id
+    attr_accessor :msg
+    # The Message's ID.
+    attr_accessor :msg_id
+    attr_accessor :response
+    # Response duration in milliseconds.
+    attr_accessor :response_duration_ms
+    attr_accessor :response_status_code
+    attr_accessor :status
+    attr_accessor :status_text
+    attr_accessor :timestamp
+    attr_accessor :trigger_type
+    attr_accessor :url
+
+    ALL_FIELD ||= [
+      "endpoint_id",
+      "id",
+      "msg",
+      "msg_id",
+      "response",
+      "response_duration_ms",
+      "response_status_code",
+      "status",
+      "status_text",
+      "timestamp",
+      "trigger_type",
+      "url"
+    ].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `HookSniff::MessageAttemptOut` new method")
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageAttemptOut")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["endpoint_id"] = attributes["endpointId"]
+      attrs["id"] = attributes["id"]
+      attrs["msg"] = HookSniff::MessageOut.deserialize(attributes["msg"]) if attributes["msg"]
+      attrs["msg_id"] = attributes["msgId"]
+      attrs["response"] = attributes["response"]
+      attrs["response_duration_ms"] = attributes["responseDurationMs"]
+      attrs["response_status_code"] = attributes["responseStatusCode"]
+      attrs["status"] = HookSniff::MessageStatus.deserialize(attributes["status"])
+      attrs["status_text"] = HookSniff::MessageStatusText.deserialize(attributes["statusText"])
+      attrs["timestamp"] = DateTime.rfc3339(attributes["timestamp"]).to_time
+      attrs["trigger_type"] = HookSniff::MessageAttemptTriggerType.deserialize(attributes["triggerType"])
+      attrs["url"] = attributes["url"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["endpointId"] = HookSniff::serialize_primitive(@endpoint_id) if @endpoint_id
+      out["id"] = HookSniff::serialize_primitive(@id) if @id
+      out["msg"] = HookSniff::serialize_schema_ref(@msg) if @msg
+      out["msgId"] = HookSniff::serialize_primitive(@msg_id) if @msg_id
+      out["response"] = HookSniff::serialize_primitive(@response) if @response
+      out["responseDurationMs"] = HookSniff::serialize_primitive(@response_duration_ms) if @response_duration_ms
+      out["responseStatusCode"] = HookSniff::serialize_primitive(@response_status_code) if @response_status_code
+      out["status"] = HookSniff::serialize_schema_ref(@status) if @status
+      out["statusText"] = HookSniff::serialize_schema_ref(@status_text) if @status_text
+      out["timestamp"] = HookSniff::serialize_primitive(@timestamp) if @timestamp
+      out["triggerType"] = HookSniff::serialize_schema_ref(@trigger_type) if @trigger_type
+      out["url"] = HookSniff::serialize_primitive(@url) if @url
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/message_attempt_recovered_event.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  # Sent on a successful dispatch after an earlier failure op webhook has already been sent.
+  class MessageAttemptRecoveredEvent
+    attr_accessor :data
+    attr_accessor :type
+
+    ALL_FIELD ||= ["data", "type"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `HookSniff::MessageAttemptRecoveredEvent` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageAttemptRecoveredEvent")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = HookSniff::MessageAttemptRecoveredEventData.deserialize(attributes["data"])
+      attrs["type"] = attributes["type"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = HookSniff::serialize_schema_ref(@data) if @data
+      out["type"] = HookSniff::serialize_primitive(@type) if @type
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/message_attempt_recovered_event_data.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  # Sent when a message delivery has failed (all of the retry attempts have been exhausted) as a "message.attempt.exhausted" type or after it's failed four times as a "message.attempt.failing" event.
+  class MessageAttemptRecoveredEventData
+    # The Application's ID.
+    attr_accessor :app_id
+    # The Application's UID.
+    attr_accessor :app_uid
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    attr_accessor :last_attempt
+    # The Message's UID.
+    attr_accessor :msg_event_id
+    # The Message's ID.
+    attr_accessor :msg_id
+
+    ALL_FIELD ||= ["app_id", "app_uid", "endpoint_id", "last_attempt", "msg_event_id", "msg_id"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `HookSniff::MessageAttemptRecoveredEventData` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageAttemptRecoveredEventData")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["app_id"] = attributes["appId"]
+      attrs["app_uid"] = attributes["appUid"]
+      attrs["endpoint_id"] = attributes["endpointId"]
+      attrs["last_attempt"] = HookSniff::MessageAttemptFailedData.deserialize(attributes["lastAttempt"])
+      attrs["msg_event_id"] = attributes["msgEventId"]
+      attrs["msg_id"] = attributes["msgId"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["appId"] = HookSniff::serialize_primitive(@app_id) if @app_id
+      out["appUid"] = HookSniff::serialize_primitive(@app_uid) if @app_uid
+      out["endpointId"] = HookSniff::serialize_primitive(@endpoint_id) if @endpoint_id
+      out["lastAttempt"] = HookSniff::serialize_schema_ref(@last_attempt) if @last_attempt
+      out["msgEventId"] = HookSniff::serialize_primitive(@msg_event_id) if @msg_event_id
+      out["msgId"] = HookSniff::serialize_primitive(@msg_id) if @msg_id
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/message_attempt_trigger_type.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# This file is @generated
+module HookSniff
+  # The reason an attempt was made:
+  #
+  # - Scheduled = 0
+  # - Manual = 1
+  class MessageAttemptTriggerType
+    SCHEDULED = 0.freeze
+    MANUAL = 1.freeze
+
+    def self.all_vars
+      @all_vars ||= [SCHEDULED, MANUAL].freeze
+    end
+
+    def initialize(value)
+      unless MessageAttemptTriggerType.all_vars.include?(value)
+        raise "Invalid ENUM value '#{value}' for class #MessageAttemptTriggerType"
+      end
+
+      @value = value
+    end
+
+    def self.deserialize(value)
+      return value if MessageAttemptTriggerType.all_vars.include?(value)
+      raise "Invalid ENUM value '#{value}' for class #MessageAttemptTriggerType"
+    end
+
+    def serialize
+      @value
+    end
+  end
+end

data/lib/hooksniff/models/message_endpoint_out.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  class MessageEndpointOut
+    # List of message channels this endpoint listens to (omit for all).
+    attr_accessor :channels
+    attr_accessor :created_at
+    # An example endpoint name.
+    attr_accessor :description
+    attr_accessor :disabled
+    attr_accessor :filter_types
+    # The Endpoint's ID.
+    attr_accessor :id
+    attr_accessor :next_attempt
+    # Deprecated, use `throttleRate` instead.
+    attr_accessor :rate_limit
+    attr_accessor :status
+    attr_accessor :status_text
+    # Maximum messages per second to send to this endpoint.
+    #
+    # Outgoing messages will be throttled to this rate.
+    attr_accessor :throttle_rate
+    # Optional unique identifier for the endpoint.
+    attr_accessor :uid
+    attr_accessor :updated_at
+    attr_accessor :url
+    attr_accessor :version
+
+    ALL_FIELD ||= [
+      "channels",
+      "created_at",
+      "description",
+      "disabled",
+      "filter_types",
+      "id",
+      "next_attempt",
+      "rate_limit",
+      "status",
+      "status_text",
+      "throttle_rate",
+      "uid",
+      "updated_at",
+      "url",
+      "version"
+    ].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `HookSniff::MessageEndpointOut` new method")
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageEndpointOut")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["channels"] = attributes["channels"]
+      attrs["created_at"] = DateTime.rfc3339(attributes["createdAt"]).to_time
+      attrs["description"] = attributes["description"]
+      attrs["disabled"] = attributes["disabled"]
+      attrs["filter_types"] = attributes["filterTypes"]
+      attrs["id"] = attributes["id"]
+      attrs["next_attempt"] = DateTime.rfc3339(attributes["nextAttempt"]).to_time if attributes["nextAttempt"]
+      attrs["rate_limit"] = attributes["rateLimit"]
+      attrs["status"] = HookSniff::MessageStatus.deserialize(attributes["status"])
+      attrs["status_text"] = HookSniff::MessageStatusText.deserialize(attributes["statusText"])
+      attrs["throttle_rate"] = attributes["throttleRate"]
+      attrs["uid"] = attributes["uid"]
+      attrs["updated_at"] = DateTime.rfc3339(attributes["updatedAt"]).to_time
+      attrs["url"] = attributes["url"]
+      attrs["version"] = attributes["version"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["channels"] = HookSniff::serialize_primitive(@channels) if @channels
+      out["createdAt"] = HookSniff::serialize_primitive(@created_at) if @created_at
+      out["description"] = HookSniff::serialize_primitive(@description) if @description
+      out["disabled"] = HookSniff::serialize_primitive(@disabled) if @disabled
+      out["filterTypes"] = HookSniff::serialize_primitive(@filter_types) if @filter_types
+      out["id"] = HookSniff::serialize_primitive(@id) if @id
+      out["nextAttempt"] = HookSniff::serialize_primitive(@next_attempt) if @next_attempt
+      out["rateLimit"] = HookSniff::serialize_primitive(@rate_limit) if @rate_limit
+      out["status"] = HookSniff::serialize_schema_ref(@status) if @status
+      out["statusText"] = HookSniff::serialize_schema_ref(@status_text) if @status_text
+      out["throttleRate"] = HookSniff::serialize_primitive(@throttle_rate) if @throttle_rate
+      out["uid"] = HookSniff::serialize_primitive(@uid) if @uid
+      out["updatedAt"] = HookSniff::serialize_primitive(@updated_at) if @updated_at
+      out["url"] = HookSniff::serialize_primitive(@url) if @url
+      out["version"] = HookSniff::serialize_primitive(@version) if @version
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/message_in.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  class MessageIn
+    # Optionally creates a new application alongside the message.
+    #
+    # If the application id or uid that is used in the path already exists, this argument is ignored.
+    attr_accessor :application
+    # List of free-form identifiers that endpoints can filter by
+    attr_accessor :channels
+    # The date and time at which the message will be delivered.
+    #
+    # Note that this time is best-effort-only. Must be at least one minute and no more than 24 hours in the future.
+    attr_accessor :deliver_at
+    # Optional unique identifier for the message
+    attr_accessor :event_id
+    # The event type's name
+    attr_accessor :event_type
+    # JSON payload to send as the request body of the webhook.
+    #
+    # We also support sending non-JSON payloads. Please contact us for more information.
+    attr_accessor :payload
+    # Optional number of hours to retain the message payload. Note that this is mutually exclusive with `payloadRetentionPeriod`.
+    attr_accessor :payload_retention_hours
+    # Optional number of days to retain the message payload. Defaults to 90. Note that this is mutually exclusive with `payloadRetentionHours`.
+    attr_accessor :payload_retention_period
+    # List of free-form tags that can be filtered by when listing messages
+    attr_accessor :tags
+    # Extra parameters to pass to Transformations (for future use)
+    attr_accessor :transformations_params
+
+    ALL_FIELD ||= [
+      "application",
+      "channels",
+      "deliver_at",
+      "event_id",
+      "event_type",
+      "payload",
+      "payload_retention_hours",
+      "payload_retention_period",
+      "tags",
+      "transformations_params"
+    ].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `HookSniff::MessageIn` new method")
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageIn")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["application"] = HookSniff::ApplicationIn.deserialize(attributes["application"]) if attributes["application"]
+      attrs["channels"] = attributes["channels"]
+      attrs["deliver_at"] = DateTime.rfc3339(attributes["deliverAt"]).to_time if attributes["deliverAt"]
+      attrs["event_id"] = attributes["eventId"]
+      attrs["event_type"] = attributes["eventType"]
+      attrs["payload"] = attributes["payload"]
+      attrs["payload_retention_hours"] = attributes["payloadRetentionHours"]
+      attrs["payload_retention_period"] = attributes["payloadRetentionPeriod"]
+      attrs["tags"] = attributes["tags"]
+      attrs["transformations_params"] = attributes["transformationsParams"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["application"] = HookSniff::serialize_schema_ref(@application) if @application
+      out["channels"] = HookSniff::serialize_primitive(@channels) if @channels
+      out["deliverAt"] = HookSniff::serialize_primitive(@deliver_at) if @deliver_at
+      out["eventId"] = HookSniff::serialize_primitive(@event_id) if @event_id
+      out["eventType"] = HookSniff::serialize_primitive(@event_type) if @event_type
+      out["payload"] = HookSniff::serialize_primitive(@payload) if @payload
+      out["payloadRetentionHours"] = HookSniff::serialize_primitive(@payload_retention_hours) if @payload_retention_hours
+      out["payloadRetentionPeriod"] = HookSniff::serialize_primitive(@payload_retention_period) if @payload_retention_period
+      out["tags"] = HookSniff::serialize_primitive(@tags) if @tags
+      out["transformationsParams"] = HookSniff::serialize_primitive(@transformations_params) if @transformations_params
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end