knockapi 0.6.1 → 1.0.0

data/rbi/knockapi/resources/audiences.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Audiences
+      # Adds one or more members to the specified audience.
+      sig do
+        params(
+          key: String,
+          members: T::Array[T.any(Knockapi::Models::AudienceAddMembersParams::Member, Knockapi::Internal::AnyHash)],
+          request_options: Knockapi::RequestOpts
+        )
+          .returns(String)
+      end
+      def add_members(
+        # The key of the audience.
+        key,
+        # A list of audience members to add.
+        members:,
+        request_options: {}
+      ); end
+      # Returns a paginated list of members for the specified audience.
+      sig do
+        params(key: String, request_options: Knockapi::RequestOpts)
+          .returns(Knockapi::Models::AudienceListMembersResponse)
+      end
+      def list_members(
+        # The key of the audience.
+        key,
+        request_options: {}
+      ); end
+      # Removes one or more members from the specified audience.
+      sig do
+        params(
+          key: String,
+          members: T::Array[T.any(Knockapi::Models::AudienceRemoveMembersParams::Member, Knockapi::Internal::AnyHash)],
+          request_options: Knockapi::RequestOpts
+        )
+          .returns(String)
+      end
+      def remove_members(
+        # The key of the audience.
+        key,
+        # A list of audience members to remove.
+        members:,
+        request_options: {}
+      ); end
+      # @api private
+      sig { params(client: Knockapi::Client).returns(T.attached_class) }
+      def self.new(client:); end
+    end
+  end
+end

data/rbi/knockapi/resources/bulk_operations.rbi

@@ -0,0 +1,18 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class BulkOperations
+      # Retrieves a bulk operation (if it exists) and displays the current state of it.
+      sig { params(id: String, request_options: Knockapi::RequestOpts).returns(Knockapi::Models::BulkOperation) }
+      def get(
+        # The ID of the bulk operation to retrieve.
+        id,
+        request_options: {}
+      ); end
+      # @api private
+      sig { params(client: Knockapi::Client).returns(T.attached_class) }
+      def self.new(client:); end
+    end
+  end
+end

data/rbi/knockapi/resources/channels/bulk.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Channels
+      class Bulk
+        # Bulk update the status of messages for a specific channel. The channel is
+        # specified by the `channel_id` parameter. The action to perform is specified by
+        # the `action` parameter, where the action is a status change action (e.g.
+        # `archive`, `unarchive`).
+        sig do
+          params(
+            channel_id: String,
+            action: Knockapi::Models::Channels::BulkUpdateMessageStatusParams::Action::OrSymbol,
+            archived: Knockapi::Models::Channels::BulkUpdateMessageStatusParams::Archived::OrSymbol,
+            delivery_status: Knockapi::Models::Channels::BulkUpdateMessageStatusParams::DeliveryStatus::OrSymbol,
+            engagement_status: Knockapi::Models::Channels::BulkUpdateMessageStatusParams::EngagementStatus::OrSymbol,
+            has_tenant: T::Boolean,
+            newer_than: Time,
+            older_than: Time,
+            recipient_ids: T::Array[String],
+            tenants: T::Array[String],
+            trigger_data: String,
+            workflows: T::Array[String],
+            request_options: Knockapi::RequestOpts
+          )
+            .returns(Knockapi::Models::BulkOperation)
+        end
+        def update_message_status(
+          # The ID of the channel to update messages for.
+          channel_id,
+          # The target status to be applied to the messages.
+          action,
+          # Limits the results to messages with the given archived status.
+          archived: nil,
+          # Limits the results to messages with the given delivery status.
+          delivery_status: nil,
+          # Limits the results to messages with the given engagement status.
+          engagement_status: nil,
+          # Limits the results to messages that have a tenant or not.
+          has_tenant: nil,
+          # Limits the results to messages inserted after the given date.
+          newer_than: nil,
+          # Limits the results to messages inserted before the given date.
+          older_than: nil,
+          # Limits the results to messages with the given recipient IDs.
+          recipient_ids: nil,
+          # Limits the results to messages with the given tenant IDs.
+          tenants: nil,
+          # Limits the results to only messages that were generated with the given data. See
+          # [trigger data filtering](/api-reference/overview/trigger-data-filtering) for
+          # more information.
+          trigger_data: nil,
+          # Limits the results to messages with the given workflow keys.
+          workflows: nil,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: Knockapi::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

data/rbi/knockapi/resources/channels.rbi

@@ -0,0 +1,14 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Channels
+      sig { returns(Knockapi::Resources::Channels::Bulk) }
+      attr_reader :bulk
+
+      # @api private
+      sig { params(client: Knockapi::Client).returns(T.attached_class) }
+      def self.new(client:); end
+    end
+  end
+end

data/rbi/knockapi/resources/integrations/census.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Integrations
+      class Census
+        # Processes a Census custom destination RPC request.
+        sig do
+          params(
+            id: String,
+            jsonrpc: String,
+            method_: String,
+            params: T::Hash[Symbol, T.anything],
+            request_options: Knockapi::RequestOpts
+          )
+            .returns(Knockapi::Models::Integrations::CensusCustomDestinationResponse)
+        end
+        def custom_destination(
+          # The unique identifier for the RPC request.
+          id:,
+          # The JSON-RPC version.
+          jsonrpc:,
+          # The method name to execute.
+          method_:,
+          # The parameters for the method.
+          params: nil,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: Knockapi::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

data/rbi/knockapi/resources/integrations/hightouch.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Integrations
+      class Hightouch
+        # Processes a Hightouch embedded destination RPC request.
+        sig do
+          params(
+            id: String,
+            jsonrpc: String,
+            method_: String,
+            params: T::Hash[Symbol, T.anything],
+            request_options: Knockapi::RequestOpts
+          )
+            .returns(Knockapi::Models::Integrations::HightouchEmbeddedDestinationResponse)
+        end
+        def embedded_destination(
+          # The unique identifier for the RPC request.
+          id:,
+          # The JSON-RPC version.
+          jsonrpc:,
+          # The method name to execute.
+          method_:,
+          # The parameters for the method.
+          params: nil,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: Knockapi::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

data/rbi/knockapi/resources/integrations.rbi

@@ -0,0 +1,17 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Integrations
+      sig { returns(Knockapi::Resources::Integrations::Census) }
+      attr_reader :census
+
+      sig { returns(Knockapi::Resources::Integrations::Hightouch) }
+      attr_reader :hightouch
+
+      # @api private
+      sig { params(client: Knockapi::Client).returns(T.attached_class) }
+      def self.new(client:); end
+    end
+  end
+end

data/rbi/knockapi/resources/messages/activities.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Messages
+      class Activities
+        # Returns a paginated list of activities for the specified message.
+        sig do
+          params(
+            message_id: String,
+            after: String,
+            before: String,
+            page_size: Integer,
+            trigger_data: String,
+            request_options: Knockapi::RequestOpts
+          )
+            .returns(Knockapi::Internal::ItemsCursor[Knockapi::Models::Activity])
+        end
+        def list(
+          # The ID of the message to fetch activities for.
+          message_id,
+          # 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,
+          # The trigger data to filter activities by.
+          trigger_data: nil,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: Knockapi::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

data/rbi/knockapi/resources/messages/batch.rbi

@@ -0,0 +1,113 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Messages
+      class Batch
+        # Marks the given messages as archived. Archived messages are hidden from the
+        # default message list in the feed but can still be accessed and unarchived later.
+        sig do
+          params(message_ids: T::Array[String], request_options: Knockapi::RequestOpts)
+            .returns(T::Array[Knockapi::Models::Message])
+        end
+        def archive(
+          # The message IDs to update the status of.
+          message_ids:,
+          request_options: {}
+        ); end
+        # Get the contents of multiple messages in a single request.
+        sig do
+          params(message_ids: T::Array[String], request_options: Knockapi::RequestOpts)
+            .returns(T::Array[Knockapi::Models::Messages::BatchGetContentResponseItem])
+        end
+        def get_content(
+          # The IDs of the messages to fetch contents of.
+          message_ids:,
+          request_options: {}
+        ); end
+        # Marks the given messages as interacted with by the user. This can include any
+        # user action on the message, with optional metadata about the specific
+        # interaction. Cannot include more than 5 key-value pairs, must not contain nested
+        # data. Read more about message engagement statuses
+        # [here](/send-notifications/message-statuses#engagement-status).
+        sig do
+          params(
+            message_ids: T::Array[String],
+            metadata: T.nilable(T::Hash[Symbol, T.anything]),
+            request_options: Knockapi::RequestOpts
+          )
+            .returns(T::Array[Knockapi::Models::Message])
+        end
+        def mark_as_interacted(
+          # The message IDs to batch mark as interacted with.
+          message_ids:,
+          # Metadata about the interaction.
+          metadata: nil,
+          request_options: {}
+        ); end
+        # Marks the given messages as `read`. Read more about message engagement statuses
+        # [here](/send-notifications/message-statuses#engagement-status).
+        sig do
+          params(message_ids: T::Array[String], request_options: Knockapi::RequestOpts)
+            .returns(T::Array[Knockapi::Models::Message])
+        end
+        def mark_as_read(
+          # The message IDs to update the status of.
+          message_ids:,
+          request_options: {}
+        ); end
+        # Marks the given messages as `seen`. This indicates that the user has viewed the
+        # message in their feed or inbox. Read more about message engagement statuses
+        # [here](/send-notifications/message-statuses#engagement-status).
+        sig do
+          params(message_ids: T::Array[String], request_options: Knockapi::RequestOpts)
+            .returns(T::Array[Knockapi::Models::Message])
+        end
+        def mark_as_seen(
+          # The message IDs to update the status of.
+          message_ids:,
+          request_options: {}
+        ); end
+        # Marks the given messages as `unread`. This reverses the `read` state. Read more
+        # about message engagement statuses
+        # [here](/send-notifications/message-statuses#engagement-status).
+        sig do
+          params(message_ids: T::Array[String], request_options: Knockapi::RequestOpts)
+            .returns(T::Array[Knockapi::Models::Message])
+        end
+        def mark_as_unread(
+          # The message IDs to update the status of.
+          message_ids:,
+          request_options: {}
+        ); end
+        # Marks the given messages as `unseen`. This reverses the `seen` state. Read more
+        # about message engagement statuses
+        # [here](/send-notifications/message-statuses#engagement-status).
+        sig do
+          params(message_ids: T::Array[String], request_options: Knockapi::RequestOpts)
+            .returns(T::Array[Knockapi::Models::Message])
+        end
+        def mark_as_unseen(
+          # The message IDs to update the status of.
+          message_ids:,
+          request_options: {}
+        ); end
+        # Marks the given messages as unarchived. This reverses the `archived` state.
+        # Archived messages are hidden from the default message list in the feed but can
+        # still be accessed and unarchived later.
+        sig do
+          params(message_ids: T::Array[String], request_options: Knockapi::RequestOpts)
+            .returns(T::Array[Knockapi::Models::Message])
+        end
+        def unarchive(
+          # The message IDs to update the status of.
+          message_ids:,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: Knockapi::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end

data/rbi/knockapi/resources/messages.rbi

@@ -0,0 +1,231 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Messages
+      sig { returns(Knockapi::Resources::Messages::Batch) }
+      attr_reader :batch
+
+      sig { returns(Knockapi::Resources::Messages::Activities) }
+      attr_reader :activities
+
+      # Returns a paginated list of messages for the current environment.
+      sig do
+        params(
+          after: String,
+          before: String,
+          channel_id: String,
+          engagement_status: T::Array[Knockapi::Models::MessageListParams::EngagementStatus::OrSymbol],
+          inserted_at: T.any(Knockapi::Models::MessageListParams::InsertedAt, Knockapi::Internal::AnyHash),
+          message_ids: T::Array[String],
+          page_size: Integer,
+          source: String,
+          status: T::Array[Knockapi::Models::MessageListParams::Status::OrSymbol],
+          tenant: String,
+          trigger_data: String,
+          workflow_categories: T::Array[String],
+          workflow_recipient_run_id: String,
+          workflow_run_id: String,
+          request_options: Knockapi::RequestOpts
+        )
+          .returns(Knockapi::Internal::EntriesCursor[Knockapi::Models::Message])
+      end
+      def list(
+        # The cursor to fetch entries after.
+        after: nil,
+        # The cursor to fetch entries before.
+        before: nil,
+        # Limits the results to items with the corresponding channel ID.
+        channel_id: nil,
+        # Limits the results to messages with the given engagement status.
+        engagement_status: nil,
+        inserted_at: nil,
+        # Limits the results to only the message IDs given (max 50). Note: when using this
+        # option, the results will be subject to any other filters applied to the query.
+        message_ids: nil,
+        # The number of items per page.
+        page_size: nil,
+        # Limits the results to messages triggered by the given workflow key.
+        source: nil,
+        # Limits the results to messages with the given delivery status.
+        status: nil,
+        # Limits the results to items with the corresponding tenant.
+        tenant: nil,
+        # Limits the results to only messages that were generated with the given data. See
+        # [trigger data filtering](/api-reference/overview/trigger-data-filtering) for
+        # more information.
+        trigger_data: nil,
+        # Limits the results to messages related to any of the provided categories.
+        workflow_categories: nil,
+        # Limits the results to messages for a specific recipient's workflow run.
+        workflow_recipient_run_id: nil,
+        # Limits the results to messages associated with the top-level workflow run ID
+        # returned by the workflow trigger request.
+        workflow_run_id: nil,
+        request_options: {}
+      ); end
+      # Archives a message for the user. Archived messages are hidden from the default
+      # message list in the feed but can still be accessed and unarchived later.
+      sig { params(message_id: String, request_options: Knockapi::RequestOpts).returns(Knockapi::Models::Message) }
+      def archive(
+        # The unique identifier for the message.
+        message_id,
+        request_options: {}
+      ); end
+      # Retrieves a specific message by its ID.
+      sig { params(message_id: String, request_options: Knockapi::RequestOpts).returns(Knockapi::Models::Message) }
+      def get(
+        # The unique identifier for the message.
+        message_id,
+        request_options: {}
+      ); end
+      # Returns the fully rendered contents of a message, where the response depends on
+      # which channel the message was sent through.
+      sig do
+        params(message_id: String, request_options: Knockapi::RequestOpts)
+          .returns(Knockapi::Models::MessageGetContentResponse)
+      end
+      def get_content(
+        # The ID of the message to fetch contents of.
+        message_id,
+        request_options: {}
+      ); end
+      # Returns a paginated list of activities for the specified message.
+      sig do
+        params(
+          message_id: String,
+          after: String,
+          before: String,
+          page_size: Integer,
+          trigger_data: String,
+          request_options: Knockapi::RequestOpts
+        )
+          .returns(Knockapi::Internal::ItemsCursor[Knockapi::Models::Activity])
+      end
+      def list_activities(
+        # The ID of the message to fetch activities for.
+        message_id,
+        # 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,
+        # The trigger data to filter activities by.
+        trigger_data: nil,
+        request_options: {}
+      ); end
+      # Returns a paginated list of delivery logs for the specified message.
+      sig do
+        params(
+          message_id: String,
+          after: String,
+          before: String,
+          page_size: Integer,
+          request_options: Knockapi::RequestOpts
+        )
+          .returns(Knockapi::Internal::EntriesCursor[Knockapi::Models::MessageDeliveryLog])
+      end
+      def list_delivery_logs(
+        # The ID of the message to fetch delivery logs for.
+        message_id,
+        # 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,
+        request_options: {}
+      ); end
+      # Returns a paginated list of events for the specified message.
+      sig do
+        params(
+          message_id: String,
+          after: String,
+          before: String,
+          page_size: Integer,
+          request_options: Knockapi::RequestOpts
+        )
+          .returns(Knockapi::Internal::EntriesCursor[Knockapi::Models::MessageEvent])
+      end
+      def list_events(
+        # The ID of the message to fetch events for.
+        message_id,
+        # 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,
+        request_options: {}
+      ); end
+      # Marks a message as `interacted` with by the user. This can include any user
+      # action on the message, with optional metadata about the specific interaction.
+      # Cannot include more than 5 key-value pairs, must not contain nested data. Read
+      # more about message engagement statuses
+      # [here](/send-notifications/message-statuses#engagement-status).
+      sig do
+        params(
+          message_id: String,
+          metadata: T::Hash[Symbol, T.anything],
+          request_options: Knockapi::RequestOpts
+        )
+          .returns(Knockapi::Models::Message)
+      end
+      def mark_as_interacted(
+        # The unique identifier for the message.
+        message_id,
+        # Metadata about the interaction.
+        metadata: nil,
+        request_options: {}
+      ); end
+      # Marks a message as `read`. This indicates that the user has read the message
+      # content. Read more about message engagement statuses
+      # [here](/send-notifications/message-statuses#engagement-status).
+      sig { params(message_id: String, request_options: Knockapi::RequestOpts).returns(Knockapi::Models::Message) }
+      def mark_as_read(
+        # The unique identifier for the message.
+        message_id,
+        request_options: {}
+      ); end
+      # Marks a message as `seen`. This indicates that the user has viewed the message
+      # in their feed or inbox. Read more about message engagement statuses
+      # [here](/send-notifications/message-statuses#engagement-status).
+      sig { params(message_id: String, request_options: Knockapi::RequestOpts).returns(Knockapi::Models::Message) }
+      def mark_as_seen(
+        # The unique identifier for the message.
+        message_id,
+        request_options: {}
+      ); end
+      # Marks a message as `unread`. This reverses the `read` state. Read more about
+      # message engagement statuses
+      # [here](/send-notifications/message-statuses#engagement-status).
+      sig { params(message_id: String, request_options: Knockapi::RequestOpts).returns(Knockapi::Models::Message) }
+      def mark_as_unread(
+        # The unique identifier for the message.
+        message_id,
+        request_options: {}
+      ); end
+      # Marks a message as `unseen`. This reverses the `seen` state. Read more about
+      # message engagement statuses
+      # [here](/send-notifications/message-statuses#engagement-status).
+      sig { params(message_id: String, request_options: Knockapi::RequestOpts).returns(Knockapi::Models::Message) }
+      def mark_as_unseen(
+        # The unique identifier for the message.
+        message_id,
+        request_options: {}
+      ); end
+      # Removes a message from the archived state, making it visible in the default
+      # message list in the feed again.
+      sig { params(message_id: String, request_options: Knockapi::RequestOpts).returns(Knockapi::Models::Message) }
+      def unarchive(
+        # The unique identifier for the message.
+        message_id,
+        request_options: {}
+      ); end
+      # @api private
+      sig { params(client: Knockapi::Client).returns(T.attached_class) }
+      def self.new(client:); end
+    end
+  end
+end

data/rbi/knockapi/resources/objects/bulk.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Knockapi
+  module Resources
+    class Objects
+      class Bulk
+        # Bulk deletes objects from the specified collection.
+        sig do
+          params(collection: String, object_ids: T::Array[String], request_options: Knockapi::RequestOpts)
+            .returns(Knockapi::Models::BulkOperation)
+        end
+        def delete(
+          # The collection this object belongs to.
+          collection,
+          # List of object IDs to delete.
+          object_ids:,
+          request_options: {}
+        ); end
+        # Add subscriptions for all objects in a single collection. If a subscription for
+        # an object in the collection already exists, it will be updated. This endpoint
+        # also handles
+        # [inline identifications](/managing-recipients/identifying-recipients#inline-identifying-recipients)
+        # for the `recipient` field.
+        sig do
+          params(
+            collection: String,
+            subscriptions: T::Array[T.any(Knockapi::Models::Objects::BulkAddSubscriptionsParams::Subscription, Knockapi::Internal::AnyHash)],
+            request_options: Knockapi::RequestOpts
+          )
+            .returns(Knockapi::Models::BulkOperation)
+        end
+        def add_subscriptions(
+          # The collection this object belongs to.
+          collection,
+          # A list of subscriptions.
+          subscriptions:,
+          request_options: {}
+        ); end
+        # Bulk sets up to 1,000 objects at a time in the specified collection.
+        sig do
+          params(
+            collection: String,
+            objects: T::Array[T.any(Knockapi::Models::InlineObjectRequest, Knockapi::Internal::AnyHash)],
+            request_options: Knockapi::RequestOpts
+          )
+            .returns(Knockapi::Models::BulkOperation)
+        end
+        def set(
+          # The collection this object belongs to.
+          collection,
+          # A list of objects.
+          objects:,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: Knockapi::Client).returns(T.attached_class) }
+        def self.new(client:); end
+      end
+    end
+  end
+end