use Steep::Diagnostic::Ruby::template

module Steep
  class Project
    class DSL
      class TargetDSL
        attr_reader name: Symbol

        attr_reader sources: Array[String]

        attr_reader libraries: Array[String]

        attr_reader signatures: Array[String]

        attr_reader ignored_sources: Array[String]

        attr_reader stdlib_root: Pathname?

        attr_reader core_root: Pathname?

        attr_reader repo_paths: Array[Pathname]

        attr_reader code_diagnostics_config: untyped

        attr_reader project: Project?

        attr_reader collection_config_path: Pathname?

        NONE: untyped

        def project!: () -> Project

        def initialize: (Symbol name, ?sources: Array[String], ?libraries: Array[String], ?signatures: Array[String], ?ignored_sources: Array[String], ?repo_paths: Array[Pathname], ?code_diagnostics_config: ::Hash[untyped, untyped], ?project: Project?, ?collection_config_path: Pathname?) -> void

        def initialize_copy: (instance other) -> void

        def check: (*String args) -> void

        def ignore: (*String args) -> void

        def library: (*String args) -> void

        def typing_options: (?untyped level, **untyped hash) -> void

        def signature: (*String args) -> void

        def update: (?name: Symbol, ?sources: Array[String], ?libraries: Array[String], ?signatures: Array[String], ?ignored_sources: Array[String], ?project: Project?) -> TargetDSL

        def no_builtin!: (?bool value) -> void

        def vendor: (?::String dir, ?stdlib: untyped?, ?gems: untyped?) -> void

        def stdlib_path: (core_root: String, stdlib_root: String) -> void

        def repo_path: (*String paths) -> void

        # Configure the code diagnostics printing setup.
        #
        # Yields a hash, and the update the hash in the block.
        #
        # ```rb
        # D = Steep::Diagnostic
        #
        # configure_code_diagnostics do |hash|
        #   # Assign one of :error, :warning, :information, :hint or :nil to error classes.
        #   hash[D::Ruby::UnexpectedPositionalArgument] = :error
        # end
        # ```
        #
        # Passing a hash is also allowed.
        #
        # ```rb
        # D = Steep::Diagnostic
        #
        # configure_code_diagnostics(D::Ruby.lenient)
        # configure_code_diagnostics(D::Ruby.strict) do |config|
        #   config[D::Ruby::NoMethod] = nil
        # end
        # ```
        #
        def configure_code_diagnostics: (template hash) ?{ (template) -> void }-> void
                                      | () { (template) -> void }-> void

        def collection_config: (Pathname path) -> void

        def disable_collection: () -> void
      end

      attr_reader project: untyped

      @@templates: Hash[Symbol, TargetDSL]

      def self.templates: () -> Hash[Symbol, TargetDSL]

      def initialize: (project: Project) -> void

      def self.register_template: (Symbol name, TargetDSL target) -> void

      def self.parse: (Project project, String code, ?filename: String) -> void

      def target: (Symbol name, ?template: Symbol?) ?{ (TargetDSL) [self: TargetDSL] -> void } -> void
    end
  end
end