rerout 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78cf1ae4573eccdeed6874c837565ea69f415c928c23def1fe506e674be53ec3
-  data.tar.gz: aa23cc62bcd1c3f2f80ee460fe691d0241027020e5d7f5d3bfacb2e909263286
+  metadata.gz: 4d7253a49e955b1812e46e3d0c435999fda4c7276d5f19bad47586ac56d06247
+  data.tar.gz: aeb26215de9a5c1e3f5de9637d348342f7cac7461179a8db7b005a438d1260ef
 SHA512:
-  metadata.gz: 4f1e411e4301abfd0009626920e3e974ca4f2b7db05de0d930e2eb9d432b3d71e8c51b5185875c04fdc8edd97cf1cc756e93215cc24e82103086f475714732e0
-  data.tar.gz: 1722814f198aca44eded94a7f5c983a7f30a9437a75652046ad61226cd454d005b248fe500a68080c4aa5b98fc0089274fe610089a3ac8f5b2a68832fcfb723b
+  metadata.gz: 1a4435295c93cc7e74812509c38d5cd7c829e004a37ec71796b3cb08b3707d7959ea4ba8d28aef0925d58bb48b00b39f8df807f4503af1fd33d880de3c4ffc04
+  data.tar.gz: ae6b3a652f246e38ca8537d4eda5699733de2fd3dcc1ed2e102eaca3e6e61041c1d8344082da8c764cdc35aeaa7c202c2818d6f0ed223bc10df376fdd5f658e6

data/CHANGELOG.md

@@ -4,6 +4,53 @@ All notable changes to the `rerout` gem are documented in this file. The
 format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2026-06-20
+
+### Added
+
+- New `tags` namespace for tag management — `client.tags.list`, `create`,
+  `update(tag_id, input)`, and `delete(tag_id)` against `/v1/projects/me/tags`
+  (API-key auth; project resolved from the key).
+- `Rerout::CreateTagInput` (required `name`, optional `color`) and
+  `Rerout::UpdateTagInput` (both fields optional; omitted fields are left
+  unchanged, no client-side empty-payload check) request bodies. Both also
+  accept a plain Hash.
+- New value models `Rerout::Models::TagSummary` (`Tag` plus `link_count`, the
+  list-response shape) and `Rerout::Models::ListTagsResult`. `tags.create` /
+  `tags.update` return the existing `Rerout::Models::Tag` (`{ id, name, color }`).
+
+## [0.4.0] - 2026-06-04
+
+### Added
+
+- Smart Link fields on `Rerout::Models::Link`: `password_protected`,
+  `max_clicks`, `click_count`, `track_conversions`, `routing_rules` (array of
+  `RoutingRule`), and `ab_variants` (array of `AbVariant`).
+- `Rerout::CreateLinkInput` gains optional `password`, `max_clicks`,
+  `track_conversions`, `routing_rules`, and `ab_variants`.
+- `Rerout::UpdateLinkInput` gains `password`, `max_clicks`,
+  `track_conversions`, `routing_rules`, and `ab_variants`. `password` and
+  `max_clicks` accept `Rerout::CLEAR` to send `null`; `routing_rules` and
+  `ab_variants` are a full replacement.
+- New `Rerout::Models::RoutingRule` and `Rerout::Models::AbVariant` value
+  objects. Routing-rule `condition_type` is `"country"` / `"device"`;
+  `condition_op` is `"is"` / `"is_not"` / `"in"`.
+- New `conversions` namespace — `client.conversions.record(click_id,
+  event_name, value_cents:, currency:)` against `POST /v1/conversions`,
+  returning a `Rerout::Models::RecordedConversion` (`recorded`, `duplicate`).
+- New `client.links.create_batch(inputs)` against `POST /v1/links/batch`,
+  returning a `Rerout::Models::BatchCreateLinksResult` (`created`, `total`,
+  `results` of `BatchLinkResult`).
+- New webhook event type `conversion.recorded`.
+
+## [0.3.0] - 2026-06-03
+
+### Added
+
+- Webhook endpoint management via a new `webhooks` namespace — `create`, `list`,
+  and `delete` against `/v1/projects/me/webhooks` (API-key auth). The signing
+  secret returned by `create` is shown once.
+
 ## [0.2.0] - 2026-06-02
 
 ### Added
@@ -40,5 +87,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Rerout::Error` with stable `code`, `status`, `path`, `timestamp`, `details`
   plus `rate_limited?` and `server_error?` convenience flags.
 
+[0.3.0]: https://github.com/ModestNerds-Co/rerout-sdks/releases/tag/ruby/v0.3.0
 [0.2.0]: https://github.com/ModestNerds-Co/rerout-sdks/releases/tag/ruby-v0.2.0
 [0.1.0]: https://github.com/ModestNerds-Co/rerout-sdks/releases/tag/ruby-v0.1.0

data/README.md

@@ -64,7 +64,8 @@ rerout = Rerout::Client.new(
 A blank or missing `api_key` raises `Rerout::Error` with code `missing_api_key`
 before any network call.
 
-The client exposes three namespaces: `links`, `project`, and `qr`.
+The client exposes these namespaces: `links`, `project`, `qr`, `webhooks`,
+`conversions`, and `tags`.
 
 ## Links
 
@@ -111,6 +112,99 @@ rerout.links.update('q4', Rerout::UpdateLinkInput.new(target_url: 'https://new.e
 An `UpdateLinkInput` with no fields set raises `Rerout::Error` (code
 `empty_update`) client-side without hitting the API.
 
+## Smart Links
+
+Links carry Smart Link configuration: `password_protected`, `max_clicks`,
+`click_count`, `track_conversions`, plus `routing_rules` (array of
+`Rerout::Models::RoutingRule`) and `ab_variants` (array of
+`Rerout::Models::AbVariant`).
+
+```ruby
+rerout.links.create(
+  Rerout::CreateLinkInput.new(
+    target_url: 'https://example.com',
+    password: 'hunter2',
+    max_clicks: 500,
+    track_conversions: true,
+    routing_rules: [
+      Rerout::Models::RoutingRule.new(
+        condition_type: 'country', # "country" | "device"
+        condition_op: 'in',        # "is" | "is_not" | "in"
+        condition_value: 'US,CA',
+        target_url: 'https://example.com/na'
+      )
+    ],
+    ab_variants: [
+      Rerout::Models::AbVariant.new(target_url: 'https://example.com/a', weight: 70),
+      Rerout::Models::AbVariant.new(target_url: 'https://example.com/b', weight: 30)
+    ]
+  )
+)
+
+# On update, password/max_clicks accept Rerout::CLEAR to null them;
+# routing_rules and ab_variants fully replace the existing config.
+rerout.links.update('q4', Rerout::UpdateLinkInput.new(password: Rerout::CLEAR, max_clicks: Rerout::CLEAR))
+rerout.links.update('q4', Rerout::UpdateLinkInput.new(routing_rules: [], ab_variants: []))
+```
+
+Routing rules and A/B variants also accept plain Hashes.
+
+## Batch link creation
+
+```ruby
+result = rerout.links.create_batch(
+  [
+    Rerout::CreateLinkInput.new(target_url: 'https://example.com/1'),
+    Rerout::CreateLinkInput.new(target_url: 'https://example.com/2', code: 'promo')
+  ]
+)
+result.created # => 2
+result.total   # => 2
+result.results.each { |r| puts [r.index, r.ok, r.code || r.error].inspect }
+```
+
+The batch endpoint accepts `target_url`, `code`, `expires_at`, and
+`domain_hostname` per link; other fields are ignored.
+
+## Conversions
+
+```ruby
+result = rerout.conversions.record('clk_123', 'purchase', value_cents: 4999, currency: 'USD')
+result.recorded  # => true
+result.duplicate # => false
+```
+
+`value_cents` and `currency` are optional. The call is idempotent — a repeat
+for the same click + event returns `duplicate: true`.
+
+## Tags
+
+Manage the tags that can be attached to links for the project that owns the API
+key. (Links carry their tags read-only as `link.tags`; this namespace lets you
+list, create, update, and delete them.)
+
+```ruby
+# List — each tag carries its live (non-deleted) link count.
+result = rerout.tags.list
+result.tags # => [Rerout::Models::TagSummary, ...] — { id, name, color, link_count }
+result.tags.first.link_count # => 4
+
+# Create — name is required; color is optional (server defaults to "teal").
+tag = rerout.tags.create(Rerout::CreateTagInput.new(name: 'Spring 2026', color: 'teal'))
+tag # => Rerout::Models::Tag — { id, name, color }
+
+# Update — only the fields you set are sent; omitted fields are left unchanged.
+rerout.tags.update(tag.id, Rerout::UpdateTagInput.new(name: 'Renamed'))
+rerout.tags.update(tag.id, Rerout::UpdateTagInput.new(color: 'red'))
+
+# Delete — also drops the tag from every link it was attached to.
+rerout.tags.delete(tag.id) # => { "deleted" => true }
+```
+
+`CreateTagInput` and `UpdateTagInput` also accept plain Hashes. An
+`UpdateTagInput` with no fields set sends an empty body; the server rejects a
+fully empty patch with HTTP `400`.
+
 ## Project
 
 ```ruby
@@ -147,6 +241,38 @@ File.write('q4.svg', svg)
 QR options: `size` (1–32), `margin` (0–16), `ecc` (`L`/`M`/`Q`/`H`), `domain`,
 and `refresh` (`true` is serialized as `1`; a string is sent verbatim).
 
+## Webhook management
+
+Manage the webhook endpoints that receive event deliveries for the project that
+owns the API key. (This is the `webhooks` namespace — distinct from
+`Rerout::Webhooks`, which verifies inbound signatures below.)
+
+```ruby
+# Create — name, url, and events are required.
+created = rerout.webhooks.create(
+  Rerout::CreateWebhookInput.new(
+    name: 'prod listener',
+    url: 'https://hooks.brand.com/rerout',
+    events: ['link.created'],
+    payload_format: 'json' # optional: "json" (default) or "slack"
+  )
+)
+
+created.endpoint.id      # => "wh_..."
+created.signing_secret   # => "whsec_..." — shown ONCE; persist it now.
+
+# List endpoints plus the event types the server can deliver.
+result = rerout.webhooks.list
+result.endpoints   # => [Rerout::Models::Webhook, ...]
+result.event_types # => ["link.created", ...]
+
+# Delete (soft delete) — idempotent.
+rerout.webhooks.delete('wh_...') # => { "deleted" => true }
+```
+
+The `signing_secret` returned by `create` is the value you pass as `secret:` to
+`verify_signature` below — store it securely, as it cannot be retrieved again.
+
 ## Webhook signature verification
 
 Rerout signs every webhook delivery with an `X-Rerout-Signature` header. Verify

data/lib/rerout/client.rb

@@ -5,14 +5,21 @@ require 'json'
 
 require_relative 'version'
 require_relative 'error'
+require_relative 'models'
+require_relative 'input_serialization'
 require_relative 'create_link_input'
 require_relative 'update_link_input'
+require_relative 'create_webhook_input'
+require_relative 'create_tag_input'
+require_relative 'update_tag_input'
 require_relative 'qr_options'
 require_relative 'webhooks'
-require_relative 'models'
 require_relative 'links'
 require_relative 'project'
 require_relative 'qr'
+require_relative 'webhooks_resource'
+require_relative 'conversions_resource'
+require_relative 'tags_resource'
 
 module Rerout
   # Default production API base URL.
@@ -36,6 +43,12 @@ module Rerout
     attr_reader :project
     # @return [Resources::Qr] QR namespace.
     attr_reader :qr
+    # @return [Resources::Webhooks] webhook endpoint management namespace.
+    attr_reader :webhooks
+    # @return [Resources::Conversions] conversion tracking namespace.
+    attr_reader :conversions
+    # @return [Resources::Tags] tag management namespace.
+    attr_reader :tags
 
     # @param api_key [String] project API key (`rrk_…`). Required.
     # @param base_url [String, nil] override base URL. Defaults to `https://api.rerout.co`.
@@ -61,6 +74,9 @@ module Rerout
       @links = Resources::Links.new(self)
       @project = Resources::Project.new(self)
       @qr = Resources::Qr.new(self)
+      @webhooks = Resources::Webhooks.new(self)
+      @conversions = Resources::Conversions.new(self)
+      @tags = Resources::Tags.new(self)
     end
 
     # Perform a JSON request against the Rerout API.

data/lib/rerout/conversions_resource.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rerout
+  module Resources
+    # Conversion tracking namespace — record a conversion against a recorded
+    # click. Reach it via `client.conversions`.
+    class Conversions
+      # @param client [Rerout::Client]
+      def initialize(client)
+        @client = client
+      end
+
+      # Record a conversion for a click via `POST /v1/conversions`.
+      #
+      # @param click_id [String] the id of the click being converted.
+      # @param event_name [String] name of the conversion event (e.g. `"purchase"`).
+      # @param value_cents [Integer, nil] optional monetary value in the
+      #   smallest currency unit (cents). Omitted when nil.
+      # @param currency [String, nil] optional ISO-4217 currency code
+      #   (e.g. `"USD"`). Omitted when nil.
+      # @return [Rerout::Models::RecordedConversion] `recorded` + `duplicate`
+      #   flags. Idempotent — a repeat for the same click + event returns
+      #   `duplicate: true`.
+      def record(click_id, event_name, value_cents: nil, currency: nil)
+        raise ArgumentError, 'click_id is required' if click_id.nil? || click_id.to_s.empty?
+        raise ArgumentError, 'event_name is required' if event_name.nil? || event_name.to_s.empty?
+
+        body = { 'click_id' => click_id, 'event_name' => event_name }
+        body['value_cents'] = value_cents unless value_cents.nil?
+        body['currency'] = currency unless currency.nil?
+
+        response = @client.request(method: :post, path: '/v1/conversions', body: body)
+        Models::RecordedConversion.from_hash(response)
+      end
+    end
+  end
+end

data/lib/rerout/create_link_input.rb

@@ -6,7 +6,9 @@ module Rerout
   class CreateLinkInput
     attr_reader :target_url, :domain_hostname, :code, :expires_at,
                 :seo_title, :seo_description, :seo_image_url,
-                :seo_canonical_url, :seo_noindex
+                :seo_canonical_url, :seo_noindex,
+                :password, :max_clicks, :track_conversions,
+                :routing_rules, :ab_variants
 
     # @param target_url [String] required, the destination URL.
     # @param domain_hostname [String, nil] verified custom domain (e.g. `go.brand.com`).
@@ -17,9 +19,18 @@ module Rerout
     # @param seo_image_url [String, nil] absolute https:// URL.
     # @param seo_canonical_url [String, nil]
     # @param seo_noindex [Boolean, nil] default server-side: `true`.
+    # @param password [String, nil] gate the link behind a password.
+    # @param max_clicks [Integer, nil] disable the link after this many clicks.
+    # @param track_conversions [Boolean, nil] enable conversion tracking.
+    # @param routing_rules [Array<Rerout::Models::RoutingRule, Hash>, nil]
+    #   Smart Link routing rules.
+    # @param ab_variants [Array<Rerout::Models::AbVariant, Hash>, nil]
+    #   A/B-test variants — each `{ target_url:, weight? }`.
     def initialize(target_url:, domain_hostname: nil, code: nil, expires_at: nil,
                    seo_title: nil, seo_description: nil, seo_image_url: nil,
-                   seo_canonical_url: nil, seo_noindex: nil)
+                   seo_canonical_url: nil, seo_noindex: nil,
+                   password: nil, max_clicks: nil, track_conversions: nil,
+                   routing_rules: nil, ab_variants: nil)
       raise ArgumentError, 'target_url is required' if target_url.nil? || target_url.to_s.empty?
 
       @target_url = target_url
@@ -31,6 +42,11 @@ module Rerout
       @seo_image_url = seo_image_url
       @seo_canonical_url = seo_canonical_url
       @seo_noindex = seo_noindex
+      @password = password
+      @max_clicks = max_clicks
+      @track_conversions = track_conversions
+      @routing_rules = routing_rules
+      @ab_variants = ab_variants
       freeze
     end
 
@@ -45,6 +61,11 @@ module Rerout
       hash['seo_image_url'] = seo_image_url unless seo_image_url.nil?
       hash['seo_canonical_url'] = seo_canonical_url unless seo_canonical_url.nil?
       hash['seo_noindex'] = seo_noindex unless seo_noindex.nil?
+      hash['password'] = password unless password.nil?
+      hash['max_clicks'] = max_clicks unless max_clicks.nil?
+      hash['track_conversions'] = track_conversions unless track_conversions.nil?
+      hash['routing_rules'] = routing_rules.map { |r| InputSerialization.rule_hash(r) } unless routing_rules.nil?
+      hash['ab_variants'] = ab_variants.map { |v| InputSerialization.variant_hash(v) } unless ab_variants.nil?
       hash
     end
   end

data/lib/rerout/create_tag_input.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rerout
+  # Request body for `POST /v1/projects/me/tags`. `name` is required; `color`
+  # is optional and omitted from the payload when not set (the server validates
+  # it against its palette and defaults to `"teal"`).
+  class CreateTagInput
+    attr_reader :name, :color
+
+    # @param name [String] required, the tag label.
+    # @param color [String, nil] optional tag color. Server default: `"teal"`.
+    def initialize(name:, color: nil)
+      raise ArgumentError, 'name is required' if name.nil? || name.to_s.empty?
+
+      @name = name
+      @color = color
+      freeze
+    end
+
+    # Serialize for the wire. `color` is only included when set.
+    def to_h
+      hash = { 'name' => name }
+      hash['color'] = color unless color.nil?
+      hash
+    end
+  end
+end

data/lib/rerout/create_webhook_input.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rerout
+  # Request body for `POST /v1/projects/me/webhooks`. `name`, `url`, and
+  # `events` are required; `is_active` and `payload_format` are optional and
+  # omitted from the payload when not set (server defaults apply).
+  class CreateWebhookInput
+    attr_reader :name, :url, :events, :is_active, :payload_format
+
+    # @param name [String] required, human-readable label for the endpoint.
+    # @param url [String] required, public https:// URL that receives deliveries.
+    # @param events [Array<String>] required, non-empty list of event types
+    #   to subscribe to (e.g. `link.created`).
+    # @param is_active [Boolean, nil] whether the endpoint starts active.
+    #   Server default: `true`.
+    # @param payload_format [String, nil] payload encoding — `"json"` or
+    #   `"slack"`. Server default: `"json"`.
+    def initialize(name:, url:, events:, is_active: nil, payload_format: nil)
+      raise ArgumentError, 'name is required' if name.nil? || name.to_s.empty?
+      raise ArgumentError, 'url is required' if url.nil? || url.to_s.empty?
+      if events.nil? || !events.is_a?(Array) || events.empty?
+        raise ArgumentError, 'events is required and must be a non-empty Array'
+      end
+
+      @name = name
+      @url = url
+      @events = events
+      @is_active = is_active
+      @payload_format = payload_format
+      freeze
+    end
+
+    # Serialize for the wire. Optional fields are only included when set.
+    def to_h
+      hash = { 'name' => name, 'url' => url, 'events' => events }
+      hash['is_active'] = is_active unless is_active.nil?
+      hash['payload_format'] = payload_format unless payload_format.nil?
+      hash
+    end
+  end
+end

data/lib/rerout/input_serialization.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rerout
+  # Internal helpers for serializing Smart Link sub-objects (routing rules and
+  # A/B variants) accepted by {CreateLinkInput} / {UpdateLinkInput}. Each input
+  # element may be a {Rerout::Models::RoutingRule} / {Rerout::Models::AbVariant}
+  # value object or a plain Hash; both are coerced to the wire shape.
+  #
+  # @api private
+  module InputSerialization
+    module_function
+
+    # @param rule [Rerout::Models::RoutingRule, Hash]
+    # @return [Hash] string-keyed routing-rule payload.
+    def rule_hash(rule)
+      return rule.to_h if rule.is_a?(Models::RoutingRule)
+      return stringify(rule) if rule.is_a?(Hash)
+
+      raise ArgumentError, 'routing_rules entries must be Rerout::Models::RoutingRule or Hash'
+    end
+
+    # @param variant [Rerout::Models::AbVariant, Hash]
+    # @return [Hash] string-keyed A/B-variant payload (no server `id`).
+    def variant_hash(variant)
+      return variant.to_h if variant.is_a?(Models::AbVariant)
+      raise ArgumentError, 'ab_variants entries must be Rerout::Models::AbVariant or Hash' unless variant.is_a?(Hash)
+
+      h = stringify(variant)
+      h.delete('id')
+      h['weight'] = 1 unless h.key?('weight')
+      h
+    end
+
+    # Normalize a Hash to string keys without mutating the caller's object.
+    def stringify(hash)
+      hash.each_with_object({}) { |(k, v), out| out[k.to_s] = v }
+    end
+  end
+end

data/lib/rerout/links.rb

@@ -21,6 +21,30 @@ module Rerout
         Models::Link.from_hash(response)
       end
 
+      # Create many links in one call via `POST /v1/links/batch`.
+      #
+      # Each item may be a {Rerout::CreateLinkInput} or a plain Hash. Only the
+      # batch-supported fields (`target_url`, `code`, `expires_at`,
+      # `domain_hostname`) are forwarded — richer Smart Link fields are not
+      # accepted by the batch endpoint. A failed item does not raise; inspect
+      # `result.results[i].ok`.
+      #
+      # @param inputs [Array<Rerout::CreateLinkInput, Hash>]
+      # @return [Rerout::Models::BatchCreateLinksResult]
+      def create_batch(inputs)
+        links = Array(inputs).map { |item| batch_link_hash(item) }
+        if links.empty?
+          raise Error.new(
+            code: 'bad_request',
+            message: 'create_batch requires at least one link.',
+            status: 0
+          )
+        end
+
+        response = @client.request(method: :post, path: '/v1/links/batch', body: { 'links' => links })
+        Models::BatchCreateLinksResult.from_hash(response)
+      end
+
       # Paginated list of links.
       #
       # @param cursor [Integer, nil]
@@ -100,6 +124,28 @@ module Rerout
           raise ArgumentError, 'input must be a Rerout::CreateLinkInput or Hash'
         end
       end
+
+      # Reduce a create-link input to the fields the batch endpoint accepts:
+      # `target_url` (required), `code`, `expires_at`, `domain_hostname`.
+      def batch_link_hash(item)
+        source =
+          case item
+          when CreateLinkInput then item.to_h
+          when Hash then InputSerialization.stringify(item)
+          else
+            raise ArgumentError, 'batch link items must be a Rerout::CreateLinkInput or Hash'
+          end
+
+        unless source.key?('target_url') && !source['target_url'].to_s.empty?
+          raise ArgumentError, 'each batch link requires a target_url'
+        end
+
+        out = { 'target_url' => source['target_url'] }
+        %w[code expires_at domain_hostname].each do |key|
+          out[key] = source[key] unless source[key].nil?
+        end
+        out
+      end
     end
   end
 end

data/lib/rerout/models.rb

@@ -35,12 +35,158 @@ module Rerout
       end
     end
 
+    # A tag with the number of live (non-deleted) links it is attached to —
+    # `{ id:, name:, color:, link_count: }`. Returned by `tags.list`; the
+    # create/update responses use the plain {Tag} (no `link_count`).
+    class TagSummary
+      attr_reader :id, :name, :color, :link_count
+
+      def initialize(id:, name:, color:, link_count:)
+        @id = id
+        @name = name
+        @color = color
+        @link_count = link_count
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          id: hash['id'],
+          name: hash['name'],
+          color: hash['color'],
+          link_count: hash.fetch('link_count', 0)
+        )
+      end
+
+      def to_h
+        { id: id, name: name, color: color, link_count: link_count }
+      end
+
+      def ==(other)
+        other.is_a?(TagSummary) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, id, name, color, link_count].hash
+      end
+    end
+
+    # Result of `tags.list` — the project's tags with their live link counts.
+    class ListTagsResult
+      attr_reader :tags
+
+      def initialize(tags:)
+        @tags = tags.freeze
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(tags: (hash['tags'] || []).map { |t| TagSummary.from_hash(t) })
+      end
+
+      def to_h
+        { tags: tags.map(&:to_h) }
+      end
+
+      def ==(other)
+        other.is_a?(ListTagsResult) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+    end
+
+    # A Smart Link routing rule — send matching visitors to `target_url`.
+    # `condition_type` is `"country"` or `"device"`; `condition_op` is `"is"`,
+    # `"is_not"`, or `"in"`; `condition_value` is the value to compare against
+    # (e.g. `"US"` or `"US,CA,GB"` for `"in"`).
+    class RoutingRule
+      attr_reader :condition_type, :condition_op, :condition_value, :target_url
+
+      def initialize(condition_type:, condition_op:, condition_value:, target_url:)
+        @condition_type = condition_type
+        @condition_op = condition_op
+        @condition_value = condition_value
+        @target_url = target_url
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          condition_type: hash['condition_type'],
+          condition_op: hash['condition_op'],
+          condition_value: hash['condition_value'],
+          target_url: hash['target_url']
+        )
+      end
+
+      def to_h
+        {
+          'condition_type' => condition_type,
+          'condition_op' => condition_op,
+          'condition_value' => condition_value,
+          'target_url' => target_url
+        }
+      end
+
+      def ==(other)
+        other.is_a?(RoutingRule) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+    end
+
+    # One A/B-test variant attached to a Smart Link. `id` is assigned
+    # server-side (read-only); `weight` controls the relative traffic share and
+    # defaults to `1`.
+    class AbVariant
+      attr_reader :id, :target_url, :weight
+
+      def initialize(target_url:, weight: 1, id: nil)
+        @id = id
+        @target_url = target_url
+        @weight = weight
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          id: hash['id'],
+          target_url: hash['target_url'],
+          weight: hash.fetch('weight', 1)
+        )
+      end
+
+      # Render for create/update. The server-assigned `id` is never sent.
+      def to_h
+        { 'target_url' => target_url, 'weight' => weight }
+      end
+
+      def ==(other)
+        other.is_a?(AbVariant) && other.id == id &&
+          other.target_url == target_url && other.weight == weight
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, id, target_url, weight].hash
+      end
+    end
+
     # A short link.
     class Link
       ATTRS = %i[
         code short_url domain_hostname target_url project_id expires_at
         is_active seo_title seo_description seo_image_url seo_canonical_url
         seo_noindex seo_updated_at tags created_at updated_at
+        password_protected max_clicks click_count track_conversions
+        routing_rules ab_variants
       ].freeze
 
       attr_reader(*ATTRS)
@@ -48,6 +194,8 @@ module Rerout
       def initialize(**attrs)
         ATTRS.each { |k| instance_variable_set(:"@#{k}", attrs[k]) }
         @tags = (@tags || []).freeze
+        @routing_rules = (@routing_rules || []).freeze
+        @ab_variants = (@ab_variants || []).freeze
         freeze
       end
 
@@ -68,13 +216,24 @@ module Rerout
           seo_updated_at: hash['seo_updated_at'],
           tags: (hash['tags'] || []).map { |t| Tag.from_hash(t) },
           created_at: hash['created_at'],
-          updated_at: hash['updated_at']
+          updated_at: hash['updated_at'],
+          password_protected: hash.fetch('password_protected', false),
+          max_clicks: hash['max_clicks'],
+          click_count: hash.fetch('click_count', 0),
+          track_conversions: hash.fetch('track_conversions', false),
+          routing_rules: (hash['routing_rules'] || []).map { |r| RoutingRule.from_hash(r) },
+          ab_variants: (hash['ab_variants'] || []).map { |v| AbVariant.from_hash(v) }
         )
       end
 
       def to_h
         ATTRS.to_h do |k|
-          [k, k == :tags ? tags.map(&:to_h) : public_send(k)]
+          [k, case k
+              when :tags then tags.map(&:to_h)
+              when :routing_rules then routing_rules.map(&:to_h)
+              when :ab_variants then ab_variants.map(&:to_h)
+              else public_send(k)
+              end]
         end
       end
 
@@ -301,5 +460,218 @@ module Rerout
         [self.class, id, name, slug].hash
       end
     end
+
+    # A webhook endpoint registered to the project. Mirrors the server-side
+    # `WebhookEndpointResponse`.
+    class Webhook
+      ATTRS = %i[
+        id project_id name url events is_active payload_format
+        created_at updated_at last_delivery_at last_success_at last_failure_at
+      ].freeze
+
+      attr_reader(*ATTRS)
+
+      def initialize(**attrs)
+        ATTRS.each { |k| instance_variable_set(:"@#{k}", attrs[k]) }
+        @events = (@events || []).freeze
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          id: hash['id'],
+          project_id: hash['project_id'],
+          name: hash['name'],
+          url: hash['url'],
+          events: hash['events'] || [],
+          is_active: hash['is_active'],
+          payload_format: hash['payload_format'],
+          created_at: hash['created_at'],
+          updated_at: hash['updated_at'],
+          last_delivery_at: hash['last_delivery_at'],
+          last_success_at: hash['last_success_at'],
+          last_failure_at: hash['last_failure_at']
+        )
+      end
+
+      def to_h
+        ATTRS.to_h { |k| [k, public_send(k)] }
+      end
+
+      def ==(other)
+        other.is_a?(Webhook) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+    end
+
+    # Result of creating a webhook. The `signing_secret` (`whsec_…`) is
+    # returned **once** — store it now; it is never shown again.
+    class CreatedWebhook
+      attr_reader :endpoint, :signing_secret
+
+      def initialize(endpoint:, signing_secret:)
+        @endpoint = endpoint
+        @signing_secret = signing_secret
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          endpoint: Webhook.from_hash(hash['endpoint'] || {}),
+          signing_secret: hash['signing_secret']
+        )
+      end
+
+      def to_h
+        { endpoint: endpoint.to_h, signing_secret: signing_secret }
+      end
+
+      def ==(other)
+        other.is_a?(CreatedWebhook) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+    end
+
+    # List of webhook endpoints plus every event type the server can deliver.
+    class ListWebhooksResult
+      attr_reader :endpoints, :event_types
+
+      def initialize(endpoints:, event_types:)
+        @endpoints = endpoints.freeze
+        @event_types = event_types.freeze
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          endpoints: (hash['endpoints'] || []).map { |e| Webhook.from_hash(e) },
+          event_types: hash['event_types'] || []
+        )
+      end
+
+      def to_h
+        { endpoints: endpoints.map(&:to_h), event_types: event_types }
+      end
+
+      def ==(other)
+        other.is_a?(ListWebhooksResult) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+    end
+
+    # Result of recording a conversion via `POST /v1/conversions`. `recorded`
+    # is true when stored; `duplicate` is true when an identical conversion for
+    # the same click had already been recorded (the call is idempotent).
+    class RecordedConversion
+      attr_reader :recorded, :duplicate
+
+      def initialize(recorded:, duplicate:)
+        @recorded = recorded
+        @duplicate = duplicate
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          recorded: hash.fetch('recorded', false),
+          duplicate: hash.fetch('duplicate', false)
+        )
+      end
+
+      def to_h
+        { recorded: recorded, duplicate: duplicate }
+      end
+
+      def ==(other)
+        other.is_a?(RecordedConversion) && other.recorded == recorded && other.duplicate == duplicate
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, recorded, duplicate].hash
+      end
+    end
+
+    # Outcome of one link in a `links.create_batch` call. `index` is the input
+    # position; `ok` is true on success (then `code` is set), false on failure
+    # (then `error` carries the reason).
+    class BatchLinkResult
+      attr_reader :index, :ok, :code, :error
+
+      def initialize(index:, ok:, code: nil, error: nil)
+        @index = index
+        @ok = ok
+        @code = code
+        @error = error
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          index: hash['index'],
+          ok: hash['ok'],
+          code: hash['code'],
+          error: hash['error']
+        )
+      end
+
+      def to_h
+        { index: index, ok: ok, code: code, error: error }
+      end
+
+      def ==(other)
+        other.is_a?(BatchLinkResult) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+    end
+
+    # Aggregate result of `links.create_batch` (`POST /v1/links/batch`).
+    class BatchCreateLinksResult
+      attr_reader :created, :total, :results
+
+      def initialize(created:, total:, results:)
+        @created = created
+        @total = total
+        @results = results.freeze
+        freeze
+      end
+
+      def self.from_hash(hash)
+        new(
+          created: hash.fetch('created', 0),
+          total: hash.fetch('total', 0),
+          results: (hash['results'] || []).map { |r| BatchLinkResult.from_hash(r) }
+        )
+      end
+
+      def to_h
+        { created: created, total: total, results: results.map(&:to_h) }
+      end
+
+      def ==(other)
+        other.is_a?(BatchCreateLinksResult) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+    end
   end
 end

data/lib/rerout/tags_resource.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Rerout
+  module Resources
+    # Tag management namespace — list, create, update, and delete the tags that
+    # can be attached to links for the project that owns the API key. Reach it
+    # via `client.tags`.
+    class Tags
+      # @param client [Rerout::Client]
+      def initialize(client)
+        @client = client
+      end
+
+      # List the project's tags with their live link counts.
+      #
+      # @return [Rerout::Models::ListTagsResult]
+      def list
+        response = @client.request(method: :get, path: '/v1/projects/me/tags')
+        Models::ListTagsResult.from_hash(response)
+      end
+
+      # Create a tag. `color` is optional; the server validates and defaults it.
+      #
+      # @param input [Rerout::CreateTagInput, Hash] the request body.
+      # @return [Rerout::Models::Tag] the created tag (no `link_count`).
+      def create(input)
+        body = coerce_create_input(input)
+        response = @client.request(method: :post, path: '/v1/projects/me/tags', body: body)
+        Models::Tag.from_hash(response)
+      end
+
+      # Update a tag's name and/or color. Mirrors `links.update`: omitted fields
+      # are left unchanged. There is no client-side empty-payload check — the
+      # server rejects a fully empty patch with `400`.
+      #
+      # @param tag_id [String] the tag id (`tag_…`).
+      # @param input [Rerout::UpdateTagInput, Hash] the patch body.
+      # @return [Rerout::Models::Tag] the updated tag.
+      def update(tag_id, input)
+        body = coerce_update_input(input)
+        response = @client.request(method: :patch, path: tag_path(tag_id), body: body)
+        Models::Tag.from_hash(response)
+      end
+
+      # Delete a tag and drop its assignments from all links. Idempotent.
+      #
+      # @param tag_id [String] the tag id (`tag_…`).
+      # @return [Hash] `{ "deleted" => true }`
+      def delete(tag_id)
+        @client.request(method: :delete, path: tag_path(tag_id))
+      end
+
+      private
+
+      def tag_path(tag_id)
+        raise ArgumentError, 'tag_id is required' if tag_id.nil? || tag_id.to_s.empty?
+
+        "/v1/projects/me/tags/#{ERB::Util.url_encode(tag_id.to_s)}"
+      end
+
+      def coerce_create_input(input)
+        case input
+        when CreateTagInput then input.to_h
+        when Hash then input
+        else
+          raise ArgumentError, 'input must be a Rerout::CreateTagInput or Hash'
+        end
+      end
+
+      def coerce_update_input(input)
+        case input
+        when UpdateTagInput then input.to_h
+        when Hash then input
+        else
+          raise ArgumentError, 'input must be a Rerout::UpdateTagInput or Hash'
+        end
+      end
+    end
+  end
+end

data/lib/rerout/update_link_input.rb

@@ -37,11 +37,18 @@ module Rerout
     FIELDS = %i[
       target_url expires_at is_active seo_title seo_description
       seo_image_url seo_canonical_url seo_noindex
+      password max_clicks track_conversions routing_rules ab_variants
     ].freeze
 
+    # Smart Link fields that are a full replacement (an Array of value objects
+    # or Hashes) rather than a scalar — serialized element-by-element.
+    LIST_FIELDS = %i[routing_rules ab_variants].freeze
+
     def initialize(target_url: OMIT, expires_at: OMIT, is_active: OMIT,
                    seo_title: OMIT, seo_description: OMIT, seo_image_url: OMIT,
-                   seo_canonical_url: OMIT, seo_noindex: OMIT)
+                   seo_canonical_url: OMIT, seo_noindex: OMIT,
+                   password: OMIT, max_clicks: OMIT, track_conversions: OMIT,
+                   routing_rules: OMIT, ab_variants: OMIT)
       @values = {
         target_url: target_url,
         expires_at: expires_at,
@@ -50,20 +57,26 @@ module Rerout
         seo_description: seo_description,
         seo_image_url: seo_image_url,
         seo_canonical_url: seo_canonical_url,
-        seo_noindex: seo_noindex
+        seo_noindex: seo_noindex,
+        password: password,
+        max_clicks: max_clicks,
+        track_conversions: track_conversions,
+        routing_rules: routing_rules,
+        ab_variants: ab_variants
       }
       freeze
     end
 
     # Serialize for the wire. Unset fields are omitted; `Rerout::CLEAR`
-    # becomes `null`.
+    # becomes `null`. `routing_rules` / `ab_variants` are a full replacement
+    # and serialize their elements (value objects or Hashes).
     def to_h
       out = {}
       FIELDS.each do |field|
         v = @values[field]
         next if v.equal?(OMIT)
 
-        out[field.to_s] = v.equal?(CLEAR) ? nil : v
+        out[field.to_s] = serialize_field(field, v)
       end
       out
     end
@@ -77,5 +90,17 @@ module Rerout
     def value_for(field)
       @values.fetch(field)
     end
+
+    private
+
+    def serialize_field(field, value)
+      return nil if value.equal?(CLEAR)
+
+      case field
+      when :routing_rules then value.map { |r| InputSerialization.rule_hash(r) }
+      when :ab_variants then value.map { |v| InputSerialization.variant_hash(v) }
+      else value
+      end
+    end
   end
 end

data/lib/rerout/update_tag_input.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rerout
+  # Request body for `PATCH /v1/projects/me/tags/:tag_id`. Both fields are
+  # optional; an omitted field is left unchanged. Unlike {UpdateLinkInput},
+  # there is no client-side empty-payload check — mirroring the reference SDKs,
+  # the server returns `400` for a fully empty patch. Neither field is nullable,
+  # so there is no `Rerout::CLEAR` handling here.
+  #
+  # @example
+  #   Rerout::UpdateTagInput.new(name: 'Renamed')
+  #   Rerout::UpdateTagInput.new(color: 'red')
+  class UpdateTagInput
+    attr_reader :name, :color
+
+    # @param name [String, nil] new label. Omitted when not set.
+    # @param color [String, nil] new color. Omitted when not set.
+    def initialize(name: OMIT, color: OMIT)
+      @name = name
+      @color = color
+      freeze
+    end
+
+    # Serialize for the wire. Only fields that were set are included.
+    def to_h
+      hash = {}
+      hash['name'] = name unless name.equal?(OMIT)
+      hash['color'] = color unless color.equal?(OMIT)
+      hash
+    end
+
+    # @return [Boolean] true when no field was set.
+    def empty?
+      to_h.empty?
+    end
+  end
+end

data/lib/rerout/version.rb

@@ -2,5 +2,5 @@
 
 module Rerout
   # Library version. Follows semantic versioning.
-  VERSION = '0.2.0'
+  VERSION = '0.5.0'
 end

data/lib/rerout/webhooks_resource.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Rerout
+  module Resources
+    # Webhook endpoint management namespace — create, list, delete endpoints
+    # for the project that owns the API key.
+    #
+    # This is distinct from {Rerout::Webhooks}, which verifies *inbound*
+    # delivery signatures. Reach it via `client.webhooks`.
+    class Webhooks
+      # @param client [Rerout::Client]
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a webhook endpoint. The returned `signing_secret` (`whsec_…`) is
+      # shown once — persist it to verify future deliveries.
+      #
+      # @param input [Rerout::CreateWebhookInput, Hash] the request body.
+      # @return [Rerout::Models::CreatedWebhook]
+      def create(input)
+        body = coerce_input(input)
+        response = @client.request(method: :post, path: '/v1/projects/me/webhooks', body: body)
+        Models::CreatedWebhook.from_hash(response)
+      end
+
+      # List webhook endpoints and the event types the server can deliver.
+      #
+      # @return [Rerout::Models::ListWebhooksResult]
+      def list
+        response = @client.request(method: :get, path: '/v1/projects/me/webhooks')
+        Models::ListWebhooksResult.from_hash(response)
+      end
+
+      # Soft-delete an endpoint and abandon its pending deliveries. Idempotent.
+      #
+      # @param endpoint_id [String] the endpoint id (`wh_…`).
+      # @return [Hash] `{ "deleted" => true }`
+      def delete(endpoint_id)
+        @client.request(method: :delete, path: webhook_path(endpoint_id))
+      end
+
+      private
+
+      def webhook_path(endpoint_id)
+        raise ArgumentError, 'endpoint_id is required' if endpoint_id.nil? || endpoint_id.to_s.empty?
+
+        "/v1/projects/me/webhooks/#{ERB::Util.url_encode(endpoint_id.to_s)}"
+      end
+
+      def coerce_input(input)
+        case input
+        when CreateWebhookInput then input.to_h
+        when Hash then input
+        else
+          raise ArgumentError, 'input must be a Rerout::CreateWebhookInput or Hash'
+        end
+      end
+    end
+  end
+end

data/lib/rerout.rb

@@ -3,13 +3,20 @@
 require_relative 'rerout/version'
 require_relative 'rerout/error'
 require_relative 'rerout/models'
+require_relative 'rerout/input_serialization'
 require_relative 'rerout/create_link_input'
 require_relative 'rerout/update_link_input'
+require_relative 'rerout/create_webhook_input'
+require_relative 'rerout/create_tag_input'
+require_relative 'rerout/update_tag_input'
 require_relative 'rerout/qr_options'
 require_relative 'rerout/webhooks'
 require_relative 'rerout/links'
 require_relative 'rerout/project'
 require_relative 'rerout/qr'
+require_relative 'rerout/webhooks_resource'
+require_relative 'rerout/conversions_resource'
+require_relative 'rerout/tags_resource'
 require_relative 'rerout/client'
 
 # Official Ruby SDK for the Rerout branded-link API.

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rerout
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Codecraft Solutions
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -109,16 +108,23 @@ files:
 - README.md
 - lib/rerout.rb
 - lib/rerout/client.rb
+- lib/rerout/conversions_resource.rb
 - lib/rerout/create_link_input.rb
+- lib/rerout/create_tag_input.rb
+- lib/rerout/create_webhook_input.rb
 - lib/rerout/error.rb
+- lib/rerout/input_serialization.rb
 - lib/rerout/links.rb
 - lib/rerout/models.rb
 - lib/rerout/project.rb
 - lib/rerout/qr.rb
 - lib/rerout/qr_options.rb
+- lib/rerout/tags_resource.rb
 - lib/rerout/update_link_input.rb
+- lib/rerout/update_tag_input.rb
 - lib/rerout/version.rb
 - lib/rerout/webhooks.rb
+- lib/rerout/webhooks_resource.rb
 homepage: https://github.com/ModestNerds-Co/rerout-sdks
 licenses:
 - MIT
@@ -129,7 +135,6 @@ metadata:
   bug_tracker_uri: https://github.com/ModestNerds-Co/rerout-sdks/issues
   documentation_uri: https://rerout.co/docs
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -144,8 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Official Ruby SDK for the Rerout branded-link API.
 test_files: []