notiflows 0.0.1

data/rbi/notiflows/models/delivery.rbi

@@ -0,0 +1,226 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class Delivery < Notiflows::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Notiflows::Delivery, Notiflows::Internal::AnyHash)
+        end
+
+      # Delivery ID
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Type of channel used for this delivery
+      sig { returns(Notiflows::Delivery::ChannelType::TaggedSymbol) }
+      attr_accessor :channel_type
+
+      # When the delivery was created
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # ID of the parent notification
+      sig { returns(String) }
+      attr_accessor :notification_id
+
+      # ID of the notiflow
+      sig { returns(String) }
+      attr_accessor :notiflow_id
+
+      # Internal ID of the recipient
+      sig { returns(String) }
+      attr_accessor :recipient_id
+
+      # Delivery status:
+      #
+      # - `pending`: Queued for sending
+      # - `sent`: Successfully sent to the provider
+      # - `failed`: Delivery failed
+      sig { returns(Notiflows::Delivery::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      # When the delivery was last updated
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      # Internal ID of the actor
+      sig { returns(T.nilable(String)) }
+      attr_accessor :actor_id
+
+      # When the recipient archived it
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :archived_at
+
+      # ID of the channel used for delivery
+      sig { returns(T.nilable(String)) }
+      attr_accessor :channel_id
+
+      # When the recipient clicked/interacted
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :clicked_at
+
+      # Rendered notification content (varies by channel type)
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :data
+
+      sig { params(data: T.anything).void }
+      attr_writer :data
+
+      # When the recipient marked it as read
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :read_at
+
+      # When the recipient saw the notification
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :seen_at
+
+      # When the delivery was sent to the provider
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :sent_at
+
+      # Topic name if triggered via topic
+      sig { returns(T.nilable(String)) }
+      attr_accessor :topic
+
+      # A single delivery attempt through a specific channel
+      sig do
+        params(
+          id: String,
+          channel_type: Notiflows::Delivery::ChannelType::OrSymbol,
+          created_at: Time,
+          notification_id: String,
+          notiflow_id: String,
+          recipient_id: String,
+          status: Notiflows::Delivery::Status::OrSymbol,
+          updated_at: Time,
+          actor_id: T.nilable(String),
+          archived_at: T.nilable(Time),
+          channel_id: T.nilable(String),
+          clicked_at: T.nilable(Time),
+          data: T.anything,
+          read_at: T.nilable(Time),
+          seen_at: T.nilable(Time),
+          sent_at: T.nilable(Time),
+          topic: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Delivery ID
+        id:,
+        # Type of channel used for this delivery
+        channel_type:,
+        # When the delivery was created
+        created_at:,
+        # ID of the parent notification
+        notification_id:,
+        # ID of the notiflow
+        notiflow_id:,
+        # Internal ID of the recipient
+        recipient_id:,
+        # Delivery status:
+        #
+        # - `pending`: Queued for sending
+        # - `sent`: Successfully sent to the provider
+        # - `failed`: Delivery failed
+        status:,
+        # When the delivery was last updated
+        updated_at:,
+        # Internal ID of the actor
+        actor_id: nil,
+        # When the recipient archived it
+        archived_at: nil,
+        # ID of the channel used for delivery
+        channel_id: nil,
+        # When the recipient clicked/interacted
+        clicked_at: nil,
+        # Rendered notification content (varies by channel type)
+        data: nil,
+        # When the recipient marked it as read
+        read_at: nil,
+        # When the recipient saw the notification
+        seen_at: nil,
+        # When the delivery was sent to the provider
+        sent_at: nil,
+        # Topic name if triggered via topic
+        topic: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            channel_type: Notiflows::Delivery::ChannelType::TaggedSymbol,
+            created_at: Time,
+            notification_id: String,
+            notiflow_id: String,
+            recipient_id: String,
+            status: Notiflows::Delivery::Status::TaggedSymbol,
+            updated_at: Time,
+            actor_id: T.nilable(String),
+            archived_at: T.nilable(Time),
+            channel_id: T.nilable(String),
+            clicked_at: T.nilable(Time),
+            data: T.anything,
+            read_at: T.nilable(Time),
+            seen_at: T.nilable(Time),
+            sent_at: T.nilable(Time),
+            topic: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Type of channel used for this delivery
+      module ChannelType
+        extend Notiflows::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Notiflows::Delivery::ChannelType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        IN_APP = T.let(:in_app, Notiflows::Delivery::ChannelType::TaggedSymbol)
+        EMAIL = T.let(:email, Notiflows::Delivery::ChannelType::TaggedSymbol)
+        SMS = T.let(:sms, Notiflows::Delivery::ChannelType::TaggedSymbol)
+        CHAT = T.let(:chat, Notiflows::Delivery::ChannelType::TaggedSymbol)
+        WEB_PUSH =
+          T.let(:web_push, Notiflows::Delivery::ChannelType::TaggedSymbol)
+        MOBILE_PUSH =
+          T.let(:mobile_push, Notiflows::Delivery::ChannelType::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Notiflows::Delivery::ChannelType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Delivery status:
+      #
+      # - `pending`: Queued for sending
+      # - `sent`: Successfully sent to the provider
+      # - `failed`: Delivery failed
+      module Status
+        extend Notiflows::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Notiflows::Delivery::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING = T.let(:pending, Notiflows::Delivery::Status::TaggedSymbol)
+        SENT = T.let(:sent, Notiflows::Delivery::Status::TaggedSymbol)
+        FAILED = T.let(:failed, Notiflows::Delivery::Status::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Notiflows::Delivery::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models/delivery_list_params.rbi

@@ -0,0 +1,123 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class DeliveryListParams < Notiflows::Internal::Type::BaseModel
+      extend Notiflows::Internal::Type::RequestParameters::Converter
+      include Notiflows::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Notiflows::DeliveryListParams, 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 channel ID (UUID)
+      sig { returns(T.nilable(String)) }
+      attr_reader :channel_id
+
+      sig { params(channel_id: String).void }
+      attr_writer :channel_id
+
+      # 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
+
+      # Filter by status (pending, sent, failed)
+      sig { returns(T.nilable(String)) }
+      attr_reader :status
+
+      sig { params(status: String).void }
+      attr_writer :status
+
+      # Filter by topic name
+      sig { returns(T.nilable(String)) }
+      attr_reader :topic
+
+      sig { params(topic: String).void }
+      attr_writer :topic
+
+      sig do
+        params(
+          after: String,
+          before: String,
+          channel_id: String,
+          created_after: String,
+          created_before: String,
+          limit: Integer,
+          status: String,
+          topic: String,
+          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 channel ID (UUID)
+        channel_id: 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,
+        # Filter by status (pending, sent, failed)
+        status: nil,
+        # Filter by topic name
+        topic: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            after: String,
+            before: String,
+            channel_id: String,
+            created_after: String,
+            created_before: String,
+            limit: Integer,
+            status: String,
+            topic: String,
+            request_options: Notiflows::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/notiflows/models/delivery_retrieve_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class DeliveryRetrieveParams < Notiflows::Internal::Type::BaseModel
+      extend Notiflows::Internal::Type::RequestParameters::Converter
+      include Notiflows::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Notiflows::DeliveryRetrieveParams, 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/notification.rbi

@@ -0,0 +1,190 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class Notification < Notiflows::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Notiflows::Notification, Notiflows::Internal::AnyHash)
+        end
+
+      # Notification ID
+      sig { returns(String) }
+      attr_accessor :id
+
+      # When the notification was created
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Template variables passed when running the notiflow
+      sig { returns(T.anything) }
+      attr_accessor :data
+
+      # ID of the notiflow that generated this notification
+      sig { returns(String) }
+      attr_accessor :notiflow_id
+
+      # ID of the specific notiflow run
+      sig { returns(String) }
+      attr_accessor :notiflow_run_id
+
+      # Internal ID of the recipient user
+      sig { returns(String) }
+      attr_accessor :recipient_id
+
+      # Notification processing status:
+      #
+      # - `pending`: Queued for processing
+      # - `processing`: Currently being processed
+      # - `processed`: Successfully processed (deliveries created)
+      # - `failed`: Processing failed
+      sig { returns(Notiflows::Notification::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      # When the notification was last updated
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      # A user (recipient) in your project
+      sig { returns(T.nilable(Notiflows::User)) }
+      attr_reader :actor
+
+      sig { params(actor: T.nilable(Notiflows::User::OrHash)).void }
+      attr_writer :actor
+
+      # Internal ID of the actor (user who triggered the notification)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :actor_id
+
+      # Delivery attempts for this notification (when expanded)
+      sig { returns(T.nilable(T::Array[Notiflows::Delivery])) }
+      attr_reader :deliveries
+
+      sig { params(deliveries: T::Array[Notiflows::Delivery::OrHash]).void }
+      attr_writer :deliveries
+
+      # When the notification was processed
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :processed_at
+
+      # A user (recipient) in your project
+      sig { returns(T.nilable(Notiflows::User)) }
+      attr_reader :recipient
+
+      sig { params(recipient: Notiflows::User::OrHash).void }
+      attr_writer :recipient
+
+      # Topic name if triggered via topic
+      sig { returns(T.nilable(String)) }
+      attr_accessor :topic
+
+      # A notification sent to a recipient through a notiflow run
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          data: T.anything,
+          notiflow_id: String,
+          notiflow_run_id: String,
+          recipient_id: String,
+          status: Notiflows::Notification::Status::OrSymbol,
+          updated_at: Time,
+          actor: T.nilable(Notiflows::User::OrHash),
+          actor_id: T.nilable(String),
+          deliveries: T::Array[Notiflows::Delivery::OrHash],
+          processed_at: T.nilable(Time),
+          recipient: Notiflows::User::OrHash,
+          topic: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Notification ID
+        id:,
+        # When the notification was created
+        created_at:,
+        # Template variables passed when running the notiflow
+        data:,
+        # ID of the notiflow that generated this notification
+        notiflow_id:,
+        # ID of the specific notiflow run
+        notiflow_run_id:,
+        # Internal ID of the recipient user
+        recipient_id:,
+        # Notification processing status:
+        #
+        # - `pending`: Queued for processing
+        # - `processing`: Currently being processed
+        # - `processed`: Successfully processed (deliveries created)
+        # - `failed`: Processing failed
+        status:,
+        # When the notification was last updated
+        updated_at:,
+        # A user (recipient) in your project
+        actor: nil,
+        # Internal ID of the actor (user who triggered the notification)
+        actor_id: nil,
+        # Delivery attempts for this notification (when expanded)
+        deliveries: nil,
+        # When the notification was processed
+        processed_at: nil,
+        # A user (recipient) in your project
+        recipient: nil,
+        # Topic name if triggered via topic
+        topic: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            data: T.anything,
+            notiflow_id: String,
+            notiflow_run_id: String,
+            recipient_id: String,
+            status: Notiflows::Notification::Status::TaggedSymbol,
+            updated_at: Time,
+            actor: T.nilable(Notiflows::User),
+            actor_id: T.nilable(String),
+            deliveries: T::Array[Notiflows::Delivery],
+            processed_at: T.nilable(Time),
+            recipient: Notiflows::User,
+            topic: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Notification processing status:
+      #
+      # - `pending`: Queued for processing
+      # - `processing`: Currently being processed
+      # - `processed`: Successfully processed (deliveries created)
+      # - `failed`: Processing failed
+      module Status
+        extend Notiflows::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Notiflows::Notification::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING = T.let(:pending, Notiflows::Notification::Status::TaggedSymbol)
+        PROCESSING =
+          T.let(:processing, Notiflows::Notification::Status::TaggedSymbol)
+        PROCESSED =
+          T.let(:processed, Notiflows::Notification::Status::TaggedSymbol)
+        FAILED = T.let(:failed, Notiflows::Notification::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Notiflows::Notification::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models/notification_list_deliveries_params.rbi

@@ -0,0 +1,126 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    class NotificationListDeliveriesParams < Notiflows::Internal::Type::BaseModel
+      extend Notiflows::Internal::Type::RequestParameters::Converter
+      include Notiflows::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Notiflows::NotificationListDeliveriesParams,
+            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 channel ID (UUID)
+      sig { returns(T.nilable(String)) }
+      attr_reader :channel_id
+
+      sig { params(channel_id: String).void }
+      attr_writer :channel_id
+
+      # 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
+
+      # Filter by status (pending, sent, failed)
+      sig { returns(T.nilable(String)) }
+      attr_reader :status
+
+      sig { params(status: String).void }
+      attr_writer :status
+
+      # Filter by topic name
+      sig { returns(T.nilable(String)) }
+      attr_reader :topic
+
+      sig { params(topic: String).void }
+      attr_writer :topic
+
+      sig do
+        params(
+          after: String,
+          before: String,
+          channel_id: String,
+          created_after: String,
+          created_before: String,
+          limit: Integer,
+          status: String,
+          topic: String,
+          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 channel ID (UUID)
+        channel_id: 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,
+        # Filter by status (pending, sent, failed)
+        status: nil,
+        # Filter by topic name
+        topic: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            after: String,
+            before: String,
+            channel_id: String,
+            created_after: String,
+            created_before: String,
+            limit: Integer,
+            status: String,
+            topic: String,
+            request_options: Notiflows::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end