synthra 0.1.0

data/lib/synthra/time_travel.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+module Synthra
+  # Time Travel for Data Generation
+  #
+  # Generate data as it would have existed at a specific point in time.
+  # Perfect for testing time-sensitive features, historical data analysis,
+  # and creating realistic time-series datasets.
+  #
+  # @example Generate data from the past
+  #   Synthra::TimeTravel.at(3.months.ago) do
+  #     user = schema.generate
+  #     user["created_at"] # => 3 months ago
+  #   end
+  #
+  # @example Generate data within a range
+  #   Synthra::TimeTravel.between(1.year.ago, 1.month.ago) do
+  #     orders = schema.generate_many(100)
+  #   end
+  #
+  # @example In DSL
+  #   HistoricalOrder:
+  #     @time_travel -30.days..-1.day
+  #     created_at: timestamp
+  #
+  module TimeTravel
+    class << self
+      # Thread-local time context
+      def current_time
+        Thread.current[:synthra_time_travel]
+      end
+
+      def current_time=(time)
+        Thread.current[:synthra_time_travel] = time
+      end
+
+      # The active time-travel anchor, as a Date, for generators that need to
+      # re-base a "relative to today" distribution (e.g. "N days in the past").
+      #
+      # Returns nil when no time-travel context is active, so callers can use
+      # it as a cheap presence check: `anchor = TimeTravel.anchor_date; return ... if anchor`.
+      #
+      # @return [Date, nil]
+      def anchor_date
+        context = current_time
+        return nil unless context
+
+        context.current_time.to_date
+      end
+
+      # Generate data at a specific point in time
+      #
+      # @param time [Time, DateTime, Date] the target time
+      # @yield block where all generated timestamps will be relative to this time
+      # @return [Object] result of the block
+      #
+      # @example
+      #   Synthra::TimeTravel.at(2.weeks.ago) do
+      #     user = Synthra[:User]
+      #     user["created_at"] # => ~2 weeks ago
+      #   end
+      #
+      def at(time, &block)
+        time = normalize_time(time)
+        with_time_context(TimeContext.new(time), &block)
+      end
+
+      # Generate data within a time range
+      #
+      # @param start_time [Time, DateTime, Date] range start
+      # @param end_time [Time, DateTime, Date] range end
+      # @yield block where timestamps will be randomly distributed in range
+      # @return [Object] result of the block
+      #
+      # @example
+      #   Synthra::TimeTravel.between(1.year.ago, Time.now) do
+      #     orders = Synthra.generate_many("Order", 1000)
+      #     # created_at distributed over the year
+      #   end
+      #
+      def between(start_time, end_time, &block)
+        start_time = normalize_time(start_time)
+        end_time = normalize_time(end_time)
+        with_time_context(TimeContext.new(start_time, end_time), &block)
+      end
+
+      # Generate historical time series data
+      #
+      # @param schema [Schema, String] schema to generate
+      # @param count [Integer] number of records
+      # @param start_time [Time] series start
+      # @param end_time [Time] series end (default: now)
+      # @param distribution [Symbol] :uniform, :linear, :exponential
+      # @return [Array<Hash>] generated records sorted by time
+      #
+      # @example Generate a year of orders
+      #   orders = Synthra::TimeTravel.time_series(
+      #     "Order",
+      #     count: 1000,
+      #     start_time: 1.year.ago,
+      #     distribution: :exponential  # More recent = more orders
+      #   )
+      #
+      def time_series(schema, count:, start_time:, end_time: Time.now, distribution: :uniform)
+        schema = Synthra.registry.schema(schema.to_s) if schema.is_a?(String) || schema.is_a?(Symbol)
+        
+        start_time = normalize_time(start_time)
+        end_time = normalize_time(end_time)
+        time_range = end_time - start_time
+
+        records = count.times.map do |i|
+          # Calculate time based on distribution
+          t = case distribution
+              when :uniform
+                random_time_in_range(start_time, end_time)
+              when :linear
+                # Linear growth - evenly distributed
+                start_time + (time_range * i / count.to_f)
+              when :exponential
+                # Exponential - more recent records
+                ratio = (i.to_f / count) ** 2
+                start_time + (time_range * ratio)
+              when :logarithmic
+                # Logarithmic - more historical records
+                ratio = Math.log(i + 1) / Math.log(count + 1)
+                start_time + (time_range * ratio)
+              else
+                random_time_in_range(start_time, end_time)
+              end
+
+          at(t) { schema.generate }
+        end
+
+        # Sort by timestamp fields
+        timestamp_field = find_timestamp_field(schema)
+        if timestamp_field
+          records.sort_by { |r| r[timestamp_field] || Time.now }
+        else
+          records
+        end
+      end
+
+      # Generate data that ages over time
+      #
+      # @param schema [Schema, String] schema to generate
+      # @param record [Hash] existing record to age
+      # @param by [Duration] how much to age
+      # @return [Hash] aged record
+      #
+      # @example Age a user by 1 year
+      #   user = Synthra[:User]
+      #   aged_user = Synthra::TimeTravel.age(user, by: 1.year)
+      #
+      def age(record, by:)
+        aged = record.dup
+        offset = duration_to_seconds(by)
+
+        record.each do |key, value|
+          if value.is_a?(Time) || value.is_a?(DateTime)
+            aged[key] = value - offset
+          elsif value.is_a?(String) && time_string?(value)
+            parsed = Time.parse(value)
+            aged[key] = (parsed - offset).iso8601
+          end
+        end
+
+        aged
+      end
+
+      # Create a progression of records over time
+      #
+      # @param schema [Schema, String] schema to generate
+      # @param seed_record [Hash] starting record
+      # @param steps [Integer] number of progression steps
+      # @param interval [Duration] time between steps
+      # @param changes [Hash] fields that change over time
+      # @yield [record, step, time] customize each step
+      # @return [Array<Hash>] progression of records
+      #
+      # @example User subscription progression
+      #   progression = Synthra::TimeTravel.progression(
+      #     "User",
+      #     steps: 12,
+      #     interval: 1.month,
+      #     changes: {
+      #       subscription_status: -> (step) { step < 3 ? "trial" : "active" },
+      #       login_count: -> (step) { step * 5 }
+      #     }
+      #   )
+      #
+      def progression(schema, steps:, interval:, seed_record: nil, changes: {}, &block)
+        schema = Synthra.registry.schema(schema.to_s) if schema.is_a?(String) || schema.is_a?(Symbol)
+        
+        interval_seconds = duration_to_seconds(interval)
+        base_time = current_time || Time.now
+        records = []
+
+        seed_record ||= schema.generate
+
+        steps.times do |step|
+          step_time = base_time + (interval_seconds * step)
+
+          record = at(step_time) do
+            step_record = seed_record.dup
+
+            # Apply time-based changes
+            changes.each do |field, change_fn|
+              step_record[field.to_s] = change_fn.call(step)
+            end
+
+            # Update timestamp fields
+            schema.fields.each do |field|
+              if timestamp_type?(field.type_name)
+                step_record[field.name] = step_time.iso8601
+              end
+            end
+
+            # Allow custom modifications
+            block&.call(step_record, step, step_time)
+
+            step_record
+          end
+
+          records << record
+        end
+
+        records
+      end
+
+      private
+
+      def with_time_context(context)
+        old_context = current_time
+        self.current_time = context
+        yield
+      ensure
+        self.current_time = old_context
+      end
+
+      def normalize_time(time)
+        case time
+        when Time
+          time
+        when DateTime
+          time.to_time
+        when Date
+          time.to_time
+        when Numeric
+          Time.at(time)
+        when Range
+          # Return as-is for range support
+          time
+        else
+          Time.parse(time.to_s)
+        end
+      end
+
+      def random_time_in_range(start_time, end_time)
+        range = end_time.to_f - start_time.to_f
+        Time.at(start_time.to_f + rand * range)
+      end
+
+      def find_timestamp_field(schema)
+        %w[created_at timestamp date created].each do |name|
+          return name if schema.fields.any? { |f| f.name == name }
+        end
+        nil
+      end
+
+      def duration_to_seconds(duration)
+        return duration if duration.is_a?(Numeric)
+
+        # Parse a "30.days"-style duration BEFORE any to_i fallback. A String responds to #to_i, so
+        # "30.days".to_i (=> 30) used to shadow this multiplier table — aging by 30 *seconds*
+        # instead of 30 days. Match on #to_s so a custom duration object works too.
+        if (match = duration.to_s.match(/(\d+)\.(year|month|week|day|hour|minute|second)s?/))
+          num, unit = match.captures
+          multipliers = {
+            "year" => 365.25 * 24 * 3600,
+            "month" => 30 * 24 * 3600,
+            "week" => 7 * 24 * 3600,
+            "day" => 24 * 3600,
+            "hour" => 3600,
+            "minute" => 60,
+            "second" => 1
+          }
+          return num.to_i * multipliers[unit]
+        end
+
+        return duration.to_i if duration.respond_to?(:to_i)
+
+        duration.to_f
+      end
+
+      def time_string?(value)
+        return false unless value.is_a?(String)
+        # Be strict about what constitutes a time string
+        # Must contain date-like patterns (YYYY-MM-DD, DD/MM/YYYY, etc.)
+        return false unless value.match?(/\d{4}-\d{2}-\d{2}|\d{2}[\/\-]\d{2}[\/\-]\d{2,4}|T\d{2}:\d{2}/)
+        Time.parse(value)
+        true
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      def timestamp_type?(type_name)
+        %w[timestamp datetime now date time].include?(type_name)
+      end
+    end
+
+    # Time context for generation
+    class TimeContext
+      attr_reader :base_time, :end_time, :range
+
+      def initialize(base_time, end_time = nil)
+        @base_time = base_time
+        @end_time = end_time
+        @range = end_time ? (base_time..end_time) : nil
+      end
+
+      def current_time
+        if @range
+          # Random time in range
+          start_f = @base_time.to_f
+          end_f = @end_time.to_f
+          Time.at(start_f + rand * (end_f - start_f))
+        else
+          @base_time
+        end
+      end
+
+      def range?
+        !@range.nil?
+      end
+    end
+  end
+
+end

data/lib/synthra/type_definitions.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+# =============================================================================
+# Synthra Type Definitions
+# =============================================================================
+#
+# This file registers all built-in type generators for Synthra.
+# Types are organized by category for easier maintenance.
+#
+# =============================================================================
+
+module Synthra
+  # Registers all built-in types
+  #
+  # This method is called automatically when the gem loads.
+  # @api private
+  #
+  def self.register_builtin_types!
+    register_core_types!
+    register_personal_types!
+    register_commerce_types!
+    register_finance_types!
+    register_address_types!
+    register_technology_types!
+    register_text_types!
+    register_media_types!
+    register_advanced_types!
+  end
+
+  class << self
+    private
+
+    def register_core_types!
+      # Require core type files
+      require_relative "types/core/identifiers"
+      require_relative "types/core/primitives"
+      require_relative "types/core/collections"
+      require_relative "types/core/references"
+      require_relative "types/core/sequences"
+      require_relative "types/core/defaults"
+      require_relative "types/core/enums"
+
+      # Identifiers
+      Types::Registry.register("uuid", Types::Core::Uuid)
+      Types::Registry.register("ulid", Types::Core::Ulid)
+      Types::Registry.register("id_sequence", Types::Core::IdSequence)
+      Types::Registry.register("snowflake_id", Types::Core::SnowflakeId)
+      Types::Registry.register("unix_timestamp_ms", Types::Core::UnixTimestampMs)
+      Types::Registry.register("numeric_string_id", Types::Core::NumericStringId)
+      Types::Registry.register("alphanumeric_id", Types::Core::AlphanumericId)
+      Types::Registry.register("locale", Types::Core::Locale)
+      Types::Registry.register("token", Types::Core::Token)
+
+      # Primitives
+      Types::Registry.register("text", Types::Core::Text)
+      Types::Registry.register("string", Types::Core::Text) # alias for OpenAPI/contract compatibility
+      Types::Registry.register("number", Types::Core::Number)
+      Types::Registry.register("boolean", Types::Core::Boolean)
+      Types::Registry.register("const", Types::Core::Const)
+
+      # Collections
+      Types::Registry.register("array", Types::Core::ArrayType)
+      Types::Registry.register("object", Types::Core::ObjectType)
+      Types::Registry.register("map_by_field", Types::Core::MapByField)
+      Types::Registry.register("one_of", Types::Core::OneOf)
+      Types::Registry.register("enum", Types::Core::Enum)
+
+      # References and sequences
+      Types::Registry.register("sequence", Types::Core::Sequence)
+      Types::Registry.register("default_value", Types::Core::DefaultValue)
+      Types::Registry.register("reference", Types::Core::Reference)
+      Types::Registry.register("custom", Types::Core::Custom)
+      Types::Registry.register("copy", Types::Core::Copy)
+      Types::Registry.register("shared", Types::Core::Shared)
+      Types::Registry.register("character_sequence", Types::Core::CharacterSequence)
+      Types::Registry.register("digit_sequence", Types::Core::DigitSequence)
+
+      # Simulyra DSL schema reference type
+      Types::Registry.register("schema_ref", Types::Core::SchemaRef)
+    end
+
+    def register_personal_types!
+      Types::Registry.register("name", Types::PersonalNames::Name)
+      Types::Registry.register("first_name", Types::PersonalNames::FirstName)
+      Types::Registry.register("last_name", Types::PersonalNames::LastName)
+      Types::Registry.register("full_name", Types::PersonalNames::FullName)
+      Types::Registry.register("gender", Types::PersonalNames::Gender)
+      Types::Registry.register("age", Types::PersonalNames::Age)
+      Types::Registry.register("username", Types::PersonalNames::Username)
+      Types::Registry.register("family_name_chinese", Types::PersonalNames::FamilyNameChinese)
+      Types::Registry.register("given_name_chinese", Types::PersonalNames::GivenNameChinese)
+      Types::Registry.register("first_name_european", Types::PersonalNames::FirstNameEuropean)
+      Types::Registry.register("first_name_female", Types::PersonalNames::FirstNameFemale)
+      Types::Registry.register("first_name_male", Types::PersonalNames::FirstNameMale)
+      Types::Registry.register("gender_abbrev", Types::PersonalNames::GenderAbbrev)
+      Types::Registry.register("gender_binary", Types::PersonalNames::GenderBinary)
+      Types::Registry.register("gender_facebook", Types::PersonalNames::GenderFacebook)
+      Types::Registry.register("suffix", Types::PersonalNames::Suffix)
+      Types::Registry.register("title", Types::PersonalNames::Title)
+    end
+
+    def register_commerce_types!
+      Types::Registry.register("job_title", Types::CommerceProducts::JobTitle)
+      Types::Registry.register("company_name", Types::CommerceProducts::CompanyName)
+      Types::Registry.register("product_name", Types::CommerceProducts::ProductName)
+      Types::Registry.register("product_category", Types::CommerceProducts::ProductCategory)
+      Types::Registry.register("sku", Types::CommerceProducts::Sku)
+      Types::Registry.register("discount", Types::CommerceProducts::Discount)
+      Types::Registry.register("tax_rate", Types::CommerceProducts::TaxRate)
+      Types::Registry.register("construction_heavy_equipment", Types::CommerceProducts::ConstructionHeavyEquipment)
+      Types::Registry.register("construction_material", Types::CommerceProducts::ConstructionMaterial)
+      Types::Registry.register("construction_role", Types::CommerceProducts::ConstructionRole)
+      Types::Registry.register("construction_standard_cost_code", Types::CommerceProducts::ConstructionStandardCostCode)
+      Types::Registry.register("construction_subcontract_category", Types::CommerceProducts::ConstructionSubcontractCategory)
+      Types::Registry.register("construction_trade", Types::CommerceProducts::ConstructionTrade)
+      Types::Registry.register("product_grocery", Types::CommerceProducts::ProductGrocery)
+      Types::Registry.register("product_description", Types::CommerceProducts::ProductDescription)
+      Types::Registry.register("product_price", Types::CommerceProducts::ProductPrice)
+      Types::Registry.register("product_subcategory", Types::CommerceProducts::ProductSubcategory)
+      Types::Registry.register("shirt_size", Types::CommerceProducts::ShirtSize)
+    end
+
+    def register_finance_types!
+      Types::Registry.register("money", Types::FinanceBanking::Money)
+      Types::Registry.register("currency", Types::FinanceBanking::Currency)
+      Types::Registry.register("currency_code", Types::FinanceBanking::Currency)
+      Types::Registry.register("credit_card", Types::FinanceBanking::CreditCard)
+      Types::Registry.register("bank_name", Types::FinanceBanking::BankName)
+      Types::Registry.register("account_number", Types::FinanceBanking::AccountNumber)
+      Types::Registry.register("iban", Types::FinanceBanking::Iban)
+      Types::Registry.register("transaction_amount", Types::FinanceBanking::TransactionAmount)
+      Types::Registry.register("ssn", Types::FinanceBanking::Ssn)
+      Types::Registry.register("ein", Types::FinanceBanking::Ein)
+      Types::Registry.register("bank_routing_number", Types::FinanceBanking::BankRoutingNumber)
+      Types::Registry.register("bank_swift_bic", Types::FinanceBanking::BankSwiftBic)
+      Types::Registry.register("bank_lei", Types::FinanceBanking::BankLei)
+      Types::Registry.register("bank_riad_code", Types::FinanceBanking::BankRiadCode)
+      Types::Registry.register("credit_card_type", Types::FinanceBanking::CreditCardType)
+      Types::Registry.register("duns_number", Types::FinanceBanking::DunsNumber)
+      Types::Registry.register("medicare_beneficiary_id", Types::FinanceBanking::MedicareBeneficiaryId)
+      Types::Registry.register("nhs_number", Types::FinanceBanking::NhsNumber)
+    end
+
+    def register_address_types!
+      Types::Registry.register("country_code", Types::AddressLocation::CountryCode)
+      Types::Registry.register("country", Types::AddressLocation::Country)
+      Types::Registry.register("city", Types::AddressLocation::City)
+      Types::Registry.register("state", Types::AddressLocation::State)
+      Types::Registry.register("address", Types::AddressLocation::Address)
+      Types::Registry.register("latitude", Types::AddressLocation::Latitude)
+      Types::Registry.register("longitude", Types::AddressLocation::Longitude)
+      Types::Registry.register("timezone", Types::AddressLocation::Timezone)
+      Types::Registry.register("postal_code", Types::AddressLocation::PostalCode)
+      Types::Registry.register("zip_code", Types::AddressLocation::PostalCode)
+      Types::Registry.register("address_line_2", Types::AddressLocation::AddressLine2)
+      Types::Registry.register("street_name", Types::AddressLocation::StreetName)
+      Types::Registry.register("street_address", Types::AddressLocation::StreetName)
+      Types::Registry.register("street_number", Types::AddressLocation::StreetNumber)
+      Types::Registry.register("street_suffix", Types::AddressLocation::StreetSuffix)
+      Types::Registry.register("airport_name", Types::AddressLocation::AirportName)
+      Types::Registry.register("airport_continent", Types::AddressLocation::AirportContinent)
+      Types::Registry.register("airport_country_code", Types::AddressLocation::AirportCountryCode)
+      Types::Registry.register("airport_elevation", Types::AddressLocation::AirportElevation)
+      Types::Registry.register("airport_gps_code", Types::AddressLocation::AirportGpsCode)
+      Types::Registry.register("airport_latitude", Types::AddressLocation::AirportLatitude)
+      Types::Registry.register("airport_longitude", Types::AddressLocation::AirportLongitude)
+      Types::Registry.register("airport_municipality", Types::AddressLocation::AirportMunicipality)
+      Types::Registry.register("airport_region_code", Types::AddressLocation::AirportRegionCode)
+      Types::Registry.register("bank_city", Types::AddressLocation::BankCity)
+      Types::Registry.register("bank_country_code", Types::AddressLocation::BankCountryCode)
+      Types::Registry.register("bank_street_address", Types::AddressLocation::BankStreetAddress)
+      Types::Registry.register("bank_state", Types::AddressLocation::BankState)
+      Types::Registry.register("hospital_city", Types::AddressLocation::HospitalCity)
+      Types::Registry.register("hospital_postal_code", Types::AddressLocation::HospitalPostalCode)
+      Types::Registry.register("hospital_state", Types::AddressLocation::HospitalState)
+      Types::Registry.register("hospital_street_address", Types::AddressLocation::HospitalStreetAddress)
+    end
+
+    def register_technology_types!
+      Types::Registry.register("email", Types::TechnologyInternet::Email)
+      Types::Registry.register("phone", Types::TechnologyInternet::Phone)
+      Types::Registry.register("url", Types::TechnologyInternet::Url)
+      Types::Registry.register("ip", Types::TechnologyInternet::Ip)
+      Types::Registry.register("ip_address", Types::TechnologyInternet::Ip)
+      Types::Registry.register("ipv6", Types::TechnologyInternet::Ipv6)
+      Types::Registry.register("mac_address", Types::TechnologyInternet::MacAddress)
+      Types::Registry.register("domain", Types::TechnologyInternet::Domain)
+      Types::Registry.register("user_agent", Types::TechnologyInternet::UserAgent)
+      Types::Registry.register("app_bundle_id", Types::TechnologyInternet::AppBundleId)
+      Types::Registry.register("app_name", Types::TechnologyInternet::AppName)
+      Types::Registry.register("app_version", Types::TechnologyInternet::AppVersion)
+      Types::Registry.register("base64_image_url", Types::TechnologyInternet::Base64ImageUrl)
+      Types::Registry.register("dummy_image_url", Types::TechnologyInternet::DummyImageUrl)
+      Types::Registry.register("ip_v4_cidr", Types::TechnologyInternet::IpV4Cidr)
+      Types::Registry.register("ip_v6_cidr", Types::TechnologyInternet::IpV6Cidr)
+      Types::Registry.register("language", Types::TechnologyInternet::Language)
+      Types::Registry.register("language_code", Types::TechnologyInternet::LanguageCode)
+      Types::Registry.register("mime_type", Types::TechnologyInternet::MimeType)
+      Types::Registry.register("mobile_device_brand", Types::TechnologyInternet::MobileDeviceBrand)
+      Types::Registry.register("mobile_device_model", Types::TechnologyInternet::MobileDeviceModel)
+      Types::Registry.register("mobile_device_os", Types::TechnologyInternet::MobileDeviceOs)
+      Types::Registry.register("mobile_device_release_date", Types::TechnologyInternet::MobileDeviceReleaseDate)
+      Types::Registry.register("mongodb_object_id", Types::TechnologyInternet::MongodbObjectId)
+      Types::Registry.register("top_level_domain", Types::TechnologyInternet::TopLevelDomain)
+    end
+
+    def register_text_types!
+      Types::Registry.register("avatar", Types::TextContent::Avatar)
+      Types::Registry.register("buzzword", Types::TextContent::Buzzword)
+      Types::Registry.register("catch_phrase", Types::TextContent::CatchPhrase)
+      Types::Registry.register("color", Types::TextContent::Color)
+      Types::Registry.register("hex_color", Types::TextContent::HexColor)
+      Types::Registry.register("short_hex_color", Types::TextContent::ShortHexColor)
+      Types::Registry.register("encrypt", Types::TextContent::Encrypt)
+      Types::Registry.register("file_name", Types::TextContent::FileName)
+      Types::Registry.register("frequency", Types::TextContent::Frequency)
+      Types::Registry.register("linkedin_skill", Types::TextContent::LinkedInSkill)
+      Types::Registry.register("md5", Types::TextContent::Md5)
+      Types::Registry.register("sha1", Types::TextContent::Sha1)
+      Types::Registry.register("sha256", Types::TextContent::Sha256)
+      Types::Registry.register("nato_phonetic", Types::TextContent::NatoPhonetic)
+      Types::Registry.register("paragraphs", Types::TextContent::Paragraphs)
+      Types::Registry.register("password", Types::TextContent::Password)
+      Types::Registry.register("password_hash", Types::TextContent::PasswordHash)
+      Types::Registry.register("row_number", Types::TextContent::RowNumber)
+      Types::Registry.register("sentences", Types::TextContent::Sentences)
+      Types::Registry.register("slogan", Types::TextContent::Slogan)
+      Types::Registry.register("sql_expression", Types::TextContent::SqlExpression)
+      Types::Registry.register("words", Types::TextContent::Words)
+      Types::Registry.register("slug", Types::TextContent::Slug)
+      Types::Registry.register("university", Types::TextContent::University)
+      Types::Registry.register("blank", Types::TextContent::Blank)
+      Types::Registry.register("race", Types::TextContent::Race)
+      Types::Registry.register("department_corporate", Types::TextContent::DepartmentCorporate)
+      Types::Registry.register("department_retail", Types::TextContent::DepartmentRetail)
+      Types::Registry.register("fake_company_name", Types::TextContent::FakeCompanyName)
+      Types::Registry.register("message_text", Types::TextContent::MessageText)
+      Types::Registry.register("empty_array", Types::TextContent::EmptyArray)
+      Types::Registry.register("hashtag_text", Types::TextContent::HashtagText)
+      Types::Registry.register("social_handle", Types::TextContent::SocialHandle)
+      Types::Registry.register("indices_pair", Types::TextContent::IndicesPair)
+    end
+
+    def register_media_types!
+      Types::Registry.register("movie_genres", Types::MediaEntertainment::MovieGenres)
+      Types::Registry.register("movie_title", Types::MediaEntertainment::MovieTitle)
+    end
+
+    def register_datetime_types!
+      Types::Registry.register("date", Types::DateTime::DateType)
+      Types::Registry.register("past_date", Types::DateTime::PastDate)
+      Types::Registry.register("future_date", Types::DateTime::FutureDate)
+      Types::Registry.register("now", Types::DateTime::Now)
+      Types::Registry.register("timestamp", Types::DateTime::Timestamp)
+      Types::Registry.register("time", Types::DateTime::TimeType)
+      Types::Registry.register("datetime", Types::DateTime::DatetimeType)
+      Types::Registry.register("date_between", Types::DateTime::DateBetween)
+    end
+
+    def register_advanced_types!
+      # Date/Time
+      register_datetime_types!
+
+      # Advanced types
+      Types::Registry.register("formula", Types::Formula)
+      Types::Registry.register("json_array", Types::JsonArray)
+      Types::Registry.register("naughty_string", Types::NaughtyString)
+      Types::Registry.register("regex", Types::Regex)
+      Types::Registry.register("repeating_element", Types::RepeatingElement)
+      Types::Registry.register("scenario", Types::Scenario)
+      Types::Registry.register("template", Types::Template)
+    end
+  end
+end