checkoff 0.228.0 → 0.229.0

data/rbi/checkoff.rbi

@@ -1,4 +1,4 @@
-# typed: true
+# typed: ignore
 module Logging
   sig { returns(T.untyped) }
   def logger; end
@@ -52,26 +52,12 @@ module Overcommit
         sig { returns(T.untyped) }
         def run; end
       end
-
-      class SolargraphTypecheck < Base
-        sig { returns(T.untyped) }
-        def run; end
-
-        sig { params(stderr: T.untyped).returns(T.untyped) }
-        def remove_harmless_glitches(stderr); end
-
-        sig { params(errors: T.untyped, files: T.untyped).returns(T.untyped) }
-        def generate_errors_for_files(errors, *files); end
-
-        sig { params(error: T.untyped).returns(T.untyped) }
-        def parse_error(error); end
-      end
     end
   end
 end
 
 module Checkoff
-  VERSION = '0.228.0'
+  VERSION = '0.229.0'
 
   class Attachments
     include Logging
@@ -479,7 +465,7 @@ module Checkoff
     SECTION_FUNCTION_EVALUATORS = (Checkoff::SelectorClasses::Section.constants.map do |const|
       Checkoff::SelectorClasses::Section.const_get(const)
     end - [Checkoff::SelectorClasses::Section::FunctionEvaluator]).freeze
-    FUNCTION_EVALUTORS = (COMMON_FUNCTION_EVALUATORS + SECTION_FUNCTION_EVALUATORS).freeze
+    FUNCTION_EVALUATORS = (COMMON_FUNCTION_EVALUATORS + SECTION_FUNCTION_EVALUATORS).freeze
 
     sig do
       params(
@@ -2408,7 +2394,7 @@ module Checkoff
     end
   end
 end
-# typed: true
+# typed: ignore
 class ENV
   # _@param_ `key`
   # 
@@ -2478,6 +2464,9 @@ module Asana
   include Asana::Resources
 
   class Client
+    sig { returns(Asana::ProxiedResourceClasses::Tag) }
+    def tags; end
+
     sig { returns(Asana::ProxiedResourceClasses::Task) }
     def tasks; end
 
@@ -2502,17 +2491,14 @@ module Asana
     sig { returns(Asana::ProxiedResourceClasses::CustomField) }
     def custom_fields; end
 
-    sig { returns(Asana::ProxiedResourceClasses::Tag) }
-    def tags; end
-
     # sord warn - Asana::HttpClient::Response wasn't able to be resolved to a constant in this project
-    # Public: Performs a GET request against an arbitrary Asana URL. Allows for
+    # Performs a GET request against an arbitrary Asana URL. Allows for
     # the user to interact with the API in ways that haven't been
     # reflected/foreseen in this library.
     # 
-    # _@param_ `url` — the URL to GET
-    # 
     # _@param_ `args` — the request I/O options
+    # 
+    # _@param_ `url`
     sig { params(url: String, args: Object).returns(Asana::HttpClient::Response) }
     def get(url, **args); end
   end
@@ -2563,6 +2549,9 @@ module Asana
         ).returns(Asana::Resources::Task)
       end
       def self.create(client, assignee:, workspace:, name:); end
+
+      sig { returns(T.any(T::Hash[T.untyped, T.untyped], Asana::Resources::Section)) }
+      def assignee_section; end
     end
 
     class Section
@@ -2626,6 +2615,22 @@ module Asana
       def get_custom_fields_for_workspace(workspace_gid: required("workspace_gid"), options: {}); end
     end
 
+    class Tag
+      # sord warn - Asana::Resources::Tag wasn't able to be resolved to a constant in this project
+      # Get tags in a workspace
+      # 
+      # > offset - [str]  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+      # > limit - [int]  Results per page. The number of objects to return per page. The value must be between 1 and 100.
+      # > opt_fields - [list[str]]  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+      # > opt_pretty - [bool]  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+      # 
+      # _@param_ `workspace_gid` — (required) Globally unique identifier for the workspace or organization.
+      # 
+      # _@param_ `options` — the request I/O options
+      sig { params(workspace_gid: String, options: T::Hash[T.untyped, T.untyped]).returns(T::Enumerable[Asana::Resources::Tag]) }
+      def get_tags_for_workspace(workspace_gid:, options: {}); end
+    end
+
     class Task
       # Get subtasks from a task
       # 
@@ -2848,69 +2853,130 @@ module Asana
       sig { params(options: T::Hash[T.untyped, T.untyped]).returns(Asana::Resources::User) }
       def me(options: {}); end
     end
+  end
+end
 
-    class Tag
-      # sord warn - Asana::Resources::Tag wasn't able to be resolved to a constant in this project
-      # Get tags in a workspace
-      # 
-      # > offset - [str]  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
-      # > limit - [int]  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-      # > opt_fields - [list[str]]  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
-      # > opt_pretty - [bool]  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
-      # 
-      # _@param_ `workspace_gid` — (required) Globally unique identifier for the workspace or organization.
-      # 
-      # _@param_ `options` — the request I/O options
-      sig { params(workspace_gid: String, options: T::Hash[T.untyped, T.untyped]).returns(T::Enumerable[Asana::Resources::Tag]) }
-      def get_tags_for_workspace(workspace_gid:, options: {}); end
-    end
+module T
+  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
+  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
+  # _@param_ `type`
+  sig { params(type: T.any(T::Types::Base, T.class_of(Object))).returns(T::Types::Base) }
+  def self.nilable(type); end
+
+  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
+  # _@param_ `obj`
+  # 
+  # _@param_ `type`
+  sig { params(obj: BasicObject, type: T.any(T::Types::Base, T.class_of(Object))).returns(BasicObject) }
+  def self.let(obj, type); end
+
+  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
+  sig { returns(T::Types::Base) }
+  def self.untyped; end
+
+  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
+  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
+  # _@param_ `type`
+  sig { params(type: T.any(T::Types::Base, T.class_of(Object))).returns(T::Types::Base) }
+  def nilable(type); end
+
+  # _@param_ `o`
+  # 
+  # _@param_ `type`
+  sig { params(o: T, type: T.class_of(T)).returns(T) }
+  def let(o, type); end
+
+  class Struct
+    extend T::Props::ClassMethods
   end
 end
 
 # Command-line and gem client for Asana (unofficial)
 module Checkoff
-  VERSION = T.let('0.228.0', T.untyped)
+  VERSION = T.let('0.229.0', T.untyped)
 
   # Move tasks from one place to another
   class MvSubcommand
-    sig { params(from_workspace_arg: T.untyped, from_project_arg: T.untyped, from_section_arg: T.untyped).returns(T.untyped) }
+    # _@param_ `from_workspace_arg`
+    # 
+    # _@param_ `from_project_arg`
+    # 
+    # _@param_ `from_section_arg`
+    sig { params(from_workspace_arg: T.any(Symbol, String), from_project_arg: T.any(Symbol, String), from_section_arg: T.nilable(String)).void }
     def validate_and_assign_from_location(from_workspace_arg, from_project_arg, from_section_arg); end
 
-    sig { params(to_project_arg: T.untyped).returns(T.untyped) }
+    # _@param_ `to_project_arg`
+    sig { params(to_project_arg: T.any(Symbol, String)).returns(T.any(String, Symbol)) }
     def create_to_project_name(to_project_arg); end
 
-    sig { params(to_section_arg: T.untyped).returns(T.untyped) }
+    # _@param_ `to_section_arg` — :source_section
+    sig { params(to_section_arg: T.nilable(T.any(Symbol, String))).void }
     def create_to_section_name(to_section_arg); end
 
-    sig { params(to_workspace_arg: T.untyped, to_project_arg: T.untyped, to_section_arg: T.untyped).returns(T.untyped) }
+    # _@param_ `to_workspace_arg`
+    # 
+    # _@param_ `to_project_arg`
+    # 
+    # _@param_ `to_section_arg` — :source_section
+    sig { params(to_workspace_arg: T.any(Symbol, String), to_project_arg: T.any(Symbol, String), to_section_arg: T.nilable(T.any(Symbol, String))).void }
     def validate_and_assign_to_location(to_workspace_arg, to_project_arg, to_section_arg); end
 
+    # _@param_ `from_workspace_arg`
+    # 
+    # _@param_ `from_project_arg`
+    # 
+    # _@param_ `from_section_arg`
+    # 
+    # _@param_ `to_workspace_arg`
+    # 
+    # _@param_ `to_project_arg`
+    # 
+    # _@param_ `to_section_arg` — :source_section
+    # 
+    # _@param_ `config`
+    # 
+    # _@param_ `projects`
+    # 
+    # _@param_ `sections`
+    # 
+    # _@param_ `logger`
     sig do
       params(
-        from_workspace_arg: T.untyped,
-        from_project_arg: T.untyped,
-        from_section_arg: T.untyped,
-        to_workspace_arg: T.untyped,
-        to_project_arg: T.untyped,
-        to_section_arg: T.untyped,
-        config: T.untyped,
-        projects: T.untyped,
-        sections: T.untyped,
-        logger: T.untyped
+        from_workspace_arg: T.any(Symbol, String),
+        from_project_arg: T.any(Symbol, String),
+        from_section_arg: T.nilable(String),
+        to_workspace_arg: T.any(Symbol, String),
+        to_project_arg: T.any(Symbol, String),
+        to_section_arg: T.nilable(T.any(Symbol, String)),
+        config: T.any(Checkoff::Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]),
+        projects: Checkoff::Projects,
+        sections: Checkoff::Sections,
+        logger: IO
       ).void
     end
     def initialize(from_workspace_arg:, from_project_arg:, from_section_arg:, to_workspace_arg:, to_project_arg:, to_section_arg:, config: Checkoff::Internal::ConfigLoader.load(:asana), projects: Checkoff::Projects.new(config:), sections: Checkoff::Sections.new(config:), logger: $stderr); end
 
-    sig { params(tasks: T.untyped, to_project: T.untyped, to_section: T.untyped).returns(T.untyped) }
+    # _@param_ `tasks`
+    # 
+    # _@param_ `to_project`
+    # 
+    # _@param_ `to_section`
+    sig { params(tasks: T::Enumerable[Asana::Resources::Task], to_project: Asana::Resources::Project, to_section: Asana::Resources::Section).void }
     def move_tasks(tasks, to_project, to_section); end
 
-    sig { params(from_workspace_name: T.untyped, from_project_name: T.untyped, from_section_name: T.untyped).returns(T.untyped) }
+    # _@param_ `from_workspace_name`
+    # 
+    # _@param_ `from_project_name`
+    # 
+    # _@param_ `from_section_name`
+    sig { params(from_workspace_name: String, from_project_name: T.any(String, Symbol), from_section_name: T.any(String, Symbol)).returns(T::Enumerable[Asana::Resources::Task]) }
     def fetch_tasks(from_workspace_name, from_project_name, from_section_name); end
 
-    sig { returns(T.untyped) }
+    sig { void }
     def run; end
 
-    sig { params(project_arg: T.untyped).returns(T.untyped) }
+    # _@param_ `project_arg`
+    sig { params(project_arg: String).returns(T.any(Symbol, String)) }
     def project_arg_to_name(project_arg); end
 
     # Returns the value of attribute from_workspace_name.
@@ -2948,49 +3014,86 @@ module Checkoff
 
   # CLI subcommand that shows tasks in JSON form
   class ViewSubcommand
+    # _@param_ `workspace_name`
+    # 
+    # _@param_ `project_name`
+    # 
+    # _@param_ `section_name`
+    # 
+    # _@param_ `task_name`
+    # 
+    # _@param_ `config`
+    # 
+    # _@param_ `projects`
+    # 
+    # _@param_ `sections`
+    # 
+    # _@param_ `tasks`
+    # 
+    # _@param_ `stderr`
     sig do
       params(
-        workspace_name: T.untyped,
-        project_name: T.untyped,
-        section_name: T.untyped,
-        task_name: T.untyped,
-        config: T.untyped,
-        projects: T.untyped,
-        sections: T.untyped,
-        tasks: T.untyped,
-        stderr: T.untyped
+        workspace_name: String,
+        project_name: T.any(String, Symbol),
+        section_name: T.nilable(T.any(String, Symbol)),
+        task_name: T.nilable(T.any(String, Symbol)),
+        config: T.any(Checkoff::Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]),
+        projects: Checkoff::Projects,
+        sections: Checkoff::Sections,
+        tasks: Checkoff::Tasks,
+        stderr: IO
       ).void
     end
     def initialize(workspace_name, project_name, section_name, task_name, config: Checkoff::Internal::ConfigLoader.load(:asana), projects: Checkoff::Projects.new(config:), sections: Checkoff::Sections.new(config:,
                                                     projects:), tasks: Checkoff::Tasks.new(config:,
                                               sections:), stderr: $stderr); end
 
-    sig { returns(T.untyped) }
+    sig { void }
     def run; end
 
-    sig { params(project_name: T.untyped).returns(T.untyped) }
+    # _@param_ `project_name`
+    sig { params(project_name: String).returns(T.any(String, Symbol)) }
     def validate_and_assign_project_name(project_name); end
 
-    sig { params(workspace: T.untyped, project: T.untyped).returns(T.untyped) }
+    # _@param_ `workspace`
+    # 
+    # _@param_ `project`
+    sig { params(workspace: T.any(String, Symbol), project: T.any(String, Symbol)).returns(String) }
     def run_on_project(workspace, project); end
 
-    sig { params(workspace: T.untyped, project: T.untyped, section: T.untyped).returns(T.untyped) }
+    # _@param_ `workspace`
+    # 
+    # _@param_ `project`
+    # 
+    # _@param_ `section`
+    sig { params(workspace: T.any(String, Symbol), project: T.any(String, Symbol), section: T.nilable(T.any(String, Symbol))).returns(String) }
     def run_on_section(workspace, project, section); end
 
+    # _@param_ `workspace`
+    # 
+    # _@param_ `project`
+    # 
+    # _@param_ `section`
+    # 
+    # _@param_ `task_name`
     sig do
       params(
-        workspace: T.untyped,
-        project: T.untyped,
-        section: T.untyped,
-        task_name: T.untyped
-      ).returns(T.untyped)
+        workspace: T.any(String, Symbol),
+        project: T.any(String, Symbol),
+        section: T.nilable(T.any(String, Symbol)),
+        task_name: String
+      ).returns(String)
     end
     def run_on_task(workspace, project, section, task_name); end
 
-    sig { params(task: T.untyped).returns(T.untyped) }
+    # sord warn - undefined is probably not a type, but using anyway
+    # sord warn - undefined wasn't able to be resolved to a constant in this project
+    # _@param_ `task`
+    sig { params(task: Asana::Resources::Task).returns(T::Hash[Symbol, undefined]) }
     def task_to_hash(task); end
 
-    sig { params(tasks: T.untyped).returns(T.untyped) }
+    # _@param_ `tasks`
+    sig { params(tasks: T::Enumerable[Asana::Resources::Task]).returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
     def tasks_to_hash(tasks); end
 
     # Returns the value of attribute workspace_name.
@@ -3024,18 +3127,27 @@ module Checkoff
 
   # CLI subcommand that creates a task
   class QuickaddSubcommand
+    # _@param_ `workspace_name`
+    # 
+    # _@param_ `task_name`
+    # 
+    # _@param_ `config`
+    # 
+    # _@param_ `workspaces`
+    # 
+    # _@param_ `tasks`
     sig do
       params(
-        workspace_name: T.untyped,
-        task_name: T.untyped,
-        config: T.untyped,
-        workspaces: T.untyped,
-        tasks: T.untyped
+        workspace_name: String,
+        task_name: String,
+        config: T.any(Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]),
+        workspaces: Checkoff::Workspaces,
+        tasks: Checkoff::Tasks
       ).void
     end
     def initialize(workspace_name, task_name, config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), tasks: Checkoff::Tasks.new(config:)); end
 
-    sig { returns(T.untyped) }
+    sig { void }
     def run; end
 
     # Returns the value of attribute workspace_name.
@@ -3073,7 +3185,7 @@ module Checkoff
     # _@param_ `workspaces`
     sig do
       params(
-        config: Checkoff::Internal::EnvFallbackConfigLoader,
+        config: T.any(Checkoff::Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]),
         clients: Checkoff::Clients,
         client: Asana::Client,
         projects: Checkoff::Projects,
@@ -3099,6 +3211,23 @@ module Checkoff
     end
     def tasks(workspace_name, tag_name, only_uncompleted: true, extra_fields: []); end
 
+    # _@param_ `workspace_name`
+    # 
+    # _@param_ `tag_gid`
+    # 
+    # _@param_ `only_uncompleted`
+    # 
+    # _@param_ `extra_fields`
+    sig do
+      params(
+        workspace_name: String,
+        tag_gid: String,
+        only_uncompleted: T::Boolean,
+        extra_fields: T::Array[String]
+      ).returns(T::Enumerable[Asana::Resources::Task])
+    end
+    def tasks_by_tag_gid(workspace_name, tag_gid, only_uncompleted: true, extra_fields: []); end
+
     # sord warn - Asana::Resources::Tag wasn't able to be resolved to a constant in this project
     # _@param_ `workspace_name`
     # 
@@ -3131,23 +3260,6 @@ module Checkoff
     sig { void }
     def self.run; end
 
-    # _@param_ `workspace_name`
-    # 
-    # _@param_ `tag_gid`
-    # 
-    # _@param_ `only_uncompleted`
-    # 
-    # _@param_ `extra_fields`
-    sig do
-      params(
-        workspace_name: String,
-        tag_gid: String,
-        only_uncompleted: T::Boolean,
-        extra_fields: T::Array[String]
-      ).returns(T::Enumerable[Asana::Resources::Task])
-    end
-    def tasks_by_tag_gid(workspace_name, tag_gid, only_uncompleted: true, extra_fields: []); end
-
     sig { returns(Checkoff::Workspaces) }
     attr_reader :workspaces
 
@@ -3188,7 +3300,7 @@ module Checkoff
     # _@param_ `asana_task`
     sig do
       params(
-        config: Checkoff::Internal::EnvFallbackConfigLoader,
+        config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader),
         client: Asana::Client,
         workspaces: Checkoff::Workspaces,
         sections: Checkoff::Sections,
@@ -3331,9 +3443,9 @@ module Checkoff
     # <regular keys from API response>
     # +
     # unwrapped:
-    #  membership_by_section_gid: Hash<String, Hash (membership)>
-    #  membership_by_project_gid: Hash<String, Hash (membership)>
-    #  membership_by_project_name: Hash<String, Hash (membership)>
+    #  membership_by_section_gid: Hash{String => Hash (membership)>
+    #  membership_by_project_gid: Hash{String => Hash (membership)>
+    #  membership_by_project_name: Hash{String => Hash (membership)>
     # task: String (name)
     # 
     # _@param_ `task`
@@ -3400,6 +3512,7 @@ module Checkoff
     sig { returns(String) }
     def default_assignee_gid; end
 
+    # @sg-ignore
     sig { returns(::Logger) }
     def logger; end
 
@@ -3467,7 +3580,7 @@ module Checkoff
     # _@param_ `asana_event_enrichment`
     sig do
       params(
-        config: Checkoff::Internal::EnvFallbackConfigLoader,
+        config: T.any(Checkoff::Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]),
         workspaces: Checkoff::Workspaces,
         tasks: Checkoff::Tasks,
         sections: Checkoff::Sections,
@@ -3495,14 +3608,8 @@ module Checkoff
     sig { params(asana_event: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped]) }
     def enrich_event(asana_event); end
 
-    # sord warn - "[String" does not appear to be a type
-    # sord warn - "Array<String>]" does not appear to be a type
-    # sord warn - Invalid hash, must have exactly two types: "Hash<String,[String,Array<String>]>".
-    # sord warn - "[String" does not appear to be a type
-    # sord warn - "Array<String>]" does not appear to be a type
-    # sord warn - Invalid hash, must have exactly two types: "Hash<String,[String,Array<String>]>".
     # _@param_ `filter`
-    sig { params(filter: T.untyped).returns(T.untyped) }
+    sig { params(filter: T::Hash[String, T.any(String, T::Array[String])]).returns(T::Hash[String, T.any(String, T::Array[String])]) }
     def enrich_filter(filter); end
 
     # _@param_ `webhook_subscription` — Hash of the request made to webhook POST endpoint - https://app.asana.com/api/1.0/webhooks https://developers.asana.com/reference/createwebhook
@@ -3512,6 +3619,7 @@ module Checkoff
     sig { void }
     def self.run; end
 
+    # @sg-ignore
     sig { returns(::Logger) }
     def logger; end
 
@@ -3586,7 +3694,7 @@ module Checkoff
     # _@param_ `date_or_time`
     # 
     # _@param_ `period` — Valid values: :this_week, :now_or_before, :indefinite, [:less_than_n_days_ago, Integer]
-    sig { params(date_or_time: T.nilable(T.any(Date, Time)), period: T.any(Symbol, T::Array[[Symbol, Integer]])).returns(T::Boolean) }
+    sig { params(date_or_time: T.nilable(T.any(Date, Time)), period: T.any(Symbol, [Symbol, Integer])).returns(T::Boolean) }
     def in_period?(date_or_time, period); end
 
     # _@param_ `date_or_time`
@@ -3658,6 +3766,7 @@ module Checkoff
     sig { void }
     def self.run; end
 
+    # @sg-ignore
     sig { returns(::Logger) }
     def logger; end
 
@@ -3698,7 +3807,7 @@ module Checkoff
     # _@param_ `config`
     # 
     # _@param_ `asana_client_class`
-    sig { params(config: Checkoff::Internal::EnvFallbackConfigLoader, asana_client_class: T.class_of(Asana::Client)).void }
+    sig { params(config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader), asana_client_class: T.class_of(Asana::Client)).void }
     def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), asana_client_class: Asana::Client); end
 
     sig { returns(Asana::Client) }
@@ -3719,7 +3828,7 @@ module Checkoff
     # _@param_ `client`
     # 
     # _@param_ `projects`
-    sig { params(config: Checkoff::Internal::EnvFallbackConfigLoader, client: Asana::Client, projects: Checkoff::Projects).void }
+    sig { params(config: T.any(Checkoff::Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]), client: Asana::Client, projects: Checkoff::Projects).void }
     def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, projects: Checkoff::Projects.new(config:,
                                                     client:)); end
 
@@ -3780,7 +3889,7 @@ module Checkoff
     # _@param_ `timing`
     sig do
       params(
-        config: Checkoff::Internal::EnvFallbackConfigLoader,
+        config: T.any(Checkoff::Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]),
         client: Asana::Client,
         workspaces: Checkoff::Workspaces,
         project_hashes: Checkoff::Internal::ProjectHashes,
@@ -3795,12 +3904,14 @@ module Checkoff
     sig { params(extra_fields: T::Array[String]).returns(T::Array[String]) }
     def task_fields(extra_fields: []); end
 
+    # sord warn - undefined is probably not a type, but using anyway
+    # sord warn - undefined wasn't able to be resolved to a constant in this project
     # Default options used in Asana API to pull tasks
     # 
     # _@param_ `extra_fields`
     # 
     # _@param_ `only_uncompleted`
-    sig { params(extra_fields: T::Array[String], only_uncompleted: T::Boolean).returns(T::Hash[Symbol, Object]) }
+    sig { params(extra_fields: T::Array[String], only_uncompleted: T::Boolean).returns(T::Hash[Symbol, undefined]) }
     def task_options(extra_fields: [], only_uncompleted: false); end
 
     # _@param_ `extra_project_fields`
@@ -3885,7 +3996,7 @@ module Checkoff
     # _@param_ `project`
     # 
     # _@param_ `period` — See Checkoff::Timing#in_period? - :now_or_before,:this_week
-    sig { params(project: Asana::Resources::Project, period: T.any(Symbol, T::Array[T.untyped])).returns(T::Boolean) }
+    sig { params(project: Asana::Resources::Project, period: T.any(Symbol, [Symbol, Integer])).returns(T::Boolean) }
     def project_ready?(project, period: :now_or_before); end
 
     # _@param_ `project`
@@ -3893,7 +4004,7 @@ module Checkoff
     # _@param_ `field_name`
     # 
     # _@param_ `period` — See Checkoff::Timing#in_period? - :now_or_before,:this_week
-    sig { params(project: Asana::Resources::Project, field_name: T.any(Symbol, T::Array[T.untyped]), period: T.any(Symbol, T::Array[T.untyped])).returns(T::Boolean) }
+    sig { params(project: Asana::Resources::Project, field_name: T.any(Symbol, T::Array[T.untyped]), period: T.any(Symbol, [Symbol, Integer])).returns(T::Boolean) }
     def in_period?(project, field_name, period); end
 
     sig { returns(T::Hash[T.untyped, T.untyped]) }
@@ -3906,6 +4017,7 @@ module Checkoff
     sig { params(workspace_name: String).returns(Asana::Resources::Project) }
     def my_tasks(workspace_name); end
 
+    # @sg-ignore
     sig { returns(::Logger) }
     def logger; end
 
@@ -3968,7 +4080,7 @@ module Checkoff
     # _@param_ `time`
     sig do
       params(
-        config: Checkoff::Internal::EnvFallbackConfigLoader,
+        config: T.any(Checkoff::Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]),
         client: Asana::Client,
         projects: Checkoff::Projects,
         workspaces: Checkoff::Workspaces,
@@ -3997,9 +4109,6 @@ module Checkoff
     sig { params(project_gid: String, extra_fields: T::Array[String]).returns(T::Enumerable[Asana::Resources::Section]) }
     def sections_by_project_gid(project_gid, extra_fields: []); end
 
-    # sord warn - "[String" does not appear to be a type
-    # sord warn - "nil]" does not appear to be a type
-    # sord warn - Invalid hash, must have exactly two types: "Hash{[String, nil] => Enumerable<Asana::Resources::Task>}".
     # Given a workspace name and project name, then provide a Hash of
     # tasks with section name -> task list of the uncompleted tasks
     # 
@@ -4016,7 +4125,7 @@ module Checkoff
         project_name: T.any(String, Symbol),
         only_uncompleted: T::Boolean,
         extra_fields: T::Array[String]
-      ).returns(T.untyped)
+      ).returns(T::Hash[T.nilable(String), T::Enumerable[Asana::Resources::Task]])
     end
     def tasks_by_section(workspace_name, project_name, only_uncompleted: true, extra_fields: []); end
 
@@ -4051,6 +4160,7 @@ module Checkoff
     def tasks(workspace_name, project_name, section_name, only_uncompleted: true, extra_fields: []); end
 
     # Pulls just names of tasks from a given section.
+    # @sg-ignore
     # 
     # _@param_ `workspace_name`
     # 
@@ -4120,9 +4230,6 @@ module Checkoff
     sig { params(response: Asana::HttpClient::Response).returns(T::Array[T.any(T::Hash[T.untyped, T.untyped], T::Hash[T.untyped, T.untyped])]) }
     def parse(response); end
 
-    # sord warn - "[String" does not appear to be a type
-    # sord warn - "nil]" does not appear to be a type
-    # sord warn - Invalid hash, must have exactly two types: "Hash<[String,nil], Enumerable<Asana::Resources::Task>>".
     # Given a project object, pull all tasks, then provide a Hash of
     # tasks with section name -> task list of the uncompleted tasks
     # 
@@ -4131,29 +4238,23 @@ module Checkoff
     # _@param_ `only_uncompleted`
     # 
     # _@param_ `extra_fields`
-    sig { params(project: Asana::Resources::Project, only_uncompleted: T::Boolean, extra_fields: T::Array[String]).returns(T.untyped) }
+    sig { params(project: Asana::Resources::Project, only_uncompleted: T::Boolean, extra_fields: T::Array[String]).returns(T::Hash[T.nilable(String), T::Enumerable[Asana::Resources::Task]]) }
     def tasks_by_section_for_project(project, only_uncompleted: true, extra_fields: []); end
 
-    # sord warn - "[String" does not appear to be a type
-    # sord warn - "nil]" does not appear to be a type
-    # sord warn - Invalid hash, must have exactly two types: "Hash<[String,nil], Enumerable<Asana::Resources::Task>>".
     # Given a list of tasks, pull a Hash of tasks with section name -> task list
     # 
     # _@param_ `tasks`
     # 
     # _@param_ `project_gid`
-    sig { params(tasks: T::Enumerable[Asana::Resources::Task], project_gid: String).returns(T.untyped) }
+    sig { params(tasks: T::Enumerable[Asana::Resources::Task], project_gid: String).returns(T::Hash[T.nilable(String), T::Enumerable[Asana::Resources::Task]]) }
     def by_section(tasks, project_gid); end
 
-    # sord warn - "[String" does not appear to be a type
-    # sord warn - "nil]" does not appear to be a type
-    # sord warn - Invalid hash, must have exactly two types: "Hash{[String, nil] => Enumerable<Asana::Resources::Task>}".
     # _@param_ `by_section`
     # 
     # _@param_ `task`
     # 
     # _@param_ `project_gid`
-    sig { params(by_section: T.untyped, task: Asana::Resources::Task, project_gid: String).void }
+    sig { params(by_section: T::Hash[T.nilable(String), T::Array[Asana::Resources::Task]], task: Asana::Resources::Task, project_gid: String).void }
     def file_task_by_section(by_section, task, project_gid); end
 
     # _@param_ `workspace_name`
@@ -4162,6 +4263,7 @@ module Checkoff
     sig { params(workspace_name: String, project_name: T.any(String, Symbol)).returns(Asana::Resources::Project) }
     def project_or_raise(workspace_name, project_name); end
 
+    # @sg-ignore
     sig { returns(::Logger) }
     def logger; end
 
@@ -4227,13 +4329,10 @@ module Checkoff
     sig { params(task: Asana::Resources::Task).returns(T::Boolean) }
     def all_subtasks_completed?(task); end
 
-    # sord warn - "[nil" does not appear to be a type
-    # sord warn - "String]" does not appear to be a type
-    # sord warn - Invalid hash, must have exactly two types: "Hash<[nil,String], Enumerable<Asana::Resources::Task>>".
     # pulls a Hash of subtasks broken out by section
     # 
     # _@param_ `tasks`
-    sig { params(tasks: T::Enumerable[Asana::Resources::Task]).returns(T.untyped) }
+    sig { params(tasks: T::Enumerable[Asana::Resources::Task]).returns(T::Hash[T.nilable(String), T::Enumerable[Asana::Resources::Task]]) }
     def by_section(tasks); end
 
     # Returns all subtasks, including section headers
@@ -4267,7 +4366,7 @@ module Checkoff
     # _@param_ `by_section`
     # 
     # _@param_ `task`
-    sig { params(current_section: T.nilable(String), by_section: T::Hash[T.untyped, T.untyped], task: Asana::Resources::Task).returns(T::Array[[String, T::Hash[T.untyped, T.untyped]]]) }
+    sig { params(current_section: T.nilable(String), by_section: T::Hash[T.untyped, T.untyped], task: Asana::Resources::Task).returns([String, T::Hash[T.untyped, T.untyped]]) }
     def file_task_by_section(current_section, by_section, task); end
 
     sig { returns(Checkoff::Projects) }
@@ -4323,7 +4422,7 @@ module Checkoff
     # _@param_ `gid`
     # 
     # _@param_ `resource_type`
-    sig { params(gid: String, resource_type: T.nilable(String)).returns(T::Array[[T.untyped, T.untyped, T.untyped, T.untyped]]) }
+    sig { params(gid: String, resource_type: T.nilable(String)).returns([T.untyped, T.untyped, T.untyped, T.untyped]) }
     def resource_by_gid(gid, resource_type: nil); end
 
     # _@param_ `gid`
@@ -4396,8 +4495,6 @@ module Checkoff
     # _@param_ `task`
     # 
     # _@param_ `limit_to_portfolio_gid`
-    # 
-    # _@param_ `project_name`
     sig { params(task: Asana::Resources::Task, limit_to_portfolio_gid: T.nilable(String)).returns(T::Boolean) }
     def task_dependent_on_previous_section_last_milestone?(task, limit_to_portfolio_gid: nil); end
 
@@ -4435,8 +4532,8 @@ module Checkoff
 
   # Pull portfolios from Asana
   class Portfolios
-    extend CacheMethod::ClassMethods
     extend T::Sig
+    extend CacheMethod::ClassMethods
     MINUTE = T.let(60, T.untyped)
     HOUR = T.let(T.let(MINUTE * 60, Numeric), T.untyped)
     DAY = T.let(T.let(24 * HOUR, Numeric), T.untyped)
@@ -4455,7 +4552,7 @@ module Checkoff
     # _@param_ `projects`
     sig do
       params(
-        config: Checkoff::Internal::EnvFallbackConfigLoader,
+        config: T.any(Checkoff::Internal::EnvFallbackConfigLoader, T::Hash[T.untyped, T.untyped]),
         clients: Checkoff::Clients,
         client: Asana::Client,
         projects: Checkoff::Projects,
@@ -4528,7 +4625,7 @@ module Checkoff
     # _@param_ `client`
     # 
     # _@param_ `asana_workspace`
-    sig { params(config: Checkoff::Internal::EnvFallbackConfigLoader, client: Asana::Client, asana_workspace: T.class_of(Asana::Resources::Workspace)).void }
+    sig { params(config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader), client: Asana::Client, asana_workspace: T.class_of(Asana::Resources::Workspace)).void }
     def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, asana_workspace: Asana::Resources::Workspace); end
 
     # Pulls an Asana workspace object
@@ -4664,6 +4761,7 @@ module Checkoff
     sig { void }
     def self.run; end
 
+    # @sg-ignore
     sig { returns(::Logger) }
     def logger; end
 
@@ -4717,7 +4815,7 @@ module Checkoff
     # _@param_ `client`
     sig do
       params(
-        config: Checkoff::Internal::EnvFallbackConfigLoader,
+        config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader),
         clients: Checkoff::Clients,
         client: Asana::Client,
         workspaces: Checkoff::Workspaces
@@ -4756,10 +4854,10 @@ module Checkoff
 
     # @sg-ignore
     # 
-    # _@param_ `project`
+    # _@param_ `resource`
     # 
     # _@param_ `custom_field_name`
-    sig { params(resource: T.untyped, custom_field_name: String).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    sig { params(resource: T.any(Asana::Resources::Task, Asana::Resources::Project), custom_field_name: String).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
     def resource_custom_field_by_name(resource, custom_field_name); end
 
     # _@param_ `resource`
@@ -4774,13 +4872,10 @@ module Checkoff
     sig { params(resource: T.any(Asana::Resources::Project, Asana::Resources::Task), custom_field_gid: String).returns(T::Hash[T.untyped, T.untyped]) }
     def resource_custom_field_by_gid_or_raise(resource, custom_field_gid); end
 
-    # sord warn - "[Hash" does not appear to be a type
-    # sord warn - "Array<Hash>]" does not appear to be a type
-    # sord warn - Invalid hash, must have exactly two types: "Hash{String => [Hash,Array<Hash>]}".
     # @sg-ignore
     # 
     # _@param_ `custom_field`
-    sig { params(custom_field: T.untyped).returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
+    sig { params(custom_field: T::Hash[String, T.any(T::Hash[T.untyped, T.untyped], T::Array[T::Hash[T.untyped, T.untyped]])]).returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
     def resource_custom_field_enum_values(custom_field); end
 
     # _@param_ `custom_field`
@@ -4874,7 +4969,7 @@ module Checkoff
         api_params: T::Hash[String, Object],
         workspace_gid: String,
         extra_fields: T::Array[String],
-        task_selector: T::Array[T.untyped],
+        task_selector: T.any(Symbol, T::Array[T.any(Symbol, Integer, T::Array[T.untyped])]),
         fetch_all: T::Boolean
       ).returns(T::Enumerable[Asana::Resources::Task])
     end
@@ -4913,18 +5008,21 @@ module Checkoff
     # _@param_ `url`
     # 
     # _@param_ `extra_fields`
-    # 
-    # _@param_ `fetch_all` — Ensure all results are provided by manually paginating
     sig { params(api_params: T::Hash[String, Object], workspace_gid: String, extra_fields: T::Array[String]).returns(T::Enumerable[Asana::Resources::Task]) }
     def iterated_raw_task_search(api_params, workspace_gid:, extra_fields:); end
 
+    # sord warn - undefined is probably not a type, but using anyway
+    # sord warn - undefined wasn't able to be resolved to a constant in this project
+    # @sg-ignore
+    # 
     # _@param_ `extra_fields`
-    sig { params(extra_fields: T::Array[String]).returns(T::Hash[String, Object]) }
+    sig { params(extra_fields: T::Array[String]).returns(T::Hash[Symbol, undefined]) }
     def calculate_api_options(extra_fields); end
 
     sig { void }
     def self.run; end
 
+    # @sg-ignore
     sig { returns(::Logger) }
     def logger; end
 
@@ -4983,13 +5081,15 @@ module Checkoff
     # _@param_ `tasks`
     # 
     # _@param_ `timelines`
+    # 
+    # _@param_ `custom_fields`
     sig do
       params(
         config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader),
         client: Asana::Client,
         tasks: Checkoff::Tasks,
         timelines: Checkoff::Timelines,
-        custom_fields: T.untyped
+        custom_fields: Checkoff::CustomFields
       ).void
     end
     def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, tasks: Checkoff::Tasks.new(config:,
@@ -5000,7 +5100,7 @@ module Checkoff
     # _@param_ `task`
     # 
     # _@param_ `task_selector` — Filter based on task details.  Examples: [:tag, 'foo'] [:not, [:tag, 'foo']] [:tag, 'foo']
-    sig { params(task: Asana::Resources::Task, task_selector: T::Array[[Symbol, T::Array[T.untyped]]]).returns(T::Boolean) }
+    sig { params(task: Asana::Resources::Task, task_selector: T.any(Symbol, T::Array[T.any(Symbol, Integer, T::Array[T.untyped])])).returns(T::Boolean) }
     def filter_via_task_selector(task, task_selector); end
 
     # @sg-ignore
@@ -5011,7 +5111,8 @@ module Checkoff
     sig { returns(String) }
     def self.workspace_name; end
 
-    sig { returns(T::Array[T.untyped]) }
+    # @sg-ignore
+    sig { returns([Symbol, T::Array[T.untyped]]) }
     def self.task_selector; end
 
     sig { void }
@@ -5065,7 +5166,7 @@ module Checkoff
     # _@param_ `project`
     # 
     # _@param_ `project_selector` — Filter based on project details.  Examples: [:tag, 'foo'] [:not, [:tag, 'foo']] [:tag, 'foo']
-    sig { params(project: Asana::Resources::Project, project_selector: T::Array[[Symbol, T::Array[T.untyped]]]).returns(T::Boolean) }
+    sig { params(project: Asana::Resources::Project, project_selector: [Symbol, T::Array[T.untyped]]).returns(T::Boolean) }
     def filter_via_project_selector(project, project_selector); end
 
     sig { void }
@@ -5122,7 +5223,7 @@ module Checkoff
     # _@param_ `section`
     # 
     # _@param_ `section_selector` — Filter based on section details.  Examples: [:tag, 'foo'] [:not, [:tag, 'foo']] [:tag, 'foo']
-    sig { params(section: Asana::Resources::Section, section_selector: T::Array[[Symbol, T::Array[T.untyped]]]).returns(T::Boolean) }
+    sig { params(section: Asana::Resources::Section, section_selector: [Symbol, T::Array[T.untyped]]).returns(T::Boolean) }
     def filter_via_section_selector(section, section_selector); end
 
     sig { void }
@@ -5159,11 +5260,10 @@ module Checkoff
       sig { params(task_hash: T::Hash[T.untyped, T.untyped]).void }
       def unwrap_custom_fields(task_hash); end
 
-      # sord warn - Invalid hash, must have exactly two types: "Hash<String, Hash, Array>".
       # _@param_ `task_hash`
       # 
       # _@param_ `memberships`
-      sig { params(task_hash: T.untyped, memberships: T::Array[T::Hash[T.untyped, T.untyped]]).void }
+      sig { params(task_hash: T::Hash[String, T.any(String, T::Hash[T.untyped, T.untyped], T::Array[T.untyped])], memberships: T::Array[T::Hash[T.untyped, T.untyped]]).void }
       def add_user_task_list(task_hash, memberships); end
 
       # _@param_ `task_hash`
@@ -5218,16 +5318,12 @@ module Checkoff
       # @sg-ignore
       # 
       # _@param_ `task`
-      # 
-      # _@param_ `field_name`
       sig { params(task: Asana::Resources::Task).returns(T.nilable(T.any(Date, Time))) }
       def start_date_or_time(task); end
 
       # @sg-ignore
       # 
       # _@param_ `task`
-      # 
-      # _@param_ `field_name`
       sig { params(task: Asana::Resources::Task).returns(T.nilable(T.any(Date, Time))) }
       def due_date_or_time(task); end
 
@@ -5257,19 +5353,21 @@ module Checkoff
       # _@param_ `name`
       # 
       # _@param_ `value`
-      sig { params(name: Symbol, value: T.any(Object, T::Boolean), block: T.untyped).returns(T.any(Object, T::Boolean)) }
+      sig { params(name: Symbol, value: T.any(Object, T::Boolean), block: T.proc.returns(T)).returns(T) }
       def with_thread_local_variable(name, value, &block); end
     end
 
     # Use the provided config from a YAML file, and fall back to env
     # variable if it's not populated for a key'
     class EnvFallbackConfigLoader
+      # sord warn - undefined is probably not a type, but using anyway
+      # sord warn - undefined wasn't able to be resolved to a constant in this project
       # _@param_ `config`
       # 
       # _@param_ `sym`
       # 
       # _@param_ `yaml_filename`
-      sig { params(config: T::Hash[Symbol, Object], sym: Symbol, yaml_filename: String).void }
+      sig { params(config: T::Hash[Symbol, undefined], sym: Symbol, yaml_filename: String).void }
       def initialize(config, sym, yaml_filename); end
 
       # _@param_ `key`
@@ -5287,14 +5385,14 @@ module Checkoff
 
     # Load configuration file
     class ConfigLoader
-      sig { params(sym: T.untyped).returns(EnvFallbackConfigLoader) }
+      # _@param_ `sym`
+      sig { params(sym: Symbol).returns(EnvFallbackConfigLoader) }
       def self.load(sym); end
 
-      # sord warn - "[String" does not appear to be a type
-      # sord warn - "Symbol]" does not appear to be a type
-      # sord warn - Invalid hash, must have exactly two types: "Hash<[String, Symbol], Object>".
+      # sord warn - undefined is probably not a type, but using anyway
+      # sord warn - undefined wasn't able to be resolved to a constant in this project
       # _@param_ `sym`
-      sig { params(sym: Symbol).returns(T.untyped) }
+      sig { params(sym: Symbol).returns(T::Hash[Symbol, undefined]) }
       def self.load_yaml_file(sym); end
 
       # _@param_ `sym`
@@ -5342,16 +5440,12 @@ module Checkoff
       # @sg-ignore
       # 
       # _@param_ `project`
-      # 
-      # _@param_ `field_name`
       sig { params(project: Asana::Resources::Project).returns(T.nilable(Date)) }
       def start_date(project); end
 
       # @sg-ignore
       # 
       # _@param_ `project`
-      # 
-      # _@param_ `field_name`
       sig { params(project: Asana::Resources::Project).returns(T.nilable(Date)) }
       def due_date(project); end
 
@@ -5379,45 +5473,34 @@ module Checkoff
         def initialize(_deps = {}); end
 
         # _@param_ `url`
-        sig { params(url: String).returns([T::Hash[String, String], T::Hash[String, String]]) }
+        sig { params(url: String).returns([T::Hash[String, String], T::Array[T.untyped]]) }
         def convert_params(url); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # _@param_ `date_url_params`
-        sig { params(date_url_params: T::Hash[String, T::Array[String]]).returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { params(date_url_params: T::Hash[String, T::Array[String]]).returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def convert_date_params(date_url_params); end
 
         # _@param_ `simple_url_params`
         sig { params(simple_url_params: T::Hash[String, T::Array[String]]).returns(T::Hash[String, String]) }
         def convert_simple_params(simple_url_params); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # _@param_ `custom_field_params`
-        sig { params(custom_field_params: T::Hash[String, T::Array[String]]).returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { params(custom_field_params: T::Hash[String, T::Array[String]]).returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def convert_custom_field_params(custom_field_params); end
 
         # _@param_ `url_params`
-        sig { params(url_params: T::Hash[String, String]).returns([T::Hash[String, String], T::Hash[String, String], T::Hash[String, String]]) }
+        sig { params(url_params: T::Hash[String, String]).returns([T::Hash[String, T::Array[String]], T::Hash[String, T::Array[String]], T::Hash[String, T::Array[String]]]) }
         def partition_url_params(url_params); end
       end
 
       # Merge task selectors and search API arguments
       class ResultsMerger
-        # sord warn - "[Hash<String, String>]" does not appear to be a type
         # _@param_ `args`
-        # 
-        # _@return_ — Hash<String, String>
-        sig { params(args: T::Array[T.untyped]).returns(T::Hash[String, String]) }
+        sig { params(args: T::Array[T::Hash[String, String]]).returns(T::Hash[String, String]) }
         def self.merge_args(*args); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # _@param_ `task_selectors`
-        sig { params(task_selectors: T::Array[T::Array[T.any(T.untyped, T.untyped)]]).returns(T::Array[T.any(T.untyped, T.untyped)]) }
+        sig { params(task_selectors: T::Array[T.any(Symbol, T::Array[T.untyped])]).returns([Symbol, T::Array[T.untyped], T::Array[T.untyped]]) }
         def self.merge_task_selectors(*task_selectors); end
       end
 
@@ -5428,12 +5511,14 @@ module Checkoff
           # _@param_ `gid`
           # 
           # _@param_ `remaining_params`
-          sig { params(gid: String, remaining_params: T::Hash[T.untyped, T.untyped]).void }
+          sig { params(gid: String, remaining_params: T::Hash[String, T::Array[String]]).void }
           def initialize(gid, remaining_params); end
 
           sig { void }
           def ensure_no_remaining_params!; end
 
+          # @sg-ignore
+          # 
           # _@param_ `param_name`
           sig { params(param_name: String).returns(String) }
           def fetch_solo_param(param_name); end
@@ -5441,25 +5526,25 @@ module Checkoff
           sig { returns(String) }
           attr_reader :gid
 
-          sig { returns(T::Hash[T.untyped, T.untyped]) }
+          sig { returns(T::Hash[String, T::Array[String]]) }
           attr_reader :remaining_params
         end
 
         # custom_field_#{gid}.variant = 'less_than'
         class LessThan < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String)]]) }
           def convert; end
         end
 
         # custom_field_#{gid}.variant = 'greater_than'
         class GreaterThan < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String)]]) }
           def convert; end
         end
 
         # custom_field_#{gid}.variant = 'equals'
         class Equals < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String)]]) }
           def convert; end
         end
 
@@ -5467,7 +5552,7 @@ module Checkoff
         # 
         # custom_field_#{gid}.variant = 'is_not'
         class IsNot < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String, T::Array[T.untyped])]]) }
           def convert; end
         end
 
@@ -5475,7 +5560,7 @@ module Checkoff
         # 
         # custom_field_#{gid}.variant = 'doesnt_contain_any'
         class DoesntContainAny < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String, T::Array[T.untyped])]]) }
           def convert; end
         end
 
@@ -5483,7 +5568,7 @@ module Checkoff
         # 
         # custom_field_#{gid}.variant = 'contains_any'
         class ContainsAny < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String, T::Array[T.untyped])]]) }
           def convert; end
         end
 
@@ -5491,13 +5576,13 @@ module Checkoff
         # 
         # custom_field_#{gid}.variant = 'contains_all'
         class ContainsAll < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String, T::Array[T.untyped])]]) }
           def convert; end
         end
 
         # custom_field_#{gid}.variant = 'no_value'
         class NoValue < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String, T::Array[T.untyped], Symbol)]]) }
           def convert; end
         end
 
@@ -5505,13 +5590,13 @@ module Checkoff
         # 
         # Not used for multi-select fields
         class AnyValue < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String, T::Array[T.untyped])]]) }
           def convert; end
         end
 
         # custom_field_#{gid}.variant = 'is'
         class Is < Checkoff::Internal::SearchUrl::CustomFieldVariant::CustomFieldVariant
-          sig { returns(T::Array[[T::Hash[T.untyped, T.untyped], T::Array[T.untyped]]]) }
+          sig { returns([T::Hash[String, String], T::Array[T.any(T::Array[String], String, T::Array[T.untyped])]]) }
           def convert; end
         end
       end
@@ -5529,50 +5614,36 @@ module Checkoff
         sig { params(date_url_params: T::Hash[String, T::Array[String]]).void }
         def initialize(date_url_params:); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # @sg-ignore
-        sig { returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def convert; end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
-        # @sg-ignore
-        # 
         # _@param_ `prefix`
-        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def convert_for_prefix(prefix); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # _@param_ `prefix`
         # 
         # _@return_ — See https://developers.asana.com/docs/search-tasks-in-a-workspace
-        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def handle_through_next(prefix); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # _@param_ `prefix`
         # 
         # _@return_ — See https://developers.asana.com/docs/search-tasks-in-a-workspace
-        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def handle_between(prefix); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # _@param_ `prefix`
         # 
         # _@return_ — See https://developers.asana.com/docs/search-tasks-in-a-workspace
-        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def handle_within_last(prefix); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # _@param_ `prefix`
         # 
         # _@return_ — See https://developers.asana.com/docs/search-tasks-in-a-workspace
-        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { params(prefix: String).returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def handle_within_next(prefix); end
 
         # _@param_ `param_key`
@@ -5651,7 +5722,7 @@ module Checkoff
 
         # Handle 'completion' search url param
         class Completion < Checkoff::Internal::SearchUrl::SimpleParam::SimpleParam
-          sig { returns(T::Array[String]) }
+          sig { returns(T::Array[T.any(String, T::Boolean)]) }
           def convert; end
         end
 
@@ -5663,9 +5734,7 @@ module Checkoff
 
         # handle 'subtask' search url param
         class Subtask < Checkoff::Internal::SearchUrl::SimpleParam::SimpleParam
-          # sord warn - "[String" does not appear to be a type
-          # sord warn - "Boolean]" does not appear to be a type
-          sig { returns(T::Array[T.any(T.untyped, T.untyped)]) }
+          sig { returns(T::Array[T.any(String, T::Boolean)]) }
           def convert; end
         end
 
@@ -5753,23 +5822,19 @@ module Checkoff
         sig { params(custom_field_params: T::Hash[String, T::Array[String]]).void }
         def initialize(custom_field_params:); end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
-        sig { returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def convert; end
 
         # @sg-ignore
         sig { returns(T::Hash[String, T::Hash[T.untyped, T.untyped]]) }
         def by_custom_field; end
 
-        # sord warn - "[Symbol" does not appear to be a type
-        # sord warn - "Array]" does not appear to be a type
         # @sg-ignore
         # 
         # _@param_ `gid`
         # 
         # _@param_ `single_custom_field_params`
-        sig { params(gid: String, single_custom_field_params: T::Hash[String, T::Array[String]]).returns([T::Hash[String, String], T::Array[T.any(T.untyped, T.untyped)]]) }
+        sig { params(gid: String, single_custom_field_params: T::Hash[String, T::Array[String]]).returns([T::Hash[String, String], T::Array[T.any(Symbol, T::Array[T.untyped])]]) }
         def convert_single_custom_field_params(gid, single_custom_field_params); end
 
         # _@param_ `key`
@@ -5842,6 +5907,7 @@ module Checkoff
       sig { params(key: String, asana_event: T::Hash[T.untyped, T.untyped], fields: T::Array[String]).returns(T.nilable(Asana::Resources::Task)) }
       def uncached_fetch_task(key, asana_event, fields); end
 
+      # @sg-ignore
       sig { returns(::Logger) }
       def logger; end
 
@@ -5890,8 +5956,6 @@ module Checkoff
       # _@param_ `clients`
       # 
       # _@param_ `client`
-      # 
-      # _@param_ `asana_event_enrichment`
       sig do
         params(
           config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader),
@@ -5913,18 +5977,12 @@ module Checkoff
       sig { params(asana_event: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped]) }
       def enrich_event(asana_event); end
 
-      # sord warn - "[String" does not appear to be a type
-      # sord warn - "Array<String>]" does not appear to be a type
-      # sord warn - Invalid hash, must have exactly two types: "Hash<String,[String,Array<String>]>".
-      # sord warn - "[String" does not appear to be a type
-      # sord warn - "Array<String>]" does not appear to be a type
-      # sord warn - Invalid hash, must have exactly two types: "Hash<String,[String,Array<String>]>".
       # _@param_ `filter`
-      sig { params(filter: T.untyped).returns(T.untyped) }
+      sig { params(filter: T::Hash[String, T.any(String, T::Array[String])]).returns(T::Hash[String, T.any(String, T::Array[String])]) }
       def enrich_filter(filter); end
 
       # _@param_ `webhook_subscription` — Hash of the request made to webhook POST endpoint - https://app.asana.com/api/1.0/webhooks https://developers.asana.com/reference/createwebhook
-      sig { params(webhook_subscription: T::Hash[T.untyped, T.untyped]).void }
+      sig { params(webhook_subscription: T.nilable(T::Hash[T.untyped, T.untyped])).void }
       def enrich_webhook_subscription!(webhook_subscription); end
 
       # sord warn - "[String" does not appear to be a type
@@ -5937,22 +5995,19 @@ module Checkoff
       # _@param_ `gid`
       # 
       # _@param_ `resource_type`
-      sig { params(gid: String, resource_type: T.nilable(String)).returns(T::Array[[T.untyped, T.untyped, T.untyped, T.untyped]]) }
+      sig { params(gid: String, resource_type: T.nilable(String)).returns([T.untyped, T.untyped, T.untyped, T.untyped]) }
       def enrich_gid(gid, resource_type: nil); end
 
       # _@param_ `filter`
-      sig { params(filter: T::Hash[String, String]).returns(T.nilable(String)) }
+      sig { params(filter: T::Hash[String, T.any(String, T::Array[String])]).returns(T.nilable(String)) }
       def enrich_filter_parent_gid!(filter); end
 
       # _@param_ `filter`
-      sig { params(filter: T::Hash[String, String]).void }
+      sig { params(filter: T::Hash[String, T.any(String, T::Array[String])]).void }
       def enrich_filter_resource!(filter); end
 
-      # sord warn - "[String" does not appear to be a type
-      # sord warn - "Array<String>]" does not appear to be a type
-      # sord warn - Invalid hash, must have exactly two types: "Hash{String => [String,Array<String>]}".
       # _@param_ `filter`
-      sig { params(filter: T.untyped).void }
+      sig { params(filter: T::Hash[String, T.any(String, T::Array[String])]).void }
       def enrich_filter_section!(filter); end
 
       # sord warn - "'resource'" does not appear to be a type
@@ -5965,6 +6020,7 @@ module Checkoff
       sig { params(asana_event: T::Hash[T.untyped, T::Hash[T.untyped, T.untyped]]).void }
       def enrich_event_resource!(asana_event); end
 
+      # @sg-ignore
       sig { returns(::Logger) }
       def logger; end
 
@@ -6015,7 +6071,7 @@ module Checkoff
   # Base class to evaluate Asana resource selectors against an Asana resource
   class SelectorEvaluator
     # _@param_ `selector`
-    sig { params(selector: T::Array[T.untyped]).returns(T.nilable(T.any(T::Boolean, Object))) }
+    sig { params(selector: T.any(Symbol, T::Array[T.any(Symbol, Integer, T::Array[T.untyped])])).returns(T.nilable(T.any(T::Boolean, Object, T::Array[T.untyped]))) }
     def evaluate(selector); end
 
     sig { returns(T::Hash[T.untyped, T.untyped]) }
@@ -6255,13 +6311,9 @@ module Checkoff
         sig { returns(T::Boolean) }
         def matches?; end
 
-        # only projects in this portfolio will be evaluated.
-        # 
         # _@param_ `task`
         # 
-        # _@param_ `project_name`
-        # 
-        # _@param_ `limit_to_portfolio_gid` — If specified,
+        # _@param_ `limit_to_portfolio_gid` — If specified, only projects in this portfolio will be evaluated.
         sig { params(task: Asana::Resources::Task, limit_to_portfolio_gid: T.nilable(String)).returns(T::Boolean) }
         def evaluate(task, limit_to_portfolio_gid: nil); end
       end
@@ -6338,18 +6390,20 @@ module Checkoff
         # _@param_ `timelines`
         # 
         # _@param_ `custom_fields`
+        # 
+        # _@param_ `_kwargs`
         sig do
           params(
-            selector: T.any(T::Array[[Symbol, T::Array[T.untyped]]], String),
+            selector: T.any([Symbol, T::Array[T.untyped]], String),
             tasks: Checkoff::Tasks,
             timelines: Checkoff::Timelines,
             custom_fields: Checkoff::CustomFields,
-            _kwargs: T.untyped
+            _kwargs: T::Hash[T.untyped, T.untyped]
           ).void
         end
         def initialize(selector:, tasks:, timelines:, custom_fields:, **_kwargs); end
 
-        sig { returns(T::Array[[Symbol, T::Array[T.untyped]]]) }
+        sig { returns([Symbol, T::Array[T.untyped]]) }
         attr_reader :selector
       end
     end
@@ -6530,12 +6584,12 @@ module Checkoff
         sig { params(_index: Integer).returns(T::Boolean) }
         def evaluate_arg?(_index); end
 
-        # @sg-ignore
-        # 
+        # sord warn - boolish is probably not a type, but using anyway
+        # sord warn - boolish wasn't able to be resolved to a constant in this project
         # _@param_ `resource`
         # 
         # _@param_ `prefix`
-        sig { params(resource: T.any(Asana::Resources::Task, Asana::Resources::Project), prefix: String).returns(T::Boolean) }
+        sig { params(resource: T.any(Asana::Resources::Task, Asana::Resources::Project), prefix: String).returns(boolish) }
         def evaluate(resource, prefix); end
       end
 
@@ -6556,10 +6610,12 @@ module Checkoff
         # _@param_ `selector`
         # 
         # _@param_ `custom_fields`
-        sig { params(selector: T.any(T::Array[[Symbol, T::Array[T.untyped]]], String), custom_fields: Checkoff::CustomFields, _kwargs: T.untyped).void }
+        # 
+        # _@param_ `_kwargs`
+        sig { params(selector: T.any([Symbol, T::Array[T.untyped]], String), custom_fields: Checkoff::CustomFields, _kwargs: T::Hash[T.untyped, T.untyped]).void }
         def initialize(selector:, custom_fields:, **_kwargs); end
 
-        sig { returns(T::Array[[Symbol, T::Array[T.untyped]]]) }
+        sig { returns(T.any([Symbol, T::Array[T.untyped]], String)) }
         attr_reader :selector
       end
     end
@@ -6626,18 +6682,20 @@ module Checkoff
         # _@param_ `portfolios`
         # 
         # _@param_ `workspaces`
+        # 
+        # _@param_ `_kwargs`
         sig do
           params(
-            selector: T.any(T::Array[[Symbol, T::Array[T.untyped]]], String),
+            selector: T.any([Symbol, T::Array[T.untyped]], String),
             projects: Checkoff::Projects,
             portfolios: Checkoff::Portfolios,
             workspaces: Checkoff::Workspaces,
-            _kwargs: T.untyped
+            _kwargs: T::Hash[T.untyped, T.untyped]
           ).void
         end
         def initialize(selector:, projects:, portfolios:, workspaces:, **_kwargs); end
 
-        sig { returns(T::Array[[Symbol, T::Array[T.untyped]]]) }
+        sig { returns([Symbol, T::Array[T.untyped]]) }
         attr_reader :selector
       end
     end
@@ -6683,7 +6741,7 @@ module Checkoff
         # _@param_ `kwargs`
         sig do
           params(
-            selector: T.any(T::Array[[Symbol, T::Array[T.untyped]]], String),
+            selector: T.any([Symbol, T::Array[T.untyped]], String),
             sections: Checkoff::Sections,
             client: Asana::Client,
             kwargs: T::Hash[T.untyped, T.untyped]
@@ -6691,7 +6749,7 @@ module Checkoff
         end
         def initialize(selector:, sections:, client:, **kwargs); end
 
-        sig { returns(T::Array[[Symbol, T::Array[T.untyped]]]) }
+        sig { returns([Symbol, T::Array[T.untyped]]) }
         attr_reader :selector
 
         sig { returns(Asana::Client) }
@@ -6703,8 +6761,6 @@ module Checkoff
     class FunctionEvaluator
       include Logging
 
-      # @sg-ignore
-      # 
       # _@param_ `_index`
       sig { params(_index: Integer).returns(T::Boolean) }
       def evaluate_arg?(_index); end
@@ -6727,6 +6783,7 @@ module Checkoff
       sig { params(object: Object, fn_name: Symbol).returns(T::Boolean) }
       def fn?(object, fn_name); end
 
+      # @sg-ignore
       sig { returns(::Logger) }
       def logger; end
 
@@ -6862,7 +6919,7 @@ end - [Checkoff::SelectorClasses::Common::FunctionEvaluator]).freeze, T.untyped)
     SECTION_FUNCTION_EVALUATORS = T.let((Checkoff::SelectorClasses::Section.constants.map do |const|
   Checkoff::SelectorClasses::Section.const_get(const)
 end - [Checkoff::SelectorClasses::Section::FunctionEvaluator]).freeze, T.untyped)
-    FUNCTION_EVALUTORS = T.let((COMMON_FUNCTION_EVALUATORS + SECTION_FUNCTION_EVALUATORS).freeze, T.untyped)
+    FUNCTION_EVALUATORS = T.let((COMMON_FUNCTION_EVALUATORS + SECTION_FUNCTION_EVALUATORS).freeze, T.untyped)
 
     # _@param_ `section`
     # 
@@ -6873,14 +6930,16 @@ end - [Checkoff::SelectorClasses::Section::FunctionEvaluator]).freeze, T.untyped
     # _@param_ `sections`
     # 
     # _@param_ `custom_fields`
+    # 
+    # _@param_ `_kwargs`
     sig do
       params(
-        section: Asana::Resources::Project,
+        section: Asana::Resources::Section,
         client: Asana::Client,
         projects: Checkoff::Projects,
         sections: Checkoff::Sections,
         custom_fields: Checkoff::CustomFields,
-        _kwargs: T.untyped
+        _kwargs: T::Hash[T.untyped, T.untyped]
       ).void
     end
     def initialize(section:, client:, projects: Checkoff::Projects.new(client:), sections: Checkoff::Sections.new(client:), custom_fields: Checkoff::CustomFields.new(client:), **_kwargs); end
@@ -6910,6 +6969,7 @@ end
 
 # include this to add ability to log at different levels
 module Logging
+  # @sg-ignore
   sig { returns(::Logger) }
   def logger; end
 
@@ -6937,26 +6997,3 @@ module Logging
   sig { returns(Symbol) }
   def log_level; end
 end
-
-module T
-  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
-  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
-  # _@param_ `type`
-  sig { params(type: T.any(T::Types::Base, T.class_of(Object))).returns(T::Types::Base) }
-  def self.nilable(type); end
-
-  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
-  # _@param_ `obj`
-  # 
-  # _@param_ `type`
-  sig { params(obj: BasicObject, type: T.any(T::Types::Base, T.class_of(Object))).returns(BasicObject) }
-  def self.let(obj, type); end
-
-  # sord warn - T::Types::Base wasn't able to be resolved to a constant in this project
-  sig { returns(T::Types::Base) }
-  def self.untyped; end
-
-  class Struct
-    extend T::Props::ClassMethods
-  end
-end