typelizer 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3deaa0f184a8406a1bcca5994b75565a861c32e4afd2af6e7c48643422127f6
-  data.tar.gz: d270f2596b33c68d7cd426866618d573c9798648376e66b8e1e0bf76d3967c28
+  metadata.gz: '0528e1e626a19920401677115cc49d13d3c2a730b8f332e285dcdaada8699a62'
+  data.tar.gz: 171dde8c90cc46ee6eb5cf434f2c7cd83f15098a233e9e2a5dbb2b5f36ba470c
 SHA512:
-  metadata.gz: 67fcb4958821e25180c5a8493ca1d16b2e9f590959d2ef97f347018e692b3d94b9f084222355db547b1de27b0a9758049e3da391c640553a81aa33a4ab821bda
-  data.tar.gz: e1fba11ea9af7e654da8dde504582748a2d1046d15cb52a343895c9453d5e779215bc15f9827fa8604a822b04e2e2acef72f7176f77bd52783df2094e8b68d37
+  metadata.gz: b3785036afe6f23d5f5f830271081d20f99810e3582d853b28bd34e5558e20609615b929a870c6ef518b75389b48c6e092a8043d8c24510ad1a01b9d82449021
+  data.tar.gz: c0bde62a2756d3b67cba8bf8fa061f898d2837bae191f80fa6960c1fe08c654044807c0c8157cffa6c45edee632716f7c105a54cae4b5f87d3ece6b546c7cda1

data/CHANGELOG.md

@@ -7,7 +7,79 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
-## [0.5.2] - 2025-11-25
+## [0.5.4] - 2025-12-08
+
+### Added
+
+- Type shortcuts for `typelize` method. ([@skryukov])
+
+  Use `?` suffix for optional and `[]` suffix for arrays:
+
+  ```ruby
+  typelize "string?"      # optional: true
+  typelize "number[]"     # multi: true
+  typelize "string?[]"    # optional: true, multi: true
+
+  # With hash syntax
+  typelize name: "string?", tags: "string[]"
+
+  # Combined with explicit options
+  typelize status: ["string?", nullable: true]
+  ```
+
+  Generates:
+
+  ```typescript
+  name?: string;
+  tags: Array<string>;
+  roles?: Array<string>;
+  status?: string | null;
+  ```
+
+- Alba: support for traits. ([@skryukov])
+
+  Typelizer now generates TypeScript types for Alba traits and supports `with_traits` in associations:
+
+  ```ruby
+  class UserResource < ApplicationResource
+    attributes :id, :name
+
+    trait :detailed do
+      attributes :email, :created_at
+    end
+
+    trait :with_posts do
+      has_many :posts, resource: PostResource, with_traits: [:summary]
+    end
+  end
+  ```
+
+  Generates:
+
+  ```typescript
+  type User = {
+    id: number;
+    name: string;
+  }
+
+  type UserDetailedTrait = {
+    email: string;
+    created_at: string;
+  }
+
+  type UserWithPostsTrait = {
+    posts: Array<Post & PostSummaryTrait>;
+  }
+  ```
+
+  When using `with_traits` in associations, Typelizer generates intersection types:
+
+  ```ruby
+  has_one :author, resource: UserResource, with_traits: [:detailed]
+  # Generates: author: User & UserDetailedTrait
+  ```
+
+## [0.5.3] - 2025-11-25
 
 ## Fixed
 
@@ -207,7 +279,8 @@ and this project adheres to [Semantic Versioning].
 [@prog-supdex]: https://github.com/prog-supdex
 [@ventsislaf]: https://github.com/ventsislaf
 
-[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.5.3...HEAD
+[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.5.4...HEAD
+[0.5.4]: https://github.com/skryukov/typelizer/compare/v0.5.3...v0.5.4
 [0.5.3]: https://github.com/skryukov/typelizer/compare/v0.5.2...v0.5.3
 [0.5.2]: https://github.com/skryukov/typelizer/compare/v0.5.1...v0.5.2
 [0.5.1]: https://github.com/skryukov/typelizer/compare/v0.5.0...v0.5.1

data/README.md

@@ -11,6 +11,7 @@ Typelizer generates TypeScript types from your Ruby serializers. It supports mul
 - [Usage](#usage)
   - [Basic Setup](#basic-setup)
   - [Manual Typing](#manual-typing)
+  - [Alba Traits](#alba-traits)
   - [TypeScript Integration](#typescript-integration)
   - [Manual Generation](#manual-generation)
   - [Automatic Generation in Development](#automatic-generation-in-development)
@@ -108,12 +109,110 @@ class PostResource < ApplicationResource
 end
 ```
 
-You can also specify more complex type definitions using a lower-level API:
+You can also use shortcut syntax for common type modifiers:
+
+```ruby
+class PostResource < ApplicationResource
+  typelize author_name: "string?"       # optional string (name?: string)
+  typelize tag_ids: "number[]"          # array of numbers (tag_ids: Array<number>)
+  typelize categories: "string?[]"      # optional array of strings (categories?: Array<string>)
+
+  # Shortcuts can be combined with explicit options
+  typelize status: ["string?", nullable: true]  # optional and nullable
+
+  # Also works with keyless typelize
+  typelize "string?"
+  attribute :nickname do |user|
+    user.nickname
+  end
+end
+```
+
+For more complex type definitions, use the full API:
 
 ```ruby
 typelize attribute_name: ["string", "Date", optional: true, nullable: true, multi: true, enum: %w[foo bar], comment: "Attribute description", deprecated: "Use `another_attribute` instead"]
 ```
 
+### Alba Traits
+
+Typelizer supports [Alba traits](https://github.com/okuramasafumi/alba#traits), generating separate TypeScript types for each trait. When using `with_traits` in associations, Typelizer generates intersection types.
+
+```ruby
+class UserResource < ApplicationResource
+  attributes :id, :name
+
+  trait :detailed do
+    attributes :email, :created_at
+  end
+
+  trait :with_posts do
+    has_many :posts, resource: PostResource, with_traits: [:summary]
+  end
+end
+```
+
+This generates:
+
+```typescript
+// User.ts
+export type User = {
+  id: number;
+  name: string;
+}
+
+type UserDetailedTrait = {
+  email: string;
+  created_at: string;
+}
+
+type UserWithPostsTrait = {
+  posts: Array<Post & PostSummaryTrait>;
+}
+
+export default User;
+```
+
+When using `with_traits` in associations, Typelizer generates intersection types combining the base type with trait types:
+
+```ruby
+class TeamResource < ApplicationResource
+  attributes :id, :name
+  has_one :lead, resource: UserResource, with_traits: [:detailed]
+  has_many :members, resource: UserResource, with_traits: [:detailed, :with_posts]
+end
+```
+
+This generates:
+
+```typescript
+// Team.ts
+import type { User, UserDetailedTrait, UserWithPostsTrait } from "@/types";
+
+export type Team = {
+  id: number;
+  name: string;
+  lead: User & UserDetailedTrait;
+  members: Array<User & UserDetailedTrait & UserWithPostsTrait>;
+}
+
+export default Team;
+```
+
+The `typelize` method works inside traits for manual type specification:
+
+```ruby
+trait :with_stats do
+  typelize :number
+  attribute :posts_count do |user|
+    user.posts.count
+  end
+
+  typelize score: :number
+  attributes :score
+end
+```
+
 ### TypeScript Integration
 
 Typelizer generates TypeScript interfaces in the specified output directory:

data/lib/typelizer/dsl.rb

@@ -37,7 +37,11 @@ module Typelizer
       # can be invoked multiple times
       def typelize(type = nil, type_params = {}, **attributes)
         if type
-          @keyless_type = [type, type_params.merge(attributes)]
+          # Parse type shortcuts like 'string?', 'string[]'
+          parsed = TypeParser.parse(type)
+          merged_params = parsed.merge(type_params).merge(attributes)
+          actual_type = merged_params.delete(:type)
+          @keyless_type = [actual_type, merged_params]
         else
           assign_type_information(:_typelizer_attributes, attributes)
         end
@@ -79,7 +83,19 @@ module Typelizer
           attrs = [attrs] if attrs && !attrs.is_a?(Array)
           options = attrs.last.is_a?(Hash) ? attrs.pop : {}
 
-          options[:type] = attrs.join(" | ") if attrs.any?
+          if attrs.any?
+            # Parse type shortcuts and merge options
+            parsed_types = attrs.map { |t| TypeParser.parse(t) }
+            type_names = parsed_types.map { |p| p[:type] }
+            options[:type] = type_names.join(" | ")
+
+            # Merge modifier flags from all parsed types
+            parsed_types.each do |parsed|
+              options[:optional] = true if parsed[:optional]
+              options[:multi] = true if parsed[:multi]
+            end
+          end
+
           instance_variable_get(instance_variable)[name.to_sym] ||= {}
           instance_variable_get(instance_variable)[name.to_sym].merge!(options)
         end

data/lib/typelizer/interface.rb

@@ -52,6 +52,12 @@ module Typelizer
       end
     end
 
+    def trait_interfaces
+      return [] unless serializer_plugin.respond_to?(:trait_interfaces)
+
+      @trait_interfaces ||= serializer_plugin.trait_interfaces
+    end
+
     def properties
       @properties ||= begin
         props = serializer_plugin.properties
@@ -89,7 +95,10 @@ module Typelizer
 
     def imports
       @imports ||= begin
-        association_serializers, attribute_types = properties_to_print.filter_map(&:type)
+        # Include both main properties and trait properties for import collection
+        all_properties = properties_to_print + trait_interfaces.flat_map(&:properties)
+
+        association_serializers, attribute_types = all_properties.filter_map(&:type)
           .uniq
           .partition { |type| type.is_a?(Interface) }
 
@@ -101,7 +110,16 @@ module Typelizer
           .uniq
           .reject { |type| global_type?(type) }
 
-        (custom_type_imports + serializer_types + Array(parent_interface&.name)).uniq - Array(self_type_name)
+        # Collect trait types from properties with with_traits (skip self-references)
+        trait_imports = all_properties.flat_map do |prop|
+          next [] unless prop.with_traits&.any? && prop.type.is_a?(Interface)
+          # Skip if the trait types are from the current interface (same file)
+          next [] if prop.type.name == name
+
+          prop.with_traits.map { |t| "#{prop.type.name}#{t.to_s.camelize}Trait" }
+        end
+
+        (custom_type_imports + serializer_types + trait_imports + Array(parent_interface&.name)).uniq - Array(self_type_name)
       end
     end
 
@@ -110,7 +128,12 @@ module Typelizer
     end
 
     def fingerprint
-      "<#{self.class.name} #{name} properties=[#{properties_to_print.map(&:fingerprint).join(", ")}]>"
+      if trait_interfaces.empty?
+        "<#{self.class.name} #{name} properties=[#{properties_to_print.map(&:fingerprint).join(", ")}]>"
+      else
+        traits_fingerprint = trait_interfaces.map { |t| "#{t.name}=[#{t.properties.map(&:fingerprint).join(", ")}]" }.join(", ")
+        "<#{self.class.name} #{name} properties=[#{properties_to_print.map(&:fingerprint).join(", ")}] traits=[#{traits_fingerprint}]>"
+      end
     end
 
     def quote(str)

data/lib/typelizer/property.rb

@@ -2,6 +2,7 @@ module Typelizer
   Property = Struct.new(
     :name, :type, :optional, :nullable,
     :multi, :column_name, :comment, :enum, :deprecated,
+    :with_traits,
     keyword_init: true
   ) do
     def inspect
@@ -17,6 +18,13 @@ module Typelizer
 
     def to_s
       type_str = type_name
+
+      # Handle intersection types for traits
+      if with_traits&.any? && type.respond_to?(:name)
+        trait_types = with_traits.map { |t| "#{type.name}#{t.to_s.camelize}Trait" }
+        type_str = ([type_str] + trait_types).join(" & ")
+      end
+
       type_str = "Array<#{type_str}>" if multi
       type_str = "#{type_str} | null" if nullable
 

data/lib/typelizer/serializer_plugins/alba/trait_attribute_collector.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module SerializerPlugins
+    class Alba::TraitAttributeCollector
+      attr_reader :collected_attributes, :collected_typelizes
+
+      def initialize
+        @collected_attributes = {}
+        @collected_typelizes = {}
+        @pending_typelize = nil
+      end
+
+      def attributes(*names, **options)
+        names.each do |name|
+          @collected_attributes[name] = name
+        end
+      end
+
+      def attribute(name, **options, &block)
+        @collected_attributes[name] = block || name
+        # Apply pending typelize to this attribute
+        if @pending_typelize
+          @collected_typelizes[name] = @pending_typelize
+          @pending_typelize = nil
+        end
+      end
+
+      # Capture typelize calls - they apply to the next attribute
+      # Handles both:
+      #   typelize :string, nullable: true  (type with options, applies to next attribute)
+      #   typelize attr_name: [:string, nullable: true]  (hash-style, applies to specific attribute)
+      def typelize(type_or_hash = nil, **options)
+        if type_or_hash.is_a?(Hash)
+          # typelize({name: [:string, nullable: true]}) - explicit hash
+          type_or_hash.each do |attr_name, type_def|
+            @collected_typelizes[attr_name] = normalize_typelize(type_def)
+          end
+        elsif type_or_hash.nil? && options.any?
+          # typelize name: [:string, nullable: true] - Ruby passes as kwargs
+          # Check if this looks like attribute definitions (values are arrays or have type-like keys)
+          if options.values.first.is_a?(Array) || options.values.first.is_a?(Symbol) || options.values.first.is_a?(String)
+            options.each do |attr_name, type_def|
+              @collected_typelizes[attr_name] = normalize_typelize(type_def)
+            end
+          else
+            # typelize :string, nullable: true - type with options
+            @pending_typelize = normalize_typelize(nil, **options)
+          end
+        else
+          # typelize :string - applies to the next attribute
+          @pending_typelize = normalize_typelize(type_or_hash, **options)
+        end
+      end
+
+      # Simple struct to hold association info from traits
+      TraitAssociation = Struct.new(:name, :resource, :with_traits, :multi, keyword_init: true)
+
+      # Support association methods that might be used in traits
+      def one(name, **options, &block)
+        resource = options[:resource] || options[:serializer]
+        with_traits = options[:with_traits]
+        @collected_attributes[name] = TraitAssociation.new(
+          name: name,
+          resource: resource,
+          with_traits: with_traits,
+          multi: false
+        )
+      end
+
+      alias_method :has_one, :one
+      alias_method :association, :one
+
+      def many(name, **options, &block)
+        resource = options[:resource] || options[:serializer]
+        with_traits = options[:with_traits]
+        @collected_attributes[name] = TraitAssociation.new(
+          name: name,
+          resource: resource,
+          with_traits: with_traits,
+          multi: true
+        )
+      end
+
+      alias_method :has_many, :many
+
+      # Ignore other DSL methods that might be called
+      def method_missing(method_name, *args, **kwargs, &block)
+        # Silently ignore unknown methods
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+
+      private
+
+      def normalize_typelize(type_def, **options)
+        case type_def
+        when Array
+          # [:string, nullable: true] or ['string?', nullable: true]
+          type, *rest = type_def
+          opts = rest.first || {}
+          TypeParser.parse(type, **opts)
+        when Symbol, String
+          TypeParser.parse(type_def, **options)
+        else
+          options
+        end
+      end
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/alba/trait_interface.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module SerializerPlugins
+    class Alba::TraitInterface
+      attr_reader :serializer, :trait_name, :context, :plugin
+
+      def initialize(serializer:, trait_name:, context:, plugin:)
+        @serializer = serializer
+        @trait_name = trait_name
+        @context = context
+        @plugin = plugin
+      end
+
+      def config
+        context.config_for(serializer)
+      end
+
+      def name
+        base_name = config.serializer_name_mapper.call(serializer).tr_s(":", "")
+        "#{base_name}#{trait_name.to_s.camelize}Trait"
+      end
+
+      def properties
+        @properties ||= begin
+          props, typelizes = plugin.trait_properties(trait_name)
+          infer_types(props, typelizes)
+        end
+      end
+
+      private
+
+      def infer_types(props, typelizes)
+        props.map do |prop|
+          # First check for typelize DSL in the trait
+          dsl_type = typelizes[prop.column_name.to_sym]
+          if dsl_type&.any?
+            next Property.new(prop.to_h.merge(dsl_type)).tap do |property|
+              property.comment ||= model_plugin.comment_for(property) if config.comments && property.comment != false
+              property.enum ||= model_plugin.enum_for(property) if property.enum != false
+            end
+          end
+
+          # Fall back to model plugin for type inference
+          model_plugin.infer_types(prop)
+        end
+      end
+
+      def model_class
+        return serializer._typelizer_model_name if serializer.respond_to?(:_typelizer_model_name)
+
+        config.instance_exec(serializer, &config.serializer_model_mapper)
+      rescue NameError
+        nil
+      end
+
+      def model_plugin
+        @model_plugin ||= config.model_plugin.new(model_class: model_class, config: config)
+      end
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/alba.rb

@@ -60,6 +60,74 @@ module Typelizer
         ]
       end
 
+      def traits
+        return {} unless serializer.instance_variable_defined?(:@_traits)
+
+        serializer.instance_variable_get(:@_traits) || {}
+      end
+
+      def trait_properties(trait_name)
+        trait_block = traits[trait_name]
+        return [], {} unless trait_block
+
+        # Create a collector to capture attributes defined in the trait block
+        collector = TraitAttributeCollector.new
+        collector.instance_exec(&trait_block)
+
+        props = collector.collected_attributes.map do |name, attr|
+          build_trait_property(name.is_a?(Symbol) ? name.name : name, attr)
+        end
+
+        [props, collector.collected_typelizes]
+      end
+
+      def build_trait_property(name, attr)
+        case attr
+        when TraitAttributeCollector::TraitAssociation
+          with_traits = Array(attr.with_traits) if attr.with_traits
+          resource = attr.resource || infer_resource_from_name(name)
+
+          Property.new(
+            name: name,
+            type: resource ? context.interface_for(resource) : nil,
+            optional: false,
+            nullable: false,
+            multi: attr.multi,
+            column_name: name,
+            with_traits: with_traits
+          )
+        else
+          build_property(name, attr)
+        end
+      end
+
+      def infer_resource_from_name(name)
+        class_name = name.to_s.classify
+        # Try common serializer naming conventions
+        ["#{class_name}Resource", "#{class_name}Serializer"].each do |resource_name|
+          return serializer.const_get(resource_name, false)
+        rescue NameError
+          # Try in parent namespace
+          begin
+            return Object.const_get("#{serializer.module_parent}::#{resource_name}")
+          rescue NameError
+            # Not found in this namespace
+          end
+        end
+        nil
+      end
+
+      def trait_interfaces
+        traits.map do |trait_name, _|
+          TraitInterface.new(
+            serializer: serializer,
+            trait_name: trait_name,
+            context: context,
+            plugin: self
+          )
+        end
+      end
+
       private
 
       def build_property(name, attr, **options)
@@ -92,6 +160,9 @@ module Typelizer
           )
         when ::Alba::Association
           resource = attr.instance_variable_get(:@resource)
+          # Alba stores with_traits directly in @with_traits, not in @params
+          with_traits = attr.instance_variable_get(:@with_traits)
+          with_traits = Array(with_traits) if with_traits
 
           Property.new(
             name: name,
@@ -100,6 +171,7 @@ module Typelizer
             nullable: false,
             multi: false, # we override this in typelize_method_transform
             column_name: attr.name.is_a?(Symbol) ? attr.name.name : attr.name,
+            with_traits: with_traits,
             **options
           )
         when ::Alba::TypedAttribute
@@ -151,3 +223,6 @@ module Typelizer
     end
   end
 end
+
+require_relative "alba/trait_attribute_collector"
+require_relative "alba/trait_interface"

data/lib/typelizer/templates/index.ts.erb

@@ -1,7 +1,7 @@
 <%- interfaces.each do |interface| -%>
 <%- if interface.config.verbatim_module_syntax -%>
-export type { <%= interface.name %> } from <%= interface.quote('./' + interface.filename) %>
+export type { <%= interface.name %><%= ", " + interface.trait_interfaces.map(&:name).join(", ") if interface.trait_interfaces.any? %> } from <%= interface.quote('./' + interface.filename) %>
 <%- else -%>
-export type { default as <%= interface.name %> } from <%= interface.quote('./' + interface.filename) %>
+export type { default as <%= interface.name %><%= ", " + interface.trait_interfaces.map(&:name).join(", ") if interface.trait_interfaces.any? %> } from <%= interface.quote('./' + interface.filename) %>
 <%- end -%>
 <%- end -%>

data/lib/typelizer/templates/interface.ts.erb

@@ -20,9 +20,20 @@ type <%= interface.name %> = {
 <% end -%>
 }
 <% end -%>
+<% interface.trait_interfaces.each do |trait| -%>
+
+type <%= trait.name %> = {
+<% trait.properties.each do |property| -%>
+<%= indent(property) %>;
+<% end -%>
+}
+<% end -%>
 
 <% if interface.config.verbatim_module_syntax -%>
-export type { <%= interface.name %> };
+export type { <%= interface.name %><%= ", " + interface.trait_interfaces.map(&:name).join(", ") if interface.trait_interfaces.any? %> };
 <% else -%>
 export default <%= interface.name %>;
+<% if interface.trait_interfaces.any? -%>
+export type { <%= interface.trait_interfaces.map(&:name).join(", ") %> };
+<% end -%>
 <% end -%>

data/lib/typelizer/type_parser.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module TypeParser
+    # Regex to match type shortcuts:
+    # - Base type (captured)
+    # - Optional `?` modifier
+    # - Optional `[]` modifier
+    # Order of ? and [] can be either way
+    TYPE_PATTERN = /\A(.+?)(\?)?(\[\])?(\?)?\z/
+
+    class << self
+      def parse(type_def, **options)
+        return options if type_def.nil?
+
+        type_str = type_def.to_s
+        match = TYPE_PATTERN.match(type_str)
+
+        return {type: type_def}.merge(options) unless match
+
+        base_type = match[1]
+        optional = match[2] == "?" || match[4] == "?"
+        multi = match[3] == "[]"
+
+        result = {type: base_type.to_sym}
+        result[:optional] = true if optional
+        result[:multi] = true if multi
+        result.merge(options)
+      end
+
+      def shortcut?(type_def)
+        return false if type_def.nil?
+
+        type_str = type_def.to_s
+        type_str.end_with?("?", "[]")
+      end
+    end
+  end
+end

data/lib/typelizer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Typelizer
-  VERSION = "0.5.3"
+  VERSION = "0.5.4"
 end

data/lib/typelizer.rb

@@ -15,6 +15,7 @@ require_relative "typelizer/interface"
 require_relative "typelizer/renderer"
 require_relative "typelizer/writer"
 require_relative "typelizer/generator"
+require_relative "typelizer/type_parser"
 require_relative "typelizer/dsl"
 
 require_relative "typelizer/serializer_plugins/oj_serializers"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typelizer
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Svyatoslav Kryukov
@@ -64,6 +64,8 @@ files:
 - lib/typelizer/renderer.rb
 - lib/typelizer/serializer_config_layer.rb
 - lib/typelizer/serializer_plugins/alba.rb
+- lib/typelizer/serializer_plugins/alba/trait_attribute_collector.rb
+- lib/typelizer/serializer_plugins/alba/trait_interface.rb
 - lib/typelizer/serializer_plugins/ams.rb
 - lib/typelizer/serializer_plugins/auto.rb
 - lib/typelizer/serializer_plugins/base.rb
@@ -75,6 +77,7 @@ files:
 - lib/typelizer/templates/inheritance.ts.erb
 - lib/typelizer/templates/inline_type.ts.erb
 - lib/typelizer/templates/interface.ts.erb
+- lib/typelizer/type_parser.rb
 - lib/typelizer/version.rb
 - lib/typelizer/writer.rb
 homepage: https://github.com/skryukov/typelizer
@@ -101,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.0
 specification_version: 4
 summary: A TypeScript type generator for Ruby serializers.
 test_files: []