diamond-orm 0.1.0

data/sig/diamond.rbs

@@ -0,0 +1,693 @@
+# sig/diamond.rbs — static signatures for the Diamond persistence layer.
+#
+# Critical modeling decision: Table/QueryObject gain their query API
+# at *runtime* (wake_up includes DSL/Domain modules guarded by
+# include?). RBS declares those includes statically — they hold for
+# any booted process, and without them `Users.where` never resolves.
+# Same for the singleton extends on Diamond itself.
+# Table proxies (`Users`) and `by_*` finders are runtime-bound and
+# intentionally absent here — see sig/generated/tables.rbs and the
+# ruby_lsp/houseki add-on respectively.
+
+module Diamond
+  RACTOR_KEYS: Hash[Symbol, Symbol]
+  IDENT_RE: Regexp
+  RUNTIME_STATUS_CODES: Hash[Symbol, Integer]
+
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  class TableNotFound < Error
+  end
+
+  class RecordNotFound < Error
+  end
+
+  class InertObjectError < Error
+  end
+
+  class UnknownColumnError < StandardError
+    def self.build: (untyped schema, Symbol name) -> UnknownColumnError
+  end
+
+  class QueryInterruptedError < Error
+  end
+
+  class FeatureNotAvailableError < Error
+  end
+
+  extend Domains::DDL
+  extend Domains::CTE
+  extend DSL::Default
+
+  def self.quote_ident: (Symbol | String name) -> String
+  def self.validate_ident!: (Symbol | String name, ?String what) -> (Symbol | String)
+  def self.wake_up: (String db_path, ?busy_timeout: Integer?, ?gvl_release_threshold: Integer?, ?on_progress: Proc?, ?extensions: Array[String], ?auto_fiber_yield: bool) -> untyped
+  def self.fiber_yield_on_progress: (?untyped _busy) -> nil
+  def self.rebind_tables!: () -> Array[untyped]
+  def self.bind_tables!: () -> Hash[Symbol, untyped]?
+  def self.note_bound_table: (Symbol name) -> Array[Symbol]
+  def self.engine: () -> Diamond::Engine
+  def self.backup: (untyped target) { (Integer, Integer) -> untyped } -> untyped
+  def self.track_changes: (*Symbol tables) { () -> untyped } -> Diamond::Changeset
+  def self.query_with_timeout: (Integer seconds) { () -> untyped } -> untyped
+  def self.sleep: (Numeric seconds) -> untyped
+  def self.transaction: (?Symbol mode) { () -> untyped } -> untyped
+  def self.savepoint: (Symbol | String name) { () -> untyped } -> untyped
+  def self.tables: () -> Array[Symbol]
+  def self.busy_timeout=: (Integer val) -> Integer
+  def self.busy_timeout: () -> Integer?
+  def self.gvl_release_threshold=: (Integer val) -> Integer
+  def self.gvl_release_threshold: () -> Integer
+  def self.on_progress: () { (bool) -> untyped } -> untyped
+  def self.load_extension: (String path) -> untyped
+  def self.trace: () { (*untyped) -> untyped } -> untyped
+  def self.runtime_status: (Symbol code) -> untyped
+  def self.status: (Symbol code) -> [untyped, untyped]
+  def self.limit: (Symbol code, ?Integer? value) -> untyped
+  def self.clear_caches!: () -> untyped
+end
+
+# Installed on every Module; resolves table proxies, else NameError.
+module DiamondConstMissing
+  def const_missing: (Symbol name) -> untyped
+end
+
+module Diamond
+  class Operator
+  end
+
+  class Engine
+    DBSTATUS_CODES: Hash[Symbol, Integer]
+    LIMIT_CODES: Hash[Symbol, Integer]
+
+    attr_reader db: untyped
+    attr_reader schema_cache: Hash[Symbol, untyped]
+    attr_reader foreign_keys: Hash[Symbol, untyped]
+    attr_reader prepared_cache: Hash[untyped, untyped]
+
+    def initialize: (String db_path, ?busy_timeout: Integer?, ?gvl_release_threshold: Integer?, ?on_progress: Proc?, ?extensions: Array[String]) -> void
+    def sync_scheduler_hook!: () -> bool
+    def reload_schema!: () -> Diamond::Engine
+    def freeze!: () -> Diamond::Engine
+    def load_one_table!: (Symbol table_name) -> Diamond::Engine
+    def busy_timeout: () -> Integer?
+    def busy_timeout=: (Integer val) -> Integer
+    def gvl_release_threshold: () -> Integer
+    def gvl_release_threshold=: (Integer val) -> Integer
+    def on_progress: () { (bool) -> untyped } -> untyped
+    def load_extension: (String path) -> untyped
+    def prepared: (String sql, ?Symbol mode) -> untyped
+    def status: (Symbol code) -> [untyped, untyped]
+    def limit: (Symbol code, ?Integer? value) -> untyped
+  end
+
+  class Table
+    include Enumerable[untyped]
+    include DSL::Default
+    include Domains::DQL
+    include Domains::DML
+    include Domains::DynamicFinders
+
+    attr_reader name: Symbol
+    attr_reader schema: Hash[Symbol, untyped]
+
+    def initialize: (Symbol name) -> void
+    def columns: () -> Array[Symbol]
+    def primary_key: () -> Symbol?
+    def []: (Integer id) -> untyped
+    def method_missing: (Symbol name, *untyped args, ?block: Proc?) -> untyped
+    def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+  end
+
+  class QueryObject
+    include Enumerable[untyped]
+    include DSL::Default
+    include Domains::DQL
+    include Domains::DML
+    include Domains::DynamicFinders
+
+    VALID_MODES: Array[Symbol]
+
+    attr_reader table: Diamond::Table
+    attr_reader ast: Array[untyped]
+    attr_reader mode: Symbol
+
+    def initialize: (Diamond::Table table, ?Array[untyped] ast) -> void
+    def materialize: () -> Array[untyped]
+    def as_hash: () -> Diamond::QueryObject
+    def as_array: () -> Diamond::QueryObject
+    def as_splat: () -> Diamond::QueryObject
+    def first: (?Integer n) -> untyped
+    def each: () { (untyped) -> untyped } -> untyped
+    def last: (?Integer n) -> untyped
+    def pluck: (*Symbol columns) -> Array[untyped]
+    def pick: (*Symbol columns) -> untyped
+    def ids: () -> Array[untyped]
+    def to_json_array: (*Symbol columns) -> Diamond::JsonString
+    def exists?: (?untyped filter) -> bool
+    def any?: (*untyped args) { (untyped) -> untyped } -> bool
+    def none?: (*untyped args) { (untyped) -> untyped } -> bool
+    def empty?: () -> bool
+    def count: (?Symbol? column) -> Integer
+    def sum: (?untyped column) ?{ (untyped) -> untyped } -> untyped
+    def minimum: (Symbol column) -> untyped
+    def maximum: (Symbol column) -> untyped
+    def average: (Symbol column) -> untyped
+    def avg: (Symbol column) -> untyped
+    def min: (?untyped column) { (untyped, untyped) -> untyped } -> untyped
+    def max: (?untyped column) { (untyped, untyped) -> untyped } -> untyped
+    def method_missing: (Symbol name, *untyped args, ?block: Proc?) -> untyped
+    def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+    def inspect: () -> String
+    def to_sql: () -> [String, Array[untyped]]
+    def explain: () -> Array[untyped]
+    def ast_tree: () -> String
+  end
+
+  class Changeset
+    def initialize: (untyped raw_changeset) -> void
+    def apply: (untyped target) -> untyped
+    def invert: () -> Diamond::Changeset
+    def to_blob: () -> String
+    def self.load: (String blob) -> Diamond::Changeset
+  end
+
+  class Cursor
+    include Enumerable[untyped]
+
+    def self.make_finalizer: (untyped stmt) -> Proc
+    def initialize: (Diamond::Table table, untyped stmt, untyped projected_columns) -> void
+    def each: () { (untyped) -> untyped } -> untyped
+  end
+
+  class NullTable
+    attr_reader name: Symbol?
+    attr_reader schema: Hash[Symbol, untyped]
+
+    def initialize: (?Symbol? name) -> void
+  end
+
+  module StructJSON
+    def to_json: (*untyped args) -> String
+  end
+
+  module StructFactory
+    def self.caches: () -> Hash[untyped, untyped]
+    def self.cache: () -> Hash[untyped, untyped]
+    def self.clear_caches!: () -> Hash[untyped, untyped]
+    def self.create: (Diamond::Table table, Hash[untyped, untyped] row_hash, ?untyped projection_nodes) -> untyped
+    def self.create_from_returning: (Diamond::Table table, untyped row, untyped columns) -> untyped
+    def self.create_eager: (Diamond::Table table, untyped row) -> untyped
+    def self.create_from_array: (Diamond::Table table, Array[untyped] row_array, ?untyped projection_nodes) -> untyped
+    def self.create_many: (Diamond::Table table, Array[untyped] rows, ?untyped projection_nodes) -> Array[untyped]
+    def self.factory_for: (Diamond::Table table, ?untyped projection_nodes) -> [Class, Integer]
+    def self.build: (Class factory, Array[untyped] row_array) -> untyped
+    def self.struct_class_for: (Diamond::Table table, Array[Symbol] member_names, untyped projection_nodes) -> Class
+    def self.resolve_members: (untyped projection_nodes, Diamond::Table table) -> Array[[Symbol, Symbol]]
+    def self.compile_node: (untyped node) -> Symbol
+    def self.member_name_for: (untyped node) -> Symbol
+  end
+
+  class JsonString < String
+  end
+
+  module AST
+    class Node
+      def &: (AST::Node other) -> AST::And
+      def |: (AST::Node other) -> AST::Or
+    end
+
+    class Column < Node
+      attr_reader name: Symbol
+      attr_reader table: Symbol?
+
+      def initialize: (Symbol name, ?table: Symbol?) -> void
+      def ==: (untyped other) -> AST::Equality
+      def !=: (untyped other) -> AST::NotEqual
+      def >: (untyped other) -> AST::GreaterThan
+      def <: (untyped other) -> AST::LessThan
+    end
+
+    class Literal < Node
+      attr_reader value: untyped
+
+      def initialize: (untyped value) -> void
+    end
+
+    class BinaryOp < Node
+      attr_reader left: AST::Node
+      attr_reader right: AST::Node
+      attr_reader operator: Symbol
+
+      def initialize: (AST::Node left, AST::Node right, Symbol operator) -> void
+    end
+
+    class Equality < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class NotEqual < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class GreaterThan < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class LessThan < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class GreaterEqual < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class LessEqual < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class Like < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class In < Node
+      attr_reader left: AST::Node
+      attr_reader right: untyped
+
+      def initialize: (AST::Node left, untyped right) -> void
+    end
+
+    class NotIn < Node
+      attr_reader left: AST::Node
+      attr_reader right: untyped
+
+      def initialize: (AST::Node left, untyped right) -> void
+    end
+
+    class Subquery < Node
+      attr_reader query: Diamond::QueryObject
+
+      def initialize: (Diamond::QueryObject query) -> void
+    end
+
+    class Not < Node
+      attr_reader condition: AST::Node
+
+      def initialize: (AST::Node condition) -> void
+    end
+
+    class IsNull < Node
+      attr_reader column: AST::Node
+
+      def initialize: (AST::Node column) -> void
+    end
+
+    class IsNotNull < Node
+      attr_reader column: AST::Node
+
+      def initialize: (AST::Node column) -> void
+    end
+
+    class Between < Node
+      attr_reader column: AST::Node
+      attr_reader low: AST::Node
+      attr_reader high: AST::Node
+
+      def initialize: (AST::Node column, AST::Node low, AST::Node high) -> void
+    end
+
+    class And < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class Or < BinaryOp
+      def initialize: (AST::Node left, AST::Node right) -> void
+    end
+
+    class Where < Node
+      attr_reader condition: AST::Node
+
+      def initialize: (AST::Node condition) -> void
+    end
+
+    class Projection < Node
+      attr_reader columns: Array[untyped]
+
+      def initialize: (Array[untyped] columns) -> void
+    end
+
+    class Distinct < Node
+    end
+
+    class Join < Node
+      attr_reader table_name: Symbol
+      attr_reader type: Symbol
+      attr_reader on: untyped
+      attr_reader eager: bool
+
+      def initialize: (Symbol table_name, Symbol type, untyped on, ?eager: bool) -> void
+    end
+
+    class With < Node
+      attr_reader name: Symbol
+      attr_reader query: untyped
+      attr_reader recursive: bool
+
+      def initialize: (Symbol name, untyped query, ?recursive: bool) -> void
+    end
+
+    class Order < Node
+      attr_reader specs: Array[untyped]
+
+      def initialize: (Array[untyped] specs) -> void
+    end
+
+    class Limit < Node
+      attr_reader value: Integer
+
+      def initialize: (Integer value) -> void
+    end
+
+    class Offset < Node
+      attr_reader value: Integer
+
+      def initialize: (Integer value) -> void
+    end
+
+    class GroupBy < Node
+      attr_reader columns: Array[untyped]
+
+      def initialize: (Array[untyped] columns) -> void
+    end
+
+    class Having < Node
+      attr_reader condition: AST::Node
+
+      def initialize: (AST::Node condition) -> void
+    end
+
+    class From < Node
+      attr_reader name: Symbol
+
+      def initialize: (Symbol name) -> void
+    end
+
+    class Function < Node
+      attr_reader name: Symbol
+      attr_reader args: Array[untyped]
+
+      def initialize: (Symbol name, Array[untyped] args) -> void
+    end
+
+    class WindowFunction < Node
+      attr_reader func_name: Symbol
+      attr_reader args: Array[untyped]
+      attr_reader partition_by: Array[untyped]
+      attr_reader order_by: Array[untyped]
+
+      def initialize: (Symbol func_name, Array[untyped] args, ?partition_by: Array[untyped], ?order_by: Array[untyped]) -> void
+    end
+
+    class Union < Node
+      attr_reader left: Diamond::QueryObject
+      attr_reader right: Diamond::QueryObject
+      attr_reader operator: String
+
+      def initialize: (Diamond::QueryObject left, Diamond::QueryObject right, ?String operator) -> void
+    end
+
+    class DefineRelation < Node
+      attr_reader name: Symbol
+      attr_reader columns: Array[untyped]
+
+      def initialize: (Symbol name, Array[untyped] columns) -> void
+    end
+
+    class ColumnDefinition < Node
+      attr_reader name: Symbol
+      attr_reader type: untyped
+      attr_reader options: Hash[untyped, untyped]
+
+      def initialize: (Symbol name, untyped type, ?Hash[untyped, untyped] options) -> void
+    end
+
+    class ForeignKey < Node
+      attr_reader local_column: Symbol
+      attr_reader ref_table: Symbol
+      attr_reader ref_column: Symbol
+      attr_reader on_delete: Symbol?
+      attr_reader on_update: Symbol?
+
+      def initialize: (Symbol local_column, Symbol ref_table, ?Symbol ref_column, ?on_delete: Symbol?, ?on_update: Symbol?) -> void
+    end
+
+    class IndexDefinition < Node
+      attr_reader name: Symbol
+      attr_reader columns: Array[untyped]
+      attr_reader unique: bool
+
+      def initialize: (Symbol name, Array[untyped] columns, ?unique: bool) -> void
+    end
+
+    class Insert < Node
+      attr_reader data: untyped
+
+      def initialize: (untyped data) -> void
+    end
+
+    class Update < Node
+      attr_reader data: untyped
+
+      def initialize: (untyped data) -> void
+    end
+
+    class Delete < Node
+    end
+
+    def self.dump: (AST::Node node, ?Integer indent) -> String
+  end
+
+  module Parser
+    WINDOW_FUNCS: Array[Symbol]
+    AGGREGATIONS: Array[Symbol]
+    DDL_METHODS: Array[Symbol]
+    DDL_FK_ACTIONS: Array[Symbol]
+
+    class BlockMismatch < StandardError
+    end
+
+    def self.caches: () -> Hash[untyped, untyped]
+    def self.clear_caches!: () -> Hash[untyped, untyped]
+    def self.cache_for: (untyped purpose) -> Hash[untyped, untyped]
+    def self.line_cache: () -> Hash[untyped, untyped]
+    def self.parse_block: (untyped block, untyped schema, ?untyped scope) -> AST::Node
+    def self.parse_block_with_prism: (untyped block, untyped schema, ?untyped scope) -> AST::Node
+    def self.parse_derive: (untyped block, untyped schema) -> Array[AST::Node]
+    def self.parse_derive_with_prism: (untyped block, untyped schema) -> Array[AST::Node]
+    def self.parse_ddl: (untyped block) -> Array[untyped]
+    def self.parse_ddl_with_prism: (untyped block) -> Array[untyped]
+    def self.parse_update: (untyped block, untyped schema) -> Hash[untyped, untyped]
+    def self.parse_update_with_prism: (untyped block, untyped schema) -> Hash[untyped, untyped]
+
+    # Runtime fallback for blocks with no source file on disk
+    # (irb/eval/-e/pry). Placeholder internals (SchemaProxy,
+    # ColumnRef, DdlRecorder, ...) are intentionally undeclared.
+    module Proxy
+      def self.file_backed?: (untyped block) -> bool
+      def self.parse_where: (untyped block, untyped schema, ?untyped scope) -> AST::Node
+      def self.parse_derive: (untyped block, untyped schema) -> Array[AST::Node]
+      def self.parse_ddl: (untyped block) -> Array[untyped]
+      def self.parse_update: (untyped block, untyped schema) -> Hash[untyped, untyped]
+    end
+    def self.candidate_blocks: (String file, Integer line) -> Array[untyped]
+    def self.index_file_blocks: (String file) -> untyped
+    def self.translate_where: (untyped node, untyped schema, ?untyped scope) -> AST::Node
+    def self.translate_receiver: (untyped node, untyped schema, untyped scope) -> AST::Node
+    def self.translate_derive: (untyped node, untyped schema) -> AST::Node
+    def self.translate_ddl_stmt: (untyped node) -> untyped
+    def self.split_args: (untyped call_node) -> [Array[untyped], Hash[untyped, untyped]]
+    def self.validate_column!: (untyped name, untyped schema) -> nil
+    def self.literal_value: (untyped node) -> untyped
+
+    module WhereOperators
+      def self.builtins: () -> Array[untyped]
+      def self.handlers: () -> Array[untyped]
+      def self.register: (untyped operator) -> nil
+      def self.clear!: () -> Array[untyped]
+      def self.call: (untyped node, untyped schema) -> untyped
+    end
+
+    module DeriveOperators
+      def self.builtins: () -> Array[untyped]
+      def self.handlers: () -> Array[untyped]
+      def self.register: (untyped operator) -> nil
+      def self.clear!: () -> Array[untyped]
+      def self.call: (untyped node, untyped schema) -> untyped
+    end
+  end
+
+  module Compiler
+    module Base
+      def self.compile: (Diamond::Table table, Array[untyped] ast, ?Array[untyped]? params) -> [String, Array[untyped], untyped]
+    end
+
+    module DQL
+      JOIN_TYPE_MAP: Hash[Symbol, String]
+
+      def self.compile: (Diamond::Table table, Array[untyped] ast, ?Array[untyped] params) -> [String, Array[untyped], untyped]
+      def self.translate_node: (untyped node, Array[untyped] params, ?prefix: String) -> String
+      def self.render_projection: (untyped node, Array[untyped] params) -> String
+      def self.column_sql: (untyped col, ?String prefix) -> String
+    end
+
+    module DML
+      def self.compile_insert: (Diamond::Table table, AST::Insert insert_node, ?returning: Array[untyped]) -> untyped
+      def self.compile_update: (Diamond::Table table, Hash[untyped, untyped] hash, Array[untyped] where_nodes, ?returning: Array[untyped]) -> untyped
+      def self.compile_delete: (Diamond::Table table, Array[untyped] where_nodes, ?returning: Array[untyped]) -> untyped
+    end
+
+    module DDL
+      TYPE_MAP: Hash[untyped, String]
+
+      def self.compile: (untyped node) -> [String, Array[untyped]]
+      def self.compile_add_column: (Symbol table_name, AST::ColumnDefinition coldef) -> [String, Array[untyped]]
+      def self.compile_index: (AST::IndexDefinition index_node, Symbol table_name) -> [String, Array[untyped]]
+    end
+
+    module Operators
+      def self.builtins: () -> Array[untyped]
+      def self.handlers: () -> Array[untyped]
+      def self.register: (untyped operator) -> nil
+      def self.clear!: () -> Array[untyped]
+      def self.call: (untyped node, Array[untyped] params) -> String?
+    end
+  end
+
+  module Domains
+    module DQL
+      RECONCILE: Hash[untyped, Symbol]
+      HASH_OPERATORS: Array[Symbol]
+
+      def _chain: (AST::Node node, ?strategy: Symbol?) -> Diamond::QueryObject
+      def _build_where: () { () -> untyped } -> Diamond::QueryObject
+      def _build_or_where: () { () -> untyped } -> Diamond::QueryObject
+      def dispatch_where_arg: (untyped arg) -> Diamond::QueryObject
+      def _build_join: (Symbol table_name, Symbol type, untyped on, ?eager: bool) -> Diamond::QueryObject
+      def _build_includes: (*Symbol tables) -> Diamond::QueryObject
+      def _build_order: (*untyped args, **untyped kwargs) -> Diamond::QueryObject
+      def _build_reorder: (*untyped args, **untyped kwargs) -> Diamond::QueryObject
+      def _order_pairs: (*untyped args, **untyped kwargs) -> Array[untyped]
+      def _build_limit: (Integer n) -> Diamond::QueryObject
+      def _build_offset: (Integer n) -> Diamond::QueryObject
+      def _build_group: (Array[untyped] columns) -> Diamond::QueryObject
+      def _build_having: () { () -> untyped } -> Diamond::QueryObject
+      def _build_projection: (*untyped args) { () -> untyped } -> Diamond::QueryObject
+    end
+
+    module DML
+      def _build_create: (Hash[untyped, untyped] hash, ?returning: Array[untyped]) -> untyped
+      def _build_update: (?returning: Array[untyped]) { () -> untyped } -> untyped
+      def _build_delete: (?returning: Array[untyped]) -> untyped
+      def batch_create: (Array[untyped] records) -> Integer
+      def insert_all: (Array[untyped] records) -> Integer
+      def batch_update: (Hash[untyped, untyped] set_hash, ?returning: Array[untyped]) -> untyped
+    end
+
+    module DDL
+      def _build_relation: (Symbol name) { () -> untyped } -> AST::DefineRelation
+    end
+
+    module CTE
+      def with: (Hash[Symbol, untyped] cte_hash) { (untyped) -> untyped } -> Diamond::QueryObject
+      def with_recursive: (Symbol name, Diamond::QueryObject base_query, Diamond::QueryObject recursive_query) -> Diamond::QueryObject
+    end
+
+    module DynamicFinders
+      FINDER_PREFIX: String
+      AND_SEPARATOR: String
+
+      def self.cache: () -> Hash[untyped, untyped]
+      def self.clear_caches!: () -> Hash[untyped, untyped]
+      def method_missing: (Symbol name, *untyped args, ?block: Proc?) -> Diamond::QueryObject
+      def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+    end
+  end
+
+  module DSL
+    module Default
+      def where: (*untyped args) { () -> untyped } -> Diamond::QueryObject
+      def or: () { () -> untyped } -> Diamond::QueryObject
+      def find: (?untyped id) ?{ (untyped) -> untyped } -> untyped
+      def find!: (Integer id) -> untyped
+      def where_in: (Symbol column, Diamond::QueryObject subquery) -> Diamond::QueryObject
+      def union: (Diamond::QueryObject other) -> Diamond::QueryObject
+      def derive: (*untyped args) { () -> untyped } -> Diamond::QueryObject
+      def join: (Symbol table_name, ?on: untyped, ?type: Symbol, ?eager: bool) -> Diamond::QueryObject
+      def includes: (*Symbol tables) -> Diamond::QueryObject
+      def define_relation: (Symbol name) { () -> untyped } -> AST::DefineRelation
+      def create_index: (Symbol table_name, Array[untyped] columns, ?unique: bool, name: Symbol) -> AST::IndexDefinition
+      def alter_table: (Symbol table_name) { () -> untyped } -> Array[untyped]
+      def create: (**untyped kwargs) -> untyped
+      def update: (?returning: Array[untyped]) { () -> untyped } -> untyped
+      def delete: (?returning: Array[untyped]) -> untyped
+      def from_cte: (Symbol alias_name) -> Diamond::QueryObject
+      def order: (*untyped args, **untyped kwargs) -> Diamond::QueryObject
+      def limit: (Integer n) -> Diamond::QueryObject
+      def offset: (Integer n) -> Diamond::QueryObject
+      def distinct: () -> Diamond::QueryObject
+      def group: (*untyped columns) -> Diamond::QueryObject
+      def having: () { () -> untyped } -> Diamond::QueryObject
+      def pluck: (*Symbol columns) -> Array[untyped]
+      def pick: (*Symbol columns) -> untyped
+      def ids: () -> Array[untyped]
+      def exists?: (?untyped filter) -> bool
+      def any?: (*untyped args) { (untyped) -> untyped } -> bool
+      def none?: (*untyped args) { (untyped) -> untyped } -> bool
+      def empty?: () -> bool
+      def count: (?Symbol? column) -> Integer
+      def sum: (?untyped column) ?{ (untyped) -> untyped } -> untyped
+      def minimum: (Symbol column) -> untyped
+      def maximum: (Symbol column) -> untyped
+      def average: (Symbol column) -> untyped
+      def avg: (Symbol column) -> untyped
+      def min: (?untyped column) { (untyped, untyped) -> untyped } -> untyped
+      def max: (?untyped column) { (untyped, untyped) -> untyped } -> untyped
+      def first: (?Integer n) -> untyped
+      def first!: () -> untyped
+      def last: (?Integer n) -> untyped
+      def last!: () -> untyped
+      def sole: () -> untyped
+      def head: (?Integer n) -> untyped
+      def each: () { (untyped) -> untyped } -> untyped
+      def as_hash: () -> Diamond::QueryObject
+      def as_array: () -> Diamond::QueryObject
+      def as_splat: () -> Diamond::QueryObject
+      def to_json_array: (*Symbol columns) -> Diamond::JsonString
+      def find_each: (?batch_size: Integer) { (untyped) -> untyped } -> untyped
+      def find_by: (**untyped attrs) -> untyped
+      def find_or_create_by: (**untyped attrs) -> untyped
+      def reorder: (*untyped args, **untyped kwargs) -> Diamond::QueryObject
+      def delete_all: (?returning: Array[untyped]) -> untyped
+      def update_all: (**untyped hash) -> untyped
+      def increment!: (Integer id, Symbol column, ?Integer by) -> untyped
+      def decrement!: (Integer id, Symbol column, ?Integer by) -> untyped
+      def toggle!: (Integer id, Symbol column) -> untyped
+    end
+  end
+
+  module Operators
+    module Like
+      PRIORITY: Integer
+
+      def self.priority: () -> Integer
+      def self.parse_where: (untyped node, untyped schema) -> AST::Node?
+      def self.handles?: (AST::Node node) -> bool
+      def self.render: (AST::Node node, Array[untyped] params) -> String
+      def self.regexp_to_like: (untyped regexp_node) -> String
+      def self.escape_like: (String ch) -> String
+    end
+  end
+end