svix 1.61.0 → 1.61.2

data/lib/svix/api/message.rb

@@ -39,10 +39,9 @@ module Svix
 
     def list(app_id, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/msg"
       res = @client.execute_request(
         "GET",
-        path,
+        "/api/v1/app/#{app_id}/msg",
         query_params: {
           "limit" => options["limit"],
           "iterator" => options["iterator"],
@@ -59,10 +58,9 @@ module Svix
 
     def create(app_id, message_in, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/msg"
       res = @client.execute_request(
         "POST",
-        path,
+        "/api/v1/app/#{app_id}/msg",
         query_params: {
           "with_content" => options["with_content"]
         },
@@ -76,23 +74,21 @@ module Svix
 
     def expunge_all_contents(app_id, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/msg/expunge-all-contents"
       res = @client.execute_request(
         "POST",
-        path,
+        "/api/v1/app/#{app_id}/msg/expunge-all-contents",
         headers: {
           "idempotency-key" => options["idempotency-key"]
         }
       )
-      ExpungAllContentsOut.deserialize(res)
+      ExpungeAllContentsOut.deserialize(res)
     end
 
     def get(app_id, msg_id, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/msg/#{msg_id}"
       res = @client.execute_request(
         "GET",
-        path,
+        "/api/v1/app/#{app_id}/msg/#{msg_id}",
         query_params: {
           "with_content" => options["with_content"]
         }
@@ -101,10 +97,9 @@ module Svix
     end
 
     def expunge_content(app_id, msg_id)
-      path = "/api/v1/app/#{app_id}/msg/#{msg_id}/content"
       @client.execute_request(
         "DELETE",
-        path
+        "/api/v1/app/#{app_id}/msg/#{msg_id}/content"
       )
     end
 

data/lib/svix/api/message_attempt.rb

@@ -11,10 +11,9 @@ module Svix
 
     def list_by_endpoint(app_id, endpoint_id, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/attempt/endpoint/#{endpoint_id}"
       res = @client.execute_request(
         "GET",
-        path,
+        "/api/v1/app/#{app_id}/attempt/endpoint/#{endpoint_id}",
         query_params: {
           "limit" => options["limit"],
           "iterator" => options["iterator"],
@@ -34,10 +33,9 @@ module Svix
 
     def list_by_msg(app_id, msg_id, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/attempt/msg/#{msg_id}"
       res = @client.execute_request(
         "GET",
-        path,
+        "/api/v1/app/#{app_id}/attempt/msg/#{msg_id}",
         query_params: {
           "limit" => options["limit"],
           "iterator" => options["iterator"],
@@ -57,10 +55,9 @@ module Svix
 
     def list_attempted_messages(app_id, endpoint_id, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/endpoint/#{endpoint_id}/msg"
       res = @client.execute_request(
         "GET",
-        path,
+        "/api/v1/app/#{app_id}/endpoint/#{endpoint_id}/msg",
         query_params: {
           "limit" => options["limit"],
           "iterator" => options["iterator"],
@@ -77,28 +74,25 @@ module Svix
     end
 
     def get(app_id, msg_id, attempt_id)
-      path = "/api/v1/app/#{app_id}/msg/#{msg_id}/attempt/#{attempt_id}"
       res = @client.execute_request(
         "GET",
-        path
+        "/api/v1/app/#{app_id}/msg/#{msg_id}/attempt/#{attempt_id}"
       )
       MessageAttemptOut.deserialize(res)
     end
 
     def expunge_content(app_id, msg_id, attempt_id)
-      path = "/api/v1/app/#{app_id}/msg/#{msg_id}/attempt/#{attempt_id}/content"
       @client.execute_request(
         "DELETE",
-        path
+        "/api/v1/app/#{app_id}/msg/#{msg_id}/attempt/#{attempt_id}/content"
       )
     end
 
     def list_attempted_destinations(app_id, msg_id, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/msg/#{msg_id}/endpoint"
       res = @client.execute_request(
         "GET",
-        path,
+        "/api/v1/app/#{app_id}/msg/#{msg_id}/endpoint",
         query_params: {
           "limit" => options["limit"],
           "iterator" => options["iterator"]
@@ -109,10 +103,9 @@ module Svix
 
     def resend(app_id, msg_id, endpoint_id, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/app/#{app_id}/msg/#{msg_id}/endpoint/#{endpoint_id}/resend"
       @client.execute_request(
         "POST",
-        path,
+        "/api/v1/app/#{app_id}/msg/#{msg_id}/endpoint/#{endpoint_id}/resend",
         headers: {
           "idempotency-key" => options["idempotency-key"]
         }

data/lib/svix/api/operational_webhook_endpoint.rb

@@ -11,10 +11,9 @@ module Svix
 
     def list(options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/operational-webhook/endpoint"
       res = @client.execute_request(
         "GET",
-        path,
+        "/api/v1/operational-webhook/endpoint",
         query_params: {
           "limit" => options["limit"],
           "iterator" => options["iterator"],
@@ -26,10 +25,9 @@ module Svix
 
     def create(operational_webhook_endpoint_in, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/operational-webhook/endpoint"
       res = @client.execute_request(
         "POST",
-        path,
+        "/api/v1/operational-webhook/endpoint",
         headers: {
           "idempotency-key" => options["idempotency-key"]
         },
@@ -39,65 +37,58 @@ module Svix
     end
 
     def get(endpoint_id)
-      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}"
       res = @client.execute_request(
         "GET",
-        path
+        "/api/v1/operational-webhook/endpoint/#{endpoint_id}"
       )
       OperationalWebhookEndpointOut.deserialize(res)
     end
 
     def update(endpoint_id, operational_webhook_endpoint_update)
-      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}"
       res = @client.execute_request(
         "PUT",
-        path,
+        "/api/v1/operational-webhook/endpoint/#{endpoint_id}",
         body: operational_webhook_endpoint_update
       )
       OperationalWebhookEndpointOut.deserialize(res)
     end
 
     def delete(endpoint_id)
-      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}"
       @client.execute_request(
         "DELETE",
-        path
+        "/api/v1/operational-webhook/endpoint/#{endpoint_id}"
       )
     end
 
     def get_headers(endpoint_id)
-      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}/headers"
       res = @client.execute_request(
         "GET",
-        path
+        "/api/v1/operational-webhook/endpoint/#{endpoint_id}/headers"
       )
       OperationalWebhookEndpointHeadersOut.deserialize(res)
     end
 
     def update_headers(endpoint_id, operational_webhook_endpoint_headers_in)
-      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}/headers"
       @client.execute_request(
         "PUT",
-        path,
+        "/api/v1/operational-webhook/endpoint/#{endpoint_id}/headers",
         body: operational_webhook_endpoint_headers_in
       )
     end
 
     def get_secret(endpoint_id)
-      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}/secret"
       res = @client.execute_request(
         "GET",
-        path
+        "/api/v1/operational-webhook/endpoint/#{endpoint_id}/secret"
       )
       OperationalWebhookEndpointSecretOut.deserialize(res)
     end
 
     def rotate_secret(endpoint_id, operational_webhook_endpoint_secret_in, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}/secret/rotate"
       @client.execute_request(
         "POST",
-        path,
+        "/api/v1/operational-webhook/endpoint/#{endpoint_id}/secret/rotate",
         headers: {
           "idempotency-key" => options["idempotency-key"]
         },

data/lib/svix/api/statistics.rb

@@ -11,10 +11,9 @@ module Svix
 
     def aggregate_app_stats(app_usage_stats_in, options = {})
       options = options.transform_keys(&:to_s)
-      path = "/api/v1/stats/usage/app"
       res = @client.execute_request(
         "POST",
-        path,
+        "/api/v1/stats/usage/app",
         headers: {
           "idempotency-key" => options["idempotency-key"]
         },
@@ -24,10 +23,9 @@ module Svix
     end
 
     def aggregate_event_types
-      path = "/api/v1/stats/usage/event-types"
       res = @client.execute_request(
         "PUT",
-        path
+        "/api/v1/stats/usage/event-types"
       )
       AggregateEventTypesOut.deserialize(res)
     end

data/lib/svix/models/endpoint_in.rb

@@ -8,6 +8,7 @@ module Svix
     attr_accessor :description
     attr_accessor :disabled
     attr_accessor :filter_types
+    attr_accessor :headers
     attr_accessor :metadata
     attr_accessor :rate_limit
     attr_accessor :secret
@@ -20,6 +21,7 @@ module Svix
       "description",
       "disabled",
       "filter_types",
+      "headers",
       "metadata",
       "rate_limit",
       "secret",
@@ -51,6 +53,7 @@ module Svix
       attrs["description"] = attributes["description"]
       attrs["disabled"] = attributes["disabled"]
       attrs["filter_types"] = attributes["filterTypes"]
+      attrs["headers"] = attributes["headers"]
       attrs["metadata"] = attributes["metadata"]
       attrs["rate_limit"] = attributes["rateLimit"]
       attrs["secret"] = attributes["secret"]
@@ -66,6 +69,7 @@ module Svix
       out["description"] = Svix::serialize_primitive(@description) if @description
       out["disabled"] = Svix::serialize_primitive(@disabled) if @disabled
       out["filterTypes"] = Svix::serialize_primitive(@filter_types) if @filter_types
+      out["headers"] = Svix::serialize_primitive(@headers) if @headers
       out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
       out["rateLimit"] = Svix::serialize_primitive(@rate_limit) if @rate_limit
       out["secret"] = Svix::serialize_primitive(@secret) if @secret

data/lib/svix/models/expunge_all_contents_out.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class ExpungeAllContentsOut
+    attr_accessor :id
+    attr_accessor :status
+    attr_accessor :task
+
+    ALL_FIELD ||= ["id", "status", "task"].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::ExpungeAllContentsOut` 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::ExpungeAllContentsOut")
+        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["id"] = attributes["id"]
+      attrs["status"] = Svix::BackgroundTaskStatus.deserialize(attributes["status"])
+      attrs["task"] = Svix::BackgroundTaskType.deserialize(attributes["task"])
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["id"] = Svix::serialize_primitive(@id) if @id
+      out["status"] = @status.serialize if @status
+      out["task"] = @task.serialize if @task
+      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_endpoint_headers_in.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class IngestEndpointHeadersIn
+    attr_accessor :headers
+
+    ALL_FIELD ||= ["headers"].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::IngestEndpointHeadersIn` 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::IngestEndpointHeadersIn")
+        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["headers"] = attributes["headers"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["headers"] = Svix::serialize_primitive(@headers) if @headers
+      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_endpoint_headers_out.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class IngestEndpointHeadersOut
+    attr_accessor :headers
+    attr_accessor :sensitive
+
+    ALL_FIELD ||= ["headers", "sensitive"].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::IngestEndpointHeadersOut` 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::IngestEndpointHeadersOut")
+        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["headers"] = attributes["headers"]
+      attrs["sensitive"] = attributes["sensitive"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["headers"] = Svix::serialize_primitive(@headers) if @headers
+      out["sensitive"] = Svix::serialize_primitive(@sensitive) if @sensitive
+      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_endpoint_in.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class IngestEndpointIn
+    attr_accessor :description
+    attr_accessor :disabled
+    attr_accessor :metadata
+    attr_accessor :rate_limit
+    attr_accessor :secret
+    attr_accessor :uid
+    attr_accessor :url
+
+    ALL_FIELD ||= ["description", "disabled", "metadata", "rate_limit", "secret", "uid", "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 `Svix::IngestEndpointIn` 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::IngestEndpointIn")
+        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["disabled"] = attributes["disabled"]
+      attrs["metadata"] = attributes["metadata"]
+      attrs["rate_limit"] = attributes["rateLimit"]
+      attrs["secret"] = attributes["secret"]
+      attrs["uid"] = attributes["uid"]
+      attrs["url"] = attributes["url"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["description"] = Svix::serialize_primitive(@description) if @description
+      out["disabled"] = Svix::serialize_primitive(@disabled) if @disabled
+      out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
+      out["rateLimit"] = Svix::serialize_primitive(@rate_limit) if @rate_limit
+      out["secret"] = Svix::serialize_primitive(@secret) if @secret
+      out["uid"] = Svix::serialize_primitive(@uid) if @uid
+      out["url"] = Svix::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/svix/models/ingest_endpoint_out.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class IngestEndpointOut
+    attr_accessor :created_at
+    attr_accessor :description
+    attr_accessor :disabled
+    attr_accessor :id
+    attr_accessor :metadata
+    attr_accessor :rate_limit
+    attr_accessor :uid
+    attr_accessor :updated_at
+    attr_accessor :url
+
+    ALL_FIELD ||= ["created_at", "description", "disabled", "id", "metadata", "rate_limit", "uid", "updated_at", "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 `Svix::IngestEndpointOut` 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::IngestEndpointOut")
+        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["description"] = attributes["description"]
+      attrs["disabled"] = attributes["disabled"]
+      attrs["id"] = attributes["id"]
+      attrs["metadata"] = attributes["metadata"]
+      attrs["rate_limit"] = attributes["rateLimit"]
+      attrs["uid"] = attributes["uid"]
+      attrs["updated_at"] = DateTime.rfc3339(attributes["updatedAt"]).to_time
+      attrs["url"] = attributes["url"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["createdAt"] = Svix::serialize_primitive(@created_at) if @created_at
+      out["description"] = Svix::serialize_primitive(@description) if @description
+      out["disabled"] = Svix::serialize_primitive(@disabled) if @disabled
+      out["id"] = Svix::serialize_primitive(@id) if @id
+      out["metadata"] = Svix::serialize_primitive(@metadata) if @metadata
+      out["rateLimit"] = Svix::serialize_primitive(@rate_limit) if @rate_limit
+      out["uid"] = Svix::serialize_primitive(@uid) if @uid
+      out["updatedAt"] = Svix::serialize_primitive(@updated_at) if @updated_at
+      out["url"] = Svix::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/svix/models/ingest_endpoint_secret_in.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class IngestEndpointSecretIn
+    attr_accessor :key
+
+    ALL_FIELD ||= ["key"].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::IngestEndpointSecretIn` 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::IngestEndpointSecretIn")
+        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["key"] = attributes["key"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["key"] = Svix::serialize_primitive(@key) if @key
+      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_endpoint_secret_out.rb

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