svix 1.76.0 → 1.77.0

data/lib/svix/models/stream_in.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class StreamIn
+    attr_accessor :metadata
+    # The stream's name.
+    attr_accessor :name
+    # An optional unique identifier for the stream.
+    attr_accessor :uid
+
+    ALL_FIELD ||= ["metadata", "name", "uid"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `Svix::StreamIn` new method")
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::StreamIn")
+        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["metadata"] = attributes["metadata"]
+      attrs["name"] = attributes["name"]
+      attrs["uid"] = attributes["uid"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
+      out["name"] = Svix::serialize_primitive(@name) if @name
+      out["uid"] = Svix::serialize_primitive(@uid) if @uid
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/stream_out.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class StreamOut
+    attr_accessor :created_at
+    # The stream's ID.
+    attr_accessor :id
+    attr_accessor :metadata
+    # The stream's name.
+    attr_accessor :name
+    # The stream's UID.
+    attr_accessor :uid
+    attr_accessor :updated_at
+
+    ALL_FIELD ||= ["created_at", "id", "metadata", "name", "uid", "updated_at"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `Svix::StreamOut` new method")
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::StreamOut")
+        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["created_at"] = DateTime.rfc3339(attributes["createdAt"]).to_time
+      attrs["id"] = attributes["id"]
+      attrs["metadata"] = attributes["metadata"]
+      attrs["name"] = attributes["name"]
+      attrs["uid"] = attributes["uid"]
+      attrs["updated_at"] = DateTime.rfc3339(attributes["updatedAt"]).to_time
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["createdAt"] = Svix::serialize_primitive(@created_at) if @created_at
+      out["id"] = Svix::serialize_primitive(@id) if @id
+      out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
+      out["name"] = Svix::serialize_primitive(@name) if @name
+      out["uid"] = Svix::serialize_primitive(@uid) if @uid
+      out["updatedAt"] = Svix::serialize_primitive(@updated_at) if @updated_at
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/stream_patch.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class StreamPatch
+    # The Stream's description.
+    attr_accessor :description
+    attr_accessor :metadata
+    # An optional unique identifier for the stream.
+    attr_accessor :uid
+
+    ALL_FIELD ||= ["description", "metadata", "uid"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `Svix::StreamPatch` new method")
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::StreamPatch")
+        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["description"] = attributes["description"]
+      attrs["metadata"] = attributes["metadata"]
+      attrs["uid"] = attributes["uid"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["description"] = Svix::serialize_primitive(@description) if @description
+      out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
+      out["uid"] = Svix::serialize_primitive(@uid) if @__uid_is_defined
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/stream_portal_access_in.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class StreamPortalAccessIn
+    # How long the token will be valid for, in seconds.
+    #
+    # Valid values are between 1 hour and 7 days. The default is 7 days.
+    attr_accessor :expiry
+    # The set of feature flags the created token will have access to.
+    attr_accessor :feature_flags
+    # An optional session ID to attach to the token.
+    #
+    # When expiring tokens with "Expire All", you can include the session ID to only expire tokens that were created with that session ID.
+    attr_accessor :session_id
+
+    ALL_FIELD ||= ["expiry", "feature_flags", "session_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 `Svix::StreamPortalAccessIn` new method")
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::StreamPortalAccessIn")
+        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["expiry"] = attributes["expiry"]
+      attrs["feature_flags"] = attributes["featureFlags"]
+      attrs["session_id"] = attributes["sessionId"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["expiry"] = Svix::serialize_primitive(@expiry) if @expiry
+      out["featureFlags"] = Svix::serialize_primitive(@feature_flags) if @feature_flags
+      out["sessionId"] = Svix::serialize_primitive(@session_id) if @session_id
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/stream_sink_in.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+require_relative "./azure_blob_storage_config"
+require_relative "./google_cloud_storage_config"
+require_relative "./s3_config"
+require_relative "./sink_http_config"
+require_relative "./sink_otel_v1_config"
+require_relative "./sink_status_in"
+
+module Svix
+  class StreamSinkInConfig
+    class Poller
+
+      def serialize
+        Hash.new
+      end
+
+      def self.deserialize(attributes = {})
+        new
+      end
+      # Serializes the object to a json string
+      # @return String
+      def to_json
+        JSON.dump(serialize)
+      end
+    end
+
+    class AzureBlobStorage < AzureBlobStorageConfig
+    end
+
+    class OtelTracing < SinkOtelV1Config
+    end
+
+    class Http < SinkHttpConfig
+    end
+
+    class AmazonS3 < S3Config
+    end
+
+    class GoogleCloudStorage < GoogleCloudStorageConfig
+    end
+  end
+
+  class StreamSinkIn
+    # How many events will be batched in a request to the Sink.
+    attr_accessor :batch_size
+    # A list of event types that filter which events are dispatched to the Sink. An empty list (or null) will not filter out any events.
+    attr_accessor :event_types
+    # How long to wait before a batch of events is sent, if the `batchSize` is not reached.
+    #
+    # For example, with a `batchSize` of 100 and `maxWaitSecs` of 10, we will send a request after 10 seconds or 100 events, whichever comes first.
+    #
+    # Note that we will never send an empty batch of events to the Sink.
+    attr_accessor :max_wait_secs
+    attr_accessor :metadata
+    # Whether the sink will receive events.
+    #
+    # If the sink is `enabled`, any events posted to the stream will be dispatched to the Sink in the same order that events were posted to the stream.
+    #
+    # If the sink is `disabled`, events will not be dispatched to the sink until the sink is reenabled.
+    attr_accessor :status
+    # An optional unique identifier for the sink.
+    attr_accessor :uid
+    attr_accessor :config
+
+    ALL_FIELD ||= ["batch_size", "event_types", "max_wait_secs", "metadata", "status", "uid", "config"].freeze
+    private_constant :ALL_FIELD
+    TYPE_TO_NAME = {
+      StreamSinkInConfig::Poller => "poller",
+      StreamSinkInConfig::AzureBlobStorage => "azureBlobStorage",
+      StreamSinkInConfig::OtelTracing => "otelTracing",
+      StreamSinkInConfig::Http => "http",
+      StreamSinkInConfig::AmazonS3 => "amazonS3",
+      StreamSinkInConfig::GoogleCloudStorage => "googleCloudStorage"
+    }
+    private_constant :TYPE_TO_NAME
+    NAME_TO_TYPE = TYPE_TO_NAME.invert
+    private_constant :NAME_TO_TYPE
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::StreamSinkIn` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::StreamSinkIn")
+        end
+
+        if k == "config"
+          unless TYPE_TO_NAME.key?(v.class)
+            fail(ArgumentError, "The field #{k} can't be a `#{v.class}` expected one of #{TYPE_TO_NAME.keys}")
+          end
+
+          instance_variable_set("@__enum_discriminator", TYPE_TO_NAME[v.class])
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+
+      if @__enum_discriminator.nil?
+        fail(ArgumentError, "Required config field was not set")
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["batch_size"] = attributes["batchSize"]
+      attrs["event_types"] = attributes["eventTypes"]
+      attrs["max_wait_secs"] = attributes["maxWaitSecs"]
+      attrs["metadata"] = attributes["metadata"]
+      attrs["status"] = Svix::SinkStatusIn.deserialize(attributes["status"]) if attributes["status"]
+      attrs["uid"] = attributes["uid"]
+      unless NAME_TO_TYPE.key?(attributes["type"])
+        fail(ArgumentError, "Invalid type `#{attributes["type"]}` expected on of #{NAME_TO_TYPE.keys}")
+      end
+
+      unless attributes.key?("config")
+        fail(ArgumentError, "Missing required field config")
+      end
+
+      attrs["config"] = NAME_TO_TYPE[attributes["type"]].deserialize(attributes["config"])
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["batchSize"] = Svix::serialize_primitive(@batch_size) if @batch_size
+      out["eventTypes"] = Svix::serialize_primitive(@event_types) if @event_types
+      out["maxWaitSecs"] = Svix::serialize_primitive(@max_wait_secs) if @max_wait_secs
+      out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
+      out["status"] = Svix::serialize_schema_ref(@status) if @status
+      out["uid"] = Svix::serialize_primitive(@uid) if @uid
+      out["type"] = @__enum_discriminator
+      out["config"] = @config.serialize
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+
+  end
+end

data/lib/svix/models/stream_sink_out.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+require_relative "./azure_blob_storage_config"
+require_relative "./google_cloud_storage_config"
+require_relative "./s3_config"
+require_relative "./sink_http_config"
+require_relative "./sink_otel_v1_config"
+require_relative "./sink_status"
+
+module Svix
+  class StreamSinkOutConfig
+    class Poller
+
+      def serialize
+        Hash.new
+      end
+
+      def self.deserialize(attributes = {})
+        new
+      end
+      # Serializes the object to a json string
+      # @return String
+      def to_json
+        JSON.dump(serialize)
+      end
+    end
+
+    class AzureBlobStorage < AzureBlobStorageConfig
+    end
+
+    class OtelTracing < SinkOtelV1Config
+    end
+
+    class Http < SinkHttpConfig
+    end
+
+    class AmazonS3 < S3Config
+    end
+
+    class GoogleCloudStorage < GoogleCloudStorageConfig
+    end
+  end
+
+  class StreamSinkOut
+    attr_accessor :batch_size
+    attr_accessor :created_at
+    attr_accessor :current_iterator
+    attr_accessor :event_types
+    attr_accessor :failure_reason
+    # The sink's ID.
+    attr_accessor :id
+    attr_accessor :max_wait_secs
+    attr_accessor :metadata
+    attr_accessor :next_retry_at
+    attr_accessor :status
+    # The sink's UID.
+    attr_accessor :uid
+    attr_accessor :updated_at
+    attr_accessor :config
+
+    ALL_FIELD ||= [
+      "batch_size",
+      "created_at",
+      "current_iterator",
+      "event_types",
+      "failure_reason",
+      "id",
+      "max_wait_secs",
+      "metadata",
+      "next_retry_at",
+      "status",
+      "uid",
+      "updated_at",
+      "config"
+    ].freeze
+    private_constant :ALL_FIELD
+    TYPE_TO_NAME = {
+      StreamSinkOutConfig::Poller => "poller",
+      StreamSinkOutConfig::AzureBlobStorage => "azureBlobStorage",
+      StreamSinkOutConfig::OtelTracing => "otelTracing",
+      StreamSinkOutConfig::Http => "http",
+      StreamSinkOutConfig::AmazonS3 => "amazonS3",
+      StreamSinkOutConfig::GoogleCloudStorage => "googleCloudStorage"
+    }
+    private_constant :TYPE_TO_NAME
+    NAME_TO_TYPE = TYPE_TO_NAME.invert
+    private_constant :NAME_TO_TYPE
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::StreamSinkOut` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::StreamSinkOut")
+        end
+
+        if k == "config"
+          unless TYPE_TO_NAME.key?(v.class)
+            fail(ArgumentError, "The field #{k} can't be a `#{v.class}` expected one of #{TYPE_TO_NAME.keys}")
+          end
+
+          instance_variable_set("@__enum_discriminator", TYPE_TO_NAME[v.class])
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+
+      if @__enum_discriminator.nil?
+        fail(ArgumentError, "Required config field was not set")
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["batch_size"] = attributes["batchSize"]
+      attrs["created_at"] = DateTime.rfc3339(attributes["createdAt"]).to_time
+      attrs["current_iterator"] = attributes["currentIterator"]
+      attrs["event_types"] = attributes["eventTypes"]
+      attrs["failure_reason"] = attributes["failureReason"]
+      attrs["id"] = attributes["id"]
+      attrs["max_wait_secs"] = attributes["maxWaitSecs"]
+      attrs["metadata"] = attributes["metadata"]
+      attrs["next_retry_at"] = DateTime.rfc3339(attributes["nextRetryAt"]).to_time if attributes["nextRetryAt"]
+      attrs["status"] = Svix::SinkStatus.deserialize(attributes["status"])
+      attrs["uid"] = attributes["uid"]
+      attrs["updated_at"] = DateTime.rfc3339(attributes["updatedAt"]).to_time
+      unless NAME_TO_TYPE.key?(attributes["type"])
+        fail(ArgumentError, "Invalid type `#{attributes["type"]}` expected on of #{NAME_TO_TYPE.keys}")
+      end
+
+      unless attributes.key?("config")
+        fail(ArgumentError, "Missing required field config")
+      end
+
+      attrs["config"] = NAME_TO_TYPE[attributes["type"]].deserialize(attributes["config"])
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["batchSize"] = Svix::serialize_primitive(@batch_size) if @batch_size
+      out["createdAt"] = Svix::serialize_primitive(@created_at) if @created_at
+      out["currentIterator"] = Svix::serialize_primitive(@current_iterator) if @current_iterator
+      out["eventTypes"] = Svix::serialize_primitive(@event_types) if @event_types
+      out["failureReason"] = Svix::serialize_primitive(@failure_reason) if @failure_reason
+      out["id"] = Svix::serialize_primitive(@id) if @id
+      out["maxWaitSecs"] = Svix::serialize_primitive(@max_wait_secs) if @max_wait_secs
+      out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
+      out["nextRetryAt"] = Svix::serialize_primitive(@next_retry_at) if @next_retry_at
+      out["status"] = Svix::serialize_schema_ref(@status) if @status
+      out["uid"] = Svix::serialize_primitive(@uid) if @uid
+      out["updatedAt"] = Svix::serialize_primitive(@updated_at) if @updated_at
+      out["type"] = @__enum_discriminator
+      out["config"] = @config.serialize
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+
+  end
+end

data/lib/svix/models/stream_sink_patch.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+require_relative "./amazon_s3_patch_config"
+require_relative "./azure_blob_storage_patch_config"
+require_relative "./google_cloud_storage_patch_config"
+require_relative "./http_patch_config"
+require_relative "./otel_tracing_patch_config"
+require_relative "./sink_status_in"
+
+module Svix
+  class StreamSinkPatchConfig
+    class Poller
+
+      def serialize
+        Hash.new
+      end
+
+      def self.deserialize(attributes = {})
+        new
+      end
+      # Serializes the object to a json string
+      # @return String
+      def to_json
+        JSON.dump(serialize)
+      end
+    end
+
+    class AzureBlobStorage < AzureBlobStoragePatchConfig
+    end
+
+    class OtelTracing < OtelTracingPatchConfig
+    end
+
+    class Http < HttpPatchConfig
+    end
+
+    class AmazonS3 < AmazonS3PatchConfig
+    end
+
+    class GoogleCloudStorage < GoogleCloudStoragePatchConfig
+    end
+  end
+
+  class StreamSinkPatch
+    attr_accessor :batch_size
+    attr_accessor :event_types
+    attr_accessor :max_wait_secs
+    attr_accessor :metadata
+    attr_accessor :status
+    # The StreamSink's UID.
+    attr_accessor :uid
+    attr_accessor :config
+
+    ALL_FIELD ||= ["batch_size", "event_types", "max_wait_secs", "metadata", "status", "uid", "config"].freeze
+    private_constant :ALL_FIELD
+    TYPE_TO_NAME = {
+      StreamSinkPatchConfig::Poller => "poller",
+      StreamSinkPatchConfig::AzureBlobStorage => "azureBlobStorage",
+      StreamSinkPatchConfig::OtelTracing => "otelTracing",
+      StreamSinkPatchConfig::Http => "http",
+      StreamSinkPatchConfig::AmazonS3 => "amazonS3",
+      StreamSinkPatchConfig::GoogleCloudStorage => "googleCloudStorage"
+    }
+    private_constant :TYPE_TO_NAME
+    NAME_TO_TYPE = TYPE_TO_NAME.invert
+    private_constant :NAME_TO_TYPE
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::StreamSinkPatch` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of Svix::StreamSinkPatch")
+        end
+
+        if k == "config"
+          unless TYPE_TO_NAME.key?(v.class)
+            fail(ArgumentError, "The field #{k} can't be a `#{v.class}` expected one of #{TYPE_TO_NAME.keys}")
+          end
+
+          instance_variable_set("@__enum_discriminator", TYPE_TO_NAME[v.class])
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+
+      if @__enum_discriminator.nil?
+        fail(ArgumentError, "Required config field was not set")
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["batch_size"] = attributes["batchSize"]
+      attrs["event_types"] = attributes["eventTypes"]
+      attrs["max_wait_secs"] = attributes["maxWaitSecs"]
+      attrs["metadata"] = attributes["metadata"]
+      attrs["status"] = Svix::SinkStatusIn.deserialize(attributes["status"]) if attributes["status"]
+      attrs["uid"] = attributes["uid"]
+      unless NAME_TO_TYPE.key?(attributes["type"])
+        fail(ArgumentError, "Invalid type `#{attributes["type"]}` expected on of #{NAME_TO_TYPE.keys}")
+      end
+
+      unless attributes.key?("config")
+        fail(ArgumentError, "Missing required field config")
+      end
+
+      attrs["config"] = NAME_TO_TYPE[attributes["type"]].deserialize(attributes["config"])
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["batchSize"] = Svix::serialize_primitive(@batch_size) if @__batch_size_is_defined
+      out["eventTypes"] = Svix::serialize_primitive(@event_types) if @event_types
+      out["maxWaitSecs"] = Svix::serialize_primitive(@max_wait_secs) if @__max_wait_secs_is_defined
+      out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
+      out["status"] = Svix::serialize_schema_ref(@status) if @__status_is_defined
+      out["uid"] = Svix::serialize_primitive(@uid) if @__uid_is_defined
+      out["type"] = @__enum_discriminator
+      out["config"] = @config.serialize
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+
+  end
+end