sentdm 0.0.2

data/lib/sentdm/request_options.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sentdm
+  # 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 < Sentdm::Internal::Type::BaseModel
+    # @api private
+    #
+    # @param opts [Sentdm::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in Sentdm::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query, Sentdm::Internal::Type::HashOf[Sentdm::Internal::Type::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, Sentdm::Internal::Type::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    #
+    #   @return [Object, nil]
+    optional :extra_body, Sentdm::Internal::Type::HashOf[Sentdm::Internal::Type::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!method initialize(values = {})
+    #   Returns a new instance of RequestOptions.
+    #
+    #   @param values [Hash{Symbol=>Object}]
+
+    define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(Sentdm::RequestOptions, Sentdm::Internal::AnyHash) }
+    end
+  end
+end

data/lib/sentdm/resources/contacts.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Sentdm
+  module Resources
+    class Contacts
+      # Retrieves a paginated list of contacts for the authenticated customer. Supports
+      # server-side pagination with configurable page size. The customer ID is extracted
+      # from the authentication token.
+      #
+      # @overload list(page:, page_size:, request_options: {})
+      #
+      # @param page [Integer] The page number (zero-indexed). Default is 0.
+      #
+      # @param page_size [Integer] The number of items per page. Default is 20.
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::ContactListResponse]
+      #
+      # @see Sentdm::Models::ContactListParams
+      def list(params)
+        parsed, options = Sentdm::ContactListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "v2/contacts",
+          query: parsed.transform_keys(page_size: "pageSize"),
+          model: Sentdm::Models::ContactListResponse,
+          options: options
+        )
+      end
+
+      # Retrieves a contact by their phone number for the authenticated customer. Phone
+      # number should be in international format (e.g., +1234567890). The customer ID is
+      # extracted from the authentication token.
+      #
+      # @overload retrieve_by_phone(phone_number:, request_options: {})
+      #
+      # @param phone_number [String] The phone number in international format (e.g., +1234567890)
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::ContactListItem]
+      #
+      # @see Sentdm::Models::ContactRetrieveByPhoneParams
+      def retrieve_by_phone(params)
+        parsed, options = Sentdm::ContactRetrieveByPhoneParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "v2/contacts/phone",
+          query: parsed.transform_keys(phone_number: "phoneNumber"),
+          model: Sentdm::ContactListItem,
+          options: options
+        )
+      end
+
+      # Retrieves a specific contact by their unique identifier for the authenticated
+      # customer. The customer ID is extracted from the authentication token. Returns
+      # detailed contact information including phone number and creation timestamp.
+      #
+      # @overload retrieve_id(id:, request_options: {})
+      #
+      # @param id [String] The unique identifier (GUID) of the resource to retrieve
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::ContactListItem]
+      #
+      # @see Sentdm::Models::ContactRetrieveIDParams
+      def retrieve_id(params)
+        parsed, options = Sentdm::ContactRetrieveIDParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "v2/contacts/id",
+          query: parsed,
+          model: Sentdm::ContactListItem,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Sentdm::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sentdm/resources/messages.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Sentdm
+  module Resources
+    class Messages
+      # Retrieves comprehensive details about a specific message using the message ID.
+      # Returns complete message data including delivery status, channel information,
+      # template details, contact information, and pricing. The customer ID is extracted
+      # from the authentication token to ensure the message belongs to the authenticated
+      # customer.
+      #
+      # @overload retrieve(id, request_options: {})
+      #
+      # @param id [String]
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::MessageRetrieveResponse]
+      #
+      # @see Sentdm::Models::MessageRetrieveParams
+      def retrieve(id, params = {})
+        @client.request(
+          method: :get,
+          path: ["v2/messages/%1$s", id],
+          model: Sentdm::Models::MessageRetrieveResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Sentdm::Models::MessageSendQuickMessageParams} for more details.
+      #
+      # Sends a message to a phone number using the default template. This endpoint is
+      # rate limited to 5 messages per customer per day. The customer ID is extracted
+      # from the authentication token.
+      #
+      # @overload send_quick_message(custom_message:, phone_number:, request_options: {})
+      #
+      # @param custom_message [String] The custom message content to include in the template
+      #
+      # @param phone_number [String] The phone number to send the message to, in international format (e.g., +1234567
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see Sentdm::Models::MessageSendQuickMessageParams
+      def send_quick_message(params)
+        parsed, options = Sentdm::MessageSendQuickMessageParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/messages/quick-message",
+          body: parsed,
+          model: NilClass,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Sentdm::Models::MessageSendToContactParams} for more details.
+      #
+      # Sends a message to a specific contact using a template. The message can be sent
+      # via SMS or WhatsApp depending on the contact's capabilities. Optionally specify
+      # a webhook URL to receive delivery status updates. The customer ID is extracted
+      # from the authentication token.
+      #
+      # @overload send_to_contact(contact_id:, template_id:, template_variables: nil, request_options: {})
+      #
+      # @param contact_id [String] The unique identifier of the contact to send the message to
+      #
+      # @param template_id [String] The unique identifier of the template to use for the message
+      #
+      # @param template_variables [Hash{Symbol=>String}, nil] Optional key-value pairs of template variables to replace in the template body.
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see Sentdm::Models::MessageSendToContactParams
+      def send_to_contact(params)
+        parsed, options = Sentdm::MessageSendToContactParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/messages/contact",
+          body: parsed,
+          model: NilClass,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Sentdm::Models::MessageSendToPhoneParams} for more details.
+      #
+      # Sends a message to a phone number using a template. The phone number doesn't
+      # need to be a pre-existing contact. The message can be sent via SMS or WhatsApp.
+      # Optionally specify a webhook URL to receive delivery status updates. The
+      # customer ID is extracted from the authentication token.
+      #
+      # @overload send_to_phone(phone_number:, template_id:, template_variables: nil, request_options: {})
+      #
+      # @param phone_number [String] The phone number to send the message to, in international format (e.g., +1234567
+      #
+      # @param template_id [String] The unique identifier of the template to use for the message
+      #
+      # @param template_variables [Hash{Symbol=>String}, nil] Optional key-value pairs of template variables to replace in the template body.
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see Sentdm::Models::MessageSendToPhoneParams
+      def send_to_phone(params)
+        parsed, options = Sentdm::MessageSendToPhoneParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/messages/phone",
+          body: parsed,
+          model: NilClass,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Sentdm::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sentdm/resources/number_lookup.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sentdm
+  module Resources
+    class NumberLookup
+      # Retrieves detailed information about a phone number including validation,
+      # formatting, country information, and available messaging channels. The customer
+      # ID is extracted from the authentication token.
+      #
+      # @overload retrieve(phone_number:, request_options: {})
+      #
+      # @param phone_number [String]
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::NumberLookupRetrieveResponse]
+      #
+      # @see Sentdm::Models::NumberLookupRetrieveParams
+      def retrieve(params)
+        parsed, options = Sentdm::NumberLookupRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "v2/number-lookup",
+          query: parsed.transform_keys(phone_number: "phoneNumber"),
+          model: Sentdm::Models::NumberLookupRetrieveResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Sentdm::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sentdm/resources/organizations/users.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Sentdm
+  module Resources
+    class Organizations
+      class Users
+        # Retrieves a specific user by their ID. Requires appropriate permissions. The
+        # customerId can be either an organization ID or a profile ID.
+        #
+        # @overload retrieve(user_id, customer_id:, request_options: {})
+        #
+        # @param user_id [String]
+        # @param customer_id [String]
+        # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Sentdm::Models::Organizations::CustomerUser]
+        #
+        # @see Sentdm::Models::Organizations::UserRetrieveParams
+        def retrieve(user_id, params)
+          parsed, options = Sentdm::Organizations::UserRetrieveParams.dump_request(params)
+          customer_id =
+            parsed.delete(:customer_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["v2/organizations/%1$s/users/%2$s", customer_id, user_id],
+            model: Sentdm::Organizations::CustomerUser,
+            options: options
+          )
+        end
+
+        # Retrieves all users associated with an organization or sender profile. Requires
+        # appropriate permissions. Supports pagination.
+        #
+        # @overload list(customer_id, page:, page_size:, request_options: {})
+        #
+        # @param customer_id [String]
+        # @param page [Integer]
+        # @param page_size [Integer]
+        # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Sentdm::Models::Organizations::UserListResponse]
+        #
+        # @see Sentdm::Models::Organizations::UserListParams
+        def list(customer_id, params)
+          parsed, options = Sentdm::Organizations::UserListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: ["v2/organizations/%1$s/users", customer_id],
+            query: parsed.transform_keys(page_size: "pageSize"),
+            model: Sentdm::Models::Organizations::UserListResponse,
+            options: options
+          )
+        end
+
+        # Removes a user from an organization or sender profile. Requires admin
+        # permissions. This action permanently deletes the user association.
+        #
+        # @overload delete(user_id, customer_id:, request_options: {})
+        #
+        # @param user_id [String]
+        # @param customer_id [String]
+        # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [nil]
+        #
+        # @see Sentdm::Models::Organizations::UserDeleteParams
+        def delete(user_id, params)
+          parsed, options = Sentdm::Organizations::UserDeleteParams.dump_request(params)
+          customer_id =
+            parsed.delete(:customer_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :delete,
+            path: ["v2/organizations/%1$s/users/%2$s", customer_id, user_id],
+            model: NilClass,
+            options: options
+          )
+        end
+
+        # Invites a user to an organization or sender profile with a specified role.
+        # Requires appropriate permissions. The customerId can be either an organization
+        # ID or a profile ID.
+        #
+        # @overload invite(customer_id, email: nil, invited_by: nil, name: nil, role: nil, request_options: {})
+        #
+        # @param customer_id [String]
+        # @param email [String]
+        # @param invited_by [String, nil]
+        # @param name [String]
+        # @param role [String]
+        # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Sentdm::Models::Organizations::CustomerUser]
+        #
+        # @see Sentdm::Models::Organizations::UserInviteParams
+        def invite(customer_id, params = {})
+          parsed, options = Sentdm::Organizations::UserInviteParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["v2/organizations/%1$s/users", customer_id],
+            body: parsed,
+            model: Sentdm::Organizations::CustomerUser,
+            options: options
+          )
+        end
+
+        # Updates a user's role within an organization or sender profile. Requires admin
+        # permissions. Valid roles are: admin, billing, developer.
+        #
+        # @overload update_role(user_id, customer_id:, role: nil, request_options: {})
+        #
+        # @param user_id [String] Path param
+        #
+        # @param customer_id [String] Path param
+        #
+        # @param role [String] Body param
+        #
+        # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Sentdm::Models::Organizations::CustomerUser]
+        #
+        # @see Sentdm::Models::Organizations::UserUpdateRoleParams
+        def update_role(user_id, params)
+          parsed, options = Sentdm::Organizations::UserUpdateRoleParams.dump_request(params)
+          customer_id =
+            parsed.delete(:customer_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :put,
+            path: ["v2/organizations/%1$s/users/%2$s", customer_id, user_id],
+            body: parsed,
+            model: Sentdm::Organizations::CustomerUser,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Sentdm::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/sentdm/resources/organizations.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Sentdm
+  module Resources
+    class Organizations
+      # @return [Sentdm::Resources::Organizations::Users]
+      attr_reader :users
+
+      # Retrieves all organizations that the authenticated user has access to, including
+      # the sender profiles within each organization that the user can access. Returns
+      # organization details with nested profiles filtered by user permissions.
+      #
+      # @overload list(request_options: {})
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::OrganizationListResponse]
+      #
+      # @see Sentdm::Models::OrganizationListParams
+      def list(params = {})
+        @client.request(
+          method: :get,
+          path: "v2/organizations",
+          model: Sentdm::Models::OrganizationListResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Retrieves all sender profiles within an organization that the authenticated user
+      # has access to. Returns filtered list based on user's permissions.
+      #
+      # @overload retrieve_profiles(org_id, request_options: {})
+      #
+      # @param org_id [String]
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::OrganizationRetrieveProfilesResponse]
+      #
+      # @see Sentdm::Models::OrganizationRetrieveProfilesParams
+      def retrieve_profiles(org_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["v2/organizations/%1$s/profiles", org_id],
+          model: Sentdm::Models::OrganizationRetrieveProfilesResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Sentdm::Client]
+      def initialize(client:)
+        @client = client
+        @users = Sentdm::Resources::Organizations::Users.new(client: client)
+      end
+    end
+  end
+end

data/lib/sentdm/resources/templates.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Sentdm
+  module Resources
+    class Templates
+      # Some parameter documentations has been truncated, see
+      # {Sentdm::Models::TemplateCreateParams} for more details.
+      #
+      # Creates a new message template for the authenticated customer with comprehensive
+      # template definitions including headers, body, footer, and interactive buttons.
+      # Supports automatic metadata generation using AI (display name, language,
+      # category). Optionally submits the template for WhatsApp review. The customer ID
+      # is extracted from the authentication token.
+      #
+      # @overload create(definition:, category: nil, language: nil, submit_for_review: nil, request_options: {})
+      #
+      # @param definition [Sentdm::Models::TemplateDefinition] Template definition containing header, body, footer, and buttons
+      #
+      # @param category [String, nil] The template category (e.g., MARKETING, UTILITY, AUTHENTICATION). Can only be se
+      #
+      # @param language [String, nil] The template language code (e.g., en_US, es_ES). Can only be set when creating a
+      #
+      # @param submit_for_review [Boolean] When false, the template will be saved as draft.
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::TemplateResponse]
+      #
+      # @see Sentdm::Models::TemplateCreateParams
+      def create(params)
+        parsed, options = Sentdm::TemplateCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/templates",
+          body: parsed,
+          model: Sentdm::TemplateResponse,
+          options: options
+        )
+      end
+
+      # Retrieves a specific message template by its unique identifier for the
+      # authenticated customer with comprehensive template definitions including
+      # headers, body, footer, and interactive buttons. The customer ID is extracted
+      # from the authentication token.
+      #
+      # @overload retrieve(id, request_options: {})
+      #
+      # @param id [String]
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::TemplateResponse]
+      #
+      # @see Sentdm::Models::TemplateRetrieveParams
+      def retrieve(id, params = {})
+        @client.request(
+          method: :get,
+          path: ["v2/templates/%1$s", id],
+          model: Sentdm::TemplateResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Retrieves all message templates available for the authenticated customer with
+      # comprehensive template definitions including headers, body, footer, and
+      # interactive buttons. Supports advanced filtering by search term, status, and
+      # category, plus pagination. The customer ID is extracted from the authentication
+      # token.
+      #
+      # @overload list(page:, page_size:, category: nil, search: nil, status: nil, request_options: {})
+      #
+      # @param page [Integer] The page number (zero-indexed). Default is 0.
+      #
+      # @param page_size [Integer] The number of items per page (1-1000). Default is 100.
+      #
+      # @param category [String, nil] Optional filter by template category (e.g., MARKETING, UTILITY, AUTHENTICATION)
+      #
+      # @param search [String, nil] Optional search term to filter templates by name or content
+      #
+      # @param status [String, nil] Optional filter by template status (e.g., APPROVED, PENDING, REJECTED, DRAFT)
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Sentdm::Models::TemplateListResponse]
+      #
+      # @see Sentdm::Models::TemplateListParams
+      def list(params)
+        parsed, options = Sentdm::TemplateListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "v2/templates",
+          query: parsed.transform_keys(page_size: "pageSize"),
+          model: Sentdm::Models::TemplateListResponse,
+          options: options
+        )
+      end
+
+      # Deletes a specific message template by its unique identifier for the
+      # authenticated customer with smart deletion strategy. Deletion behavior: - If
+      # template has NO messages: Permanently deleted from database (hard delete). - If
+      # template has messages: Marked as deleted but preserved for message history (soft
+      # delete with snapshot). The template must exist and belong to the authenticated
+      # customer to be deleted successfully. The customer ID is extracted from the
+      # authentication token.
+      #
+      # @overload delete(id, request_options: {})
+      #
+      # @param id [String] The unique identifier (GUID) of the resource to retrieve
+      #
+      # @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see Sentdm::Models::TemplateDeleteParams
+      def delete(id, params = {})
+        @client.request(
+          method: :delete,
+          path: ["v2/templates/%1$s", id],
+          model: NilClass,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Sentdm::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sentdm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sentdm
+  VERSION = "0.0.2"
+end