checkoff 0.226.0 → 0.228.0

data/rbi/checkoff.rbi

@@ -1,4 +1,2414 @@
-# typed: strong
+# typed: true
+module Logging
+  sig { returns(T.untyped) }
+  def logger; end
+
+  sig { params(message: T.untyped, block: T.untyped).returns(T.untyped) }
+  def error(message = nil, &block); end
+
+  sig { params(message: T.untyped, block: T.untyped).returns(T.untyped) }
+  def warn(message = nil, &block); end
+
+  sig { params(message: T.untyped, block: T.untyped).returns(T.untyped) }
+  def info(message = nil, &block); end
+
+  sig { params(message: T.untyped, block: T.untyped).returns(T.untyped) }
+  def debug(message = nil, &block); end
+
+  sig { params(message: T.untyped, block: T.untyped).returns(T.untyped) }
+  def finer(message = nil, &block); end
+
+  sig { returns(T.untyped) }
+  def log_level; end
+end
+
+module Asana
+  module Resources
+    class Resource
+      sig { returns(T.untyped) }
+      def marshal_dump; end
+
+      sig { params(data: T.untyped).returns(T.untyped) }
+      def marshal_load(data); end
+    end
+  end
+end
+
+module Overcommit
+  module Hook
+    module PreCommit
+      class CircleCi < Base
+        sig { returns(T.untyped) }
+        def run; end
+      end
+
+      class Punchlist < Base
+        sig { params(stdout: T.untyped).returns(T.untyped) }
+        def parse_output(stdout); end
+
+        sig { returns(T.untyped) }
+        def files_glob; end
+
+        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'
+
+  class Attachments
+    include Logging
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        workspaces: T.untyped,
+        clients: T.untyped,
+        client: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
+
+    sig do
+      params(
+        url: T.untyped,
+        resource: T.untyped,
+        attachment_name: T.untyped,
+        verify_mode: T.untyped,
+        just_the_url: T.untyped
+      ).returns(T.untyped)
+    end
+    def create_attachment_from_url!(url, resource, attachment_name: nil, verify_mode: OpenSSL::SSL::VERIFY_PEER, just_the_url: false); end
+
+    sig { params(uri: T.untyped, verify_mode: T.untyped, block: T.untyped).returns(T.untyped) }
+    def download_uri(uri, verify_mode: OpenSSL::SSL::VERIFY_PEER, &block); end
+
+    sig { params(response: T.untyped).returns(T.untyped) }
+    def write_tempfile_from_response(response); end
+
+    sig do
+      params(
+        url: T.untyped,
+        resource: T.untyped,
+        attachment_name: T.untyped,
+        verify_mode: T.untyped
+      ).returns(T.untyped)
+    end
+    def create_attachment_from_downloaded_url!(url, resource, attachment_name:, verify_mode: OpenSSL::SSL::VERIFY_PEER); end
+
+    sig { params(url: T.untyped, resource: T.untyped, attachment_name: T.untyped).returns(T.untyped) }
+    def create_attachment_from_url_alone!(url, resource, attachment_name:); end
+
+    sig { params(filename: T.untyped).returns(T.untyped) }
+    def content_type_from_filename(filename); end
+
+    sig { params(response: T.untyped).returns(T.untyped) }
+    def parse(response); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class MvSubcommand
+    sig { params(from_workspace_arg: T.untyped, from_project_arg: T.untyped, from_section_arg: T.untyped).returns(T.untyped) }
+    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) }
+    def create_to_project_name(to_project_arg); end
+
+    sig { params(to_section_arg: T.untyped).returns(T.untyped) }
+    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) }
+    def validate_and_assign_to_location(to_workspace_arg, to_project_arg, to_section_arg); end
+
+    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
+      ).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) }
+    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) }
+    def fetch_tasks(from_workspace_name, from_project_name, from_section_name); end
+
+    sig { returns(T.untyped) }
+    def run; end
+
+    sig { returns(T.untyped) }
+    attr_reader :from_workspace_name
+
+    sig { returns(T.untyped) }
+    attr_reader :from_project_name
+
+    sig { returns(T.untyped) }
+    attr_reader :from_section_name
+
+    sig { returns(T.untyped) }
+    attr_reader :to_workspace_name
+
+    sig { returns(T.untyped) }
+    attr_reader :to_project_name
+
+    sig { returns(T.untyped) }
+    attr_reader :to_section_name
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :sections
+
+    sig { params(project_arg: T.untyped).returns(T.untyped) }
+    def project_arg_to_name(project_arg); end
+  end
+
+  class ViewSubcommand
+    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
+      ).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) }
+    def run; end
+
+    sig { params(project_name: T.untyped).returns(T.untyped) }
+    def validate_and_assign_project_name(project_name); end
+
+    sig { params(workspace: T.untyped, project: T.untyped).returns(T.untyped) }
+    def run_on_project(workspace, project); end
+
+    sig { params(workspace: T.untyped, project: T.untyped, section: T.untyped).returns(T.untyped) }
+    def run_on_section(workspace, project, section); end
+
+    sig do
+      params(
+        workspace: T.untyped,
+        project: T.untyped,
+        section: T.untyped,
+        task_name: T.untyped
+      ).returns(T.untyped)
+    end
+    def run_on_task(workspace, project, section, task_name); end
+
+    sig { params(task: T.untyped).returns(T.untyped) }
+    def task_to_hash(task); end
+
+    sig { params(tasks: T.untyped).returns(T.untyped) }
+    def tasks_to_hash(tasks); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspace_name
+
+    sig { returns(T.untyped) }
+    attr_reader :project_name
+
+    sig { returns(T.untyped) }
+    attr_reader :section_name
+
+    sig { returns(T.untyped) }
+    attr_reader :task_name
+
+    sig { returns(T.untyped) }
+    attr_reader :sections
+
+    sig { returns(T.untyped) }
+    attr_reader :tasks
+
+    sig { returns(T.untyped) }
+    attr_reader :stderr
+  end
+
+  class QuickaddSubcommand
+    sig do
+      params(
+        workspace_name: T.untyped,
+        task_name: T.untyped,
+        config: T.untyped,
+        workspaces: T.untyped,
+        tasks: T.untyped
+      ).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) }
+    def run; end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspace_name
+
+    sig { returns(T.untyped) }
+    attr_reader :task_name
+  end
+
+  class CheckoffGLIApp
+    extend ::GLI::App
+  end
+
+  class Clients
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig { params(config: T.untyped, asana_client_class: T.untyped).void }
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), asana_client_class: Asana::Client); end
+
+    sig { returns(T.untyped) }
+    def client; end
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class CustomFields
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        clients: T.untyped,
+        client: T.untyped,
+        workspaces: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config:), client: clients.client, workspaces: Checkoff::Workspaces.new(config:,
+                                                        client:)); end
+
+    sig { params(workspace_name: T.untyped, custom_field_name: T.untyped).returns(T.untyped) }
+    def custom_field_or_raise(workspace_name, custom_field_name); end
+
+    sig { params(workspace_name: T.untyped, custom_field_name: T.untyped).returns(T.untyped) }
+    def custom_field(workspace_name, custom_field_name); end
+
+    sig { params(resource: T.untyped, custom_field_gid: T.untyped).returns(T.untyped) }
+    def resource_custom_field_values_gids_or_raise(resource, custom_field_gid); end
+
+    sig { params(resource: T.untyped, custom_field_name: T.untyped).returns(T.untyped) }
+    def resource_custom_field_values_names_by_name(resource, custom_field_name); end
+
+    sig { params(resource: T.untyped, custom_field_name: T.untyped).returns(T.untyped) }
+    def resource_custom_field_by_name(resource, custom_field_name); end
+
+    sig { params(resource: T.untyped, custom_field_name: T.untyped).returns(T.untyped) }
+    def resource_custom_field_by_name_or_raise(resource, custom_field_name); end
+
+    sig { params(resource: T.untyped, custom_field_gid: T.untyped).returns(T.untyped) }
+    def resource_custom_field_by_gid_or_raise(resource, custom_field_gid); end
+
+    sig { params(custom_field: T.untyped).returns(T.untyped) }
+    def resource_custom_field_enum_values(custom_field); end
+
+    sig { params(custom_field: T.untyped, enum_value: T.untyped).returns(T.untyped) }
+    def find_gids(custom_field, enum_value); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class Events
+    include Logging
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        workspaces: T.untyped,
+        tasks: T.untyped,
+        sections: T.untyped,
+        projects: T.untyped,
+        clients: T.untyped,
+        client: T.untyped,
+        asana_event_filter_class: T.untyped,
+        asana_event_enrichment: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), tasks: Checkoff::Tasks.new(config:), sections: Checkoff::Sections.new(config:), projects: Checkoff::Projects.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client, asana_event_filter_class: Checkoff::Internal::AsanaEventFilter, asana_event_enrichment: Checkoff::Internal::AsanaEventEnrichment.new); end
+
+    sig { params(filters: T.untyped, asana_events: T.untyped).returns(T.untyped) }
+    def filter_asana_events(filters, asana_events); end
+
+    sig { params(asana_event: T.untyped).returns(T.untyped) }
+    def enrich_event(asana_event); end
+
+    sig { params(filter: T.untyped).returns(T.untyped) }
+    def enrich_filter(filter); end
+
+    sig { params(webhook_subscription: T.untyped).returns(T.untyped) }
+    def enrich_webhook_subscription!(webhook_subscription); end
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :sections
+
+    sig { returns(T.untyped) }
+    attr_reader :tasks
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    attr_reader :asana_event_enrichment
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class ProjectSelectorEvaluator < SelectorEvaluator
+    COMMON_FUNCTION_EVALUATORS = (Checkoff::SelectorClasses::Common.constants.map do |const|
+      Checkoff::SelectorClasses::Common.const_get(const)
+    end - [Checkoff::SelectorClasses::Common::FunctionEvaluator]).freeze
+    PROJECT_FUNCTION_EVALUATORS = (Checkoff::SelectorClasses::Project.constants.map do |const|
+      Checkoff::SelectorClasses::Project.const_get(const)
+    end - [Checkoff::SelectorClasses::Project::FunctionEvaluator]).freeze
+    FUNCTION_EVALUTORS = (COMMON_FUNCTION_EVALUATORS + PROJECT_FUNCTION_EVALUATORS).freeze
+
+    sig do
+      params(
+        project: T.untyped,
+        projects: T.untyped,
+        custom_fields: T.untyped,
+        workspaces: T.untyped,
+        portfolios: T.untyped
+      ).void
+    end
+    def initialize(project:, projects: Checkoff::Projects.new, custom_fields: Checkoff::CustomFields.new, workspaces: Checkoff::Workspaces.new, portfolios: Checkoff::Portfolios.new); end
+
+    sig { returns(T.untyped) }
+    def function_evaluators; end
+
+    sig { returns(T.untyped) }
+    def initializer_kwargs; end
+
+    sig { returns(T.untyped) }
+    attr_reader :item
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :custom_fields
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :portfolios
+  end
+
+  class SectionSelectorEvaluator < SelectorEvaluator
+    COMMON_FUNCTION_EVALUATORS = (Checkoff::SelectorClasses::Common.constants.map do |const|
+      Checkoff::SelectorClasses::Common.const_get(const)
+    end - [Checkoff::SelectorClasses::Common::FunctionEvaluator]).freeze
+    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
+
+    sig do
+      params(
+        section: T.untyped,
+        client: T.untyped,
+        projects: T.untyped,
+        sections: T.untyped,
+        custom_fields: T.untyped,
+        _kwargs: 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
+
+    sig { returns(T.untyped) }
+    def function_evaluators; end
+
+    sig { returns(T.untyped) }
+    def initializer_kwargs; end
+
+    sig { returns(T.untyped) }
+    attr_reader :item
+
+    sig { returns(T.untyped) }
+    attr_reader :sections
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :custom_fields
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+  end
+
+  class SelectorEvaluator
+    sig { params(selector: T.untyped).returns(T.untyped) }
+    def evaluate(selector); end
+
+    sig { returns(T.untyped) }
+    def initializer_kwargs; end
+
+    sig { returns(T.untyped) }
+    def function_evaluators; end
+
+    sig { params(selector: T.untyped, evaluator: T.untyped).returns(T.untyped) }
+    def evaluate_args(selector, evaluator); end
+
+    sig { params(selector: T.untyped, evaluator: T.untyped).returns(T.untyped) }
+    def try_this_evaluator(selector, evaluator); end
+
+    sig { returns(T.untyped) }
+    attr_reader :item
+  end
+
+  class TaskSelectorEvaluator < SelectorEvaluator
+    COMMON_FUNCTION_EVALUATORS = (Checkoff::SelectorClasses::Common.constants.map do |const|
+      Checkoff::SelectorClasses::Common.const_get(const)
+    end - [Checkoff::SelectorClasses::Common::FunctionEvaluator]).freeze
+    TASK_FUNCTION_EVALUATORS = (Checkoff::SelectorClasses::Task.constants.map do |const|
+      Checkoff::SelectorClasses::Task.const_get(const)
+    end - [Checkoff::SelectorClasses::Task::FunctionEvaluator]).freeze
+    FUNCTION_EVALUTORS = (COMMON_FUNCTION_EVALUATORS + TASK_FUNCTION_EVALUATORS).freeze
+
+    sig do
+      params(
+        task: T.untyped,
+        tasks: T.untyped,
+        timelines: T.untyped,
+        custom_fields: T.untyped
+      ).void
+    end
+    def initialize(task:, tasks: Checkoff::Tasks.new, timelines: Checkoff::Timelines.new, custom_fields: Checkoff::CustomFields.new); end
+
+    sig { returns(T.untyped) }
+    def function_evaluators; end
+
+    sig { returns(T.untyped) }
+    def initializer_kwargs; end
+
+    sig { returns(T.untyped) }
+    attr_reader :item
+
+    sig { returns(T.untyped) }
+    attr_reader :tasks
+
+    sig { returns(T.untyped) }
+    attr_reader :timelines
+
+    sig { returns(T.untyped) }
+    attr_reader :custom_fields
+  end
+
+  class MyTasks
+    MINUTE = 60
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE * 5
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { params(config: T.untyped, client: T.untyped, projects: T.untyped).void }
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, projects: Checkoff::Projects.new(config:,
+                                                    client:)); end
+
+    sig { params(project: T.untyped, only_uncompleted: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def tasks_by_section_for_my_tasks(project, only_uncompleted: true, extra_fields: []); end
+
+    sig { params(name: T.untyped).returns(T.untyped) }
+    def section_key(name); end
+
+    sig { params(tasks: T.untyped, project_gid: T.untyped).returns(T.untyped) }
+    def by_my_tasks_section(tasks, project_gid); end
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+  end
+
+  class Portfolios
+    extend T::Sig
+    MINUTE = 60
+    HOUR = T.let(MINUTE * 60, Numeric)
+    DAY = T.let(24 * HOUR, Numeric)
+    REALLY_LONG_CACHE_TIME = T.let(HOUR * 1, Numeric)
+    LONG_CACHE_TIME = T.let(MINUTE * 15, Numeric)
+    SHORT_CACHE_TIME = T.let(MINUTE, Numeric)
+
+    sig do
+      params(
+        config: T.untyped,
+        clients: T.untyped,
+        client: T.untyped,
+        projects: T.untyped,
+        workspaces: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config:), client: clients.client, projects: Checkoff::Projects.new(config:, client:), workspaces: Checkoff::Workspaces.new(config:, client:)); end
+
+    sig { params(workspace_name: T.untyped, portfolio_name: T.untyped).returns(T.untyped) }
+    def portfolio_or_raise(workspace_name, portfolio_name); end
+
+    sig { params(workspace_name: T.untyped, portfolio_name: T.untyped).returns(T.untyped) }
+    def portfolio(workspace_name, portfolio_name); end
+
+    sig { params(portfolio_gid: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def portfolio_by_gid(portfolio_gid, extra_fields: []); end
+
+    sig { params(workspace_name: T.untyped, portfolio_name: T.untyped, extra_project_fields: T.untyped).returns(T.untyped) }
+    def projects_in_portfolio(workspace_name, portfolio_name, extra_project_fields: []); end
+
+    sig { params(portfolio: T.untyped, extra_project_fields: T.untyped).returns(T.untyped) }
+    def projects_in_portfolio_obj(portfolio, extra_project_fields: []); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class ProjectSelectors
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        workspaces: T.untyped,
+        projects: T.untyped,
+        custom_fields: T.untyped,
+        portfolios: T.untyped,
+        clients: T.untyped,
+        client: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), projects: Checkoff::Projects.new(config:), custom_fields: Checkoff::CustomFields.new(config:), portfolios: Checkoff::Portfolios.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
+
+    sig { params(project: T.untyped, project_selector: T.untyped).returns(T.untyped) }
+    def filter_via_project_selector(project, project_selector); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :custom_fields
+
+    sig { returns(T.untyped) }
+    attr_reader :portfolios
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class Projects
+    include Logging
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = MINUTE * 30
+    LONG_CACHE_TIME = MINUTE * 15
+    MEDIUM_CACHE_TIME = MINUTE * 5
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        client: T.untyped,
+        workspaces: T.untyped,
+        project_hashes: T.untyped,
+        project_timing: T.untyped,
+        timing: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, workspaces: Checkoff::Workspaces.new(config:,
+                                                        client:), project_hashes: Checkoff::Internal::ProjectHashes.new, project_timing: Checkoff::Internal::ProjectTiming.new(client:), timing: Checkoff::Timing.new); end
+
+    sig { params(extra_fields: T.untyped).returns(T.untyped) }
+    def task_fields(extra_fields: []); end
+
+    sig { params(extra_fields: T.untyped, only_uncompleted: T.untyped).returns(T.untyped) }
+    def task_options(extra_fields: [], only_uncompleted: false); end
+
+    sig { params(extra_project_fields: T.untyped).returns(T.untyped) }
+    def project_fields(extra_project_fields: []); end
+
+    sig { params(extra_project_fields: T.untyped).returns(T.untyped) }
+    def project_options(extra_project_fields: []); end
+
+    sig { params(workspace_name: T.untyped, project_name: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def project(workspace_name, project_name, extra_fields: []); end
+
+    sig { params(workspace_name: T.untyped, project_name: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def project_or_raise(workspace_name, project_name, extra_fields: []); end
+
+    sig { params(gid: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def project_by_gid(gid, extra_fields: []); end
+
+    sig { params(tasks: T.untyped).returns(T.untyped) }
+    def active_tasks(tasks); end
+
+    sig { params(project: T.untyped, only_uncompleted: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def tasks_from_project(project, only_uncompleted: true, extra_fields: []); end
+
+    sig { params(project_gid: T.untyped, only_uncompleted: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def tasks_from_project_gid(project_gid, only_uncompleted: true, extra_fields: []); end
+
+    sig { params(workspace_name: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def projects_by_workspace_name(workspace_name, extra_fields: []); end
+
+    sig { params(project_obj: T.untyped, project: T.untyped).returns(T.untyped) }
+    def project_to_h(project_obj, project: :not_specified); end
+
+    sig { params(project: T.untyped, period: T.untyped).returns(T.untyped) }
+    def project_ready?(project, period: :now_or_before); end
+
+    sig { params(project: T.untyped, field_name: T.untyped, period: T.untyped).returns(T.untyped) }
+    def in_period?(project, field_name, period); end
+
+    sig { returns(T.untyped) }
+    def as_cache_key; end
+
+    sig { returns(T.untyped) }
+    attr_reader :timing
+
+    sig { returns(T.untyped) }
+    attr_reader :project_timing
+
+    sig { returns(T.untyped) }
+    attr_reader :project_hashes
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    def projects; end
+
+    sig { params(workspace_name: T.untyped).returns(T.untyped) }
+    def my_tasks(workspace_name); end
+  end
+
+  class Resources
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        workspaces: T.untyped,
+        tasks: T.untyped,
+        sections: T.untyped,
+        projects: T.untyped,
+        clients: T.untyped,
+        client: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), tasks: Checkoff::Tasks.new(config:), sections: Checkoff::Sections.new(config:), projects: Checkoff::Projects.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
+
+    sig { params(gid: T.untyped, resource_type: T.untyped).returns(T.untyped) }
+    def resource_by_gid(gid, resource_type: nil); end
+
+    sig { params(gid: T.untyped).returns(T.untyped) }
+    def fetch_task_gid(gid); end
+
+    sig { params(section_gid: T.untyped).returns(T.untyped) }
+    def fetch_section_gid(section_gid); end
+
+    sig { params(project_gid: T.untyped).returns(T.untyped) }
+    def fetch_project_gid(project_gid); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :sections
+
+    sig { returns(T.untyped) }
+    attr_reader :tasks
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class SectionSelectors
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        workspaces: T.untyped,
+        sections: T.untyped,
+        custom_fields: T.untyped,
+        clients: T.untyped,
+        client: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), sections: Checkoff::Sections.new(config:), custom_fields: Checkoff::CustomFields.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
+
+    sig { params(section: T.untyped, section_selector: T.untyped).returns(T.untyped) }
+    def filter_via_section_selector(section, section_selector); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :sections
+
+    sig { returns(T.untyped) }
+    attr_reader :custom_fields
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class Sections
+    include Logging
+    extend Forwardable
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    REALLY_LONG_CACHE_TIME = MINUTE * 30
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE * 5
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :time
+
+    sig { returns(T.untyped) }
+    attr_reader :my_tasks
+
+    sig do
+      params(
+        config: T.untyped,
+        client: T.untyped,
+        projects: T.untyped,
+        workspaces: T.untyped,
+        time: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, projects: Checkoff::Projects.new(config:,
+                                                    client:), workspaces: Checkoff::Workspaces.new(config:,
+                                                        client:), time: Time); end
+
+    sig { params(workspace_name: T.untyped, project_name: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def sections_or_raise(workspace_name, project_name, extra_fields: []); end
+
+    sig { params(project_gid: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def sections_by_project_gid(project_gid, extra_fields: []); end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        project_name: T.untyped,
+        only_uncompleted: T.untyped,
+        extra_fields: T.untyped
+      ).returns(T.untyped)
+    end
+    def tasks_by_section(workspace_name, project_name, only_uncompleted: true, extra_fields: []); end
+
+    sig { params(section_gid: T.untyped, only_uncompleted: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def tasks_by_section_gid(section_gid, only_uncompleted: true, extra_fields: []); end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        project_name: T.untyped,
+        section_name: T.untyped,
+        only_uncompleted: T.untyped,
+        extra_fields: T.untyped
+      ).returns(T.untyped)
+    end
+    def tasks(workspace_name, project_name, section_name, only_uncompleted: true, extra_fields: []); end
+
+    sig { params(workspace_name: T.untyped, project_name: T.untyped, section_name: T.untyped).returns(T.untyped) }
+    def section_task_names(workspace_name, project_name, section_name); end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        project_name: T.untyped,
+        section_name: T.untyped,
+        extra_section_fields: T.untyped
+      ).returns(T.untyped)
+    end
+    def section_or_raise(workspace_name, project_name, section_name, extra_section_fields: []); end
+
+    sig { params(name: T.untyped).returns(T.untyped) }
+    def section_key(name); end
+
+    sig { params(section: T.untyped).returns(T.untyped) }
+    def previous_section(section); end
+
+    sig { params(gid: T.untyped).returns(T.untyped) }
+    def section_by_gid(gid); end
+
+    sig { returns(T.untyped) }
+    def as_cache_key; end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        project_name: T.untyped,
+        section_name: T.untyped,
+        extra_section_fields: T.untyped
+      ).returns(T.untyped)
+    end
+    def section(workspace_name, project_name, section_name, extra_section_fields: []); end
+
+    sig { params(response: T.untyped).returns(T.untyped) }
+    def parse(response); end
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { params(project: T.untyped, only_uncompleted: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def tasks_by_section_for_project(project, only_uncompleted: true, extra_fields: []); end
+
+    sig { params(tasks: T.untyped, project_gid: T.untyped).returns(T.untyped) }
+    def by_section(tasks, project_gid); end
+
+    sig { params(by_section: T.untyped, task: T.untyped, project_gid: T.untyped).returns(T.untyped) }
+    def file_task_by_section(by_section, task, project_gid); end
+
+    sig { params(workspace_name: T.untyped, project_name: T.untyped).returns(T.untyped) }
+    def project_or_raise(workspace_name, project_name); end
+  end
+
+  class Subtasks
+    extend Forwardable
+    MINUTE = 60
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE * 5
+
+    sig { params(config: T.untyped, projects: T.untyped, clients: T.untyped).void }
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), projects: Checkoff::Projects.new(config:), clients: Checkoff::Clients.new(config:)); end
+
+    sig { params(task: T.untyped).returns(T.untyped) }
+    def all_subtasks_completed?(task); end
+
+    sig { params(tasks: T.untyped).returns(T.untyped) }
+    def by_section(tasks); end
+
+    sig { params(task: T.untyped).returns(T.untyped) }
+    def raw_subtasks(task); end
+
+    sig { params(task_gid: T.untyped, extra_fields: T.untyped, only_uncompleted: T.untyped).returns(T.untyped) }
+    def subtasks_by_gid(task_gid, extra_fields: [], only_uncompleted: true); end
+
+    sig { params(subtask: T.untyped).returns(T.untyped) }
+    def subtask_section?(subtask); end
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { params(current_section: T.untyped, by_section: T.untyped, task: T.untyped).returns(T.untyped) }
+    def file_task_by_section(current_section, by_section, task); end
+  end
+
+  class Tags
+    MINUTE = 60
+    HOUR = T.let(MINUTE * 60, Numeric)
+    DAY = T.let(24 * HOUR, Numeric)
+    REALLY_LONG_CACHE_TIME = T.let(HOUR * 1, Numeric)
+    LONG_CACHE_TIME = T.let(MINUTE * 15, Numeric)
+    SHORT_CACHE_TIME = T.let(MINUTE, Numeric)
+
+    sig do
+      params(
+        config: T.untyped,
+        clients: T.untyped,
+        client: T.untyped,
+        projects: T.untyped,
+        workspaces: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config:), client: clients.client, projects: Checkoff::Projects.new(config:, client:), workspaces: Checkoff::Workspaces.new(config:, client:)); end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        tag_name: T.untyped,
+        only_uncompleted: T.untyped,
+        extra_fields: T.untyped
+      ).returns(T.untyped)
+    end
+    def tasks(workspace_name, tag_name, only_uncompleted: true, extra_fields: []); end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        tag_gid: T.untyped,
+        only_uncompleted: T.untyped,
+        extra_fields: T.untyped
+      ).returns(T.untyped)
+    end
+    def tasks_by_tag_gid(workspace_name, tag_gid, only_uncompleted: true, extra_fields: []); end
+
+    sig { params(workspace_name: T.untyped, tag_name: T.untyped).returns(T.untyped) }
+    def tag_or_raise(workspace_name, tag_name); end
+
+    sig { params(workspace_name: T.untyped, tag_name: T.untyped).returns(T.untyped) }
+    def tag(workspace_name, tag_name); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { params(options: T.untyped).returns(T.untyped) }
+    def build_params(options); end
+
+    sig { params(response: T.untyped).returns(T.untyped) }
+    def parse(response); end
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class TaskSearches
+    include Logging
+    include Asana::Resources::ResponseHelper
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        workspaces: T.untyped,
+        task_selectors: T.untyped,
+        projects: T.untyped,
+        clients: T.untyped,
+        client: T.untyped,
+        search_url_parser: T.untyped,
+        asana_resources_collection_class: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), task_selectors: Checkoff::TaskSelectors.new(config:), projects: Checkoff::Projects.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client, search_url_parser: Checkoff::Internal::SearchUrl::Parser.new, asana_resources_collection_class: Asana::Resources::Collection); end
+
+    sig { params(workspace_name: T.untyped, url: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def task_search(workspace_name, url, extra_fields: []); end
+
+    sig do
+      params(
+        api_params: T.untyped,
+        workspace_gid: T.untyped,
+        extra_fields: T.untyped,
+        task_selector: T.untyped,
+        fetch_all: T.untyped
+      ).returns(T.untyped)
+    end
+    def raw_task_search(api_params, workspace_gid:, extra_fields: [], task_selector: [], fetch_all: true); end
+
+    sig { returns(T.untyped) }
+    def as_cache_key; end
+
+    sig { params(api_params: T.untyped, workspace_gid: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def api_task_search_request(api_params, workspace_gid:, extra_fields:); end
+
+    sig { params(api_params: T.untyped, workspace_gid: T.untyped, extra_fields: T.untyped).returns(T.untyped) }
+    def iterated_raw_task_search(api_params, workspace_gid:, extra_fields:); end
+
+    sig { params(extra_fields: T.untyped).returns(T.untyped) }
+    def calculate_api_options(extra_fields); end
+
+    sig { returns(T.untyped) }
+    def self.run; end
+
+    sig { returns(T.untyped) }
+    attr_reader :task_selectors
+
+    sig { returns(T.untyped) }
+    attr_reader :projects
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+  end
+
+  class TaskSelectors
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        client: T.untyped,
+        tasks: T.untyped,
+        timelines: T.untyped,
+        custom_fields: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, tasks: Checkoff::Tasks.new(config:,
+                                              client:), timelines: Checkoff::Timelines.new(config:,
+                                                      client:), custom_fields: Checkoff::CustomFields.new(config:,
+                                                             client:)); end
+
+    sig { params(task: T.untyped, task_selector: T.untyped).returns(T.untyped) }
+    def filter_via_task_selector(task, task_selector); end
+
+    sig { returns(T.untyped) }
+    attr_reader :tasks
+
+    sig { returns(T.untyped) }
+    attr_reader :timelines
+
+    sig { returns(T.untyped) }
+    attr_reader :custom_fields
+
+    sig { returns(T.untyped) }
+    def self.project_name; end
+
+    sig { returns(T.untyped) }
+    def self.workspace_name; end
+
+    sig { returns(T.untyped) }
+    def self.task_selector; end
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class Tasks
+    include Logging
+    extend T::Sig
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = MINUTE * 30
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE * 5
+
+    sig do
+      params(
+        config: T.untyped,
+        client: T.untyped,
+        workspaces: T.untyped,
+        sections: T.untyped,
+        portfolios: T.untyped,
+        custom_fields: T.untyped,
+        time_class: T.untyped,
+        date_class: T.untyped,
+        asana_task: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, workspaces: Checkoff::Workspaces.new(config:,
+                                                        client:), sections: Checkoff::Sections.new(config:,
+                                                    client:), portfolios: Checkoff::Portfolios.new(config:,
+                                                        client:), custom_fields: Checkoff::CustomFields.new(config:,
+                                                             client:), time_class: Time, date_class: Date, asana_task: Asana::Resources::Task); end
+
+    sig { params(task: T.untyped, period: T.untyped, ignore_dependencies: T.untyped).returns(T.untyped) }
+    def task_ready?(task, period: :now_or_before, ignore_dependencies: false); end
+
+    sig { params(task: T.untyped, field_name: T.untyped, period: T.untyped).returns(T.untyped) }
+    def in_period?(task, field_name, period); end
+
+    sig { params(task: T.untyped, field_name: T.untyped).returns(T.untyped) }
+    def date_or_time_field_by_name(task, field_name); end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        project_name: T.untyped,
+        task_name: T.untyped,
+        section_name: T.untyped,
+        only_uncompleted: T.untyped,
+        extra_fields: T.untyped
+      ).returns(T.untyped)
+    end
+    def task(workspace_name, project_name, task_name, section_name: :unspecified, only_uncompleted: true, extra_fields: []); end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        project_name: T.untyped,
+        section_name: T.untyped,
+        task_name: T.untyped
+      ).returns(T.untyped)
+    end
+    def gid_for_task(workspace_name, project_name, section_name, task_name); end
+
+    sig { params(task_gid: T.untyped, extra_fields: T.untyped, only_uncompleted: T.untyped).returns(T.untyped) }
+    def task_by_gid(task_gid, extra_fields: [], only_uncompleted: true); end
+
+    sig { params(name: T.untyped, workspace_gid: T.untyped, assignee_gid: T.untyped).returns(T.untyped) }
+    def add_task(name, workspace_gid: @workspaces.default_workspace_gid, assignee_gid: default_assignee_gid); end
+
+    sig { params(task: T.untyped).returns(T.untyped) }
+    def url_of_task(task); end
+
+    sig { params(task: T.untyped).returns(T.untyped) }
+    def incomplete_dependencies?(task); end
+
+    sig { params(task: T.untyped, extra_task_fields: T.untyped).returns(T.untyped) }
+    def all_dependent_tasks(task, extra_task_fields: []); end
+
+    sig { params(task: T.untyped).returns(T.untyped) }
+    def task_to_h(task); end
+
+    sig { params(task_data: T.untyped).returns(T.untyped) }
+    def h_to_task(task_data); end
+
+    sig { params(task: T.untyped, portfolio_name: T.untyped, workspace_name: T.untyped).returns(T.untyped) }
+    def in_portfolio_named?(task, portfolio_name, workspace_name: @workspaces.default_workspace.name); end
+
+    sig { params(task: T.untyped, portfolio_name: T.untyped, workspace_name: T.untyped).returns(T.untyped) }
+    def in_portfolio_more_than_once?(task, portfolio_name, workspace_name: @workspaces.default_workspace.name); end
+
+    sig { returns(T.untyped) }
+    def as_cache_key; end
+
+    sig { returns(T.untyped) }
+    def task_timing; end
+
+    sig { returns(T.untyped) }
+    def task_hashes; end
+
+    sig do
+      params(
+        workspace_name: T.untyped,
+        project_name: T.untyped,
+        only_uncompleted: T.untyped,
+        extra_fields: T.untyped,
+        section_name: T.untyped
+      ).returns(T.untyped)
+    end
+    def tasks(workspace_name, project_name, only_uncompleted:, extra_fields: [], section_name: :unspecified); end
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    attr_reader :timing
+
+    sig { returns(T.untyped) }
+    attr_reader :custom_fields
+
+    sig { returns(T.untyped) }
+    def projects; end
+
+    sig { returns(T.untyped) }
+    def default_assignee_gid; end
+  end
+
+  class Timelines
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig do
+      params(
+        config: T.untyped,
+        workspaces: T.untyped,
+        sections: T.untyped,
+        tasks: T.untyped,
+        portfolios: T.untyped,
+        clients: T.untyped,
+        client: T.untyped
+      ).void
+    end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), sections: Checkoff::Sections.new(config:), tasks: Checkoff::Tasks.new(config:), portfolios: Checkoff::Portfolios.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
+
+    sig { params(task: T.untyped, limit_to_portfolio_gid: T.untyped).returns(T.untyped) }
+    def task_dependent_on_previous_section_last_milestone?(task, limit_to_portfolio_gid: nil); end
+
+    sig { params(task: T.untyped, limit_to_portfolio_name: T.untyped).returns(T.untyped) }
+    def last_task_milestone_depends_on_this_task?(task, limit_to_portfolio_name: nil); end
+
+    sig { params(task: T.untyped, limit_to_portfolio_name: T.untyped).returns(T.untyped) }
+    def any_milestone_depends_on_this_task?(task, limit_to_portfolio_name: nil); end
+
+    sig { params(section_gid: T.untyped).returns(T.untyped) }
+    def last_milestone_in_section(section_gid); end
+
+    sig { params(task_data: T.untyped, section: T.untyped).returns(T.untyped) }
+    def task_data_dependent_on_previous_section_last_milestone?(task_data, section); end
+
+    sig { returns(T.untyped) }
+    attr_reader :workspaces
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class Timing
+    include Logging
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+    WDAY_FROM_DAY_OF_WEEK = {
+      monday: 1,
+      tuesday: 2,
+      wednesday: 3,
+      thursday: 4,
+      friday: 5,
+      saturday: 6,
+      sunday: 0,
+    }.freeze
+
+    sig { params(today_getter: T.untyped, now_getter: T.untyped).void }
+    def initialize(today_getter: Date, now_getter: Time); end
+
+    sig { params(date_or_time: T.untyped, period: T.untyped).returns(T.untyped) }
+    def in_period?(date_or_time, period); end
+
+    sig { params(date_or_time: T.untyped, num_days: T.untyped).returns(T.untyped) }
+    def greater_than_or_equal_to_n_days_from_today?(date_or_time, num_days); end
+
+    sig { params(date_or_time: T.untyped, num_days: T.untyped).returns(T.untyped) }
+    def greater_than_or_equal_to_n_days_from_now?(date_or_time, num_days); end
+
+    sig { params(date_or_time: T.untyped, num_days: T.untyped).returns(T.untyped) }
+    def less_than_n_days_ago?(date_or_time, num_days); end
+
+    sig { params(date_or_time: T.untyped, num_days: T.untyped).returns(T.untyped) }
+    def less_than_n_days_from_now?(date_or_time, num_days); end
+
+    sig { params(date_or_time: T.untyped).returns(T.untyped) }
+    def this_week?(date_or_time); end
+
+    sig { params(date_or_time: T.untyped).returns(T.untyped) }
+    def next_week?(date_or_time); end
+
+    sig { params(date_or_time: T.untyped, day_of_week: T.untyped).returns(T.untyped) }
+    def day_of_week?(date_or_time, day_of_week); end
+
+    sig { params(date_or_time: T.untyped).returns(T.untyped) }
+    def now_or_before?(date_or_time); end
+
+    sig { params(num_days: T.untyped).returns(T.untyped) }
+    def n_days_from_now(num_days); end
+
+    sig { params(num_days: T.untyped).returns(T.untyped) }
+    def n_days_from_today(num_days); end
+
+    sig { params(date_or_time: T.untyped, beginning_num_days_from_now: T.untyped, end_num_days_from_now: T.untyped).returns(T.untyped) }
+    def between_relative_days?(date_or_time, beginning_num_days_from_now, end_num_days_from_now); end
+
+    sig { params(date_or_time: T.untyped, period_name: T.untyped, args: T.untyped).returns(T.untyped) }
+    def compound_in_period?(date_or_time, period_name, *args); end
+
+    sig { returns(T.untyped) }
+    def self.run; end
+  end
+
+  class Workspaces
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    sig { params(config: T.untyped, client: T.untyped, asana_workspace: T.untyped).void }
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, asana_workspace: Asana::Resources::Workspace); end
+
+    sig { params(workspace_name: T.untyped).returns(T.untyped) }
+    def workspace(workspace_name); end
+
+    sig { returns(T.untyped) }
+    def default_workspace; end
+
+    sig { params(workspace_name: T.untyped).returns(T.untyped) }
+    def workspace_or_raise(workspace_name); end
+
+    sig { returns(T.untyped) }
+    def default_workspace_gid; end
+
+    sig { returns(T.untyped) }
+    attr_reader :client
+  end
+
+  module Internal
+    class AsanaEventEnrichment
+      include Logging
+
+      sig do
+        params(
+          config: T.untyped,
+          workspaces: T.untyped,
+          tasks: T.untyped,
+          sections: T.untyped,
+          projects: T.untyped,
+          resources: T.untyped,
+          clients: T.untyped,
+          client: T.untyped
+        ).void
+      end
+      def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), tasks: Checkoff::Tasks.new(config:), sections: Checkoff::Sections.new(config:), projects: Checkoff::Projects.new(config:), resources: Checkoff::Resources.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
+
+      sig { params(asana_event: T.untyped).returns(T.untyped) }
+      def enrich_event(asana_event); end
+
+      sig { params(filter: T.untyped).returns(T.untyped) }
+      def enrich_filter(filter); end
+
+      sig { params(webhook_subscription: T.untyped).returns(T.untyped) }
+      def enrich_webhook_subscription!(webhook_subscription); end
+
+      sig { params(gid: T.untyped, resource_type: T.untyped).returns(T.untyped) }
+      def enrich_gid(gid, resource_type: nil); end
+
+      sig { params(filter: T.untyped).returns(T.untyped) }
+      def enrich_filter_parent_gid!(filter); end
+
+      sig { params(filter: T.untyped).returns(T.untyped) }
+      def enrich_filter_resource!(filter); end
+
+      sig { params(filter: T.untyped).returns(T.untyped) }
+      def enrich_filter_section!(filter); end
+
+      sig { params(asana_event: T.untyped).returns(T.untyped) }
+      def enrich_event_parent!(asana_event); end
+
+      sig { params(asana_event: T.untyped).returns(T.untyped) }
+      def enrich_event_resource!(asana_event); end
+
+      sig { returns(T.untyped) }
+      attr_reader :projects
+
+      sig { returns(T.untyped) }
+      attr_reader :sections
+
+      sig { returns(T.untyped) }
+      attr_reader :tasks
+
+      sig { returns(T.untyped) }
+      attr_reader :workspaces
+
+      sig { returns(T.untyped) }
+      attr_reader :resources
+
+      sig { returns(T.untyped) }
+      attr_reader :client
+    end
+
+    class AsanaEventFilter
+      include Logging
+
+      sig do
+        params(
+          filters: T.untyped,
+          clients: T.untyped,
+          tasks: T.untyped,
+          client: T.untyped
+        ).void
+      end
+      def initialize(filters:, clients: Checkoff::Clients.new, tasks: Checkoff::Tasks.new, client: clients.client); end
+
+      sig { params(asana_event: T.untyped).returns(T.untyped) }
+      def matches?(asana_event); end
+
+      sig { params(filter: T.untyped, asana_event: T.untyped, failures: T.untyped).returns(T.untyped) }
+      def filter_matches_asana_event?(filter, asana_event, failures); end
+
+      sig { params(key: T.untyped, value: T.untyped, asana_event: T.untyped).returns(T.untyped) }
+      def asana_event_matches_filter_item?(key, value, asana_event); end
+
+      sig { params(key: T.untyped, asana_event: T.untyped, fields: T.untyped).returns(T.untyped) }
+      def uncached_fetch_task(key, asana_event, fields); end
+    end
+
+    class EnvFallbackConfigLoader
+      sig { params(config: T.untyped, sym: T.untyped, yaml_filename: T.untyped).void }
+      def initialize(config, sym, yaml_filename); end
+
+      sig { params(key: T.untyped).returns(T.untyped) }
+      def [](key); end
+
+      sig { params(key: T.untyped).returns(T.untyped) }
+      def fetch(key); end
+
+      sig { params(key: T.untyped).returns(T.untyped) }
+      def envvar_name(key); end
+    end
+
+    class ConfigLoader
+      sig { params(sym: T.untyped).returns(T.untyped) }
+      def self.load(sym); end
+
+      sig { params(sym: T.untyped).returns(T.untyped) }
+      def self.load_yaml_file(sym); end
+
+      sig { params(sym: T.untyped).returns(T.untyped) }
+      def self.yaml_filename(sym); end
+    end
+
+    class ProjectHashes
+      sig { params(_deps: T.untyped).void }
+      def initialize(_deps = {}); end
+
+      sig { params(project_obj: T.untyped, project: T.untyped).returns(T.untyped) }
+      def project_to_h(project_obj, project: :not_specified); end
+
+      sig { params(project_hash: T.untyped).returns(T.untyped) }
+      def unwrap_custom_fields(project_hash); end
+    end
+
+    class ProjectTiming
+      sig do
+        params(
+          time_class: T.untyped,
+          date_class: T.untyped,
+          client: T.untyped,
+          custom_fields: T.untyped
+        ).void
+      end
+      def initialize(time_class: Time, date_class: Date, client: Checkoff::Clients.new.client, custom_fields: Checkoff::CustomFields.new(client:)); end
+
+      sig { params(project: T.untyped).returns(T.untyped) }
+      def start_date(project); end
+
+      sig { params(project: T.untyped).returns(T.untyped) }
+      def due_date(project); end
+
+      sig { params(project: T.untyped, custom_field_name: T.untyped).returns(T.untyped) }
+      def custom_field(project, custom_field_name); end
+
+      sig { params(project: T.untyped, field_name: T.untyped).returns(T.untyped) }
+      def date_or_time_field_by_name(project, field_name); end
+    end
+
+    class TaskHashes
+      sig { params(task: T.untyped).returns(T.untyped) }
+      def task_to_h(task); end
+
+      sig { params(task_data: T.untyped, client: T.untyped).returns(T.untyped) }
+      def h_to_task(task_data, client:); end
+
+      sig { params(task_hash: T.untyped).returns(T.untyped) }
+      def unwrap_custom_fields(task_hash); end
+
+      sig { params(task_hash: T.untyped, memberships: T.untyped).returns(T.untyped) }
+      def add_user_task_list(task_hash, memberships); end
+
+      sig do
+        params(
+          task_hash: T.untyped,
+          memberships: T.untyped,
+          resource: T.untyped,
+          key: T.untyped
+        ).returns(T.untyped)
+      end
+      def unwrap_memberships(task_hash, memberships, resource, key); end
+
+      sig { params(task_hash: T.untyped).returns(T.untyped) }
+      def unwrap_all_memberships(task_hash); end
+    end
+
+    class TaskTiming
+      sig do
+        params(
+          time_class: T.untyped,
+          date_class: T.untyped,
+          client: T.untyped,
+          custom_fields: T.untyped
+        ).void
+      end
+      def initialize(time_class: Time, date_class: Date, client: Checkoff::Clients.new.client, custom_fields: Checkoff::CustomFields.new(client:)); end
+
+      sig { params(task: T.untyped).returns(T.untyped) }
+      def start_time(task); end
+
+      sig { params(task: T.untyped).returns(T.untyped) }
+      def due_time(task); end
+
+      sig { params(task: T.untyped).returns(T.untyped) }
+      def start_date_or_time(task); end
+
+      sig { params(task: T.untyped).returns(T.untyped) }
+      def due_date_or_time(task); end
+
+      sig { params(task: T.untyped).returns(T.untyped) }
+      def modified_time(task); end
+
+      sig { params(task: T.untyped, custom_field_name: T.untyped).returns(T.untyped) }
+      def custom_field(task, custom_field_name); end
+
+      sig { params(task: T.untyped, field_name: T.untyped).returns(T.untyped) }
+      def date_or_time_field_by_name(task, field_name); end
+    end
+
+    class ThreadLocal
+      sig { params(name: T.untyped, value: T.untyped, block: T.untyped).returns(T.untyped) }
+      def with_thread_local_variable(name, value, &block); end
+    end
+
+    module SearchUrl
+      class CustomFieldParamConverter
+        VARIANTS = {
+          'is' => CustomFieldVariant::Is,
+          'no_value' => CustomFieldVariant::NoValue,
+          'any_value' => CustomFieldVariant::AnyValue,
+          'is_not' => CustomFieldVariant::IsNot,
+          'less_than' => CustomFieldVariant::LessThan,
+          'greater_than' => CustomFieldVariant::GreaterThan,
+          'equals' => CustomFieldVariant::Equals,
+          'doesnt_contain_any' => CustomFieldVariant::DoesntContainAny,
+          'contains_any' => CustomFieldVariant::ContainsAny,
+          'contains_all' => CustomFieldVariant::ContainsAll,
+        }.freeze
+
+        sig { params(custom_field_params: T.untyped).void }
+        def initialize(custom_field_params:); end
+
+        sig { returns(T.untyped) }
+        def convert; end
+
+        sig { returns(T.untyped) }
+        def by_custom_field; end
+
+        sig { params(gid: T.untyped, single_custom_field_params: T.untyped).returns(T.untyped) }
+        def convert_single_custom_field_params(gid, single_custom_field_params); end
+
+        sig { params(key: T.untyped).returns(T.untyped) }
+        def gid_from_custom_field_key(key); end
+
+        sig { returns(T.untyped) }
+        attr_reader :custom_field_params
+      end
+
+      module CustomFieldVariant
+        class CustomFieldVariant
+          sig { params(gid: T.untyped, remaining_params: T.untyped).void }
+          def initialize(gid, remaining_params); end
+
+          sig { returns(T.untyped) }
+          attr_reader :gid
+
+          sig { returns(T.untyped) }
+          attr_reader :remaining_params
+
+          sig { returns(T.untyped) }
+          def ensure_no_remaining_params!; end
+
+          sig { params(param_name: T.untyped).returns(T.untyped) }
+          def fetch_solo_param(param_name); end
+        end
+
+        class LessThan < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class GreaterThan < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class Equals < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class IsNot < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class DoesntContainAny < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class ContainsAny < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class ContainsAll < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class NoValue < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class AnyValue < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class Is < CustomFieldVariant
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+      end
+
+      class DateParamConverter
+        API_PREFIX = {
+          'due_date' => 'due_on',
+          'start_date' => 'start_on',
+          'completion_date' => 'completed_on',
+        }.freeze
+
+        sig { params(date_url_params: T.untyped).void }
+        def initialize(date_url_params:); end
+
+        sig { returns(T.untyped) }
+        def convert; end
+
+        sig { params(prefix: T.untyped).returns(T.untyped) }
+        def convert_for_prefix(prefix); end
+
+        sig { params(prefix: T.untyped).returns(T.untyped) }
+        def handle_through_next(prefix); end
+
+        sig { params(prefix: T.untyped).returns(T.untyped) }
+        def handle_between(prefix); end
+
+        sig { params(prefix: T.untyped).returns(T.untyped) }
+        def handle_within_last(prefix); end
+
+        sig { params(prefix: T.untyped).returns(T.untyped) }
+        def handle_within_next(prefix); end
+
+        sig { params(param_key: T.untyped).returns(T.untyped) }
+        def get_single_param(param_key); end
+
+        sig { params(prefix: T.untyped).returns(T.untyped) }
+        def validate_unit_not_provided!(prefix); end
+
+        sig { params(prefix: T.untyped).returns(T.untyped) }
+        def validate_unit_is_day!(prefix); end
+
+        sig { returns(T.untyped) }
+        attr_reader :date_url_params
+      end
+
+      class Parser
+        sig { params(_deps: T.untyped).void }
+        def initialize(_deps = {}); end
+
+        sig { params(url: T.untyped).returns(T.untyped) }
+        def convert_params(url); end
+
+        sig { params(date_url_params: T.untyped).returns(T.untyped) }
+        def convert_date_params(date_url_params); end
+
+        sig { params(simple_url_params: T.untyped).returns(T.untyped) }
+        def convert_simple_params(simple_url_params); end
+
+        sig { params(custom_field_params: T.untyped).returns(T.untyped) }
+        def convert_custom_field_params(custom_field_params); end
+
+        sig { params(url_params: T.untyped).returns(T.untyped) }
+        def partition_url_params(url_params); end
+      end
+
+      class ResultsMerger
+        sig { params(args: T.untyped).returns(T.untyped) }
+        def self.merge_args(*args); end
+
+        sig { params(task_selectors: T.untyped).returns(T.untyped) }
+        def self.merge_task_selectors(*task_selectors); end
+      end
+
+      module SimpleParam
+        class SimpleParam
+          sig { params(key: T.untyped, values: T.untyped).void }
+          def initialize(key:, values:); end
+
+          sig { returns(T.untyped) }
+          def single_value; end
+
+          sig { returns(T.untyped) }
+          attr_reader :key
+
+          sig { returns(T.untyped) }
+          attr_reader :values
+
+          sig { params(projects: T.untyped, sections: T.untyped).returns(T.untyped) }
+          def parse_projects_and_sections(projects, sections); end
+
+          sig { params(verb: T.untyped).returns(T.untyped) }
+          def convert_from_projects_and_sections(verb); end
+        end
+
+        class PortfoliosIds < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class AnyProjectsIds < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class NotProjectsIds < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class Completion < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class NotTagsIds < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class Subtask < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class AnyTagsIds < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class Sort < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class Milestone < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+
+        class SearchedType < SimpleParam
+          sig { returns(T.untyped) }
+          def convert; end
+        end
+      end
+
+      class SimpleParamConverter
+        ARGS = {
+          'portfolios.ids' => SimpleParam::PortfoliosIds,
+          'any_projects.ids' => SimpleParam::AnyProjectsIds,
+          'not_projects.ids' => SimpleParam::NotProjectsIds,
+          'completion' => SimpleParam::Completion,
+          'not_tags.ids' => SimpleParam::NotTagsIds,
+          'any_tags.ids' => SimpleParam::AnyTagsIds,
+          'subtask' => SimpleParam::Subtask,
+          'sort' => SimpleParam::Sort,
+          'milestone' => SimpleParam::Milestone,
+          'searched_type' => SimpleParam::SearchedType,
+        }.freeze
+
+        sig { params(simple_url_params: T.untyped).void }
+        def initialize(simple_url_params:); end
+
+        sig { returns(T.untyped) }
+        def convert; end
+
+        sig { params(key: T.untyped, values: T.untyped).returns(T.untyped) }
+        def convert_arg(key, values); end
+
+        sig { returns(T.untyped) }
+        attr_reader :simple_url_params
+      end
+    end
+  end
+
+  module SelectorClasses
+    class FunctionEvaluator
+      include Logging
+
+      sig { params(_index: T.untyped).returns(T.untyped) }
+      def evaluate_arg?(_index); end
+
+      sig { returns(T.untyped) }
+      def matches?; end
+
+      sig { params(_task: T.untyped, _args: T.untyped).returns(T.untyped) }
+      def evaluate(_task, *_args); end
+
+      sig { params(object: T.untyped, fn_name: T.untyped).returns(T.untyped) }
+      def fn?(object, fn_name); end
+    end
+
+    module Common
+      class AndFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :and
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_resource: T.untyped, args: T.untyped).returns(T.untyped) }
+        def evaluate(_resource, *args); end
+      end
+
+      class OrFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :or
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_resource: T.untyped, args: T.untyped).returns(T.untyped) }
+        def evaluate(_resource, *args); end
+      end
+
+      class NotFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :not
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_resource: T.untyped, subvalue: T.untyped).returns(T.untyped) }
+        def evaluate(_resource, subvalue); end
+      end
+
+      class NilPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_resource: T.untyped, subvalue: T.untyped).returns(T.untyped) }
+        def evaluate(_resource, subvalue); end
+      end
+
+      class EqualsPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :equals?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_resource: T.untyped, lhs: T.untyped, rhs: T.untyped).returns(T.untyped) }
+        def evaluate(_resource, lhs, rhs); end
+      end
+
+      class CustomFieldValueFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :custom_field_value
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(resource: T.untyped, custom_field_name: T.untyped).returns(T.untyped) }
+        def evaluate(resource, custom_field_name); end
+      end
+
+      class CustomFieldGidValueFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(resource: T.untyped, custom_field_gid: T.untyped).returns(T.untyped) }
+        def evaluate(resource, custom_field_gid); end
+      end
+
+      class CustomFieldGidValueContainsAnyGidPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :custom_field_gid_value_contains_any_gid?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(resource: T.untyped, custom_field_gid: T.untyped, custom_field_values_gids: T.untyped).returns(T.untyped) }
+        def evaluate(resource, custom_field_gid, custom_field_values_gids); end
+      end
+
+      class CustomFieldValueContainsAnyValuePFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :custom_field_value_contains_any_value?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(resource: T.untyped, custom_field_name: T.untyped, custom_field_value_names: T.untyped).returns(T.untyped) }
+        def evaluate(resource, custom_field_name, custom_field_value_names); end
+      end
+
+      class CustomFieldGidValueContainsAllGidsPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :custom_field_gid_value_contains_all_gids?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(resource: T.untyped, custom_field_gid: T.untyped, custom_field_values_gids: T.untyped).returns(T.untyped) }
+        def evaluate(resource, custom_field_gid, custom_field_values_gids); end
+      end
+
+      class NameStartsWithPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :name_starts_with?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(resource: T.untyped, prefix: T.untyped).returns(T.untyped) }
+        def evaluate(resource, prefix); end
+      end
+
+      class StringLiteralEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_resource: T.untyped).returns(T.untyped) }
+        def evaluate(_resource); end
+      end
+
+      class FunctionEvaluator < ::Checkoff::SelectorClasses::FunctionEvaluator
+        sig { params(selector: T.untyped, custom_fields: T.untyped, _kwargs: T.untyped).void }
+        def initialize(selector:, custom_fields:, **_kwargs); end
+
+        sig { returns(T.untyped) }
+        attr_reader :selector
+      end
+    end
+
+    module Project
+      class DueDateFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :due_date
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(resource: T.untyped).returns(T.untyped) }
+        def evaluate(resource); end
+      end
+
+      class ReadyPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :ready?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(project: T.untyped, period: T.untyped).returns(T.untyped) }
+        def evaluate(project, period = :now_or_before); end
+      end
+
+      class InPortfolioNamedPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :in_portfolio_named?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig do
+          params(
+            project: T.untyped,
+            portfolio_name: T.untyped,
+            workspace_name: T.untyped,
+            extra_project_fields: T.untyped
+          ).returns(T.untyped)
+        end
+        def evaluate(project, portfolio_name, workspace_name: nil, extra_project_fields: []); end
+      end
+
+      class FunctionEvaluator < ::Checkoff::SelectorClasses::FunctionEvaluator
+        sig do
+          params(
+            selector: T.untyped,
+            projects: T.untyped,
+            portfolios: T.untyped,
+            workspaces: T.untyped,
+            _kwargs: T.untyped
+          ).void
+        end
+        def initialize(selector:, projects:, portfolios:, workspaces:, **_kwargs); end
+
+        sig { returns(T.untyped) }
+        attr_reader :selector
+      end
+    end
+
+    module Section
+      class EndsWithMilestoneFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :ends_with_milestone
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(section: T.untyped).returns(T.untyped) }
+        def evaluate(section); end
+      end
+
+      class HasTasksPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :has_tasks?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(section: T.untyped).returns(T.untyped) }
+        def evaluate(section); end
+      end
+
+      class FunctionEvaluator < ::Checkoff::SelectorClasses::FunctionEvaluator
+        sig do
+          params(
+            selector: T.untyped,
+            sections: T.untyped,
+            client: T.untyped,
+            kwargs: T.untyped
+          ).void
+        end
+        def initialize(selector:, sections:, client:, **kwargs); end
+
+        sig { returns(T.untyped) }
+        attr_reader :selector
+
+        sig { returns(T.untyped) }
+        attr_reader :client
+      end
+    end
+
+    module Task
+      class InARealProjectPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped).returns(T.untyped) }
+        def evaluate(task); end
+      end
+
+      class SectionNameStartsWithPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, section_name_prefix: T.untyped).returns(T.untyped) }
+        def evaluate(task, section_name_prefix); end
+      end
+
+      class InSectionNamedPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, section_name: T.untyped).returns(T.untyped) }
+        def evaluate(task, section_name); end
+      end
+
+      class InProjectNamedPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, project_name: T.untyped).returns(T.untyped) }
+        def evaluate(task, project_name); end
+      end
+
+      class InPortfolioMoreThanOncePFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, portfolio_name: T.untyped).returns(T.untyped) }
+        def evaluate(task, portfolio_name); end
+      end
+
+      class TagPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, tag_name: T.untyped).returns(T.untyped) }
+        def evaluate(task, tag_name); end
+      end
+
+      class ReadyPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, period: T.untyped, ignore_dependencies: T.untyped).returns(T.untyped) }
+        def evaluate(task, period = :now_or_before, ignore_dependencies = false); end
+      end
+
+      class InPeriodPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, field_name: T.untyped, period: T.untyped).returns(T.untyped) }
+        def evaluate(task, field_name, period); end
+      end
+
+      class UnassignedPFunctionEvaluator < FunctionEvaluator
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(task: T.untyped).returns(T.untyped) }
+        def evaluate(task); end
+      end
+
+      class DueDateSetPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :due_date_set?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(task: T.untyped).returns(T.untyped) }
+        def evaluate(task); end
+      end
+
+      class LastStoryCreatedLessThanNDaysAgoPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :last_story_created_less_than_n_days_ago?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, num_days: T.untyped, excluding_resource_subtypes: T.untyped).returns(T.untyped) }
+        def evaluate(task, num_days, excluding_resource_subtypes); end
+      end
+
+      class EstimateExceedsDurationPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :estimate_exceeds_duration?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(task: T.untyped).returns(T.untyped) }
+        def calculate_allocated_hours(task); end
+
+        sig { params(task: T.untyped).returns(T.untyped) }
+        def evaluate(task); end
+      end
+
+      class DependentOnPreviousSectionLastMilestonePFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :dependent_on_previous_section_last_milestone?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(task: T.untyped, limit_to_portfolio_gid: T.untyped).returns(T.untyped) }
+        def evaluate(task, limit_to_portfolio_gid: nil); end
+      end
+
+      class InPortfolioNamedPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :in_portfolio_named?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(task: T.untyped, portfolio_name: T.untyped).returns(T.untyped) }
+        def evaluate(task, portfolio_name); end
+      end
+
+      class LastTaskMilestoneDoesNotDependOnThisTaskPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :last_task_milestone_does_not_depend_on_this_task?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, limit_to_portfolio_name: T.untyped).returns(T.untyped) }
+        def evaluate(task, limit_to_portfolio_name = nil); end
+      end
+
+      class MilestonePFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :milestone?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped).returns(T.untyped) }
+        def evaluate(task); end
+      end
+
+      class NoMilestoneDependsOnThisTaskPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :no_milestone_depends_on_this_task?
+
+        sig { returns(T.untyped) }
+        def matches?; end
+
+        sig { params(_index: T.untyped).returns(T.untyped) }
+        def evaluate_arg?(_index); end
+
+        sig { params(task: T.untyped, limit_to_portfolio_name: T.untyped).returns(T.untyped) }
+        def evaluate(task, limit_to_portfolio_name = nil); end
+      end
+
+      class FunctionEvaluator < ::Checkoff::SelectorClasses::FunctionEvaluator
+        sig do
+          params(
+            selector: T.untyped,
+            tasks: T.untyped,
+            timelines: T.untyped,
+            custom_fields: T.untyped,
+            _kwargs: T.untyped
+          ).void
+        end
+        def initialize(selector:, tasks:, timelines:, custom_fields:, **_kwargs); end
+
+        sig { returns(T.untyped) }
+        attr_reader :selector
+      end
+    end
+  end
+end
+# typed: true
 class ENV
   # _@param_ `key`
   # 
@@ -459,7 +2869,7 @@ end
 
 # Command-line and gem client for Asana (unofficial)
 module Checkoff
-  VERSION = T.let('0.226.0', T.untyped)
+  VERSION = T.let('0.228.0', T.untyped)
 
   # Move tasks from one place to another
   class MvSubcommand
@@ -489,7 +2899,7 @@ module Checkoff
         logger: T.untyped
       ).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: config), sections: Checkoff::Sections.new(config: config), logger: $stderr); 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) }
     def move_tasks(tasks, to_project, to_section); end
@@ -551,9 +2961,9 @@ module Checkoff
         stderr: T.untyped
       ).void
     end
-    def initialize(workspace_name, project_name, section_name, task_name, config: Checkoff::Internal::ConfigLoader.load(:asana), projects: Checkoff::Projects.new(config: config), sections: Checkoff::Sections.new(config: config,
-                                                    projects: projects), tasks: Checkoff::Tasks.new(config: config,
-                                              sections: sections), stderr: $stderr); 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) }
     def run; end
@@ -623,7 +3033,7 @@ module Checkoff
         tasks: T.untyped
       ).void
     end
-    def initialize(workspace_name, task_name, config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), tasks: Checkoff::Tasks.new(config: config)); 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) }
     def run; end
@@ -670,7 +3080,7 @@ module Checkoff
         workspaces: Checkoff::Workspaces
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config: config), client: clients.client, projects: Checkoff::Projects.new(config: config, client: client), workspaces: Checkoff::Workspaces.new(config: config, client: client)); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config:), client: clients.client, projects: Checkoff::Projects.new(config:, client:), workspaces: Checkoff::Workspaces.new(config:, client:)); end
 
     # _@param_ `workspace_name`
     # 
@@ -789,11 +3199,11 @@ module Checkoff
         asana_task: T.class_of(Asana::Resources::Task)
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config: config).client, workspaces: Checkoff::Workspaces.new(config: config,
-                                                        client: client), sections: Checkoff::Sections.new(config: config,
-                                                    client: client), portfolios: Checkoff::Portfolios.new(config: config,
-                                                        client: client), custom_fields: Checkoff::CustomFields.new(config: config,
-                                                             client: client), time_class: Time, date_class: Date, asana_task: Asana::Resources::Task); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, workspaces: Checkoff::Workspaces.new(config:,
+                                                        client:), sections: Checkoff::Sections.new(config:,
+                                                    client:), portfolios: Checkoff::Portfolios.new(config:,
+                                                        client:), custom_fields: Checkoff::CustomFields.new(config:,
+                                                             client:), time_class: Time, date_class: Date, asana_task: Asana::Resources::Task); end
 
     # Indicates a task is ready for a person to work on it.  This is
     # subtly different than what is used by Asana to mark a date as
@@ -1068,7 +3478,7 @@ module Checkoff
         asana_event_enrichment: Checkoff::Internal::AsanaEventEnrichment
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), tasks: Checkoff::Tasks.new(config: config), sections: Checkoff::Sections.new(config: config), projects: Checkoff::Projects.new(config: config), clients: Checkoff::Clients.new(config: config), client: clients.client, asana_event_filter_class: Checkoff::Internal::AsanaEventFilter, asana_event_enrichment: Checkoff::Internal::AsanaEventEnrichment.new); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), tasks: Checkoff::Tasks.new(config:), sections: Checkoff::Sections.new(config:), projects: Checkoff::Projects.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client, asana_event_filter_class: Checkoff::Internal::AsanaEventFilter, asana_event_enrichment: Checkoff::Internal::AsanaEventEnrichment.new); end
 
     # _@param_ `filters` — The filters to match against
     # 
@@ -1310,8 +3720,8 @@ module Checkoff
     # 
     # _@param_ `projects`
     sig { params(config: Checkoff::Internal::EnvFallbackConfigLoader, client: Asana::Client, projects: Checkoff::Projects).void }
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config: config).client, projects: Checkoff::Projects.new(config: config,
-                                                    client: client)); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, projects: Checkoff::Projects.new(config:,
+                                                    client:)); end
 
     # Given a 'My Tasks' project object, pull all tasks, then provide
     # a Hash of tasks with section name -> task list of the
@@ -1378,8 +3788,8 @@ module Checkoff
         timing: Checkoff::Timing
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config: config).client, workspaces: Checkoff::Workspaces.new(config: config,
-                                                        client: client), project_hashes: Checkoff::Internal::ProjectHashes.new, project_timing: Checkoff::Internal::ProjectTiming.new(client: client), timing: Checkoff::Timing.new); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, workspaces: Checkoff::Workspaces.new(config:,
+                                                        client:), project_hashes: Checkoff::Internal::ProjectHashes.new, project_timing: Checkoff::Internal::ProjectTiming.new(client:), timing: Checkoff::Timing.new); end
 
     # _@param_ `extra_fields`
     sig { params(extra_fields: T::Array[String]).returns(T::Array[String]) }
@@ -1565,9 +3975,9 @@ module Checkoff
         time: T.class_of(Time)
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config: config).client, projects: Checkoff::Projects.new(config: config,
-                                                    client: client), workspaces: Checkoff::Workspaces.new(config: config,
-                                                        client: client), time: Time); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, projects: Checkoff::Projects.new(config:,
+                                                    client:), workspaces: Checkoff::Workspaces.new(config:,
+                                                        client:), time: Time); end
 
     # Returns a list of Asana API section objects for a given project
     # 
@@ -1808,8 +4218,8 @@ module Checkoff
     # _@param_ `projects`
     # 
     # _@param_ `clients`
-    sig { params(config: T::Hash[T.untyped, T.untyped], projects: Checkoff::Projects, clients: Checkoff::Clients).void }
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), projects: Checkoff::Projects.new(config: config), clients: Checkoff::Clients.new(config: config)); end
+    sig { params(config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader), projects: Checkoff::Projects, clients: Checkoff::Clients).void }
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), projects: Checkoff::Projects.new(config:), clients: Checkoff::Clients.new(config:)); end
 
     # True if all subtasks of the task are completed
     # 
@@ -1892,7 +4302,7 @@ module Checkoff
     # _@param_ `client`
     sig do
       params(
-        config: T::Hash[T.untyped, T.untyped],
+        config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader),
         workspaces: Checkoff::Workspaces,
         tasks: Checkoff::Tasks,
         sections: Checkoff::Sections,
@@ -1901,7 +4311,7 @@ module Checkoff
         client: Asana::Client
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), tasks: Checkoff::Tasks.new(config: config), sections: Checkoff::Sections.new(config: config), projects: Checkoff::Projects.new(config: config), clients: Checkoff::Clients.new(config: config), client: clients.client); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), tasks: Checkoff::Tasks.new(config:), sections: Checkoff::Sections.new(config:), projects: Checkoff::Projects.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
 
     # sord warn - "[Asana::Resource" does not appear to be a type
     # sord warn - "nil]" does not appear to be a type
@@ -1972,7 +4382,7 @@ module Checkoff
     # _@param_ `client`
     sig do
       params(
-        config: T::Hash[T.untyped, T.untyped],
+        config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader),
         workspaces: Checkoff::Workspaces,
         sections: Checkoff::Sections,
         tasks: Checkoff::Tasks,
@@ -1981,7 +4391,7 @@ module Checkoff
         client: Asana::Client
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), sections: Checkoff::Sections.new(config: config), tasks: Checkoff::Tasks.new(config: config), portfolios: Checkoff::Portfolios.new(config: config), clients: Checkoff::Clients.new(config: config), client: clients.client); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), sections: Checkoff::Sections.new(config:), tasks: Checkoff::Tasks.new(config:), portfolios: Checkoff::Portfolios.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
 
     # _@param_ `task`
     # 
@@ -2052,7 +4462,7 @@ module Checkoff
         workspaces: Checkoff::Workspaces
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config: config), client: clients.client, projects: Checkoff::Projects.new(config: config, client: client), workspaces: Checkoff::Workspaces.new(config: config, client: client)); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config:), client: clients.client, projects: Checkoff::Projects.new(config:, client:), workspaces: Checkoff::Workspaces.new(config:, client:)); end
 
     # _@param_ `workspace_name`
     # 
@@ -2119,7 +4529,7 @@ module Checkoff
     # 
     # _@param_ `asana_workspace`
     sig { params(config: 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: config).client, asana_workspace: Asana::Resources::Workspace); end
+    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
     # @sg-ignore
@@ -2162,13 +4572,13 @@ module Checkoff
     # _@param_ `client`
     sig do
       params(
-        config: T::Hash[T.untyped, T.untyped],
+        config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader),
         workspaces: Checkoff::Workspaces,
         clients: Checkoff::Clients,
         client: Asana::Client
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), clients: Checkoff::Clients.new(config: config), client: clients.client); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
 
     # sord warn - Asana::Resources::Attachment wasn't able to be resolved to a constant in this project
     # _@param_ `url`
@@ -2313,8 +4723,8 @@ module Checkoff
         workspaces: Checkoff::Workspaces
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config: config), client: clients.client, workspaces: Checkoff::Workspaces.new(config: config,
-                                                        client: client)); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), clients: Checkoff::Clients.new(config:), client: clients.client, workspaces: Checkoff::Workspaces.new(config:,
+                                                        client:)); end
 
     # sord warn - Asana::Resources::CustomField wasn't able to be resolved to a constant in this project
     # _@param_ `workspace_name`
@@ -2419,7 +4829,7 @@ module Checkoff
     # _@param_ `asana_resources_collection_class`
     sig do
       params(
-        config: T::Hash[Symbol, Object],
+        config: T.any(T::Hash[Symbol, Object], Checkoff::Internal::EnvFallbackConfigLoader),
         workspaces: Checkoff::Workspaces,
         task_selectors: Checkoff::TaskSelectors,
         projects: Checkoff::Projects,
@@ -2429,7 +4839,7 @@ module Checkoff
         asana_resources_collection_class: T.class_of(Asana::Resources::Collection)
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), task_selectors: Checkoff::TaskSelectors.new(config: config), projects: Checkoff::Projects.new(config: config), clients: Checkoff::Clients.new(config: config), client: clients.client, search_url_parser: Checkoff::Internal::SearchUrl::Parser.new, asana_resources_collection_class: Asana::Resources::Collection); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), task_selectors: Checkoff::TaskSelectors.new(config:), projects: Checkoff::Projects.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client, search_url_parser: Checkoff::Internal::SearchUrl::Parser.new, asana_resources_collection_class: Asana::Resources::Collection); end
 
     # Perform an equivalent search API to an Asana search URL in the
     # web UI.  Not all URL parameters are supported; each one must be
@@ -2575,17 +4985,17 @@ module Checkoff
     # _@param_ `timelines`
     sig do
       params(
-        config: T::Hash[T.untyped, T.untyped],
+        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
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config: config).client, tasks: Checkoff::Tasks.new(config: config,
-                                              client: client), timelines: Checkoff::Timelines.new(config: config,
-                                                      client: client), custom_fields: Checkoff::CustomFields.new(config: config,
-                                                             client: client)); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), client: Checkoff::Clients.new(config:).client, tasks: Checkoff::Tasks.new(config:,
+                                              client:), timelines: Checkoff::Timelines.new(config:,
+                                                      client:), custom_fields: Checkoff::CustomFields.new(config:,
+                                                             client:)); end
 
     # _@param_ `task`
     # 
@@ -2641,7 +5051,7 @@ module Checkoff
     # _@param_ `client`
     sig do
       params(
-        config: T::Hash[Symbol, Object],
+        config: T.any(T::Hash[Symbol, Object], Checkoff::Internal::EnvFallbackConfigLoader),
         workspaces: Checkoff::Workspaces,
         projects: Checkoff::Projects,
         custom_fields: Checkoff::CustomFields,
@@ -2650,7 +5060,7 @@ module Checkoff
         client: Asana::Client
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), projects: Checkoff::Projects.new(config: config), custom_fields: Checkoff::CustomFields.new(config: config), portfolios: Checkoff::Portfolios.new(config: config), clients: Checkoff::Clients.new(config: config), client: clients.client); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), projects: Checkoff::Projects.new(config:), custom_fields: Checkoff::CustomFields.new(config:), portfolios: Checkoff::Portfolios.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
 
     # _@param_ `project`
     # 
@@ -2699,7 +5109,7 @@ module Checkoff
     # _@param_ `client`
     sig do
       params(
-        config: T::Hash[Symbol, Object],
+        config: T.any(T::Hash[Symbol, Object], Checkoff::Internal::EnvFallbackConfigLoader),
         workspaces: Checkoff::Workspaces,
         sections: Checkoff::Sections,
         custom_fields: Checkoff::CustomFields,
@@ -2707,7 +5117,7 @@ module Checkoff
         client: Asana::Client
       ).void
     end
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), sections: Checkoff::Sections.new(config: config), custom_fields: Checkoff::CustomFields.new(config: config), clients: Checkoff::Clients.new(config: config), client: clients.client); end
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), sections: Checkoff::Sections.new(config:), custom_fields: Checkoff::CustomFields.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
 
     # _@param_ `section`
     # 
@@ -2795,7 +5205,7 @@ module Checkoff
           custom_fields: Checkoff::CustomFields
         ).void
       end
-      def initialize(time_class: Time, date_class: Date, client: Checkoff::Clients.new.client, custom_fields: Checkoff::CustomFields.new(client: client)); end
+      def initialize(time_class: Time, date_class: Date, client: Checkoff::Clients.new.client, custom_fields: Checkoff::CustomFields.new(client:)); end
 
       # _@param_ `task`
       sig { params(task: Asana::Resources::Task).returns(T.nilable(Time)) }
@@ -2927,7 +5337,7 @@ module Checkoff
           custom_fields: Checkoff::CustomFields
         ).void
       end
-      def initialize(time_class: Time, date_class: Date, client: Checkoff::Clients.new.client, custom_fields: Checkoff::CustomFields.new(client: client)); end
+      def initialize(time_class: Time, date_class: Date, client: Checkoff::Clients.new.client, custom_fields: Checkoff::CustomFields.new(client:)); end
 
       # @sg-ignore
       # 
@@ -3484,7 +5894,7 @@ module Checkoff
       # _@param_ `asana_event_enrichment`
       sig do
         params(
-          config: T::Hash[T.untyped, T.untyped],
+          config: T.any(T::Hash[T.untyped, T.untyped], Checkoff::Internal::EnvFallbackConfigLoader),
           workspaces: Checkoff::Workspaces,
           tasks: Checkoff::Tasks,
           sections: Checkoff::Sections,
@@ -3494,7 +5904,7 @@ module Checkoff
           client: Asana::Client
         ).void
       end
-      def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config: config), tasks: Checkoff::Tasks.new(config: config), sections: Checkoff::Sections.new(config: config), projects: Checkoff::Projects.new(config: config), resources: Checkoff::Resources.new(config: config), clients: Checkoff::Clients.new(config: config), client: clients.client); end
+      def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana), workspaces: Checkoff::Workspaces.new(config:), tasks: Checkoff::Tasks.new(config:), sections: Checkoff::Sections.new(config:), projects: Checkoff::Projects.new(config:), resources: Checkoff::Resources.new(config:), clients: Checkoff::Clients.new(config:), client: clients.client); end
 
       # Add useful info (like resource task names) into an event for
       # human consumption
@@ -4473,7 +6883,7 @@ end - [Checkoff::SelectorClasses::Section::FunctionEvaluator]).freeze, T.untyped
         _kwargs: T.untyped
       ).void
     end
-    def initialize(section:, client:, projects: Checkoff::Projects.new(client: client), sections: Checkoff::Sections.new(client: client), custom_fields: Checkoff::CustomFields.new(client: client), **_kwargs); end
+    def initialize(section:, client:, projects: Checkoff::Projects.new(client:), sections: Checkoff::Sections.new(client:), custom_fields: Checkoff::CustomFields.new(client:), **_kwargs); end
 
     sig { returns(T::Array[T.class_of(Checkoff::SelectorClasses::Project::FunctionEvaluator)]) }
     def function_evaluators; end
@@ -4527,3 +6937,26 @@ 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