cybrid_api_organization_ruby 0.117.27 → 0.117.28

data/vendor/bundle/ruby/3.2.0/gems/{ffi-1.16.3 → ffi-1.17.0-x86_64-linux-gnu}/lib/ffi/struct.rb

@@ -41,12 +41,12 @@ module FFI
   class Struct
 
     # Get struct size
-    # @return [Numeric]
+    # @return [Integer]
     def size
       self.class.size
     end
 
-    # @return [Fixnum] Struct alignment
+    # @return [Integer] Struct alignment
     def alignment
       self.class.alignment
     end
@@ -87,13 +87,13 @@ module FFI
     end
 
     # Get struct size
-    # @return [Numeric]
+    # @return [Integer]
     def self.size
       defined?(@layout) ? @layout.size : defined?(@size) ? @size : 0
     end
 
     # set struct size
-    # @param [Numeric] size
+    # @param [Integer] size
     # @return [size]
     def self.size=(size)
       raise ArgumentError, "Size already set" if defined?(@size) || defined?(@layout)

data/vendor/bundle/ruby/3.2.0/gems/{ffi-1.16.3 → ffi-1.17.0-x86_64-linux-gnu}/lib/ffi/struct_layout.rb

@@ -35,13 +35,13 @@ module FFI
 
   class StructLayout
 
-    # @return [Array<Array(Symbol, Numeric)>
+    # @return [Array<Array(Symbol, Integer)>
     # Get an array of tuples (field name, offset of the field).
     def offsets
       members.map { |m| [ m, self[m].offset ] }
     end
 
-    # @return [Numeric]
+    # @return [Integer]
     # Get the offset of a field.
     def offset_of(field_name)
       self[field_name].offset

data/vendor/bundle/ruby/3.2.0/gems/{ffi-1.16.3 → ffi-1.17.0-x86_64-linux-gnu}/lib/ffi/struct_layout_builder.rb

@@ -46,13 +46,13 @@ module FFI
     end
 
     # Set size attribute with +size+ only if +size+ is greater than attribute value.
-    # @param [Numeric] size
+    # @param [Integer] size
     def size=(size)
       @size = size if size > @size
     end
 
     # Set alignment attribute with +align+ only if it is greater than attribute value.
-    # @param [Numeric] align
+    # @param [Integer] align
     def alignment=(align)
       @alignment = align if align > @alignment
       @min_alignment = align
@@ -78,7 +78,7 @@ module FFI
     # @overload packed=(packed) Set alignment and packed attributes to
     #   +packed+.
     #
-    #   @param [Fixnum] packed
+    #   @param [Integer] packed
     #
     #   @return [packed]
     # @overload packed=(packed) Set packed attribute.
@@ -116,7 +116,7 @@ module FFI
 
     # @param [String, Symbol] name name of the field
     # @param [Array, DataConverter, Struct, StructLayout::Field, Symbol, Type] type type of the field
-    # @param [Numeric, nil] offset
+    # @param [Integer, nil] offset
     # @return [self]
     # Add a field to the builder.
     # @note Setting +offset+ to +nil+ or +-1+ is equivalent to +0+.
@@ -154,7 +154,7 @@ module FFI
 
     # @param name (see #add)
     # @param type (see #add)
-    # @param [Numeric] count array length
+    # @param [Integer] count array length
     # @param offset (see #add)
     # @return (see #add)
     # Add an array as a field to the builder.
@@ -175,9 +175,9 @@ module FFI
 
     private
 
-    # @param [Numeric] offset
-    # @param [Numeric] align
-    # @return [Numeric]
+    # @param [Integer] offset
+    # @param [Integer] align
+    # @return [Integer]
     def align(offset, align)
       align + ((offset - 1) & ~(align - 1));
     end

data/vendor/bundle/ruby/3.2.0/gems/{ffi-1.16.3 → ffi-1.17.0-x86_64-linux-gnu}/lib/ffi/types.rb

@@ -33,7 +33,8 @@
 # see {file:README}
 module FFI
 
-  unless defined?(self.custom_typedefs)
+  # Unless custom_typedefs already defined in the C-ext?
+  unless defined?(custom_typedefs)
     # Truffleruby and JRuby don't support Ractor so far.
     # So they don't need separation between builtin and custom types.
     def self.custom_typedefs
@@ -42,55 +43,63 @@ module FFI
     writable_typemap = true
   end
 
-  # @param [Type, DataConverter, Symbol] old type definition used by {FFI.find_type}
-  # @param [Symbol] add new type definition's name to add
-  # @return [Type]
-  # Add a definition type to type definitions.
-  #
-  # The type definition is local per Ractor.
-  def self.typedef(old, add)
-    tm = custom_typedefs
-    tm[add] = self.find_type(old)
-  end
-
-  # (see FFI.typedef)
-  def self.add_typedef(old, add)
-    typedef old, add
-  end
-
   class << self
-    private def __typedef(old, add)
-      TypeDefs[add] = self.find_type(old)
-    end
 
     private :custom_typedefs
-  end
 
+    # @param [Type, DataConverter, Symbol] old type definition used by {FFI.find_type}
+    # @param [Symbol] add new type definition's name to add
+    # @return [Type]
+    # Add a definition type to type definitions.
+    #
+    # The type definition is local per Ractor.
+    def typedef(old, add)
+      tm = custom_typedefs
+      tm[add] = find_type(old)
+    end
 
-  # @param [Type, DataConverter, Symbol] name
-  # @param [Hash] type_map if nil, {FFI::TypeDefs} is used
-  # @return [Type]
-  # Find a type in +type_map+ ({FFI::TypeDefs}, by default) from
-  # a type objet, a type name (symbol). If +name+ is a {DataConverter},
-  # a new {Type::Mapped} is created.
-  def self.find_type(name, type_map = nil)
-    if name.is_a?(Type)
-      name
-
-    elsif type_map&.has_key?(name)
-      type_map[name]
+    # (see FFI.typedef)
+    def add_typedef(old, add)
+      typedef old, add
+    end
 
-    elsif (tm=custom_typedefs).has_key?(name)
-      tm[name]
+    private def __typedef(old, add)
+      TypeDefs[add] = find_type(old, TypeDefs)
+    end
 
-    elsif TypeDefs.has_key?(name)
-      TypeDefs[name]
+    # @param [Type, DataConverter, Symbol] name
+    # @param [Hash] type_map if nil, {FFI::TypeDefs} is used
+    # @return [Type]
+    # Find a type in +type_map+ ({FFI::TypeDefs}, by default) from
+    # a type objet, a type name (symbol). If +name+ is a {DataConverter},
+    # a new {Type::Mapped} is created.
+    def find_type(name, type_map = nil)
+      if name.is_a?(Type)
+        name
+
+      elsif type_map&.has_key?(name)
+        type_map[name]
+
+      elsif (tm=custom_typedefs).has_key?(name)
+        tm[name]
+
+      elsif TypeDefs.has_key?(name)
+        TypeDefs[name]
+
+      elsif name.is_a?(DataConverter)
+        # Add a typedef so next time the converter is used, it hits the cache
+        tm = (type_map || custom_typedefs)
+        tm[name] = Type::Mapped.new(name)
+      else
+        raise TypeError, "unable to resolve type '#{name}'"
+      end
+    end
 
-    elsif name.is_a?(DataConverter)
-      tm = (type_map || custom_typedefs)
-      tm[name] = Type::Mapped.new(name)
-    else
-      raise TypeError, "unable to resolve type '#{name}'"
+    # @param type +type+ is an instance of class accepted by {FFI.find_type}
+    # @return [Integer]
+    # Get +type+ size, in bytes.
+    def type_size(type)
+      find_type(type).size
     end
   end
 
@@ -194,13 +203,6 @@ module FFI
 
   __typedef(StrPtrConverter, :strptr)
 
-  # @param type +type+ is an instance of class accepted by {FFI.find_type}
-  # @return [Numeric]
-  # Get +type+ size, in bytes.
-  def self.type_size(type)
-    find_type(type).size
-  end
-
   # Load all the platform dependent types
   begin
     File.open(File.join(Platform::CONF_DIR, 'types.conf'), "r") do |f|

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/lib/ffi/version.rb

@@ -0,0 +1,3 @@
+module FFI
+  VERSION = '1.17.0'
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/abstract_memory.rbs

@@ -0,0 +1,165 @@
+module FFI
+  class AbstractMemory
+    interface _Size
+      def size: () -> Integer
+    end
+    include _Size
+    type type_size = Integer | _Size | Symbol
+
+    type order_out = :big | :little
+    type order_in = order_out | :network
+
+    def []: (Integer idx) -> instance
+    def clear: () -> self
+    def freeze: ...
+    def get: (ffi_type type, Integer offset) -> top
+    def put: (ffi_type type, Integer offset, top value) -> nil
+    def size_limit?: () -> bool
+    def type_size: () -> Integer
+    alias total size
+
+    def get_int8: (Integer offset) -> Integer
+    def get_int16: (Integer offset) -> Integer
+    def get_int32: (Integer offset) -> Integer
+    def get_int64: (Integer offset) -> Integer
+    def get_uint8: (Integer offset) -> Integer
+    def get_uint16: (Integer offset) -> Integer
+    def get_uint32: (Integer offset) -> Integer
+    def get_uint64: (Integer offset) -> Integer
+    def get_char: (Integer offset) -> Integer
+    def get_short: (Integer offset) -> Integer
+    def get_int: (Integer offset) -> Integer
+    def get_long_long: (Integer offset) -> Integer
+    def get_float32: (Integer offset) -> Float
+    def get_float64: (Integer offset) -> Float
+    def get_pointer: (Integer offset) -> Pointer
+    def get_bytes: (Integer offset, Integer length) -> String
+    def get_string: (Integer offset, ?Integer? length) -> String
+    alias get_float get_float32
+    alias get_double get_float64
+
+    def put_int8: (Integer offset, int value) -> self
+    def put_int16: (Integer offset, int value) -> self
+    def put_int32: (Integer offset, int value) -> self
+    def put_int64: (Integer offset, int value) -> self
+    def put_uint8: (Integer offset, int value) -> self
+    def put_uint16: (Integer offset, int value) -> self
+    def put_uint32: (Integer offset, int value) -> self
+    def put_uint64: (Integer offset, int value) -> self
+    def put_char: (Integer offset, int value) -> self
+    def put_short: (Integer offset, int value) -> self
+    def put_int: (Integer offset, int value) -> self
+    def put_long_long: (Integer offset, int value) -> self
+    def put_float32: (Integer offset, Numeric value) -> self
+    def put_float64: (Integer offset, Numeric value) -> self
+    def put_pointer: (Integer offset, pointer value) -> self
+    def put_bytes: (Integer offset, String str, ?Integer index, ?Integer? length) -> self
+    def put_string: (Integer offset, String value) -> self
+    alias put_float put_float32
+    alias put_double put_float64
+
+    def read_int8: () -> Integer
+    def read_int16: () -> Integer
+    def read_int32: () -> Integer
+    def read_int64: () -> Integer
+    def read_uint8: () -> Integer
+    def read_uint16: () -> Integer
+    def read_uint32: () -> Integer
+    def read_uint64: () -> Integer
+    def read_char: () -> Integer
+    def read_short: () -> Integer
+    def read_int: () -> Integer
+    def read_long_long: () -> Integer
+    def read_float: () -> Float
+    def read_double: () -> Float
+    def read_pointer: () -> Pointer
+    def read_bytes: (Integer length) -> String
+
+    def write_int8: (int value) -> self
+    def write_int16: (int value) -> self
+    def write_int32: (int value) -> self
+    def write_int64: (int value) -> self
+    def write_uint8: (int value) -> self
+    def write_uint16: (int value) -> self
+    def write_uint32: (int value) -> self
+    def write_uint64: (int value) -> self
+    def write_char: (int value) -> self
+    def write_short: (int value) -> self
+    def write_int: (int value) -> self
+    def write_long_long: (int value) -> self
+    def write_float: (Numeric value) -> self
+    def write_double: (Numeric value) -> self
+    def write_pointer: (pointer value) -> self
+    def write_bytes: (String str, ?Integer index, ?Integer? length) -> self
+
+    def get_array_of_int8: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int16: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int32: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int64: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint8: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint16: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint32: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint64: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_char: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_short: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_long_long: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_float32: (Integer offset, Integer length) -> Array[Float]
+    def get_array_of_float64: (Integer offset, Integer length) -> Array[Float]
+    def get_array_of_pointer: (Integer offset, Integer length) -> Array[Pointer]
+    def get_array_of_string: (Integer offset, ?Integer? count) -> Array[String?]
+    alias get_array_of_float get_array_of_float32
+    alias get_array_of_double get_array_of_float64
+
+    def put_array_of_int8: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int16: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int32: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int64: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint8: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint16: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint32: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint64: (Integer offset, Array[int] ary) -> self
+    def put_array_of_char: (Integer offset, Array[int] ary) -> self
+    def put_array_of_short: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int: (Integer offset, Array[int] ary) -> self
+    def put_array_of_long_long: (Integer offset, Array[int] ary) -> self
+    def put_array_of_float32: (Integer offset, Array[Numeric] ary) -> self
+    def put_array_of_float64: (Integer offset, Array[Numeric] ary) -> self
+    def put_array_of_pointer: (Integer offset, Array[pointer] ary) -> self
+    alias put_array_of_float put_array_of_float32
+    alias put_array_of_double put_array_of_float64
+
+    def read_array_of_int8: (Integer length) -> Array[Integer]
+    def read_array_of_int16: (Integer length) -> Array[Integer]
+    def read_array_of_int32: (Integer length) -> Array[Integer]
+    def read_array_of_int64: (Integer length) -> Array[Integer]
+    def read_array_of_uint8: (Integer length) -> Array[Integer]
+    def read_array_of_uint16: (Integer length) -> Array[Integer]
+    def read_array_of_uint32: (Integer length) -> Array[Integer]
+    def read_array_of_uint64: (Integer length) -> Array[Integer]
+    def read_array_of_char: (Integer length) -> Array[Integer]
+    def read_array_of_short: (Integer length) -> Array[Integer]
+    def read_array_of_int: (Integer length) -> Array[Integer]
+    def read_array_of_long_long: (Integer length) -> Array[Integer]
+    def read_array_of_float: (Integer length) -> Array[Float]
+    def read_array_of_double: (Integer length) -> Array[Float]
+    def read_array_of_pointer: (Integer length) -> Array[Pointer]
+    def read_array_of_string: (?Integer? count) -> Array[String?]
+
+    def write_array_of_int8: (Array[int] ary) -> self
+    def write_array_of_int16: (Array[int] ary) -> self
+    def write_array_of_int32: (Array[int] ary) -> self
+    def write_array_of_int64: (Array[int] ary) -> self
+    def write_array_of_uint8: (Array[int] ary) -> self
+    def write_array_of_uint16: (Array[int] ary) -> self
+    def write_array_of_uint32: (Array[int] ary) -> self
+    def write_array_of_uint64: (Array[int] ary) -> self
+    def write_array_of_char: (Array[int] ary) -> self
+    def write_array_of_short: (Array[int] ary) -> self
+    def write_array_of_int: (Array[int] ary) -> self
+    def write_array_of_long_long: (Array[int] ary) -> self
+    def write_array_of_float: (Array[Numeric] ary) -> self
+    def write_array_of_double: (Array[Numeric] ary) -> self
+    def write_array_of_pointer: (Array[pointer] ary) -> self
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/auto_pointer.rbs

@@ -0,0 +1,27 @@
+module FFI
+  class AutoPointer < Pointer
+    class Releaser
+      attr_accessor autorelease: boolish
+      interface _Proc[P < Pointer]
+        def call: (P) -> void
+      end
+      def initialize: [P < Pointer] (P ptr, _Proc[P] proc) -> void
+
+      def call: (*untyped) -> void
+      def free: () -> nil
+      def release: (Pointer ptr) -> void
+    end
+
+    def initialize: (Pointer pointer, Method | ^(self) -> void | Releaser::_Proc[self] callable) -> self
+                # | (Pointer pointer) { (self) -> void } -> self # https://github.com/ffi/ffi/issues/1071
+                  | (Pointer pointer) -> self # where class < `def self.release: (instance pointer) -> void`
+
+    extend DataConverter[Pointer, instance, nil]
+    def self.from_native: ...
+    def self.native_type: () -> Type::Builtin
+
+    def autorelease?: ...
+    def autorelease=: ...
+    def free: () -> nil
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/buffer.rbs

@@ -0,0 +1,18 @@
+module FFI
+  class Buffer < AbstractMemory
+    def initialize: (AbstractMemory::type_size, ?Integer count, boolish clear) -> self
+    alias self.alloc_inout self.new
+    alias self.new_inout self.alloc_inout
+    alias self.alloc_in self.alloc_inout
+    alias self.new_in self.alloc_in
+    alias self.alloc_out self.alloc_inout
+    alias self.new_out self.alloc_out
+
+    def +: (Integer) -> Buffer
+    def inspect: ...
+    def order: () -> AbstractMemory::order_out
+             | (AbstractMemory::order_in order) -> Buffer
+             | (untyped order) -> (self | Buffer)
+    def slice: (Integer offset, Integer length) -> Buffer
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/data_converter.rbs

@@ -0,0 +1,10 @@
+module FFI
+  interface _DataConverter[N, R, in C]
+    def from_native: (N value, C ctx) -> R
+    def native_type: (?ffi_auto_type? type) -> Type
+    def to_native: (R value, C ctx) -> N
+  end
+  module DataConverter[N, R, in C]
+    include _DataConverter[N, R, C]
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/dynamic_library.rbs

@@ -0,0 +1,9 @@
+module FFI
+  class DynamicLibrary
+    # TODO
+
+    class Symbol < Pointer
+      # TODO
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/enum.rbs

@@ -0,0 +1,38 @@
+module FFI
+  class Enums
+    def initialize: () -> void
+
+    def <<: (Enum enum) -> void
+    def __map_symbol: (Symbol symbol) -> Integer?
+    def find: (Symbol query) -> Enum
+  end
+
+  class Enum
+    include DataConverter[Integer, Symbol | Integer, untyped]
+
+    attr_reader native_type: Type
+    attr_reader tag: Symbol?
+    def initialize: (Enumerable[Symbol | Integer], ?Symbol? tag, *untyped) -> void
+                  | (Type native_type, Enumerable[Symbol | Integer], ?Symbol? tag, *untyped) -> void
+
+    def []: (Symbol query) -> Integer?
+          | (Integer query) -> Symbol?
+    def symbol_map: () -> Hash[Symbol, Integer]
+    alias to_h symbol_map
+    alias to_hash symbol_map
+    def symbols: () -> Array[Symbol]
+    def to_native: (Symbol | int value, untyped ctx) -> Integer
+  end
+
+  class Bitmask < Enum
+    def initialize: ...
+
+    def []: (*Symbol query) -> Integer
+          | (Array[Symbol] query) -> Integer
+          | (*Integer query) -> Array[Symbol]
+          | (Array[Integer] query) -> Array[Symbol]
+    def from_native: (Integer, untyped ctx) -> Array[Symbol | Integer]
+    def to_native: (Array[Symbol | int] value, untyped ctx) -> Integer
+                 | ...
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/function.rbs

@@ -0,0 +1,39 @@
+module FFI
+  interface _Function
+    # TODO: leads to a endless recursion when used with -rrbs/test/setup
+    # def attach: (Module mod, String name) -> self
+    def call: (*untyped args) -> untyped
+    def param_types: () -> Array[Type]
+    def return_type: () -> Type
+  end
+
+  class Function < Pointer
+    include _Function
+    # ?blocking: boolish?, ?convention: Library::convention?, ?enums: Enums?
+    def initialize:
+      (
+        ffi_type return_type, Array[ffi_type] param_types,
+        ?Hash[Symbol, untyped] options
+      ) { (*untyped) -> untyped } -> self
+    | (
+        ffi_type return_type, Array[ffi_type] param_types, Proc | Pointer proc,
+        ?Hash[Symbol, untyped] options
+      ) -> self
+
+    def autorelease?: ...
+    alias autorelease autorelease?
+    def autorelease=: ...
+    def free: () -> self
+  end
+
+  class VariadicInvoker
+    include _Function
+    def initialize:
+      (
+        Pointer function, Array[ffi_type] parameter_types, ffi_type return_type,
+        Hash[Symbol, untyped] options #TODO
+      ) -> void
+
+    def invoke: (Array[Type] parameter_types, Array[untyped] parameter_values) -> untyped
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/library.rbs

@@ -0,0 +1,42 @@
+module FFI
+  module Library
+    type convention = :default | :stdcall
+    type ffi_lib_flag = :global | :local | :lazy | :now
+    type ffi_lib_type = ffi_auto_type | singleton(Struct)
+
+    CURRENT_PROCESS: current_process
+    LIBC: String
+    FlagsMap: Hash[ffi_lib_flag, Integer]
+
+    def self.extended: ...
+
+    def attach_function: (           _ToS func, Array[ffi_lib_type] args,  ffi_lib_type? returns, ?blocking: boolish, ?convention: convention, ?enums: Enums, ?type_map: type_map) -> (Function | VariadicInvoker)
+                       | (_ToS name, _ToS func, Array[ffi_lib_type] args, ?ffi_lib_type? returns, ?blocking: boolish, ?convention: convention, ?enums: Enums, ?type_map: type_map) -> (Function | VariadicInvoker)
+    def attach_variable: (?_ToS mname, _ToS cname, ffi_lib_type type) -> DynamicLibrary::Symbol
+    def attached_functions: () -> Hash[Symbol, Function | VariadicInvoker]
+    def attached_variables: () -> Hash[Symbol, Type | singleton(Struct)]
+
+    def bitmask: (?Type native_type, Symbol name, Array[Symbol | Integer] values) -> Bitmask
+               | (?Type native_type, *Symbol | Integer args) -> Bitmask
+               | (?Type native_type, Array[Symbol | Integer] values) -> Bitmask
+    def enum: (?Type native_type, Symbol name, Array[Symbol | Integer] values) -> Enum
+            | (?Type native_type, *Symbol | Integer args) -> Enum
+            | (?Type native_type, Array[Symbol | Integer] values) -> Enum
+    def enum_type: (Symbol name) -> Enum?
+    def enum_for: (Symbol name) -> Integer?
+
+    def callback: (?Symbol name, Array[ffi_lib_type] params, ffi_lib_type ret) -> CallbackInfo
+    def ffi_convention: (?convention? convention) -> convention
+    def ffi_lib: (*_ToS names) -> Array[DynamicLibrary]
+    def ffi_lib_flags: (*ffi_lib_flag flags) -> Integer
+    def ffi_libraries: () -> Array[DynamicLibrary]
+    def find_type: (ffi_lib_type t) -> Type
+    def freeze: () -> void
+    def function_names: (_ToS name, Array[Type | singleton(Struct)] arg_types) -> Array[String]
+    def typedef: [T < Type] (T old, Symbol | DataConverter add, ?untyped) -> T
+               | (Symbol old, Symbol add, ?untyped) -> (Type | Enum)
+               | [X < DataConverter[N, R, C], N, R, C] (X old, Symbol add, ?untyped) -> Type::Mapped[X, N, R, C]
+               | (:enum old, Array[Symbol | Integer] add, ?untyped) -> Enum
+               | (:enum old, Symbol | Type add, Array[Symbol | Integer] info) -> Enum
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.17.0-x86_64-linux-gnu/sig/ffi/native_type.rbs

@@ -0,0 +1,86 @@
+module FFI
+  class Type
+    INT8: Builtin
+    SCHAR: Builtin
+    CHAR: Builtin
+    UINT8: Builtin
+    UCHAR: Builtin
+    INT16: Builtin
+    SHORT: Builtin
+    SSHORT: Builtin
+    UINT16: Builtin
+    USHORT: Builtin
+    INT32: Builtin
+    INT: Builtin
+    SINT: Builtin
+    UINT32: Builtin
+    UINT: Builtin
+    INT64: Builtin
+    LONG_LONG: Builtin
+    SLONG_LONG: Builtin
+    UINT64: Builtin
+    ULONG_LONG: Builtin
+    LONG: Builtin
+    SLONG: Builtin
+    ULONG: Builtin
+    FLOAT32: Builtin
+    FLOAT: Builtin
+    FLOAT64: Builtin
+    DOUBLE: Builtin
+    LONGDOUBLE: Builtin
+    POINTER: Builtin
+    BOOL: Builtin
+    STRING: Builtin
+    BUFFER_IN: Builtin
+    BUFFER_OUT: Builtin
+    BUFFER_INOUT: Builtin
+    VARARGS: Builtin
+    VOID: Builtin
+  end
+
+  module NativeType
+    INT8: Type::Builtin
+    UINT8: Type::Builtin
+    INT16: Type::Builtin
+    UINT16: Type::Builtin
+    INT32: Type::Builtin
+    UINT32: Type::Builtin
+    INT64: Type::Builtin
+    UINT64: Type::Builtin
+    LONG: Type::Builtin
+    ULONG: Type::Builtin
+    FLOAT32: Type::Builtin
+    FLOAT64: Type::Builtin
+    LONGDOUBLE: Type::Builtin
+    POINTER: Type::Builtin
+    BOOL: Type::Builtin
+    STRING: Type::Builtin
+    BUFFER_IN: Type::Builtin
+    BUFFER_OUT: Type::Builtin
+    BUFFER_INOUT: Type::Builtin
+    VARARGS: Type::Builtin
+    VOID: Type::Builtin
+  end
+
+  TYPE_INT8: Type::Builtin
+  TYPE_UINT8: Type::Builtin
+  TYPE_INT16: Type::Builtin
+  TYPE_UINT16: Type::Builtin
+  TYPE_INT32: Type::Builtin
+  TYPE_UINT32: Type::Builtin
+  TYPE_INT64: Type::Builtin
+  TYPE_UINT64: Type::Builtin
+  TYPE_LONG: Type::Builtin
+  TYPE_ULONG: Type::Builtin
+  TYPE_FLOAT32: Type::Builtin
+  TYPE_FLOAT64: Type::Builtin
+  TYPE_LONGDOUBLE: Type::Builtin
+  TYPE_POINTER: Type::Builtin
+  TYPE_BOOL: Type::Builtin
+  TYPE_STRING: Type::Builtin
+  TYPE_BUFFER_IN: Type::Builtin
+  TYPE_BUFFER_OUT: Type::Builtin
+  TYPE_BUFFER_INOUT: Type::Builtin
+  TYPE_VARARGS: Type::Builtin
+  TYPE_VOID: Type::Builtin
+end