telnyx 5.103.0 → 5.103.1

data/rbi/telnyx/models/ai/assistants/clause.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      module Assistants
+        class Clause < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(Telnyx::AI::Assistants::Clause, Telnyx::Internal::AnyHash)
+            end
+
+          # Attribute name from the routing context
+          sig { returns(String) }
+          attr_accessor :attribute
+
+          # Match operator
+          sig { returns(Telnyx::AI::Assistants::Clause::Operator::OrSymbol) }
+          attr_accessor :operator
+
+          sig { returns(T::Array[String]) }
+          attr_accessor :values
+
+          # A single attribute/operator/values check.
+          #
+          # A clause matches when the routing context's value for `attribute` satisfies
+          # `operator` against any of `values`.
+          sig do
+            params(
+              attribute: String,
+              operator: Telnyx::AI::Assistants::Clause::Operator::OrSymbol,
+              values: T::Array[String]
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Attribute name from the routing context
+            attribute:,
+            # Match operator
+            operator:,
+            values:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                attribute: String,
+                operator: Telnyx::AI::Assistants::Clause::Operator::OrSymbol,
+                values: T::Array[String]
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Match operator
+          module Operator
+            extend Telnyx::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, Telnyx::AI::Assistants::Clause::Operator)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            IN =
+              T.let(:in, Telnyx::AI::Assistants::Clause::Operator::TaggedSymbol)
+            NOT_IN =
+              T.let(
+                :not_in,
+                Telnyx::AI::Assistants::Clause::Operator::TaggedSymbol
+              )
+            STARTS_WITH =
+              T.let(
+                :starts_with,
+                Telnyx::AI::Assistants::Clause::Operator::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[Telnyx::AI::Assistants::Clause::Operator::TaggedSymbol]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/assistants/rollout_slot.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      module Assistants
+        class RolloutSlot < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::AI::Assistants::RolloutSlot,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :version_id
+
+          sig { returns(Float) }
+          attr_accessor :weight
+
+          # One slot in a percentage rollout.
+          sig do
+            params(version_id: String, weight: Float).returns(T.attached_class)
+          end
+          def self.new(version_id:, weight:)
+          end
+
+          sig { override.returns({ version_id: String, weight: Float }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/assistants/rule_input.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      module Assistants
+        class RuleInput < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::AI::Assistants::RuleInput,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # What a rule serves when matched.
+          #
+          # Exactly one of:
+          #
+          # - `version_id` — serve a specific version
+          # - `rollout` — weighted random across versions; weights must sum to less than
+          #   100, with the leftover routing to the main version
+          sig { returns(Telnyx::AI::Assistants::Serve) }
+          attr_reader :serve
+
+          sig { params(serve: Telnyx::AI::Assistants::Serve::OrHash).void }
+          attr_writer :serve
+
+          sig { returns(T.nilable(T::Array[Telnyx::AI::Assistants::Clause])) }
+          attr_reader :match
+
+          sig do
+            params(match: T::Array[Telnyx::AI::Assistants::Clause::OrHash]).void
+          end
+          attr_writer :match
+
+          # A targeting rule: `match` clauses (AND) gate `serve`.
+          #
+          # An empty `match` is a catch-all (always fires).
+          sig do
+            params(
+              serve: Telnyx::AI::Assistants::Serve::OrHash,
+              match: T::Array[Telnyx::AI::Assistants::Clause::OrHash]
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # What a rule serves when matched.
+            #
+            # Exactly one of:
+            #
+            # - `version_id` — serve a specific version
+            # - `rollout` — weighted random across versions; weights must sum to less than
+            #   100, with the leftover routing to the main version
+            serve:,
+            match: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                serve: Telnyx::AI::Assistants::Serve,
+                match: T::Array[Telnyx::AI::Assistants::Clause]
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/assistants/rule_output.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      module Assistants
+        class RuleOutput < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::AI::Assistants::RuleOutput,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # What a rule serves when matched.
+          #
+          # Exactly one of:
+          #
+          # - `version_id` — serve a specific version
+          # - `rollout` — weighted random across versions; weights must sum to less than
+          #   100, with the leftover routing to the main version
+          sig { returns(Telnyx::AI::Assistants::Serve) }
+          attr_reader :serve
+
+          sig { params(serve: Telnyx::AI::Assistants::Serve::OrHash).void }
+          attr_writer :serve
+
+          sig { returns(T.nilable(T::Array[Telnyx::AI::Assistants::Clause])) }
+          attr_reader :match
+
+          sig do
+            params(match: T::Array[Telnyx::AI::Assistants::Clause::OrHash]).void
+          end
+          attr_writer :match
+
+          # A targeting rule: `match` clauses (AND) gate `serve`.
+          #
+          # An empty `match` is a catch-all (always fires).
+          sig do
+            params(
+              serve: Telnyx::AI::Assistants::Serve::OrHash,
+              match: T::Array[Telnyx::AI::Assistants::Clause::OrHash]
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # What a rule serves when matched.
+            #
+            # Exactly one of:
+            #
+            # - `version_id` — serve a specific version
+            # - `rollout` — weighted random across versions; weights must sum to less than
+            #   100, with the leftover routing to the main version
+            serve:,
+            match: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                serve: Telnyx::AI::Assistants::Serve,
+                match: T::Array[Telnyx::AI::Assistants::Clause]
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/assistants/serve.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      module Assistants
+        class Serve < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(Telnyx::AI::Assistants::Serve, Telnyx::Internal::AnyHash)
+            end
+
+          sig do
+            returns(T.nilable(T::Array[Telnyx::AI::Assistants::RolloutSlot]))
+          end
+          attr_reader :rollout
+
+          sig do
+            params(
+              rollout: T::Array[Telnyx::AI::Assistants::RolloutSlot::OrHash]
+            ).void
+          end
+          attr_writer :rollout
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :version_id
+
+          sig { params(version_id: String).void }
+          attr_writer :version_id
+
+          # What a rule serves when matched.
+          #
+          # Exactly one of:
+          #
+          # - `version_id` — serve a specific version
+          # - `rollout` — weighted random across versions; weights must sum to less than
+          #   100, with the leftover routing to the main version
+          sig do
+            params(
+              rollout: T::Array[Telnyx::AI::Assistants::RolloutSlot::OrHash],
+              version_id: String
+            ).returns(T.attached_class)
+          end
+          def self.new(rollout: nil, version_id: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                rollout: T::Array[Telnyx::AI::Assistants::RolloutSlot],
+                version_id: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end