notiflows 0.0.1

data/rbi/notiflows/models/users/subscription_retrieve_params.rbi

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

data/rbi/notiflows/models/users/subscription_subscribe_params.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    module Users
+      class SubscriptionSubscribeParams < Notiflows::Internal::Type::BaseModel
+        extend Notiflows::Internal::Type::RequestParameters::Converter
+        include Notiflows::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Notiflows::Users::SubscriptionSubscribeParams,
+              Notiflows::Internal::AnyHash
+            )
+          end
+
+        # Name of the topic to subscribe to. Topics are created automatically if they
+        # don't exist.
+        sig { returns(String) }
+        attr_accessor :topic_name
+
+        sig do
+          params(
+            topic_name: String,
+            request_options: Notiflows::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Name of the topic to subscribe to. Topics are created automatically if they
+          # don't exist.
+          topic_name:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            { topic_name: String, request_options: Notiflows::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models/users/subscription_unsubscribe_params.rbi

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

data/rbi/notiflows/models/users/update_preferences_request.rbi

@@ -0,0 +1,124 @@
+# typed: strong
+
+module Notiflows
+  module Models
+    module Users
+      class UpdatePreferencesRequest < ::Notiflows::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ::Notiflows::Users::UpdatePreferencesRequest,
+              ::Notiflows::Internal::AnyHash
+            )
+          end
+
+        # Global channel type preferences
+        sig { returns(T.nilable(T::Hash[Symbol, T::Boolean])) }
+        attr_reader :channel_types
+
+        sig { params(channel_types: T::Hash[Symbol, T::Boolean]).void }
+        attr_writer :channel_types
+
+        # Per-notiflow preferences (keyed by notiflow ID)
+        sig do
+          returns(
+            T.nilable(
+              T::Hash[
+                Symbol,
+                ::Notiflows::Users::UpdatePreferencesRequest::Notiflow
+              ]
+            )
+          )
+        end
+        attr_reader :notiflows
+
+        sig do
+          params(
+            notiflows:
+              T::Hash[
+                Symbol,
+                ::Notiflows::Users::UpdatePreferencesRequest::Notiflow::OrHash
+              ]
+          ).void
+        end
+        attr_writer :notiflows
+
+        # Request body for updating user preferences. Only provided fields are updated.
+        sig do
+          params(
+            channel_types: T::Hash[Symbol, T::Boolean],
+            notiflows:
+              T::Hash[
+                Symbol,
+                ::Notiflows::Users::UpdatePreferencesRequest::Notiflow::OrHash
+              ]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Global channel type preferences
+          channel_types: nil,
+          # Per-notiflow preferences (keyed by notiflow ID)
+          notiflows: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              channel_types: T::Hash[Symbol, T::Boolean],
+              notiflows:
+                T::Hash[
+                  Symbol,
+                  ::Notiflows::Users::UpdatePreferencesRequest::Notiflow
+                ]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Notiflow < ::Notiflows::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                ::Notiflows::Users::UpdatePreferencesRequest::Notiflow,
+                ::Notiflows::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(T::Hash[Symbol, T::Boolean])) }
+          attr_reader :channel_types
+
+          sig { params(channel_types: T::Hash[Symbol, T::Boolean]).void }
+          attr_writer :channel_types
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :enabled
+
+          sig { params(enabled: T::Boolean).void }
+          attr_writer :enabled
+
+          sig do
+            params(
+              channel_types: T::Hash[Symbol, T::Boolean],
+              enabled: T::Boolean
+            ).returns(T.attached_class)
+          end
+          def self.new(channel_types: nil, enabled: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                channel_types: T::Hash[Symbol, T::Boolean],
+                enabled: T::Boolean
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/notiflows/models.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Notiflows
+  Delivery = Notiflows::Models::Delivery
+
+  DeliveryListParams = Notiflows::Models::DeliveryListParams
+
+  DeliveryRetrieveParams = Notiflows::Models::DeliveryRetrieveParams
+
+  Notification = Notiflows::Models::Notification
+
+  NotificationListDeliveriesParams =
+    Notiflows::Models::NotificationListDeliveriesParams
+
+  NotificationListParams = Notiflows::Models::NotificationListParams
+
+  NotificationRetrieveParams = Notiflows::Models::NotificationRetrieveParams
+
+  NotiflowRunParams = Notiflows::Models::NotiflowRunParams
+
+  Topic = Notiflows::Models::Topic
+
+  TopicDeleteParams = Notiflows::Models::TopicDeleteParams
+
+  TopicListParams = Notiflows::Models::TopicListParams
+
+  TopicRetrieveParams = Notiflows::Models::TopicRetrieveParams
+
+  Topics = Notiflows::Models::Topics
+
+  User = Notiflows::Models::User
+
+  UserDeleteParams = Notiflows::Models::UserDeleteParams
+
+  UserListParams = Notiflows::Models::UserListParams
+
+  UserRetrieveParams = Notiflows::Models::UserRetrieveParams
+
+  Users = Notiflows::Models::Users
+
+  UserUpsertParams = Notiflows::Models::UserUpsertParams
+end

data/rbi/notiflows/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Notiflows
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Notiflows::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(Notiflows::RequestOptions, Notiflows::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: Notiflows::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: Notiflows::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/notiflows/resources/deliveries.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Notiflows
+  module Resources
+    class Deliveries
+      # Retrieve details of a single delivery attempt.
+      #
+      # Includes the rendered content (`data`), channel information, and all timestamp
+      # tracking (sent, seen, read, clicked, archived).
+      sig do
+        params(
+          id: String,
+          request_options: Notiflows::RequestOptions::OrHash
+        ).returns(Notiflows::Delivery)
+      end
+      def retrieve(
+        # Delivery ID (UUID)
+        id,
+        request_options: {}
+      )
+      end
+
+      # Retrieve a paginated list of all deliveries in your project.
+      #
+      # A delivery represents a single attempt to send a notification through a specific
+      # channel. Use filters to narrow down results by channel, status, or time range.
+      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(Notiflows::Internal::CursorPage[Notiflows::Delivery])
+      end
+      def list(
+        # 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
+
+      # @api private
+      sig { params(client: Notiflows::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/notiflows/resources/notifications.rbi

@@ -0,0 +1,100 @@
+# typed: strong
+
+module Notiflows
+  module Resources
+    class Notifications
+      # Retrieve a single notification by ID, including the recipient, actor, and all
+      # delivery attempts.
+      sig do
+        params(
+          id: String,
+          request_options: Notiflows::RequestOptions::OrHash
+        ).returns(Notiflows::Notification)
+      end
+      def retrieve(
+        # Notification ID (UUID)
+        id,
+        request_options: {}
+      )
+      end
+
+      # Retrieve a paginated list of all notifications in your project.
+      #
+      # A notification represents a message sent to a single recipient through a
+      # notiflow run. Each notification can have multiple deliveries (one per channel).
+      sig do
+        params(
+          after: String,
+          before: String,
+          created_after: String,
+          created_before: String,
+          limit: Integer,
+          status: String,
+          topic: String,
+          request_options: Notiflows::RequestOptions::OrHash
+        ).returns(Notiflows::Internal::CursorPage[Notiflows::Notification])
+      end
+      def list(
+        # 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,
+        # Filter by status
+        status: nil,
+        # Filter by topic
+        topic: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve all delivery attempts for a specific notification.
+      sig do
+        params(
+          notification_id: String,
+          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(Notiflows::Internal::CursorPage[Notiflows::Delivery])
+      end
+      def list_deliveries(
+        # Notification ID (UUID)
+        notification_id,
+        # 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
+
+      # @api private
+      sig { params(client: Notiflows::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/notiflows/resources/notiflows.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Notiflows
+  module Resources
+    class Notiflows
+      # Execute a notiflow to send notifications to one or more recipients.
+      #
+      # You must provide either `recipients` (direct targeting) or `topic` (pub/sub
+      # targeting), but not both.
+      #
+      # **Direct targeting (`recipients`):** Specify exactly which users should receive
+      # the notification. Users are identified by their `external_id`. If a user doesn't
+      # exist, they will be created automatically with the provided attributes.
+      #
+      # **Topic targeting (`topic`):** Send to all users subscribed to the specified
+      # topic. Useful for broadcast scenarios.
+      #
+      # **Template variables:** The `data` object is passed to notification templates.
+      # Access variables using Liquid syntax: `{{ data.variable_name }}`
+      sig do
+        params(
+          notiflow_id: String,
+          actor: Notiflows::NotiflowRunParams::Actor::OrHash,
+          data: T.anything,
+          recipients: T::Array[Notiflows::NotiflowRunParams::Recipient::OrHash],
+          topic: String,
+          request_options: Notiflows::RequestOptions::OrHash
+        ).returns(Notiflows::Models::NotiflowRunResponse)
+      end
+      def run(
+        # Notiflow ID (UUID)
+        notiflow_id,
+        # Actor (triggering user) specification. Accessible in templates as `actor.*`.
+        actor: nil,
+        # Template variables. Accessible in notification templates as `data.*`.
+        data: nil,
+        # List of recipients. Each recipient must have an `external_id`. Users are
+        # auto-created if they don't exist.
+        recipients: nil,
+        # Topic name for pub/sub targeting. Cannot be used with `recipients`.
+        topic: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Notiflows::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/notiflows/resources/topics/subscriptions.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Notiflows
+  module Resources
+    class Topics
+      class Subscriptions
+        # Retrieve all users subscribed to a specific topic.
+        sig do
+          params(
+            topic_id: String,
+            after: String,
+            before: String,
+            created_after: String,
+            created_before: String,
+            limit: Integer,
+            request_options: Notiflows::RequestOptions::OrHash
+          ).returns(
+            Notiflows::Internal::CursorPage[Notiflows::Users::Subscription]
+          )
+        end
+        def list(
+          # Topic name
+          topic_id,
+          # 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
+
+        # Subscribe multiple users to a topic in a single request.
+        #
+        # - Topics are created automatically if they don't exist.
+        # - If a user is already subscribed, they are included in the `successful`
+        #   response.
+        # - Returns `207 Multi-Status` if some subscriptions failed.
+        sig do
+          params(
+            topic_id: String,
+            user_external_ids: T::Array[String],
+            request_options: Notiflows::RequestOptions::OrHash
+          ).returns(Notiflows::Topics::BulkOperationResponse)
+        end
+        def subscribe_bulk(
+          # Topic name
+          topic_id,
+          # List of user external IDs to subscribe/unsubscribe
+          user_external_ids:,
+          request_options: {}
+        )
+        end
+
+        # Unsubscribe multiple users from a topic in a single request.
+        #
+        # - Returns `207 Multi-Status` if some unsubscriptions failed (e.g., user not
+        #   found).
+        # - Users not subscribed to the topic are included in the `failed` response.
+        sig do
+          params(
+            topic_id: String,
+            user_external_ids: T::Array[String],
+            request_options: Notiflows::RequestOptions::OrHash
+          ).returns(Notiflows::Topics::BulkOperationResponse)
+        end
+        def unsubscribe_bulk(
+          # Topic name
+          topic_id,
+          # List of user external IDs to subscribe/unsubscribe
+          user_external_ids:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Notiflows::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end