svix 1.60.1 → 1.61.0

data/lib/svix/api/integration.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class Integration
+    def initialize(client)
+      @client = client
+    end
+
+    def list(app_id, options = {})
+      options = options.transform_keys(&:to_s)
+      path = "/api/v1/app/#{app_id}/integration"
+      res = @client.execute_request(
+        "GET",
+        path,
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "order" => options["order"]
+        }
+      )
+      ListResponseIntegrationOut.deserialize(res)
+    end
+
+    def create(app_id, integration_in, options = {})
+      options = options.transform_keys(&:to_s)
+      path = "/api/v1/app/#{app_id}/integration"
+      res = @client.execute_request(
+        "POST",
+        path,
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: integration_in
+      )
+      IntegrationOut.deserialize(res)
+    end
+
+    def get(app_id, integ_id)
+      path = "/api/v1/app/#{app_id}/integration/#{integ_id}"
+      res = @client.execute_request(
+        "GET",
+        path
+      )
+      IntegrationOut.deserialize(res)
+    end
+
+    def update(app_id, integ_id, integration_update)
+      path = "/api/v1/app/#{app_id}/integration/#{integ_id}"
+      res = @client.execute_request(
+        "PUT",
+        path,
+        body: integration_update
+      )
+      IntegrationOut.deserialize(res)
+    end
+
+    def delete(app_id, integ_id)
+      path = "/api/v1/app/#{app_id}/integration/#{integ_id}"
+      @client.execute_request(
+        "DELETE",
+        path
+      )
+    end
+
+    def get_key(app_id, integ_id)
+      path = "/api/v1/app/#{app_id}/integration/#{integ_id}/key"
+      res = @client.execute_request(
+        "GET",
+        path
+      )
+      IntegrationKeyOut.deserialize(res)
+    end
+
+    def rotate_key(app_id, integ_id, options = {})
+      options = options.transform_keys(&:to_s)
+      path = "/api/v1/app/#{app_id}/integration/#{integ_id}/key/rotate"
+      res = @client.execute_request(
+        "POST",
+        path,
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        }
+      )
+      IntegrationKeyOut.deserialize(res)
+    end
+
+  end
+end

data/lib/svix/api/message.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  module_function
+  # Creates a [`MessageIn`] with a raw string payload.
+  #
+  # The payload is not normalized on the server. Normally, payloads are required
+  # to be JSON, and Svix will minify the payload before sending the webhook
+  # (for example, by removing extraneous whitespace or unnecessarily escaped
+  # characters in strings). With this function, the payload will be sent
+  # "as is", without any minification or other processing.
+  #
+  # `attributes[:payload]` must be a string. An extra attribute `content_type`
+  # is accepted that sets the `content-type` header of the webhook sent by Svix,
+  # overwriting the default of `application/json` if specified. Other than that,
+  # the attributes are forwarded [`MessageIn.new`], so all the same ones are
+  # accepted.
+  def message_in_raw(attributes = {})
+    attributes[:transformations_params] ||= {}
+    attributes[:transformations_params][:rawPayload] = attributes[:payload]
+    attributes[:payload] = {}
+
+    content_type = attributes.delete(:content_type)
+    if content_type != nil
+      attributes[:transformations_params][:headers] ||= {}
+      attributes[:transformations_params][:headers][:"content-type"] = content_type
+    end
+
+    MessageIn.new(attributes)
+  end
+
+  class Message
+    def initialize(client)
+      @client = client
+    end
+
+    def list(app_id, options = {})
+      options = options.transform_keys(&:to_s)
+      path = "/api/v1/app/#{app_id}/msg"
+      res = @client.execute_request(
+        "GET",
+        path,
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "channel" => options["channel"],
+          "before" => options["before"],
+          "after" => options["after"],
+          "with_content" => options["with_content"],
+          "tag" => options["tag"],
+          "event_types" => options["event_types"]
+        }
+      )
+      ListResponseMessageOut.deserialize(res)
+    end
+
+    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,
+        query_params: {
+          "with_content" => options["with_content"]
+        },
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: message_in
+      )
+      MessageOut.deserialize(res)
+    end
+
+    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,
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        }
+      )
+      ExpungAllContentsOut.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,
+        query_params: {
+          "with_content" => options["with_content"]
+        }
+      )
+      MessageOut.deserialize(res)
+    end
+
+    def expunge_content(app_id, msg_id)
+      path = "/api/v1/app/#{app_id}/msg/#{msg_id}/content"
+      @client.execute_request(
+        "DELETE",
+        path
+      )
+    end
+
+  end
+end

data/lib/svix/api/message_attempt.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class MessageAttempt
+    def initialize(client)
+      @client = client
+    end
+
+    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,
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "status" => options["status"],
+          "status_code_class" => options["status_code_class"],
+          "channel" => options["channel"],
+          "tag" => options["tag"],
+          "before" => options["before"],
+          "after" => options["after"],
+          "with_content" => options["with_content"],
+          "with_msg" => options["with_msg"],
+          "event_types" => options["event_types"]
+        }
+      )
+      ListResponseMessageAttemptOut.deserialize(res)
+    end
+
+    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,
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "status" => options["status"],
+          "status_code_class" => options["status_code_class"],
+          "channel" => options["channel"],
+          "tag" => options["tag"],
+          "endpoint_id" => options["endpoint_id"],
+          "before" => options["before"],
+          "after" => options["after"],
+          "with_content" => options["with_content"],
+          "event_types" => options["event_types"]
+        }
+      )
+      ListResponseMessageAttemptOut.deserialize(res)
+    end
+
+    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,
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "channel" => options["channel"],
+          "tag" => options["tag"],
+          "status" => options["status"],
+          "before" => options["before"],
+          "after" => options["after"],
+          "with_content" => options["with_content"],
+          "event_types" => options["event_types"]
+        }
+      )
+      ListResponseEndpointMessageOut.deserialize(res)
+    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
+      )
+      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
+      )
+    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,
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"]
+        }
+      )
+      ListResponseMessageEndpointOut.deserialize(res)
+    end
+
+    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,
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        }
+      )
+    end
+
+  end
+end

data/lib/svix/api/operational_webhook_endpoint.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class OperationalWebhookEndpoint
+    def initialize(client)
+      @client = client
+    end
+
+    def list(options = {})
+      options = options.transform_keys(&:to_s)
+      path = "/api/v1/operational-webhook/endpoint"
+      res = @client.execute_request(
+        "GET",
+        path,
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "order" => options["order"]
+        }
+      )
+      ListResponseOperationalWebhookEndpointOut.deserialize(res)
+    end
+
+    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,
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: operational_webhook_endpoint_in
+      )
+      OperationalWebhookEndpointOut.deserialize(res)
+    end
+
+    def get(endpoint_id)
+      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}"
+      res = @client.execute_request(
+        "GET",
+        path
+      )
+      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,
+        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
+      )
+    end
+
+    def get_headers(endpoint_id)
+      path = "/api/v1/operational-webhook/endpoint/#{endpoint_id}/headers"
+      res = @client.execute_request(
+        "GET",
+        path
+      )
+      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,
+        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
+      )
+      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,
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: operational_webhook_endpoint_secret_in
+      )
+    end
+
+  end
+end

data/lib/svix/api/statistics.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class Statistics
+    def initialize(client)
+      @client = client
+    end
+
+    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,
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: app_usage_stats_in
+      )
+      AppUsageStatsOut.deserialize(res)
+    end
+
+    def aggregate_event_types
+      path = "/api/v1/stats/usage/event-types"
+      res = @client.execute_request(
+        "PUT",
+        path
+      )
+      AggregateEventTypesOut.deserialize(res)
+    end
+
+  end
+end

data/lib/svix/api_error.rb

@@ -1,14 +1,4 @@
-=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
-Generator version: 7.9.0
-
-=end
+# frozen_string_literal: true
 
 module Svix
   class ApiError < StandardError
@@ -20,18 +10,18 @@ module Svix
     #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
     #   ApiError.new(:code => 404, :message => "Not Found")
     def initialize(arg = nil)
-      if arg.is_a? Hash
-        if arg.key?(:message) || arg.key?('message')
-          super(arg[:message] || arg['message'])
+      if arg.is_a?(Hash)
+        if arg.key?(:message) || arg.key?("message")
+          super(arg[:message] || arg["message"])
         else
-          super arg
+          super(arg)
         end
 
         arg.each do |k, v|
-          instance_variable_set "@#{k}", v
+          instance_variable_set("@#{k}", v)
         end
       else
-        super arg
+        super(arg)
         @message = arg
       end
     end

data/lib/svix/errors.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
 module Svix
-    class SvixError < StandardError
-        attr_reader :message
+  class SvixError < StandardError
+    attr_reader :message
 
-        def initialize(message = nil)
-            @message = message
-        end
+    def initialize(message = nil)
+      @message = message
     end
+  end
 
-    class WebhookVerificationError < SvixError
-    end
+  class WebhookVerificationError < SvixError
+  end
 
-    class WebhookSigningError < SvixError
-    end
+  class WebhookSigningError < SvixError
+  end
 end

data/lib/svix/http_error_out.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Svix
+  class HttpErrorOut
+    attr_accessor :code
+
+    attr_accessor :detail
+
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `Svix::HttpErrorOut` initialize method")
+      end
+
+      @detail = attributes[:"detail"]
+      @code = attributes[:"code"]
+    end
+  end
+end

data/lib/svix/http_validation_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Svix
+  class HTTPValidationError
+    attr_accessor :detail
+
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::HTTPValidationError` initialize method"
+        )
+      end
+
+      @detail = attributes[:"detail"]
+    end
+  end
+end

data/lib/svix/internal.rb

@@ -1,15 +1,6 @@
 # frozen_string_literal: true
 
 module Svix
-  private_constant :ApiClient
-  private_constant :Configuration
-  private_constant :ApplicationApi
-  private_constant :AuthenticationApi
-  private_constant :EndpointApi
-  private_constant :HealthApi
-  private_constant :IntegrationApi
-  private_constant :MessageApi
-  private_constant :MessageAttemptApi
   private_constant :HttpErrorOut
   private_constant :HTTPValidationError
   private_constant :ValidationError