svix 1.76.0 → 1.77.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0148235317e7356b99e74d270759d177187c07caec50d24926305a962bd79c07'
-  data.tar.gz: 2346aebcc478937f00381a582662f142d87b8dbdb622dd644e15dc3ac29d7b6c
+  metadata.gz: 3eb66c82478ac852d11fe4b73805133befe9cfa6e0acbbf9e255cbc275c0047d
+  data.tar.gz: 866bf7e77e58dbb76d5df21afe1b756053f4014bba46c6c44cb0efa4581158bd
 SHA512:
-  metadata.gz: c6c2a7e37c92e75a3346ef8eb029af6bfdb293d78c1f7f7d6ed5c6360b93d10044530545a7abc1bf153b680cde1817699538fa8d62c7f10b8cde8748878e1902
-  data.tar.gz: 4e1c52373d1926792c6c1356bcd209bf29c97b85cf5c22addfddc0e951838e29740c7859ab048299597fce9bd446288e2192b3b9a51cf2256f0c187d01f75371
+  metadata.gz: 33faa28d934642209dc906cc37e1785f2b9384c88230019d4860b07e6a799798780faa58bc30c5fe685437be24f5d51dca136030ca18628e58136556c805f198
+  data.tar.gz: 1907d71eb96a046bfe7a6a0bc3908c6a13551229fe29321d152a8e0f65b308f5048e4fb227e4c1d61f914d280f44a1d2e803b9cf53b1202ff117130506310c3f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    svix (1.76.0)
+    svix (1.77.0)
 
 GEM
   remote: https://rubygems.org/
@@ -19,7 +19,7 @@ GEM
     ostruct (0.6.1)
     public_suffix (6.0.1)
     rake (13.2.1)
-    rexml (3.4.1)
+    rexml (3.4.2)
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)

data/lib/svix/api/authentication.rb

@@ -57,5 +57,39 @@ module Svix
       )
     end
 
+    def stream_portal_access(stream_id, stream_portal_access_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/api/v1/auth/stream-portal-access/#{stream_id}",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: stream_portal_access_in
+      )
+      AppPortalAccessOut.deserialize(res)
+    end
+
+    def get_stream_poller_token(stream_id, sink_id)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/auth/stream/#{stream_id}/sink/#{sink_id}/poller/token"
+      )
+      ApiTokenOut.deserialize(res)
+    end
+
+    def rotate_stream_poller_token(stream_id, sink_id, rotate_poller_token_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/api/v1/auth/stream/#{stream_id}/sink/#{sink_id}/poller/token/rotate",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: rotate_poller_token_in
+      )
+      ApiTokenOut.deserialize(res)
+    end
+
   end
 end

data/lib/svix/api/streaming.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class Streaming
+    attr_accessor :event_type
+    attr_accessor :events
+    attr_accessor :sink
+    attr_accessor :stream
+    def initialize(client)
+      @client = client
+      @event_type = StreamingEventType.new(client)
+      @events = StreamingEvents.new(client)
+      @sink = StreamingSink.new(client)
+      @stream = StreamingStream.new(client)
+    end
+
+    def sink_headers_get(stream_id, sink_id)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}/headers"
+      )
+      EndpointHeadersOut.deserialize(res)
+    end
+
+    def sink_headers_patch(stream_id, sink_id, http_sink_headers_patch_in)
+      res = @client.execute_request(
+        "PATCH",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}/headers",
+        body: http_sink_headers_patch_in
+      )
+      EndpointHeadersOut.deserialize(res)
+    end
+
+    def sink_transformation_get(stream_id, sink_id)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}/transformation"
+      )
+      SinkTransformationOut.deserialize(res)
+    end
+
+  end
+end

data/lib/svix/api/streaming_event_type.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class StreamingEventType
+    def initialize(client)
+      @client = client
+    end
+
+    def list(options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/event-type",
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "order" => options["order"],
+          "include_archived" => options["include_archived"]
+        }
+      )
+      ListResponseStreamEventTypeOut.deserialize(res)
+    end
+
+    def create(stream_event_type_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/api/v1/stream/event-type",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: stream_event_type_in
+      )
+      StreamEventTypeOut.deserialize(res)
+    end
+
+    def get(name)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/event-type/#{name}"
+      )
+      StreamEventTypeOut.deserialize(res)
+    end
+
+    def update(name, stream_event_type_in)
+      res = @client.execute_request(
+        "PUT",
+        "/api/v1/stream/event-type/#{name}",
+        body: stream_event_type_in
+      )
+      StreamEventTypeOut.deserialize(res)
+    end
+
+    def delete(name, options = {})
+      options = options.transform_keys(&:to_s)
+      @client.execute_request(
+        "DELETE",
+        "/api/v1/stream/event-type/#{name}",
+        query_params: {
+          "expunge" => options["expunge"]
+        }
+      )
+    end
+
+    def patch(name, stream_event_type_patch)
+      res = @client.execute_request(
+        "PATCH",
+        "/api/v1/stream/event-type/#{name}",
+        body: stream_event_type_patch
+      )
+      StreamEventTypeOut.deserialize(res)
+    end
+
+  end
+end

data/lib/svix/api/streaming_events.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class StreamingEvents
+    def initialize(client)
+      @client = client
+    end
+
+    def create(stream_id, create_stream_events_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/api/v1/stream/#{stream_id}/events",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: create_stream_events_in
+      )
+      CreateStreamEventsOut.deserialize(res)
+    end
+
+    def get(stream_id, sink_id, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}/events",
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "after" => options["after"]
+        }
+      )
+      EventStreamOut.deserialize(res)
+    end
+
+  end
+end

data/lib/svix/api/streaming_sink.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class StreamingSink
+    def initialize(client)
+      @client = client
+    end
+
+    def list(stream_id, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/#{stream_id}/sink",
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "order" => options["order"]
+        }
+      )
+      ListResponseStreamSinkOut.deserialize(res)
+    end
+
+    def create(stream_id, stream_sink_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/api/v1/stream/#{stream_id}/sink",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: stream_sink_in
+      )
+      StreamSinkOut.deserialize(res)
+    end
+
+    def get(stream_id, sink_id)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}"
+      )
+      StreamSinkOut.deserialize(res)
+    end
+
+    def update(stream_id, sink_id, stream_sink_in)
+      res = @client.execute_request(
+        "PUT",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}",
+        body: stream_sink_in
+      )
+      StreamSinkOut.deserialize(res)
+    end
+
+    def delete(stream_id, sink_id)
+      @client.execute_request(
+        "DELETE",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}"
+      )
+    end
+
+    def patch(stream_id, sink_id, stream_sink_patch)
+      res = @client.execute_request(
+        "PATCH",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}",
+        body: stream_sink_patch
+      )
+      StreamSinkOut.deserialize(res)
+    end
+
+    def get_secret(stream_id, sink_id)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}/secret"
+      )
+      SinkSecretOut.deserialize(res)
+    end
+
+    def rotate_secret(stream_id, sink_id, endpoint_secret_rotate_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}/secret/rotate",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: endpoint_secret_rotate_in
+      )
+      EmptyResponse.deserialize(res)
+    end
+
+    def transformation_partial_update(stream_id, sink_id, sink_transform_in)
+      res = @client.execute_request(
+        "PATCH",
+        "/api/v1/stream/#{stream_id}/sink/#{sink_id}/transformation",
+        body: sink_transform_in
+      )
+      EmptyResponse.deserialize(res)
+    end
+
+  end
+end

data/lib/svix/api/streaming_stream.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# This file is @generated
+
+require "net/http"
+
+module Svix
+  class StreamingStream
+    def initialize(client)
+      @client = client
+    end
+
+    def list(options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream",
+        query_params: {
+          "limit" => options["limit"],
+          "iterator" => options["iterator"],
+          "order" => options["order"]
+        }
+      )
+      ListResponseStreamOut.deserialize(res)
+    end
+
+    def create(stream_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/api/v1/stream",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: stream_in
+      )
+      StreamOut.deserialize(res)
+    end
+
+    def get(stream_id)
+      res = @client.execute_request(
+        "GET",
+        "/api/v1/stream/#{stream_id}"
+      )
+      StreamOut.deserialize(res)
+    end
+
+    def update(stream_id, stream_in)
+      res = @client.execute_request(
+        "PUT",
+        "/api/v1/stream/#{stream_id}",
+        body: stream_in
+      )
+      StreamOut.deserialize(res)
+    end
+
+    def delete(stream_id)
+      @client.execute_request(
+        "DELETE",
+        "/api/v1/stream/#{stream_id}"
+      )
+    end
+
+    def patch(stream_id, stream_patch)
+      res = @client.execute_request(
+        "PATCH",
+        "/api/v1/stream/#{stream_id}",
+        body: stream_patch
+      )
+      StreamOut.deserialize(res)
+    end
+
+  end
+end

data/lib/svix/models/amazon_s3_patch_config.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class AmazonS3PatchConfig
+    attr_accessor :access_key_id
+    attr_accessor :bucket
+    attr_accessor :region
+    attr_accessor :secret_access_key
+
+    ALL_FIELD ||= ["access_key_id", "bucket", "region", "secret_access_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::AmazonS3PatchConfig` 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::AmazonS3PatchConfig")
+        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["access_key_id"] = attributes["accessKeyId"]
+      attrs["bucket"] = attributes["bucket"]
+      attrs["region"] = attributes["region"]
+      attrs["secret_access_key"] = attributes["secretAccessKey"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["accessKeyId"] = Svix::serialize_primitive(@access_key_id) if @access_key_id
+      out["bucket"] = Svix::serialize_primitive(@bucket) if @bucket
+      out["region"] = Svix::serialize_primitive(@region) if @region
+      out["secretAccessKey"] = Svix::serialize_primitive(@secret_access_key) if @secret_access_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/api_token_out.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module Svix
+  class ApiTokenOut
+    attr_accessor :created_at
+    attr_accessor :expires_at
+    # The GlobalApplicationToken's ID.
+    attr_accessor :id
+    attr_accessor :name
+    attr_accessor :scopes
+    attr_accessor :token
+
+    ALL_FIELD ||= ["created_at", "expires_at", "id", "name", "scopes", "token"].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::ApiTokenOut` 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::ApiTokenOut")
+        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["expires_at"] = DateTime.rfc3339(attributes["expiresAt"]).to_time if attributes["expiresAt"]
+      attrs["id"] = attributes["id"]
+      attrs["name"] = attributes["name"]
+      attrs["scopes"] = attributes["scopes"]
+      attrs["token"] = attributes["token"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["createdAt"] = Svix::serialize_primitive(@created_at) if @created_at
+      out["expiresAt"] = Svix::serialize_primitive(@expires_at) if @expires_at
+      out["id"] = Svix::serialize_primitive(@id) if @id
+      out["name"] = Svix::serialize_primitive(@name) if @name
+      out["scopes"] = Svix::serialize_primitive(@scopes) if @scopes
+      out["token"] = Svix::serialize_primitive(@token) if @token
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/svix/models/azure_blob_storage_config.rb

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

data/lib/svix/models/azure_blob_storage_patch_config.rb

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

data/lib/svix/models/connector_in.rb

@@ -5,12 +5,9 @@ require "json"
 module Svix
   class ConnectorIn
     attr_accessor :description
-    # Deprecated - prefer featureFlags instead.
-    attr_accessor :feature_flag
     attr_accessor :feature_flags
     attr_accessor :filter_types
     attr_accessor :instructions
-    attr_accessor :instructions_link
     attr_accessor :kind
     attr_accessor :logo
     attr_accessor :name
@@ -18,11 +15,9 @@ module Svix
 
     ALL_FIELD ||= [
       "description",
-      "feature_flag",
       "feature_flags",
       "filter_types",
       "instructions",
-      "instructions_link",
       "kind",
       "logo",
       "name",
@@ -49,11 +44,9 @@ module Svix
       attributes = attributes.transform_keys(&:to_s)
       attrs = Hash.new
       attrs["description"] = attributes["description"]
-      attrs["feature_flag"] = attributes["featureFlag"]
       attrs["feature_flags"] = attributes["featureFlags"]
       attrs["filter_types"] = attributes["filterTypes"]
       attrs["instructions"] = attributes["instructions"]
-      attrs["instructions_link"] = attributes["instructionsLink"]
       attrs["kind"] = Svix::ConnectorKind.deserialize(attributes["kind"]) if attributes["kind"]
       attrs["logo"] = attributes["logo"]
       attrs["name"] = attributes["name"]
@@ -64,11 +57,9 @@ module Svix
     def serialize
       out = Hash.new
       out["description"] = Svix::serialize_primitive(@description) if @description
-      out["featureFlag"] = Svix::serialize_primitive(@feature_flag) if @feature_flag
       out["featureFlags"] = Svix::serialize_primitive(@feature_flags) if @feature_flags
       out["filterTypes"] = Svix::serialize_primitive(@filter_types) if @filter_types
       out["instructions"] = Svix::serialize_primitive(@instructions) if @instructions
-      out["instructionsLink"] = Svix::serialize_primitive(@instructions_link) if @instructions_link
       out["kind"] = Svix::serialize_schema_ref(@kind) if @kind
       out["logo"] = Svix::serialize_primitive(@logo) if @logo
       out["name"] = Svix::serialize_primitive(@name) if @name