knockapi 0.6.1 → 1.0.0

data/rbi/knockapi/models/schedule_create_params.rbi

@@ -0,0 +1,98 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class ScheduleCreateParams < Knockapi::Internal::Type::BaseModel
+      extend Knockapi::Internal::Type::RequestParameters::Converter
+      include Knockapi::Internal::Type::RequestParameters
+
+      # The recipients to trigger the workflow for. Can inline identify users, objects,
+      # or use a list of user IDs. Limited to 1,000 recipients.
+      sig do
+        returns(
+          T::Array[T.any(String, Knockapi::Models::InlineIdentifyUserRequest, Knockapi::Models::InlineObjectRequest)]
+        )
+      end
+      attr_accessor :recipients
+
+      # The repeat rule for the schedule.
+      sig { returns(T::Array[Knockapi::Models::ScheduleRepeatRule]) }
+      attr_accessor :repeats
+
+      # The key of the workflow.
+      sig { returns(String) }
+      attr_accessor :workflow
+
+      # An optional map of data to pass into the workflow execution.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :data
+
+      # The ending date and time for the schedule.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :ending_at
+
+      # The starting date and time for the schedule.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :scheduled_at
+
+      # An request to set a tenant inline.
+      sig { returns(T.nilable(T.any(String, Knockapi::Models::TenantRequest))) }
+      attr_accessor :tenant
+
+      sig do
+        params(
+          recipients: T::Array[
+            T.any(
+              String,
+              Knockapi::Models::InlineIdentifyUserRequest,
+              Knockapi::Internal::AnyHash,
+              Knockapi::Models::InlineObjectRequest
+            )
+          ],
+          repeats: T::Array[T.any(Knockapi::Models::ScheduleRepeatRule, Knockapi::Internal::AnyHash)],
+          workflow: String,
+          data: T.nilable(T::Hash[Symbol, T.anything]),
+          ending_at: T.nilable(Time),
+          scheduled_at: T.nilable(Time),
+          tenant: T.nilable(T.any(String, Knockapi::Models::TenantRequest, Knockapi::Internal::AnyHash)),
+          request_options: T.any(Knockapi::RequestOptions, Knockapi::Internal::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The recipients to trigger the workflow for. Can inline identify users, objects,
+        # or use a list of user IDs. Limited to 1,000 recipients.
+        recipients:,
+        # The repeat rule for the schedule.
+        repeats:,
+        # The key of the workflow.
+        workflow:,
+        # An optional map of data to pass into the workflow execution.
+        data: nil,
+        # The ending date and time for the schedule.
+        ending_at: nil,
+        # The starting date and time for the schedule.
+        scheduled_at: nil,
+        # An request to set a tenant inline.
+        tenant: nil,
+        request_options: {}
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              recipients: T::Array[T.any(String, Knockapi::Models::InlineIdentifyUserRequest, Knockapi::Models::InlineObjectRequest)],
+              repeats: T::Array[Knockapi::Models::ScheduleRepeatRule],
+              workflow: String,
+              data: T.nilable(T::Hash[Symbol, T.anything]),
+              ending_at: T.nilable(Time),
+              scheduled_at: T.nilable(Time),
+              tenant: T.nilable(T.any(String, Knockapi::Models::TenantRequest)),
+              request_options: Knockapi::RequestOptions
+            }
+          )
+      end
+      def to_hash; end
+    end
+  end
+end

data/rbi/knockapi/models/schedule_create_response.rbi

@@ -0,0 +1,8 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    ScheduleCreateResponse =
+      T.let(Knockapi::Internal::Type::ArrayOf[Knockapi::Models::Schedule], Knockapi::Internal::Type::Converter)
+  end
+end

data/rbi/knockapi/models/schedule_delete_params.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class ScheduleDeleteParams < Knockapi::Internal::Type::BaseModel
+      extend Knockapi::Internal::Type::RequestParameters::Converter
+      include Knockapi::Internal::Type::RequestParameters
+
+      # A list of schedule IDs.
+      sig { returns(T::Array[String]) }
+      attr_accessor :schedule_ids
+
+      sig do
+        params(
+          schedule_ids: T::Array[String],
+          request_options: T.any(Knockapi::RequestOptions, Knockapi::Internal::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # A list of schedule IDs.
+        schedule_ids:,
+        request_options: {}
+      ); end
+      sig { override.returns({schedule_ids: T::Array[String], request_options: Knockapi::RequestOptions}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/knockapi/models/schedule_delete_response.rbi

@@ -0,0 +1,8 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    ScheduleDeleteResponse =
+      T.let(Knockapi::Internal::Type::ArrayOf[Knockapi::Models::Schedule], Knockapi::Internal::Type::Converter)
+  end
+end

data/rbi/knockapi/models/schedule_list_params.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class ScheduleListParams < Knockapi::Internal::Type::BaseModel
+      extend Knockapi::Internal::Type::RequestParameters::Converter
+      include Knockapi::Internal::Type::RequestParameters
+
+      # Filter by workflow key.
+      sig { returns(String) }
+      attr_accessor :workflow
+
+      # The cursor to fetch entries after.
+      sig { returns(T.nilable(String)) }
+      attr_reader :after
+
+      sig { params(after: String).void }
+      attr_writer :after
+
+      # The cursor to fetch entries before.
+      sig { returns(T.nilable(String)) }
+      attr_reader :before
+
+      sig { params(before: String).void }
+      attr_writer :before
+
+      # The number of items per page.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :page_size
+
+      sig { params(page_size: Integer).void }
+      attr_writer :page_size
+
+      # Filter by recipient IDs.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :recipients
+
+      sig { params(recipients: T::Array[String]).void }
+      attr_writer :recipients
+
+      # Filter by tenant ID.
+      sig { returns(T.nilable(String)) }
+      attr_reader :tenant
+
+      sig { params(tenant: String).void }
+      attr_writer :tenant
+
+      sig do
+        params(
+          workflow: String,
+          after: String,
+          before: String,
+          page_size: Integer,
+          recipients: T::Array[String],
+          tenant: String,
+          request_options: T.any(Knockapi::RequestOptions, Knockapi::Internal::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # Filter by workflow key.
+        workflow:,
+        # The cursor to fetch entries after.
+        after: nil,
+        # The cursor to fetch entries before.
+        before: nil,
+        # The number of items per page.
+        page_size: nil,
+        # Filter by recipient IDs.
+        recipients: nil,
+        # Filter by tenant ID.
+        tenant: nil,
+        request_options: {}
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              workflow: String,
+              after: String,
+              before: String,
+              page_size: Integer,
+              recipients: T::Array[String],
+              tenant: String,
+              request_options: Knockapi::RequestOptions
+            }
+          )
+      end
+      def to_hash; end
+    end
+  end
+end

data/rbi/knockapi/models/schedule_repeat_rule.rbi

@@ -0,0 +1,118 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class ScheduleRepeatRule < Knockapi::Internal::Type::BaseModel
+      # The typename of the schema.
+      sig { returns(String) }
+      attr_accessor :_typename
+
+      # The frequency of the schedule.
+      sig { returns(Knockapi::Models::ScheduleRepeatRule::Frequency::OrSymbol) }
+      attr_accessor :frequency
+
+      # The day of the month to repeat the schedule.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :day_of_month
+
+      # The days of the week to repeat the schedule.
+      sig { returns(T.nilable(T::Array[Knockapi::Models::ScheduleRepeatRule::Day::OrSymbol])) }
+      attr_accessor :days
+
+      # The hour of the day to repeat the schedule.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :hours
+
+      # The interval of the schedule.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :interval
+
+      sig { params(interval: Integer).void }
+      attr_writer :interval
+
+      # The minute of the hour to repeat the schedule.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :minutes
+
+      # The repeat rule for the schedule.
+      sig do
+        params(
+          _typename: String,
+          frequency: Knockapi::Models::ScheduleRepeatRule::Frequency::OrSymbol,
+          day_of_month: T.nilable(Integer),
+          days: T.nilable(T::Array[Knockapi::Models::ScheduleRepeatRule::Day::OrSymbol]),
+          hours: T.nilable(Integer),
+          interval: Integer,
+          minutes: T.nilable(Integer)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The typename of the schema.
+        _typename:,
+        # The frequency of the schedule.
+        frequency:,
+        # The day of the month to repeat the schedule.
+        day_of_month: nil,
+        # The days of the week to repeat the schedule.
+        days: nil,
+        # The hour of the day to repeat the schedule.
+        hours: nil,
+        # The interval of the schedule.
+        interval: nil,
+        # The minute of the hour to repeat the schedule.
+        minutes: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              _typename: String,
+              frequency: Knockapi::Models::ScheduleRepeatRule::Frequency::OrSymbol,
+              day_of_month: T.nilable(Integer),
+              days: T.nilable(T::Array[Knockapi::Models::ScheduleRepeatRule::Day::OrSymbol]),
+              hours: T.nilable(Integer),
+              interval: Integer,
+              minutes: T.nilable(Integer)
+            }
+          )
+      end
+      def to_hash; end
+
+      # The frequency of the schedule.
+      module Frequency
+        extend Knockapi::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Knockapi::Models::ScheduleRepeatRule::Frequency) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DAILY = T.let(:daily, Knockapi::Models::ScheduleRepeatRule::Frequency::TaggedSymbol)
+        WEEKLY = T.let(:weekly, Knockapi::Models::ScheduleRepeatRule::Frequency::TaggedSymbol)
+        MONTHLY = T.let(:monthly, Knockapi::Models::ScheduleRepeatRule::Frequency::TaggedSymbol)
+        HOURLY = T.let(:hourly, Knockapi::Models::ScheduleRepeatRule::Frequency::TaggedSymbol)
+
+        sig { override.returns(T::Array[Knockapi::Models::ScheduleRepeatRule::Frequency::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      # An identifier for a day of the week.
+      module Day
+        extend Knockapi::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Knockapi::Models::ScheduleRepeatRule::Day) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MON = T.let(:mon, Knockapi::Models::ScheduleRepeatRule::Day::TaggedSymbol)
+        TUE = T.let(:tue, Knockapi::Models::ScheduleRepeatRule::Day::TaggedSymbol)
+        WED = T.let(:wed, Knockapi::Models::ScheduleRepeatRule::Day::TaggedSymbol)
+        THU = T.let(:thu, Knockapi::Models::ScheduleRepeatRule::Day::TaggedSymbol)
+        FRI = T.let(:fri, Knockapi::Models::ScheduleRepeatRule::Day::TaggedSymbol)
+        SAT = T.let(:sat, Knockapi::Models::ScheduleRepeatRule::Day::TaggedSymbol)
+        SUN = T.let(:sun, Knockapi::Models::ScheduleRepeatRule::Day::TaggedSymbol)
+
+        sig { override.returns(T::Array[Knockapi::Models::ScheduleRepeatRule::Day::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/knockapi/models/schedule_update_params.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    class ScheduleUpdateParams < Knockapi::Internal::Type::BaseModel
+      extend Knockapi::Internal::Type::RequestParameters::Converter
+      include Knockapi::Internal::Type::RequestParameters
+
+      # A list of schedule IDs.
+      sig { returns(T::Array[String]) }
+      attr_accessor :schedule_ids
+
+      # A reference to a recipient, either a user identifier (string) or an object
+      # reference (ID, collection).
+      sig { returns(T.nilable(T.any(String, Knockapi::Models::RecipientReference::ObjectReference))) }
+      attr_accessor :actor
+
+      # An optional map of data to pass into the workflow execution.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :data
+
+      # The ending date and time for the schedule.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :ending_at
+
+      # The repeat rule for the schedule.
+      sig { returns(T.nilable(T::Array[Knockapi::Models::ScheduleRepeatRule])) }
+      attr_reader :repeats
+
+      sig { params(repeats: T::Array[T.any(Knockapi::Models::ScheduleRepeatRule, Knockapi::Internal::AnyHash)]).void }
+      attr_writer :repeats
+
+      # The starting date and time for the schedule.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :scheduled_at
+
+      # An request to set a tenant inline.
+      sig { returns(T.nilable(T.any(String, Knockapi::Models::TenantRequest))) }
+      attr_accessor :tenant
+
+      sig do
+        params(
+          schedule_ids: T::Array[String],
+          actor: T.nilable(
+            T.any(String, Knockapi::Models::RecipientReference::ObjectReference, Knockapi::Internal::AnyHash)
+          ),
+          data: T.nilable(T::Hash[Symbol, T.anything]),
+          ending_at: T.nilable(Time),
+          repeats: T::Array[T.any(Knockapi::Models::ScheduleRepeatRule, Knockapi::Internal::AnyHash)],
+          scheduled_at: T.nilable(Time),
+          tenant: T.nilable(T.any(String, Knockapi::Models::TenantRequest, Knockapi::Internal::AnyHash)),
+          request_options: T.any(Knockapi::RequestOptions, Knockapi::Internal::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # A list of schedule IDs.
+        schedule_ids:,
+        # A reference to a recipient, either a user identifier (string) or an object
+        # reference (ID, collection).
+        actor: nil,
+        # An optional map of data to pass into the workflow execution.
+        data: nil,
+        # The ending date and time for the schedule.
+        ending_at: nil,
+        # The repeat rule for the schedule.
+        repeats: nil,
+        # The starting date and time for the schedule.
+        scheduled_at: nil,
+        # An request to set a tenant inline.
+        tenant: nil,
+        request_options: {}
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              schedule_ids: T::Array[String],
+              actor: T.nilable(T.any(String, Knockapi::Models::RecipientReference::ObjectReference)),
+              data: T.nilable(T::Hash[Symbol, T.anything]),
+              ending_at: T.nilable(Time),
+              repeats: T::Array[Knockapi::Models::ScheduleRepeatRule],
+              scheduled_at: T.nilable(Time),
+              tenant: T.nilable(T.any(String, Knockapi::Models::TenantRequest)),
+              request_options: Knockapi::RequestOptions
+            }
+          )
+      end
+      def to_hash; end
+    end
+  end
+end

data/rbi/knockapi/models/schedule_update_response.rbi

@@ -0,0 +1,8 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    ScheduleUpdateResponse =
+      T.let(Knockapi::Internal::Type::ArrayOf[Knockapi::Models::Schedule], Knockapi::Internal::Type::Converter)
+  end
+end

data/rbi/knockapi/models/schedules/bulk_create_params.rbi

@@ -0,0 +1,172 @@
+# typed: strong
+
+module Knockapi
+  module Models
+    module Schedules
+      class BulkCreateParams < Knockapi::Internal::Type::BaseModel
+        extend Knockapi::Internal::Type::RequestParameters::Converter
+        include Knockapi::Internal::Type::RequestParameters
+
+        # A list of schedules.
+        sig { returns(T::Array[Knockapi::Models::Schedules::BulkCreateParams::Schedule]) }
+        attr_accessor :schedules
+
+        sig do
+          params(
+            schedules: T::Array[T.any(Knockapi::Models::Schedules::BulkCreateParams::Schedule, Knockapi::Internal::AnyHash)],
+            request_options: T.any(Knockapi::RequestOptions, Knockapi::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # A list of schedules.
+          schedules:,
+          request_options: {}
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                schedules: T::Array[Knockapi::Models::Schedules::BulkCreateParams::Schedule],
+                request_options: Knockapi::RequestOptions
+              }
+            )
+        end
+        def to_hash; end
+
+        class Schedule < Knockapi::Internal::Type::BaseModel
+          # The key of the workflow.
+          sig { returns(String) }
+          attr_accessor :workflow
+
+          # Specifies a recipient in a request. This can either be a user identifier
+          # (string), an inline user request (object), or an inline object request, which is
+          # determined by the presence of a `collection` property.
+          sig do
+            returns(
+              T.nilable(
+                T.any(String, Knockapi::Models::InlineIdentifyUserRequest, Knockapi::Models::InlineObjectRequest)
+              )
+            )
+          end
+          attr_accessor :actor
+
+          # An optional map of data to pass into the workflow execution.
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_accessor :data
+
+          # The ending date and time for the schedule.
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :ending_at
+
+          # Specifies a recipient in a request. This can either be a user identifier
+          # (string), an inline user request (object), or an inline object request, which is
+          # determined by the presence of a `collection` property.
+          sig do
+            returns(
+              T.nilable(
+                T.any(String, Knockapi::Models::InlineIdentifyUserRequest, Knockapi::Models::InlineObjectRequest)
+              )
+            )
+          end
+          attr_reader :recipient
+
+          sig do
+            params(
+              recipient: T.any(
+                String,
+                Knockapi::Models::InlineIdentifyUserRequest,
+                Knockapi::Internal::AnyHash,
+                Knockapi::Models::InlineObjectRequest
+              )
+            )
+              .void
+          end
+          attr_writer :recipient
+
+          # The repeat rule for the schedule.
+          sig { returns(T.nilable(T::Array[Knockapi::Models::ScheduleRepeatRule])) }
+          attr_reader :repeats
+
+          sig { params(repeats: T::Array[T.any(Knockapi::Models::ScheduleRepeatRule, Knockapi::Internal::AnyHash)]).void }
+          attr_writer :repeats
+
+          # The starting date and time for the schedule.
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :scheduled_at
+
+          # An request to set a tenant inline.
+          sig { returns(T.nilable(T.any(String, Knockapi::Models::TenantRequest))) }
+          attr_accessor :tenant
+
+          # A schedule represents a recurring workflow execution.
+          sig do
+            params(
+              workflow: String,
+              actor: T.nilable(
+                T.any(
+                  String,
+                  Knockapi::Models::InlineIdentifyUserRequest,
+                  Knockapi::Internal::AnyHash,
+                  Knockapi::Models::InlineObjectRequest
+                )
+              ),
+              data: T.nilable(T::Hash[Symbol, T.anything]),
+              ending_at: T.nilable(Time),
+              recipient: T.any(
+                String,
+                Knockapi::Models::InlineIdentifyUserRequest,
+                Knockapi::Internal::AnyHash,
+                Knockapi::Models::InlineObjectRequest
+              ),
+              repeats: T::Array[T.any(Knockapi::Models::ScheduleRepeatRule, Knockapi::Internal::AnyHash)],
+              scheduled_at: T.nilable(Time),
+              tenant: T.nilable(T.any(String, Knockapi::Models::TenantRequest, Knockapi::Internal::AnyHash))
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+            # The key of the workflow.
+            workflow:,
+            # Specifies a recipient in a request. This can either be a user identifier
+            # (string), an inline user request (object), or an inline object request, which is
+            # determined by the presence of a `collection` property.
+            actor: nil,
+            # An optional map of data to pass into the workflow execution.
+            data: nil,
+            # The ending date and time for the schedule.
+            ending_at: nil,
+            # Specifies a recipient in a request. This can either be a user identifier
+            # (string), an inline user request (object), or an inline object request, which is
+            # determined by the presence of a `collection` property.
+            recipient: nil,
+            # The repeat rule for the schedule.
+            repeats: nil,
+            # The starting date and time for the schedule.
+            scheduled_at: nil,
+            # An request to set a tenant inline.
+            tenant: nil
+          ); end
+          sig do
+            override
+              .returns(
+                {
+                  workflow: String,
+                  actor: T.nilable(
+                    T.any(String, Knockapi::Models::InlineIdentifyUserRequest, Knockapi::Models::InlineObjectRequest)
+                  ),
+                  data: T.nilable(T::Hash[Symbol, T.anything]),
+                  ending_at: T.nilable(Time),
+                  recipient: T.any(String, Knockapi::Models::InlineIdentifyUserRequest, Knockapi::Models::InlineObjectRequest),
+                  repeats: T::Array[Knockapi::Models::ScheduleRepeatRule],
+                  scheduled_at: T.nilable(Time),
+                  tenant: T.nilable(T.any(String, Knockapi::Models::TenantRequest))
+                }
+              )
+          end
+          def to_hash; end
+        end
+      end
+    end
+  end
+end