vihaya-events 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bc964189032da23b22704e70018dfc84d1e062626c4dd1ce773afaba4746e30d
+  data.tar.gz: 9408a9f45ee799454fb04b93d4c0103c26016b478d07d830e232b7f5061c3b8e
+SHA512:
+  metadata.gz: cc1711f1be3cd370091be2183c39dcda4c43e20d40a29d1a44f35d38237a34b95c8620aa7a5bcf98acd8fad0a6d129063a162a878c38bb59ed2c412904b2df84
+  data.tar.gz: e0df7f05daadcc52963abd838db56440ac685ec0326e797b00a85f3f9f20ef92a447fa66335c5a242a988d95b4a299710e9a0a597a1413e95c1d7ceda4f0939b

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## 0.1.0 — 2026-04-08
+
+First public release on RubyGems.
+
+### Added
+- `Vihaya::Client` with `events` and `payments` resource namespaces.
+- `events.list`, `events.get(id)`, `events.register(id, data)` methods.
+- `payments.verify(payment_id:, order_id:, signature:, amount: nil)` method.
+- Plain-Ruby models for `Event`, `CustomField`, `SpecialPrice`, `Contact`,
+  `AgendaItem`, `Speaker`, `Sponsor`, `FAQItem`, `PromoCode`, and
+  `RegisterData` — feature parity with the JavaScript, Flutter, and Python
+  SDKs.
+- `Vihaya::Error` exception class with `#status` and `#data` accessors.
+- Zero runtime dependencies — built on `net/http` and `json` from stdlib.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vihaya Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+# Vihaya Events — Ruby SDK
+
+[![Gem Version](https://img.shields.io/gem/v/vihaya-events.svg)](https://rubygems.org/gems/vihaya-events)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+The official Ruby SDK for the [Vihaya Events](https://vihaya.app) platform.
+Built on the Ruby standard library (`net/http` + `json`) with **zero runtime
+dependencies**, and feature parity with the JavaScript, Flutter, and Python
+SDKs.
+
+## Install
+
+```bash
+gem install vihaya-events
+```
+
+Or add it to your Gemfile:
+
+```ruby
+gem "vihaya-events"
+```
+
+Requires Ruby 3.0+.
+
+## Quick start
+
+```ruby
+require "vihaya"
+
+vh = Vihaya::Client.new("vh_live_...")  # get your key from the developer dashboard
+
+vh.events.list.each do |event|
+  puts "#{event.title} — #{event.location}"
+end
+```
+
+## Fetch a full event
+
+`events.get` returns an `Event` with every piece of metadata the organizer
+has configured — speakers, agenda, sponsors, FAQs, custom fields, pricing
+tiers, and sub-events for mega events.
+
+```ruby
+event = vh.events.get("evt_8x42j9")
+
+puts event.title
+puts "Mode: #{event.event_mode}  Timezone: #{event.timezone}"
+
+event.speaker_list.each do |speaker|
+  puts "- #{speaker.name} (#{speaker.role})"
+end
+
+event.agenda_list.each do |item|
+  puts "[#{item.time}] #{item.title}"
+end
+
+event.special_prices.each do |tier|
+  puts "  #{tier.name}: ₹#{tier.amount}"
+end
+```
+
+### Mega events
+
+If `event.mega_event?` is true, it contains sub-events. Each sub-event has
+its own tiers, custom fields, etc.
+
+```ruby
+if event.mega_event?
+  event.sub_events.each do |sub|
+    price = sub.free? ? "Free" : "₹#{sub.price}"
+    puts "- #{sub.title} (#{price})"
+  end
+end
+```
+
+## Register an attendee
+
+```ruby
+registration = Vihaya::RegisterData.new(
+  name: "Anjali Mehta",
+  email: "anjali@example.com",
+  phone: "+919820012345",
+  custom_fields: { "T-Shirt Size" => "L", "College" => "Vihaya Institute" }
+)
+
+result = vh.events.register("evt_8x42j9", registration)
+
+if result[:isPaid]
+  order_id = result[:orderId]
+  # Launch Razorpay checkout with this order_id, then verify server-side:
+  vh.payments.verify(
+    payment_id: "pay_xxx",
+    order_id: order_id,
+    signature: "sig_xxx"
+  )
+else
+  puts "Registered! ID: #{result[:registrationId]}"
+end
+```
+
+You can also pass a plain `Hash` instead of `RegisterData` if you prefer — the
+SDK will send it as-is, so use camelCase keys for that path.
+
+## Error handling
+
+All API failures raise `Vihaya::Error` with the HTTP status and raw body:
+
+```ruby
+begin
+  vh.events.get("evt_does_not_exist")
+rescue Vihaya::Error => e
+  puts "#{e.message} (status=#{e.status})"
+  puts e.data.inspect
+end
+```
+
+## API reference
+
+### `Vihaya::Client.new(api_key, base_url: ..., headers: {}, timeout: 30)`
+
+The main client. `api_key` is required; everything else is keyword.
+
+### `vh.events`
+
+| Method | Returns | Description |
+| --- | --- | --- |
+| `list` | `Array<Vihaya::Event>` | All events on the authenticated account. |
+| `get(event_id)` | `Vihaya::Event` | Full metadata for one event. |
+| `register(event_id, data)` | `Hash` | Submit a registration. `data` can be `RegisterData` or `Hash`. |
+
+### `vh.payments`
+
+| Method | Returns | Description |
+| --- | --- | --- |
+| `verify(payment_id:, order_id:, signature:, amount: nil)` | `Hash` | Server-side Razorpay signature verification. |
+
+> **Security:** never hard-code a live secret key in client-side code. Use
+> environment variables and perform payment verification from a trusted
+> backend environment only.
+
+## Development
+
+```bash
+git clone https://github.com/Vishnu252005/vihaya-sdk-ruby.git
+cd vihaya-sdk-ruby
+ruby test/test_client.rb
+gem build vihaya-events.gemspec
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/examples/quickstart.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Quickstart example for the Vihaya Ruby SDK.
+#
+# Run with:
+#
+#     VIHAYA_API_KEY=vh_live_... ruby examples/quickstart.rb
+
+require "vihaya"
+
+api_key = ENV.fetch("VIHAYA_API_KEY", nil)
+if api_key.nil? || api_key.empty?
+  warn "Set VIHAYA_API_KEY in your environment first."
+  exit 1
+end
+
+vh = Vihaya::Client.new(api_key)
+
+begin
+  puts "Fetching events..."
+  events = vh.events.list
+  puts "Found #{events.length} event(s)."
+
+  events.first(5).each do |event|
+    price = event.free? ? "Free" : "₹#{event.price}"
+    puts "  - [#{event.id}] #{event.title}  #{price}"
+  end
+
+  exit 0 if events.empty?
+
+  first = events.first
+  puts "\nFetching details for: #{first.id}"
+  detail = vh.events.get(first.id)
+  puts "  title:    #{detail.title}"
+  puts "  mode:     #{detail.event_mode}"
+  puts "  timezone: #{detail.timezone}"
+  puts "  speakers: #{detail.speaker_list.length}"
+  puts "  agenda:   #{detail.agenda_list.length} items"
+
+  puts "\nRegistering a test attendee for: #{first.id}"
+  registration = Vihaya::RegisterData.new(
+    name: "Quickstart User",
+    email: "quickstart@vihaya.app",
+    phone: "+919999999999",
+    custom_fields: { "College" => "Vihaya Institute" }
+  )
+  response = vh.events.register(first.id, registration)
+
+  if response[:isPaid]
+    puts "  Payment required. Order ID: #{response[:orderId]}"
+  else
+    puts "  Registered. Registration ID: #{response[:registrationId]}"
+  end
+rescue Vihaya::Error => e
+  warn "API error: #{e.message} (status=#{e.status})"
+  exit 2
+end

data/lib/vihaya/client.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+require_relative "error"
+require_relative "models"
+require_relative "version"
+
+module Vihaya
+  # The main Vihaya API client.
+  #
+  # @example
+  #   require "vihaya"
+  #
+  #   vh = Vihaya::Client.new("vh_live_...")
+  #   vh.events.list.each do |event|
+  #     puts "#{event.title} - #{event.date}"
+  #   end
+  class Client
+    DEFAULT_BASE_URL = "https://events.vihaya.app"
+    DEFAULT_TIMEOUT  = 30
+
+    attr_reader :events, :payments
+
+    # @param api_key  [String] Your Vihaya API key. Get one from the developer
+    #                          dashboard at https://events.vihaya.app/profile/developer.
+    # @param base_url [String] Override the API base URL. Defaults to
+    #                          "https://events.vihaya.app".
+    # @param headers  [Hash]   Extra headers to send with every request.
+    # @param timeout  [Integer, Float] Per-request timeout in seconds (default 30).
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, headers: {}, timeout: DEFAULT_TIMEOUT)
+      raise ArgumentError, "api_key is required" if api_key.nil? || api_key.to_s.empty?
+
+      @api_key = api_key
+      @base_url = base_url.to_s.sub(%r{/\z}, "")
+      @extra_headers = headers || {}
+      @timeout = timeout
+
+      @events = EventsAPI.new(self)
+      @payments = PaymentsAPI.new(self)
+    end
+
+    # Internal: perform a JSON request. Raises {Vihaya::Error} on any
+    # non-2xx response or transport error.
+    #
+    # @api private
+    def request(method, path, body: nil, query: nil)
+      uri = URI.parse(@base_url + path)
+      uri.query = URI.encode_www_form(query) if query && !query.empty?
+
+      req = build_request(method, uri, body)
+
+      response = perform(uri, req)
+      parse_response(response)
+    rescue Vihaya::Error
+      raise
+    rescue StandardError => e
+      raise Vihaya::Error, "Network error: #{e.message}"
+    end
+
+    private
+
+    def build_request(method, uri, body)
+      klass = {
+        "GET"    => Net::HTTP::Get,
+        "POST"   => Net::HTTP::Post,
+        "PUT"    => Net::HTTP::Put,
+        "PATCH"  => Net::HTTP::Patch,
+        "DELETE" => Net::HTTP::Delete
+      }.fetch(method.to_s.upcase) { raise ArgumentError, "Unsupported HTTP method: #{method}" }
+
+      req = klass.new(uri.request_uri)
+      default_headers.each { |k, v| req[k] = v }
+      @extra_headers.each { |k, v| req[k.to_s] = v.to_s }
+      req.body = JSON.generate(body) if body
+      req
+    end
+
+    def default_headers
+      {
+        "x-api-key" => @api_key,
+        "Content-Type" => "application/json",
+        "Accept" => "application/json",
+        "User-Agent" => "vihaya-ruby/#{Vihaya::VERSION}"
+      }
+    end
+
+    def perform(uri, req)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = @timeout
+      http.read_timeout = @timeout
+      http.request(req)
+    end
+
+    def parse_response(response)
+      body = response.body.to_s
+      data =
+        if body.empty?
+          nil
+        else
+          begin
+            JSON.parse(body, symbolize_names: true)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+
+      code = response.code.to_i
+      return data if code.between?(200, 299)
+
+      message =
+        (data.is_a?(Hash) && (data[:error] || data[:message])) ||
+        "Vihaya API error (#{code})"
+      raise Vihaya::Error.new(message, status: code, data: data)
+    end
+
+    # ------------------------------------------------------------------
+    # Resource namespaces
+    # ------------------------------------------------------------------
+
+    # Event-related API methods. Access via {Vihaya::Client#events}.
+    class EventsAPI
+      def initialize(client)
+        @client = client
+      end
+
+      # List all events on the authenticated account.
+      # @return [Array<Vihaya::Event>]
+      def list
+        result = @client.request("GET", "/api/v1/events")
+        data = Client.unwrap(result, default: [])
+        Event.from_list(data)
+      end
+
+      # Fetch comprehensive metadata for a single event by ID.
+      # @param event_id [String]
+      # @return [Vihaya::Event]
+      def get(event_id)
+        result = @client.request("GET", "/api/v1/events/#{event_id}")
+        Event.new(Client.unwrap(result, default: result) || {})
+      end
+
+      # Register an attendee for an event.
+      #
+      # For paid events the response will include an `orderId` you should
+      # use to launch Razorpay checkout. For free events the response
+      # confirms the registration directly.
+      #
+      # @param event_id [String]
+      # @param data     [Vihaya::RegisterData, Hash] payload
+      # @return [Hash] raw API response (symbol keys)
+      def register(event_id, data)
+        payload =
+          case data
+          when RegisterData then data.to_payload
+          when Hash         then data
+          else
+            raise ArgumentError, "data must be a Vihaya::RegisterData or Hash"
+          end
+
+        result = @client.request("POST", "/api/v1/events/#{event_id}/register", body: payload)
+        result.is_a?(Hash) ? result : { data: result }
+      end
+    end
+
+    # Payment-related API methods. Access via {Vihaya::Client#payments}.
+    class PaymentsAPI
+      def initialize(client)
+        @client = client
+      end
+
+      # Server-side verification of a Razorpay payment signature.
+      #
+      # Call this from a trusted environment (backend, cron job, CLI) after
+      # the frontend Razorpay checkout succeeds.
+      #
+      # @param payment_id [String] Razorpay payment ID (e.g. "pay_O8K2...")
+      # @param order_id   [String] Razorpay order ID from the registration response
+      # @param signature  [String] The signature Razorpay returned to the frontend
+      # @param amount     [Numeric, nil] Optional expected amount
+      # @return [Hash] raw API response (symbol keys)
+      def verify(payment_id:, order_id:, signature:, amount: nil)
+        payload = {
+          paymentId: payment_id,
+          orderId: order_id,
+          signature: signature
+        }
+        payload[:amount] = amount unless amount.nil?
+
+        result = @client.request("POST", "/api/v1/payments/verify", body: payload)
+        result.is_a?(Hash) ? result : { data: result }
+      end
+    end
+
+    # Unwraps the `{"success": true, "data": ...}` envelope used by the Vihaya
+    # API. Older endpoints returned the data directly, so we fall back.
+    #
+    # @api private
+    def self.unwrap(result, default:)
+      return result[:data] if result.is_a?(Hash) && result.key?(:data)
+
+      result.nil? ? default : result
+    end
+  end
+end

data/lib/vihaya/error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Vihaya
+  # Raised when the Vihaya API returns an error response, or when the SDK
+  # cannot reach the API at all.
+  #
+  # @!attribute [r] message
+  #   @return [String] human-readable error message from the server
+  # @!attribute [r] status
+  #   @return [Integer, nil] HTTP status code, or nil for transport errors
+  # @!attribute [r] data
+  #   @return [Hash, nil] raw parsed JSON response body, or nil
+  class Error < StandardError
+    attr_reader :status, :data
+
+    def initialize(message, status: nil, data: nil)
+      super(message)
+      @status = status
+      @data = data
+    end
+
+    def inspect
+      "#<Vihaya::Error message=#{message.inspect} status=#{status.inspect}>"
+    end
+  end
+end

data/lib/vihaya/models.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module Vihaya
+  # Lightweight base model for Vihaya API responses.
+  #
+  # Instead of pulling in an ORM or Dry::Struct, each model is a plain Ruby
+  # object with explicit snake_case accessors. Unknown fields are preserved
+  # in {#raw} so forward-compatible API additions don't break clients.
+  #
+  # Every model also responds to Hash-like access (`event[:title]`,
+  # `event["title"]`) and has `to_h` for serialization back out.
+  class Model
+    attr_reader :raw
+
+    # Override in subclasses: map of snake_case Ruby name to camelCase API key.
+    FIELDS = {}.freeze
+
+    def initialize(data = {})
+      @raw = symbolize(data)
+      self.class::FIELDS.each do |ruby_name, api_key|
+        instance_variable_set(:"@#{ruby_name}", @raw[api_key.to_sym])
+      end
+    end
+
+    def [](key)
+      @raw[key.to_sym]
+    end
+
+    def to_h
+      @raw.dup
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.raw == @raw
+    end
+
+    def self.from(data)
+      return nil if data.nil?
+
+      new(data)
+    end
+
+    def self.from_list(list)
+      return [] if list.nil?
+
+      Array(list).map { |item| new(item) }
+    end
+
+    private
+
+    def symbolize(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = symbolize(v) }
+      when Array
+        obj.map { |item| symbolize(item) }
+      else
+        obj
+      end
+    end
+  end
+
+  # A custom input field on an event registration form.
+  class CustomField < Model
+    FIELDS = {
+      id: :id,
+      name: :name,
+      type: :type,
+      required: :required,
+      options: :options,
+      replaces_default: :replacesDefault
+    }.freeze
+
+    attr_reader :id, :name, :type, :required, :options, :replaces_default
+  end
+
+  # A pricing tier (VIP, Early Bird, Student, etc.).
+  class SpecialPrice < Model
+    FIELDS = {
+      name: :name,
+      amount: :amount,
+      early_bird_amount: :earlyBirdAmount,
+      requires_valid_id: :requiresValidId,
+      valid_ids: :validIds,
+      custom_fields: :customFields
+    }.freeze
+
+    attr_reader :name, :amount, :early_bird_amount, :requires_valid_id, :valid_ids
+
+    def custom_fields
+      CustomField.from_list(@raw[:customFields])
+    end
+  end
+
+  # A contact person for an event.
+  class Contact < Model
+    FIELDS = { id: :id, name: :name, phone: :phone, email: :email }.freeze
+    attr_reader :id, :name, :phone, :email
+  end
+
+  # A session / slot in the event schedule.
+  class AgendaItem < Model
+    FIELDS = {
+      id: :id,
+      title: :title,
+      time: :time,
+      description: :description,
+      speaker_id: :speakerId
+    }.freeze
+
+    attr_reader :id, :title, :time, :description, :speaker_id
+  end
+
+  # A speaker appearing at an event.
+  class Speaker < Model
+    FIELDS = {
+      id: :id,
+      name: :name,
+      role: :role,
+      bio: :bio,
+      image_url: :imageUrl,
+      linkedin_url: :linkedinUrl,
+      twitter_url: :twitterUrl,
+      website_url: :websiteUrl
+    }.freeze
+
+    attr_reader :id, :name, :role, :bio,
+                :image_url, :linkedin_url, :twitter_url, :website_url
+  end
+
+  # An event sponsor.
+  class Sponsor < Model
+    FIELDS = {
+      id: :id,
+      name: :name,
+      logo_url: :logoUrl,
+      category: :category,
+      website_url: :websiteUrl
+    }.freeze
+
+    attr_reader :id, :name, :logo_url, :category, :website_url
+  end
+
+  # A frequently-asked question entry for an event.
+  class FAQItem < Model
+    FIELDS = { id: :id, question: :question, answer: :answer }.freeze
+    attr_reader :id, :question, :answer
+  end
+
+  # A promo / discount code applied at registration time.
+  class PromoCode < Model
+    FIELDS = {
+      code: :code,
+      type: :type,
+      value: :value,
+      usage_limit: :usageLimit,
+      used_count: :usedCount,
+      is_active: :isActive
+    }.freeze
+
+    attr_reader :code, :type, :value, :usage_limit, :used_count, :is_active
+  end
+
+  # A Vihaya event with full metadata.
+  #
+  # Mirrors the `VihayaEvent` shape exposed by the JavaScript, Flutter, and
+  # Python SDKs. Every non-identifier field may be nil because the API
+  # only returns what the organizer has configured for that event.
+  class Event < Model
+    FIELDS = {
+      id: :id,
+      title: :title,
+      event_type: :eventType,
+      description: :description,
+      date: :date,
+      end_date: :endDate,
+      location: :location,
+      price: :price,
+      is_free: :isFree,
+      creator_id: :creatorId,
+      created_at: :createdAt,
+      has_special_prices: :hasSpecialPrices,
+      has_platform_fee: :hasPlatformFee,
+      platform_fee: :platformFee,
+      platform_fee_type: :platformFeeType,
+      pass_platform_fee_to_user: :passPlatformFeeToUser,
+      collect_dietary_preferences: :collectDietaryPreferences,
+      collect_accessibility_needs: :collectAccessibilityNeeds,
+      collect_emergency_contact: :collectEmergencyContact,
+      collect_affiliation: :collectAffiliation,
+      collect_research_interests: :collectResearchInterests,
+      collect_t_shirt_size: :collectTShirtSize,
+      enable_food_scanning: :enableFoodScanning,
+      food_scan_limit: :foodScanLimit,
+      is_team_event: :isTeamEvent,
+      min_team_size: :minTeamSize,
+      max_team_size: :maxTeamSize,
+      venue_name: :venueName,
+      full_address: :fullAddress,
+      city: :city,
+      country: :country,
+      google_map_link: :googleMapLink,
+      contact_phone: :contactPhone,
+      contact_email: :contactEmail,
+      contact_person_name: :contactPersonName,
+      event_mode: :eventMode,
+      timezone: :timezone,
+      currency: :currency,
+      registration_deadline: :registrationDeadline,
+      requires_approval: :requiresApproval,
+      waitlist_available: :waitlistAvailable
+    }.freeze
+
+    attr_reader :id, :title, :event_type, :description, :date, :end_date,
+                :location, :price, :is_free, :creator_id, :created_at,
+                :has_special_prices, :has_platform_fee, :platform_fee,
+                :platform_fee_type, :pass_platform_fee_to_user,
+                :collect_dietary_preferences, :collect_accessibility_needs,
+                :collect_emergency_contact, :collect_affiliation,
+                :collect_research_interests, :collect_t_shirt_size,
+                :enable_food_scanning, :food_scan_limit,
+                :is_team_event, :min_team_size, :max_team_size,
+                :venue_name, :full_address, :city, :country, :google_map_link,
+                :contact_phone, :contact_email, :contact_person_name,
+                :event_mode, :timezone, :currency,
+                :registration_deadline, :requires_approval, :waitlist_available
+
+    def free?
+      is_free == true
+    end
+
+    def mega_event?
+      event_type == "megaEvent"
+    end
+
+    def agenda_list
+      AgendaItem.from_list(@raw[:agendaList])
+    end
+
+    def speaker_list
+      Speaker.from_list(@raw[:speakerList])
+    end
+
+    def sponsor_list
+      Sponsor.from_list(@raw[:sponsorList])
+    end
+
+    def faq_list
+      FAQItem.from_list(@raw[:faqList])
+    end
+
+    def contact_list
+      Contact.from_list(@raw[:contactList])
+    end
+
+    def custom_fields
+      CustomField.from_list(@raw[:customFields])
+    end
+
+    def special_prices
+      SpecialPrice.from_list(@raw[:specialPrices])
+    end
+
+    def promo_codes
+      PromoCode.from_list(@raw[:promoCodes])
+    end
+
+    def sub_events
+      Event.from_list(@raw[:subEvents])
+    end
+  end
+
+  # Payload for {Vihaya::Client#events}.register.
+  #
+  # Only `name`, `email`, and `phone` are required. Everything else is
+  # optional and mirrors the JS/Flutter/Python SDK shapes.
+  class RegisterData
+    # Map of Ruby kwarg name -> wire (camelCase) key.
+    FIELDS = {
+      name: :name,
+      email: :email,
+      phone: :phone,
+      payment_id: :paymentId,
+      order_id: :orderId,
+      registration_id: :registrationId,
+      special_price: :specialPrice,
+      promo_code: :promoCode,
+      is_early_bird_applied: :isEarlyBirdApplied,
+      team_name: :teamName,
+      team_members: :teamMembers,
+      accommodation: :accommodation,
+      dietary_preference: :dietaryPreference,
+      preferences: :preferences,
+      custom_fields: :customFields,
+      user_id: :userId,
+      source: :source
+    }.freeze
+
+    attr_accessor(*FIELDS.keys)
+
+    def initialize(name:, email:, phone:, **extras)
+      @name = name
+      @email = email
+      @phone = phone
+      extras.each do |key, value|
+        unless FIELDS.key?(key)
+          raise ArgumentError, "Unknown RegisterData field: #{key.inspect}"
+        end
+
+        public_send("#{key}=", value)
+      end
+    end
+
+    # Serializes to the wire format (camelCase keys, nils dropped).
+    def to_payload
+      FIELDS.each_with_object({}) do |(ruby_name, wire_key), memo|
+        value = public_send(ruby_name)
+        memo[wire_key] = value unless value.nil?
+      end
+    end
+
+    alias to_h to_payload
+  end
+end

data/lib/vihaya/version.rb

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

data/lib/vihaya.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Official Ruby SDK for the Vihaya Events platform.
+#
+# Quick start:
+#
+#     require "vihaya"
+#
+#     vh = Vihaya::Client.new("vh_live_...")
+#     vh.events.list.each do |event|
+#       puts "#{event.title} - #{event.date}"
+#     end
+#
+# See https://events.vihaya.app/profile/developer/docs for the full API
+# reference.
+module Vihaya
+end
+
+require_relative "vihaya/version"
+require_relative "vihaya/error"
+require_relative "vihaya/models"
+require_relative "vihaya/client"

data/vihaya-events.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/vihaya/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "vihaya-events"
+  spec.version       = Vihaya::VERSION
+  spec.authors       = ["Vihaya Team"]
+  spec.email         = ["vihaya.app@gmail.com"]
+
+  spec.summary       = "Official Ruby SDK for the Vihaya Events platform."
+  spec.description   = "Fetch events, register attendees, and verify Razorpay " \
+                       "payments on the Vihaya Events platform with a fully-typed " \
+                       "Ruby client. Feature parity with the JavaScript, Flutter, " \
+                       "and Python SDKs."
+  spec.homepage      = "https://github.com/Vishnu252005/vihaya-sdk-ruby"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"]      = spec.homepage
+  spec.metadata["source_code_uri"]   = "https://github.com/Vishnu252005/vihaya-sdk-ruby"
+  spec.metadata["changelog_uri"]     = "https://github.com/Vishnu252005/vihaya-sdk-ruby/blob/main/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "https://events.vihaya.app/profile/developer/docs"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/Vishnu252005/vihaya-sdk-ruby/issues"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "examples/**/*.rb",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "vihaya-events.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+
+  # Zero runtime dependencies — built on Ruby stdlib (net/http + json).
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: vihaya-events
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vihaya Team
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Fetch events, register attendees, and verify Razorpay payments on the
+  Vihaya Events platform with a fully-typed Ruby client. Feature parity with the JavaScript,
+  Flutter, and Python SDKs.
+email:
+- vihaya.app@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- examples/quickstart.rb
+- lib/vihaya.rb
+- lib/vihaya/client.rb
+- lib/vihaya/error.rb
+- lib/vihaya/models.rb
+- lib/vihaya/version.rb
+- vihaya-events.gemspec
+homepage: https://github.com/Vishnu252005/vihaya-sdk-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Vishnu252005/vihaya-sdk-ruby
+  source_code_uri: https://github.com/Vishnu252005/vihaya-sdk-ruby
+  changelog_uri: https://github.com/Vishnu252005/vihaya-sdk-ruby/blob/main/CHANGELOG.md
+  documentation_uri: https://events.vihaya.app/profile/developer/docs
+  bug_tracker_uri: https://github.com/Vishnu252005/vihaya-sdk-ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Official Ruby SDK for the Vihaya Events platform.
+test_files: []