svix 1.61.3 → 1.61.4

data/lib/svix/models/hubspot_config.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class HubspotConfig
+    attr_accessor :secret
+
+    ALL_FIELD ||= ["secret"].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::HubspotConfig` 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::HubspotConfig")
+        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["secret"] = attributes["secret"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["secret"] = Svix::serialize_primitive(@secret) if @secret
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/hubspot_config_out.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class HubspotConfigOut
+
+    ALL_FIELD ||= [].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::HubspotConfigOut` 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::HubspotConfigOut")
+        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
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/ingest_source_consumer_portal_access_in.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class IngestSourceConsumerPortalAccessIn
+    attr_accessor :expiry
+    attr_accessor :read_only
+
+    ALL_FIELD ||= ["expiry", "read_only"].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::IngestSourceConsumerPortalAccessIn` 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::IngestSourceConsumerPortalAccessIn")
+        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["read_only"] = attributes["readOnly"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["expiry"] = Svix::serialize_primitive(@expiry) if @expiry
+      out["readOnly"] = Svix::serialize_primitive(@read_only) if @read_only
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/ingest_source_in.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+require_relative "./adobe_sign_config"
+require_relative "./cron_config"
+require_relative "./docusign_config"
+require_relative "./github_config"
+require_relative "./hubspot_config"
+require_relative "./segment_config"
+require_relative "./shopify_config"
+require_relative "./slack_config"
+require_relative "./stripe_config"
+require_relative "./svix_config"
+require_relative "./zoom_config"
+
+module Svix
+  class IngestSourceInConfig
+    class GenericWebhook
+
+      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 Cron < CronConfig
+    end
+
+    class AdobeSign < AdobeSignConfig
+    end
+
+    class Beehiiv < SvixConfig
+    end
+
+    class Brex < SvixConfig
+    end
+
+    class Clerk < SvixConfig
+    end
+
+    class Docusign < DocusignConfig
+    end
+
+    class Github < GithubConfig
+    end
+
+    class Guesty < SvixConfig
+    end
+
+    class Hubspot < HubspotConfig
+    end
+
+    class IncidentIo < SvixConfig
+    end
+
+    class Lithic < SvixConfig
+    end
+
+    class Nash < SvixConfig
+    end
+
+    class Pleo < SvixConfig
+    end
+
+    class Replicate < SvixConfig
+    end
+
+    class Resend < SvixConfig
+    end
+
+    class Safebase < SvixConfig
+    end
+
+    class Sardine < SvixConfig
+    end
+
+    class Segment < SegmentConfig
+    end
+
+    class Shopify < ShopifyConfig
+    end
+
+    class Slack < SlackConfig
+    end
+
+    class Stripe < StripeConfig
+    end
+
+    class Stych < SvixConfig
+    end
+
+    class Svix < SvixConfig
+    end
+
+    class Zoom < ZoomConfig
+    end
+  end
+
+  class IngestSourceIn
+    attr_accessor :name
+    attr_accessor :uid
+    attr_accessor :config
+
+    ALL_FIELD ||= ["name", "uid", "config"].freeze
+    private_constant :ALL_FIELD
+    TYPE_TO_NAME = {
+      IngestSourceInConfig::GenericWebhook => "generic-webhook",
+      IngestSourceInConfig::Cron => "cron",
+      IngestSourceInConfig::AdobeSign => "adobe-sign",
+      IngestSourceInConfig::Beehiiv => "beehiiv",
+      IngestSourceInConfig::Brex => "brex",
+      IngestSourceInConfig::Clerk => "clerk",
+      IngestSourceInConfig::Docusign => "docusign",
+      IngestSourceInConfig::Github => "github",
+      IngestSourceInConfig::Guesty => "guesty",
+      IngestSourceInConfig::Hubspot => "hubspot",
+      IngestSourceInConfig::IncidentIo => "incident-io",
+      IngestSourceInConfig::Lithic => "lithic",
+      IngestSourceInConfig::Nash => "nash",
+      IngestSourceInConfig::Pleo => "pleo",
+      IngestSourceInConfig::Replicate => "replicate",
+      IngestSourceInConfig::Resend => "resend",
+      IngestSourceInConfig::Safebase => "safebase",
+      IngestSourceInConfig::Sardine => "sardine",
+      IngestSourceInConfig::Segment => "segment",
+      IngestSourceInConfig::Shopify => "shopify",
+      IngestSourceInConfig::Slack => "slack",
+      IngestSourceInConfig::Stripe => "stripe",
+      IngestSourceInConfig::Stych => "stych",
+      IngestSourceInConfig::Svix => "svix",
+      IngestSourceInConfig::Zoom => "zoom"
+    }
+    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::IngestSourceIn` 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::IngestSourceIn")
+        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["name"] = attributes["name"]
+      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["name"] = Svix::serialize_primitive(@name) if @name
+      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/ingest_source_out.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+require_relative "./adobe_sign_config_out"
+require_relative "./cron_config"
+require_relative "./docusign_config_out"
+require_relative "./github_config_out"
+require_relative "./hubspot_config_out"
+require_relative "./segment_config_out"
+require_relative "./shopify_config_out"
+require_relative "./slack_config_out"
+require_relative "./stripe_config_out"
+require_relative "./svix_config_out"
+require_relative "./zoom_config_out"
+
+module Svix
+  class IngestSourceOutConfig
+    class GenericWebhook
+
+      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 Cron < CronConfig
+    end
+
+    class AdobeSign < AdobeSignConfigOut
+    end
+
+    class Beehiiv < SvixConfigOut
+    end
+
+    class Brex < SvixConfigOut
+    end
+
+    class Clerk < SvixConfigOut
+    end
+
+    class Docusign < DocusignConfigOut
+    end
+
+    class Github < GithubConfigOut
+    end
+
+    class Guesty < SvixConfigOut
+    end
+
+    class Hubspot < HubspotConfigOut
+    end
+
+    class IncidentIo < SvixConfigOut
+    end
+
+    class Lithic < SvixConfigOut
+    end
+
+    class Nash < SvixConfigOut
+    end
+
+    class Pleo < SvixConfigOut
+    end
+
+    class Replicate < SvixConfigOut
+    end
+
+    class Resend < SvixConfigOut
+    end
+
+    class Safebase < SvixConfigOut
+    end
+
+    class Sardine < SvixConfigOut
+    end
+
+    class Segment < SegmentConfigOut
+    end
+
+    class Shopify < ShopifyConfigOut
+    end
+
+    class Slack < SlackConfigOut
+    end
+
+    class Stripe < StripeConfigOut
+    end
+
+    class Stych < SvixConfigOut
+    end
+
+    class Svix < SvixConfigOut
+    end
+
+    class Zoom < ZoomConfigOut
+    end
+  end
+
+  class IngestSourceOut
+    attr_accessor :created_at
+    attr_accessor :id
+    attr_accessor :ingest_url
+    attr_accessor :name
+    attr_accessor :uid
+    attr_accessor :updated_at
+    attr_accessor :config
+
+    ALL_FIELD ||= ["created_at", "id", "ingest_url", "name", "uid", "updated_at", "config"].freeze
+    private_constant :ALL_FIELD
+    TYPE_TO_NAME = {
+      IngestSourceOutConfig::GenericWebhook => "generic-webhook",
+      IngestSourceOutConfig::Cron => "cron",
+      IngestSourceOutConfig::AdobeSign => "adobe-sign",
+      IngestSourceOutConfig::Beehiiv => "beehiiv",
+      IngestSourceOutConfig::Brex => "brex",
+      IngestSourceOutConfig::Clerk => "clerk",
+      IngestSourceOutConfig::Docusign => "docusign",
+      IngestSourceOutConfig::Github => "github",
+      IngestSourceOutConfig::Guesty => "guesty",
+      IngestSourceOutConfig::Hubspot => "hubspot",
+      IngestSourceOutConfig::IncidentIo => "incident-io",
+      IngestSourceOutConfig::Lithic => "lithic",
+      IngestSourceOutConfig::Nash => "nash",
+      IngestSourceOutConfig::Pleo => "pleo",
+      IngestSourceOutConfig::Replicate => "replicate",
+      IngestSourceOutConfig::Resend => "resend",
+      IngestSourceOutConfig::Safebase => "safebase",
+      IngestSourceOutConfig::Sardine => "sardine",
+      IngestSourceOutConfig::Segment => "segment",
+      IngestSourceOutConfig::Shopify => "shopify",
+      IngestSourceOutConfig::Slack => "slack",
+      IngestSourceOutConfig::Stripe => "stripe",
+      IngestSourceOutConfig::Stych => "stych",
+      IngestSourceOutConfig::Svix => "svix",
+      IngestSourceOutConfig::Zoom => "zoom"
+    }
+    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::IngestSourceOut` 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::IngestSourceOut")
+        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["created_at"] = DateTime.rfc3339(attributes["createdAt"]).to_time
+      attrs["id"] = attributes["id"]
+      attrs["ingest_url"] = attributes["ingestUrl"]
+      attrs["name"] = attributes["name"]
+      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["createdAt"] = Svix::serialize_primitive(@created_at) if @created_at
+      out["id"] = Svix::serialize_primitive(@id) if @id
+      out["ingestUrl"] = Svix::serialize_primitive(@ingest_url) if @ingest_url
+      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["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/list_response_ingest_source_out.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class ListResponseIngestSourceOut
+    attr_accessor :data
+    attr_accessor :done
+    attr_accessor :iterator
+    attr_accessor :prev_iterator
+
+    ALL_FIELD ||= ["data", "done", "iterator", "prev_iterator"].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::ListResponseIngestSourceOut` 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::ListResponseIngestSourceOut")
+        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| Svix::IngestSourceOut.deserialize(v) }
+      attrs["done"] = attributes["done"]
+      attrs["iterator"] = attributes["iterator"]
+      attrs["prev_iterator"] = attributes["prevIterator"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = @data.map { |v| v.serialize } if @data
+      out["done"] = Svix::serialize_primitive(@done) if @done
+      out["iterator"] = Svix::serialize_primitive(@iterator) if @iterator
+      out["prevIterator"] = Svix::serialize_primitive(@prev_iterator) if @prev_iterator
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/message_attempt_exhausted_event.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  # Sent when a message delivery has failed (all of the retry attempts have been exhausted).
+  class MessageAttemptExhaustedEvent
+    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 `Svix::MessageAttemptExhaustedEvent` 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::MessageAttemptExhaustedEvent")
+        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"] = Svix::MessageAttemptExhaustedEventData.deserialize(attributes["data"])
+      attrs["type"] = attributes["type"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = Svix::serialize_schema_ref(@data) if @data
+      out["type"] = Svix::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