notiflows 0.0.1

data/rbi/notiflows/models/topics/bulk_operation_response.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    module Topics
+      class BulkOperationResponse < Notiflows::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Notiflows::Topics::BulkOperationResponse,
+              Notiflows::Internal::AnyHash
+            )
+          end
+
+        # Failed operations with error details
+        sig do
+          returns(T::Array[Notiflows::Topics::BulkOperationResponse::Failed])
+        end
+        attr_accessor :failed
+
+        # Successfully processed subscriptions
+        sig { returns(T::Array[Notiflows::Users::Subscription]) }
+        attr_accessor :successful
+
+        # Response for bulk operations showing successful and failed items
+        sig do
+          params(
+            failed:
+              T::Array[
+                Notiflows::Topics::BulkOperationResponse::Failed::OrHash
+              ],
+            successful: T::Array[Notiflows::Users::Subscription::OrHash]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Failed operations with error details
+          failed:,
+          # Successfully processed subscriptions
+          successful:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              failed:
+                T::Array[Notiflows::Topics::BulkOperationResponse::Failed],
+              successful: T::Array[Notiflows::Users::Subscription]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Failed < Notiflows::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Notiflows::Topics::BulkOperationResponse::Failed,
+                Notiflows::Internal::AnyHash
+              )
+            end
+
+          # The external ID that failed
+          sig { returns(String) }
+          attr_accessor :external_id
+
+          # Human-readable error reason
+          sig { returns(String) }
+          attr_accessor :reason
+
+          # Details of a failed bulk operation item
+          sig do
+            params(external_id: String, reason: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # The external ID that failed
+            external_id:,
+            # Human-readable error reason
+            reason:
+          )
+          end
+
+          sig { override.returns({ external_id: String, reason: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models/topics/bulk_subscribe_request.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    module Topics
+      class BulkSubscribeRequest < Notiflows::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Notiflows::Topics::BulkSubscribeRequest,
+              Notiflows::Internal::AnyHash
+            )
+          end
+
+        # List of user external IDs to subscribe/unsubscribe
+        sig { returns(T::Array[String]) }
+        attr_accessor :user_external_ids
+
+        # Request body for bulk subscribe/unsubscribe operations
+        sig do
+          params(user_external_ids: T::Array[String]).returns(T.attached_class)
+        end
+        def self.new(
+          # List of user external IDs to subscribe/unsubscribe
+          user_external_ids:
+        )
+        end
+
+        sig { override.returns({ user_external_ids: T::Array[String] }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models/topics/subscription_list_params.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    module Topics
+      class SubscriptionListParams < Notiflows::Internal::Type::BaseModel
+        extend Notiflows::Internal::Type::RequestParameters::Converter
+        include Notiflows::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Notiflows::Topics::SubscriptionListParams,
+              Notiflows::Internal::AnyHash
+            )
+          end
+
+        # Cursor for fetching the next page
+        sig { returns(T.nilable(String)) }
+        attr_reader :after
+
+        sig { params(after: String).void }
+        attr_writer :after
+
+        # Cursor for fetching the previous page
+        sig { returns(T.nilable(String)) }
+        attr_reader :before
+
+        sig { params(before: String).void }
+        attr_writer :before
+
+        # Filter by created after (ISO 8601 datetime)
+        sig { returns(T.nilable(String)) }
+        attr_reader :created_after
+
+        sig { params(created_after: String).void }
+        attr_writer :created_after
+
+        # Filter by created before (ISO 8601 datetime)
+        sig { returns(T.nilable(String)) }
+        attr_reader :created_before
+
+        sig { params(created_before: String).void }
+        attr_writer :created_before
+
+        # Number of items per page (default: 25, max: 1000)
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        sig do
+          params(
+            after: String,
+            before: String,
+            created_after: String,
+            created_before: String,
+            limit: Integer,
+            request_options: Notiflows::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Cursor for fetching the next page
+          after: nil,
+          # Cursor for fetching the previous page
+          before: nil,
+          # Filter by created after (ISO 8601 datetime)
+          created_after: nil,
+          # Filter by created before (ISO 8601 datetime)
+          created_before: nil,
+          # Number of items per page (default: 25, max: 1000)
+          limit: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              after: String,
+              before: String,
+              created_after: String,
+              created_before: String,
+              limit: Integer,
+              request_options: Notiflows::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models/topics/subscription_subscribe_bulk_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    module Topics
+      class SubscriptionSubscribeBulkParams < Notiflows::Models::Topics::BulkSubscribeRequest
+        extend Notiflows::Internal::Type::RequestParameters::Converter
+        include Notiflows::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Notiflows::Topics::SubscriptionSubscribeBulkParams,
+              Notiflows::Internal::AnyHash
+            )
+          end
+
+        sig do
+          params(request_options: Notiflows::RequestOptions::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(request_options: {})
+        end
+
+        sig { override.returns({ request_options: Notiflows::RequestOptions }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models/topics/subscription_unsubscribe_bulk_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    module Topics
+      class SubscriptionUnsubscribeBulkParams < Notiflows::Models::Topics::BulkSubscribeRequest
+        extend Notiflows::Internal::Type::RequestParameters::Converter
+        include Notiflows::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Notiflows::Topics::SubscriptionUnsubscribeBulkParams,
+              Notiflows::Internal::AnyHash
+            )
+          end
+
+        sig do
+          params(request_options: Notiflows::RequestOptions::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(request_options: {})
+        end
+
+        sig { override.returns({ request_options: Notiflows::RequestOptions }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models/user.rbi

@@ -0,0 +1,126 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class User < Notiflows::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Notiflows::User, Notiflows::Internal::AnyHash) }
+
+      # Internal Notiflows user ID (UUIDv7)
+      sig { returns(String) }
+      attr_accessor :id
+
+      # When the user was created (ISO 8601)
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Your system's unique identifier for this user
+      sig { returns(String) }
+      attr_accessor :external_id
+
+      # When the user was last updated (ISO 8601)
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      # URL to user's avatar image (must be https://)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :avatar
+
+      # Arbitrary JSON object for additional user attributes. Accessible in templates as
+      # `recipient.custom_fields.*`
+      sig { returns(T.nilable(T.anything)) }
+      attr_accessor :custom_fields
+
+      # User's email address for email notifications
+      sig { returns(T.nilable(String)) }
+      attr_accessor :email
+
+      # User's first name for personalization
+      sig { returns(T.nilable(String)) }
+      attr_accessor :first_name
+
+      # User's last name for personalization
+      sig { returns(T.nilable(String)) }
+      attr_accessor :last_name
+
+      # BCP 47 locale code for localized notifications
+      sig { returns(T.nilable(String)) }
+      attr_accessor :locale
+
+      # User's phone number in E.164 format for SMS notifications
+      sig { returns(T.nilable(String)) }
+      attr_accessor :phone
+
+      # IANA timezone for time-sensitive notifications
+      sig { returns(T.nilable(String)) }
+      attr_accessor :timezone
+
+      # A user (recipient) in your project
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          external_id: String,
+          updated_at: Time,
+          avatar: T.nilable(String),
+          custom_fields: T.nilable(T.anything),
+          email: T.nilable(String),
+          first_name: T.nilable(String),
+          last_name: T.nilable(String),
+          locale: T.nilable(String),
+          phone: T.nilable(String),
+          timezone: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Internal Notiflows user ID (UUIDv7)
+        id:,
+        # When the user was created (ISO 8601)
+        created_at:,
+        # Your system's unique identifier for this user
+        external_id:,
+        # When the user was last updated (ISO 8601)
+        updated_at:,
+        # URL to user's avatar image (must be https://)
+        avatar: nil,
+        # Arbitrary JSON object for additional user attributes. Accessible in templates as
+        # `recipient.custom_fields.*`
+        custom_fields: nil,
+        # User's email address for email notifications
+        email: nil,
+        # User's first name for personalization
+        first_name: nil,
+        # User's last name for personalization
+        last_name: nil,
+        # BCP 47 locale code for localized notifications
+        locale: nil,
+        # User's phone number in E.164 format for SMS notifications
+        phone: nil,
+        # IANA timezone for time-sensitive notifications
+        timezone: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            external_id: String,
+            updated_at: Time,
+            avatar: T.nilable(String),
+            custom_fields: T.nilable(T.anything),
+            email: T.nilable(String),
+            first_name: T.nilable(String),
+            last_name: T.nilable(String),
+            locale: T.nilable(String),
+            phone: T.nilable(String),
+            timezone: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/notiflows/models/user_delete_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class UserDeleteParams < Notiflows::Internal::Type::BaseModel
+      extend Notiflows::Internal::Type::RequestParameters::Converter
+      include Notiflows::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Notiflows::UserDeleteParams, Notiflows::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: Notiflows::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Notiflows::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/notiflows/models/user_list_params.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class UserListParams < Notiflows::Internal::Type::BaseModel
+      extend Notiflows::Internal::Type::RequestParameters::Converter
+      include Notiflows::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Notiflows::UserListParams, Notiflows::Internal::AnyHash)
+        end
+
+      # Cursor for fetching the next page
+      sig { returns(T.nilable(String)) }
+      attr_reader :after
+
+      sig { params(after: String).void }
+      attr_writer :after
+
+      # Cursor for fetching the previous page
+      sig { returns(T.nilable(String)) }
+      attr_reader :before
+
+      sig { params(before: String).void }
+      attr_writer :before
+
+      # Filter users created after this datetime (ISO 8601)
+      sig { returns(T.nilable(String)) }
+      attr_reader :created_after
+
+      sig { params(created_after: String).void }
+      attr_writer :created_after
+
+      # Filter users created before this datetime (ISO 8601)
+      sig { returns(T.nilable(String)) }
+      attr_reader :created_before
+
+      sig { params(created_before: String).void }
+      attr_writer :created_before
+
+      # Number of items per page (default: 25, max: 1000)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      sig do
+        params(
+          after: String,
+          before: String,
+          created_after: String,
+          created_before: String,
+          limit: Integer,
+          request_options: Notiflows::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Cursor for fetching the next page
+        after: nil,
+        # Cursor for fetching the previous page
+        before: nil,
+        # Filter users created after this datetime (ISO 8601)
+        created_after: nil,
+        # Filter users created before this datetime (ISO 8601)
+        created_before: nil,
+        # Number of items per page (default: 25, max: 1000)
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            after: String,
+            before: String,
+            created_after: String,
+            created_before: String,
+            limit: Integer,
+            request_options: Notiflows::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/notiflows/models/user_retrieve_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class UserRetrieveParams < Notiflows::Internal::Type::BaseModel
+      extend Notiflows::Internal::Type::RequestParameters::Converter
+      include Notiflows::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Notiflows::UserRetrieveParams, Notiflows::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: Notiflows::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Notiflows::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end