danger-packwerk 0.7.1 → 0.9.0

data/lib/danger-packwerk/private/ownership_information.rb

@@ -0,0 +1,60 @@
+# typed: strict
+
+require 'code_ownership'
+
+module DangerPackwerk
+  module Private
+    class OwnershipInformation < T::Struct
+      extend T::Sig
+
+      const :owning_team, T.nilable(CodeTeams::Team)
+      const :github_team, T.nilable(String)
+      const :slack_channel, T.nilable(String)
+      const :org_name, T.nilable(String)
+
+      sig { params(package: ParsePackwerk::Package, org_name: String).returns(OwnershipInformation) }
+      def self.for_package(package, org_name)
+        team = CodeOwnership.for_package(package)
+
+        if team.nil?
+          OwnershipInformation.new
+        else
+          OwnershipInformation.new(
+            owning_team: team,
+            github_team: team.raw_hash.fetch('github', {}).fetch('team', nil),
+            slack_channel: team.raw_hash.fetch('slack', {}).fetch('room_for_humans', nil),
+            org_name: org_name
+          )
+        end
+      end
+
+      sig { returns(String) }
+      def ownership_copy
+        github_team_flow_sensitive = github_team
+        slack_channel_flow_sensitive = slack_channel
+
+        if owning_team && github_team_flow_sensitive && slack_channel_flow_sensitive
+          team_slack_link = markdown_link_to_slack_room
+          "- Owned by #{markdown_link_to_github_members_no_tag} (Slack: #{team_slack_link})"
+        else
+          '- This pack is unowned.'
+        end
+      end
+
+      sig { returns(String) }
+      def markdown_link_to_slack_room
+        "[<ins>#{slack_channel}</ins>](https://slack.com/app_redirect?channel=#{T.must(slack_channel).delete('#')})"
+      end
+
+      #
+      # Note this will NOT tag the team on Github, but it will link
+      # to the mentioned team's members page. If you want to tag and
+      # link the team, simply use the string and Github will handle it.
+      #
+      sig { returns(String) }
+      def markdown_link_to_github_members_no_tag
+        "[<ins>#{github_team}</ins>](https://github.com/orgs/#{org_name}/teams/#{T.must(github_team).gsub("@#{org_name}/", '')}/members)"
+      end
+    end
+  end
+end

data/lib/danger-packwerk/private/{deprecated_references.rb → package_todo.rb}

@@ -3,7 +3,7 @@
 module DangerPackwerk
   module Private
     #
-    # The `Violation` and `DeprecatedReferences` classes come from Gusto's private `ParsePackwerk` gem.
+    # The `Violation` and `PackageTodo` classes come from Gusto's private `ParsePackwerk` gem.
     # Until we decide to open source that gem, we inline these as a private implementation detail of `DangerPackwerk` for now.
     #
     class Violation < T::Struct
@@ -25,22 +25,22 @@ module DangerPackwerk
       end
     end
 
-    class DeprecatedReferences < T::Struct
+    class PackageTodo < T::Struct
       extend T::Sig
 
       const :pathname, Pathname
       const :violations, T::Array[Violation]
 
-      sig { params(pathname: Pathname).returns(DeprecatedReferences) }
+      sig { params(pathname: Pathname).returns(PackageTodo) }
       def self.from(pathname)
         if pathname.exist?
-          deprecated_references_loaded_yml = YAML.load_file(pathname)
+          package_todo_loaded_yml = YAML.load_file(pathname)
 
           all_violations = []
-          deprecated_references_loaded_yml&.each_key do |to_package_name|
-            deprecated_references_per_package = deprecated_references_loaded_yml[to_package_name]
-            deprecated_references_per_package.each_key do |class_name|
-              symbol_usage = deprecated_references_per_package[class_name]
+          package_todo_loaded_yml&.each_key do |to_package_name|
+            package_todo_per_package = package_todo_loaded_yml[to_package_name]
+            package_todo_per_package.each_key do |class_name|
+              symbol_usage = package_todo_per_package[class_name]
               files = symbol_usage['files']
               violations = symbol_usage['violations']
               all_violations << Violation.new(type: 'dependency', to_package_name: to_package_name, class_name: class_name, files: files) if violations.include? 'dependency'

data/lib/danger-packwerk/private.rb

@@ -1,7 +1,7 @@
 # typed: strict
 
-require 'danger-packwerk/private/deprecated_references'
-require 'danger-packwerk/private/default_offenses_formatter'
+require 'danger-packwerk/private/package_todo'
+require 'danger-packwerk/private/ownership_information'
 require 'constant_resolver'
 
 module DangerPackwerk

data/lib/danger-packwerk/update/default_formatter.rb

@@ -0,0 +1,67 @@
+# typed: strict
+
+module DangerPackwerk
+  module Update
+    class DefaultFormatter
+      extend T::Sig
+      include OffensesFormatter
+
+      sig do
+        params(
+          custom_help_message: T.nilable(String)
+        ).void
+      end
+      def initialize(custom_help_message: nil)
+        @custom_help_message = custom_help_message
+      end
+
+      sig { override.params(offenses: T::Array[BasicReferenceOffense], repo_link: String, org_name: String).returns(String) }
+      def format_offenses(offenses, repo_link, org_name)
+        violation = T.must(offenses.first)
+        referencing_file_pack = ParsePackwerk.package_from_path(violation.file)
+        # We remove leading double colons as they feel like an implementation detail of packwerk.
+        constant_name = violation.class_name.delete_prefix('::')
+        constant_source_package_name = violation.to_package_name
+
+        constant_source_package = T.must(ParsePackwerk.find(constant_source_package_name))
+        constant_source_package_owner = Private::OwnershipInformation.for_package(constant_source_package, org_name)
+
+        package_referring_to_constant_owner = Private::OwnershipInformation.for_package(referencing_file_pack, org_name)
+
+        disclaimer = 'We noticed you ran `bin/packwerk update-deprecations`. Check out [the docs](https://github.com/Shopify/packwerk/blob/main/RESOLVING_VIOLATIONS.md) to see other ways to resolve violations.'
+        pluralized_violation = offenses.count > 1 ? 'these violations' : 'this violation'
+        request_to_add_context = "- Could you add some context as a reply here about why we needed to add #{pluralized_violation}?\n"
+
+        dependency_violation_message = "- cc #{package_referring_to_constant_owner.github_team} (#{package_referring_to_constant_owner.markdown_link_to_slack_room}) for the dependency violation.\n" if package_referring_to_constant_owner.owning_team
+
+        privacy_violation_message = "- cc #{constant_source_package_owner.github_team} (#{constant_source_package_owner.markdown_link_to_slack_room}) for the privacy violation.\n" if constant_source_package_owner.owning_team
+
+        if offenses.any?(&:dependency?) && offenses.any?(&:privacy?)
+          <<~MESSAGE.chomp
+            Hi again! It looks like `#{constant_name}` is private API of `#{constant_source_package_name}`, which is also not in `#{referencing_file_pack.name}`'s list of dependencies.
+            #{disclaimer}
+
+            #{request_to_add_context}#{dependency_violation_message}#{privacy_violation_message}
+            #{@custom_help_message}
+          MESSAGE
+        elsif offenses.any?(&:dependency?)
+          <<~MESSAGE.chomp
+            Hi again! It looks like `#{constant_name}` belongs to `#{constant_source_package_name}`, which is not in `#{referencing_file_pack.name}`'s list of dependencies.
+            #{disclaimer}
+
+            #{request_to_add_context}#{dependency_violation_message}
+            #{@custom_help_message}
+          MESSAGE
+        else # violations.any?(&:privacy?)
+          <<~MESSAGE.chomp
+            Hi again! It looks like `#{constant_name}` is private API of `#{constant_source_package_name}`.
+            #{disclaimer}
+
+            #{request_to_add_context}#{privacy_violation_message}
+            #{@custom_help_message}
+          MESSAGE
+        end
+      end
+    end
+  end
+end

data/lib/danger-packwerk/update/offenses_formatter.rb

@@ -0,0 +1,23 @@
+# typed: strict
+
+require 'code_ownership'
+
+module DangerPackwerk
+  module Update
+    module OffensesFormatter
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig do
+        abstract.params(
+          offenses: T::Array[BasicReferenceOffense],
+          repo_link: String,
+          org_name: String
+        ).returns(String)
+      end
+      def format_offenses(offenses, repo_link, org_name); end
+    end
+  end
+end

data/lib/danger-packwerk/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module DangerPackwerk
-  VERSION = '0.7.1'
+  VERSION = '0.9.0'
 end

data/lib/danger-packwerk.rb

@@ -5,8 +5,14 @@
 require 'sorbet-runtime'
 
 module DangerPackwerk
-  DEPRECATED_REFERENCES_PATTERN = T.let(/.*?deprecated_references\.yml\z/.freeze, Regexp)
+  PACKAGE_TODO_PATTERN = T.let(/.*?package_todo\.yml\z/.freeze, Regexp)
+  DEPENDENCY_VIOLATION_TYPE = 'dependency'
+  PRIVACY_VIOLATION_TYPE = 'privacy'
 
   require 'danger-packwerk/danger_packwerk'
-  require 'danger-packwerk/danger_deprecated_references_yml_changes'
+  require 'danger-packwerk/danger_package_todo_yml_changes'
+  require 'danger-packwerk/check/offenses_formatter'
+  require 'danger-packwerk/check/default_formatter'
+  require 'danger-packwerk/update/offenses_formatter'
+  require 'danger-packwerk/update/default_formatter'
 end

data/sorbet/rbi/gems/code_ownership@1.29.1.rbi

@@ -0,0 +1,336 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `code_ownership` gem.
+# Please instead update this file by running `bin/tapioca gem code_ownership`.
+
+module CodeOwnership
+  extend ::CodeOwnership
+
+  requires_ancestor { Kernel }
+
+  sig do
+    params(
+      backtrace: T.nilable(T::Array[::String]),
+      excluded_teams: T::Array[::CodeTeams::Team]
+    ).returns(T.nilable(::CodeTeams::Team))
+  end
+  def for_backtrace(backtrace, excluded_teams: T.unsafe(nil)); end
+
+  sig { params(klass: T.nilable(T.any(::Class, ::Module))).returns(T.nilable(::CodeTeams::Team)) }
+  def for_class(klass); end
+
+  sig { params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
+  def for_file(file); end
+
+  sig { params(package: ::ParsePackwerk::Package).returns(T.nilable(::CodeTeams::Team)) }
+  def for_package(package); end
+
+  sig { params(team: T.any(::CodeTeams::Team, ::String)).returns(::String) }
+  def for_team(team); end
+
+  sig { params(files: T::Array[::String], autocorrect: T::Boolean, stage_changes: T::Boolean).void }
+  def validate!(files: T.unsafe(nil), autocorrect: T.unsafe(nil), stage_changes: T.unsafe(nil)); end
+
+  class << self
+    sig { void }
+    def bust_caches!; end
+
+    sig { params(filename: ::String).void }
+    def remove_file_annotation!(filename); end
+  end
+end
+
+class CodeOwnership::Cli
+  class << self
+    def for_file(argv); end
+    def for_team(argv); end
+    def run!(argv); end
+
+    private
+
+    def validate!(argv); end
+  end
+end
+
+class CodeOwnership::InvalidCodeOwnershipConfigurationError < ::StandardError; end
+
+module CodeOwnership::Private
+  class << self
+    sig { void }
+    def bust_caches!; end
+
+    sig { returns(::CodeOwnership::Private::Configuration) }
+    def configuration; end
+
+    sig { returns(::CodeOwnership::Private::OwnershipMappers::FileAnnotations) }
+    def file_annotations_mapper; end
+
+    sig { params(files: T::Array[::String]).returns(T::Hash[::String, T::Array[::String]]) }
+    def files_by_mapper(files); end
+
+    sig { params(team_name: ::String, location_of_reference: ::String).returns(::CodeTeams::Team) }
+    def find_team!(team_name, location_of_reference); end
+
+    sig { returns(T::Array[::CodeOwnership::Private::OwnershipMappers::Interface]) }
+    def mappers; end
+
+    sig { params(klass: T.nilable(T.any(::Class, ::Module))).returns(T.nilable(::String)) }
+    def path_from_klass(klass); end
+
+    sig { returns(T::Array[::String]) }
+    def tracked_files; end
+
+    sig { params(files: T::Array[::String], autocorrect: T::Boolean, stage_changes: T::Boolean).void }
+    def validate!(files:, autocorrect: T.unsafe(nil), stage_changes: T.unsafe(nil)); end
+  end
+end
+
+class CodeOwnership::Private::Configuration < ::T::Struct
+  const :js_package_paths, T::Array[::String]
+  const :owned_globs, T::Array[::String]
+  const :skip_codeowners_validation, T::Boolean
+  const :unowned_globs, T::Array[::String]
+
+  class << self
+    sig { returns(::CodeOwnership::Private::Configuration) }
+    def fetch; end
+
+    def inherited(s); end
+
+    sig { params(config_hash: T::Hash[T.untyped, T.untyped]).returns(T::Array[::String]) }
+    def js_package_paths(config_hash); end
+  end
+end
+
+CodeOwnership::Private::Configuration::DEFAULT_JS_PACKAGE_PATHS = T.let(T.unsafe(nil), Array)
+module CodeOwnership::Private::OwnershipMappers; end
+
+class CodeOwnership::Private::OwnershipMappers::FileAnnotations
+  include ::CodeOwnership::Private::OwnershipMappers::Interface
+
+  sig { override.void }
+  def bust_caches!; end
+
+  sig { override.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def codeowners_lines_to_owners; end
+
+  sig { override.returns(::String) }
+  def description; end
+
+  sig { params(filename: ::String).returns(T.nilable(::CodeTeams::Team)) }
+  def file_annotation_based_owner(filename); end
+
+  sig { override.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
+  def map_file_to_owner(file); end
+
+  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def map_files_to_owners(files); end
+
+  sig { params(filename: ::String).void }
+  def remove_file_annotation!(filename); end
+end
+
+CodeOwnership::Private::OwnershipMappers::FileAnnotations::TEAM_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+module CodeOwnership::Private::OwnershipMappers::Interface
+  interface!
+
+  sig { abstract.void }
+  def bust_caches!; end
+
+  sig { abstract.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def codeowners_lines_to_owners; end
+
+  sig { abstract.returns(::String) }
+  def description; end
+
+  sig { abstract.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
+  def map_file_to_owner(file); end
+
+  sig { abstract.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def map_files_to_owners(files); end
+end
+
+class CodeOwnership::Private::OwnershipMappers::JsPackageOwnership
+  include ::CodeOwnership::Private::OwnershipMappers::Interface
+
+  sig { override.void }
+  def bust_caches!; end
+
+  sig { override.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def codeowners_lines_to_owners; end
+
+  sig { override.returns(::String) }
+  def description; end
+
+  sig { override.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
+  def map_file_to_owner(file); end
+
+  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def map_files_to_owners(files); end
+
+  sig { params(package: ::CodeOwnership::Private::ParseJsPackages::Package).returns(T.nilable(::CodeTeams::Team)) }
+  def owner_for_package(package); end
+
+  private
+
+  sig { params(file: ::String).returns(T.nilable(::CodeOwnership::Private::ParseJsPackages::Package)) }
+  def map_file_to_relevant_package(file); end
+end
+
+class CodeOwnership::Private::OwnershipMappers::PackageOwnership
+  include ::CodeOwnership::Private::OwnershipMappers::Interface
+
+  sig { override.void }
+  def bust_caches!; end
+
+  sig { override.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def codeowners_lines_to_owners; end
+
+  sig { override.returns(::String) }
+  def description; end
+
+  sig { override.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
+  def map_file_to_owner(file); end
+
+  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def map_files_to_owners(files); end
+
+  sig { params(package: ::ParsePackwerk::Package).returns(T.nilable(::CodeTeams::Team)) }
+  def owner_for_package(package); end
+end
+
+class CodeOwnership::Private::OwnershipMappers::TeamGlobs
+  include ::CodeOwnership::Private::OwnershipMappers::Interface
+
+  sig { override.void }
+  def bust_caches!; end
+
+  sig { override.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def codeowners_lines_to_owners; end
+
+  sig { override.returns(::String) }
+  def description; end
+
+  sig { override.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
+  def map_file_to_owner(file); end
+
+  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
+  def map_files_to_owners(files); end
+end
+
+module CodeOwnership::Private::ParseJsPackages
+  class << self
+    sig { returns(T::Array[::CodeOwnership::Private::ParseJsPackages::Package]) }
+    def all; end
+  end
+end
+
+CodeOwnership::Private::ParseJsPackages::METADATA = T.let(T.unsafe(nil), String)
+CodeOwnership::Private::ParseJsPackages::PACKAGE_JSON_NAME = T.let(T.unsafe(nil), String)
+
+class CodeOwnership::Private::ParseJsPackages::Package < ::T::Struct
+  const :metadata, T::Hash[::String, T.untyped]
+  const :name, ::String
+
+  sig { returns(::Pathname) }
+  def directory; end
+
+  class << self
+    sig { params(pathname: ::Pathname).returns(::CodeOwnership::Private::ParseJsPackages::Package) }
+    def from(pathname); end
+
+    def inherited(s); end
+  end
+end
+
+CodeOwnership::Private::ParseJsPackages::ROOT_PACKAGE_NAME = T.let(T.unsafe(nil), String)
+module CodeOwnership::Private::TeamPlugins; end
+
+class CodeOwnership::Private::TeamPlugins::Github < ::CodeTeams::Plugin
+  sig { returns(::CodeOwnership::Private::TeamPlugins::Github::GithubStruct) }
+  def github; end
+end
+
+class CodeOwnership::Private::TeamPlugins::Github::GithubStruct < ::Struct
+  def do_not_add_to_codeowners_file; end
+  def do_not_add_to_codeowners_file=(_); end
+  def team; end
+  def team=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class CodeOwnership::Private::TeamPlugins::Ownership < ::CodeTeams::Plugin
+  sig { returns(T::Array[::String]) }
+  def owned_globs; end
+end
+
+module CodeOwnership::Private::Validations; end
+
+class CodeOwnership::Private::Validations::FilesHaveOwners
+  include ::CodeOwnership::Private::Validations::Interface
+
+  sig do
+    override
+      .params(
+        files: T::Array[::String],
+        autocorrect: T::Boolean,
+        stage_changes: T::Boolean
+      ).returns(T::Array[::String])
+  end
+  def validation_errors(files:, autocorrect: T.unsafe(nil), stage_changes: T.unsafe(nil)); end
+end
+
+class CodeOwnership::Private::Validations::FilesHaveUniqueOwners
+  include ::CodeOwnership::Private::Validations::Interface
+
+  sig do
+    override
+      .params(
+        files: T::Array[::String],
+        autocorrect: T::Boolean,
+        stage_changes: T::Boolean
+      ).returns(T::Array[::String])
+  end
+  def validation_errors(files:, autocorrect: T.unsafe(nil), stage_changes: T.unsafe(nil)); end
+end
+
+class CodeOwnership::Private::Validations::GithubCodeownersUpToDate
+  include ::CodeOwnership::Private::Validations::Interface
+
+  sig do
+    override
+      .params(
+        files: T::Array[::String],
+        autocorrect: T::Boolean,
+        stage_changes: T::Boolean
+      ).returns(T::Array[::String])
+  end
+  def validation_errors(files:, autocorrect: T.unsafe(nil), stage_changes: T.unsafe(nil)); end
+
+  private
+
+  sig { returns(T::Array[::String]) }
+  def codeowners_file_lines; end
+end
+
+module CodeOwnership::Private::Validations::Interface
+  interface!
+
+  sig do
+    abstract
+      .params(
+        files: T::Array[::String],
+        autocorrect: T::Boolean,
+        stage_changes: T::Boolean
+      ).returns(T::Array[::String])
+  end
+  def validation_errors(files:, autocorrect: T.unsafe(nil), stage_changes: T.unsafe(nil)); end
+end

data/sorbet/rbi/gems/code_teams@1.0.0.rbi

@@ -0,0 +1,120 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `code_teams` gem.
+# Please instead update this file by running `bin/tapioca gem code_teams`.
+
+module CodeTeams
+  class << self
+    sig { returns(T::Array[::CodeTeams::Team]) }
+    def all; end
+
+    sig { void }
+    def bust_caches!; end
+
+    sig { params(name: ::String).returns(T.nilable(::CodeTeams::Team)) }
+    def find(name); end
+
+    sig { params(dir: ::String).returns(T::Array[::CodeTeams::Team]) }
+    def for_directory(dir); end
+
+    sig { params(string: ::String).returns(::String) }
+    def tag_value_for(string); end
+
+    sig { params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
+    def validation_errors(teams); end
+  end
+end
+
+class CodeTeams::IncorrectPublicApiUsageError < ::StandardError; end
+
+class CodeTeams::Plugin
+  abstract!
+
+  sig { params(team: ::CodeTeams::Team).void }
+  def initialize(team); end
+
+  class << self
+    sig { returns(T::Array[T.class_of(CodeTeams::Plugin)]) }
+    def all_plugins; end
+
+    sig { params(team: ::CodeTeams::Team).returns(T.attached_class) }
+    def for(team); end
+
+    sig { params(base: T.untyped).void }
+    def inherited(base); end
+
+    sig { params(team: ::CodeTeams::Team, key: ::String).returns(::String) }
+    def missing_key_error_message(team, key); end
+
+    sig { params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
+    def validation_errors(teams); end
+
+    private
+
+    sig { params(team: ::CodeTeams::Team).returns(T.attached_class) }
+    def register_team(team); end
+
+    sig { returns(T::Hash[T.nilable(::String), T::Hash[::Class, ::CodeTeams::Plugin]]) }
+    def registry; end
+  end
+end
+
+module CodeTeams::Plugins; end
+
+class CodeTeams::Plugins::Identity < ::CodeTeams::Plugin
+  sig { returns(::CodeTeams::Plugins::Identity::IdentityStruct) }
+  def identity; end
+
+  class << self
+    sig { override.params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
+    def validation_errors(teams); end
+  end
+end
+
+class CodeTeams::Plugins::Identity::IdentityStruct < ::Struct
+  def name; end
+  def name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class CodeTeams::Team
+  sig { params(config_yml: T.nilable(::String), raw_hash: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(config_yml:, raw_hash:); end
+
+  sig { params(other: ::Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(T.nilable(::String)) }
+  def config_yml; end
+
+  def eql?(*args, &blk); end
+
+  sig { returns(::Integer) }
+  def hash; end
+
+  sig { returns(::String) }
+  def name; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def raw_hash; end
+
+  sig { returns(::String) }
+  def to_tag; end
+
+  class << self
+    sig { params(raw_hash: T::Hash[T.untyped, T.untyped]).returns(::CodeTeams::Team) }
+    def from_hash(raw_hash); end
+
+    sig { params(config_yml: ::String).returns(::CodeTeams::Team) }
+    def from_yml(config_yml); end
+  end
+end
+
+CodeTeams::UNKNOWN_TEAM_STRING = T.let(T.unsafe(nil), String)