phoebe 0.1.0.pre.alpha.1

data/rbi/phoebe/resources/product/lists/historical.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Product
+      class Lists
+        class Historical
+          # Get information on the checklists submitted on a given date for a country or
+          # region.
+          sig do
+            params(
+              d: Integer,
+              region_code: String,
+              y_: Integer,
+              m: Integer,
+              max_results: Integer,
+              sort_key:
+                Phoebe::Product::Lists::HistoricalRetrieveParams::SortKey::OrSymbol,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(
+              T::Array[
+                Phoebe::Models::Product::Lists::HistoricalRetrieveResponseItem
+              ]
+            )
+          end
+          def retrieve(
+            # Path param: The day in the month.
+            d,
+            # Path param: The country, subnational1, subnational2 or location code.
+            region_code:,
+            # Path param: The year, from 1800 to the present.
+            y_:,
+            # Path param: The month, from 1-12.
+            m:,
+            # Query param: Only fetch this number of checklists.
+            max_results: nil,
+            # Query param: Order the results by the date of the checklist or by the date it
+            # was submitted.
+            sort_key: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/product/lists.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Product
+      class Lists
+        sig { returns(Phoebe::Resources::Product::Lists::Historical) }
+        attr_reader :historical
+
+        # Get information on the most recently submitted checklists for a region.
+        sig do
+          params(
+            region_code: String,
+            max_results: Integer,
+            request_options: Phoebe::RequestOptions::OrHash
+          ).returns(T::Array[Phoebe::Models::Product::ListRetrieveResponseItem])
+        end
+        def retrieve(
+          # The country, subnational1, subnational2 or location code.
+          region_code,
+          # Only fetch this number of checklists.
+          max_results: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Phoebe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/product/species_list.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Product
+      class SpeciesList
+        # Get a list of species codes ever seen in a region, in taxonomic order (species
+        # taxa only)
+        #
+        # #### Notes The results are usually updated every 10 seconds for locations, every day for larger regions.
+        sig do
+          params(
+            region_code: String,
+            request_options: Phoebe::RequestOptions::OrHash
+          ).returns(T::Array[String])
+        end
+        def list(
+          # Any location, USFWS region, subnational2, subnational1, country, or custom
+          # region code
+          region_code,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Phoebe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/product/stats.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Product
+      class Stats
+        # Get a summary of the number of checklist submitted, species seen and
+        # contributors on a given date for a country or region.
+        #
+        # #### Notes The results are updated every 15 minutes.
+        sig do
+          params(
+            d: Integer,
+            region_code: String,
+            y_: Integer,
+            m: Integer,
+            request_options: Phoebe::RequestOptions::OrHash
+          ).returns(Phoebe::Models::Product::StatRetrieveResponse)
+        end
+        def retrieve(
+          # The day in the month.
+          d,
+          # The country, subnational1, subnational2 or location code.
+          region_code:,
+          # The year, from 1800 to the present.
+          y_:,
+          # The month, from 1-12.
+          m:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Phoebe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/product/top100.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Product
+      class Top100
+        # Get the top 100 contributors on a given date for a country or region.
+        #
+        # #### Notes
+        #
+        # The results are updated every 15 minutes.
+        #
+        # When ordering by the number of completed checklists, the number of species seen
+        # will always be zero. Similarly when ordering by the number of species seen the
+        # number of completed checklists will always be zero. <b>Selected Response Field
+        # Notes</b>
+        #
+        # profileHandle - if a user has enabled their profile, this is the handle to reach
+        # it via ebird.org/ebird/profile/{profileHandle}
+        #
+        # numSpecies - always zero when checklistSort parameter is true. Invalid
+        # observations ARE included in this total numCompleteChecklists - always zero when
+        # checklistSort parameter is false
+        sig do
+          params(
+            d: Integer,
+            region_code: String,
+            y_: Integer,
+            m: Integer,
+            max_results: Integer,
+            ranked_by:
+              Phoebe::Product::Top100RetrieveParams::RankedBy::OrSymbol,
+            request_options: Phoebe::RequestOptions::OrHash
+          ).returns(
+            T::Array[Phoebe::Models::Product::Top100RetrieveResponseItem]
+          )
+        end
+        def retrieve(
+          # Path param: The day in the month.
+          d,
+          # Path param: The country, subnational1, or location code.
+          region_code:,
+          # Path param: The year, from 1800 to the present.
+          y_:,
+          # Path param: The month, from 1-12.
+          m:,
+          # Query param: Only fetch this number of contributors.
+          max_results: nil,
+          # Query param: Order by number of complete checklists (cl) or by number of species
+          # seen (spp).
+          ranked_by: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Phoebe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/product.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Product
+      sig { returns(Phoebe::Resources::Product::Lists) }
+      attr_reader :lists
+
+      sig { returns(Phoebe::Resources::Product::Top100) }
+      attr_reader :top100
+
+      sig { returns(Phoebe::Resources::Product::Stats) }
+      attr_reader :stats
+
+      sig { returns(Phoebe::Resources::Product::SpeciesList) }
+      attr_reader :species_list
+
+      sig { returns(Phoebe::Resources::Product::Checklist) }
+      attr_reader :checklist
+
+      # @api private
+      sig { params(client: Phoebe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/hotspot/geo.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Hotspot
+        class Geo
+          # Get the list of hotspots, within a radius of up to 50 kilometers, from a given
+          # set of coordinates.
+          sig do
+            params(
+              lat: Float,
+              lng: Float,
+              back: Integer,
+              dist: Integer,
+              fmt: Phoebe::Ref::Hotspot::GeoRetrieveParams::Fmt::OrSymbol,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(
+              T::Array[Phoebe::Models::Ref::Hotspot::GeoRetrieveResponseItem]
+            )
+          end
+          def retrieve(
+            lat:,
+            lng:,
+            # The number of days back to fetch hotspots.
+            back: nil,
+            # The search radius from the given position, in kilometers.
+            dist: nil,
+            # Fetch the records in CSV or JSON format.
+            fmt: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/hotspot/info.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Hotspot
+        class Info
+          # Get information on the location of a hotspot. #### Notes This API call only
+          # works for hotspots. If you pass the location code for a private location or an
+          # invalid location code then an HTTP 410 (Gone) error is returned.
+          sig do
+            params(
+              loc_id: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(Phoebe::Models::Ref::Hotspot::InfoRetrieveResponse)
+          end
+          def retrieve(
+            # The location code.
+            loc_id,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/hotspot.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Hotspot
+        sig { returns(Phoebe::Resources::Ref::Hotspot::Geo) }
+        attr_reader :geo
+
+        sig { returns(Phoebe::Resources::Ref::Hotspot::Info) }
+        attr_reader :info
+
+        # Hotspots in a region
+        sig do
+          params(
+            region_code: String,
+            back: Integer,
+            fmt: Phoebe::Ref::HotspotListParams::Fmt::OrSymbol,
+            request_options: Phoebe::RequestOptions::OrHash
+          ).returns(T::Array[Phoebe::Models::Ref::HotspotListResponseItem])
+        end
+        def list(
+          # The country, subnational1 or subnational2 code.
+          region_code,
+          # The number of days back to fetch hotspots.
+          back: nil,
+          # Fetch the records in CSV or JSON format.
+          fmt: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Phoebe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/region/adjacent.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Region
+        class Adjacent
+          # Get the list of countries or regions that share a border with this one. ####
+          # Notes Only subnational2 codes in the United States, New Zealand, or Mexico are
+          # currently supported
+          sig do
+            params(
+              region_code: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(
+              T::Array[Phoebe::Models::Ref::Region::AdjacentListResponseItem]
+            )
+          end
+          def list(
+            # The country, subnational1 or subnational2 code.
+            region_code,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/region/info.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Region
+        class Info
+          # Get information on the name and geographical area covered by a region.
+          #
+          # #### Notes
+          #
+          # Taking Madison County, New York, USA (location code US-NY-053) as an example the
+          # various values for the regionNameFormat query parameter work as follows:
+          #
+          # | Value          | Description                                | Result                           |
+          # | -------------- | ------------------------------------------ | -------------------------------- |
+          # | detailed       | return a detailed description              | Madison County, New York, US     |
+          # | detailednoqual | return the name to the subnational1 level  | Madison, New York                |
+          # | full           | return the full description                | Madison, New York, United States |
+          # | namequal       | return the qualified name                  | Madison County                   |
+          # | nameonly       | return only the name of the region         | Madison                          |
+          # | revdetailed    | return the detailed description in reverse | US, New York, Madison County     |
+          sig do
+            params(
+              region_code: String,
+              delim: String,
+              region_name_format:
+                Phoebe::Ref::Region::InfoRetrieveParams::RegionNameFormat::OrSymbol,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(Phoebe::Models::Ref::Region::InfoRetrieveResponse)
+          end
+          def retrieve(
+            # The major region, country, subnational1 or subnational2 code, or locId
+            region_code,
+            # The characters used to separate elements in the name.
+            delim: nil,
+            # Control how the name is displayed.
+            region_name_format: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/region/list.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Region
+        class List
+          # Get the list of sub-regions for a given country or region. #### Notes Not all
+          # combinations of region type and region code are valid. You can fetch all the
+          # subnational1 or subnational2 regions for a country however you can only specify
+          # a region type of 'country' when using 'world' as a region code.
+          sig do
+            params(
+              parent_region_code: String,
+              region_type: String,
+              fmt: Phoebe::Ref::Region::ListListParams::Fmt::OrSymbol,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(
+              T::Array[Phoebe::Models::Ref::Region::ListListResponseItem]
+            )
+          end
+          def list(
+            # Path param: The country or subnational1 code, or 'world'.
+            parent_region_code,
+            # Path param: The region type: 'country', 'subnational1' or 'subnational2'.
+            region_type:,
+            # Query param: Fetch the records in CSV or JSON format.
+            fmt: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/region.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Region
+        sig { returns(Phoebe::Resources::Ref::Region::Adjacent) }
+        attr_reader :adjacent
+
+        sig { returns(Phoebe::Resources::Ref::Region::Info) }
+        attr_reader :info
+
+        sig { returns(Phoebe::Resources::Ref::Region::List) }
+        attr_reader :list
+
+        # @api private
+        sig { params(client: Phoebe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/taxonomy/ebird.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Taxonomy
+        class Ebird
+          # Get the taxonomy used by eBird. #### Notes Each entry in the taxonomy contains a
+          # species code for example, barswa for Barn Swallow. You can download the taxonomy
+          # for selected species using the _species_ query parameter with a comma separating
+          # each code. Otherwise the full taxonomy is downloaded.
+          sig do
+            params(
+              cat: String,
+              fmt: Phoebe::Ref::Taxonomy::EbirdRetrieveParams::Fmt::OrSymbol,
+              locale: String,
+              species: String,
+              version: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(
+              T::Array[Phoebe::Models::Ref::Taxonomy::EbirdRetrieveResponseItem]
+            )
+          end
+          def retrieve(
+            # Only fetch records from these taxonomic categories.
+            cat: nil,
+            # Fetch the records in CSV or JSON format.
+            fmt: nil,
+            # Use this language for common names.
+            locale: nil,
+            # Only fetch records for these species.
+            species: nil,
+            # Fetch a specific version of the taxonomy.
+            version: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/taxonomy/forms.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Taxonomy
+        class Forms
+          # For a species, get the list of subspecies recognised in the taxonomy. The
+          # results include the species that was passed in.
+          sig do
+            params(
+              species_code: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(T::Array[String])
+          end
+          def list(
+            # The eBird species code.
+            species_code,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/taxonomy/locales.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Taxonomy
+        class Locales
+          # Returns the list of supported locale codes and names for species common names,
+          # with the last time they were updated. Use the accept-language header to get
+          # translated language names when available.
+          #
+          # NOTE: The locale codes and names are stable but the other fields in this result
+          # are not yet finalized and should be used with caution.
+          sig do
+            params(
+              accept_language: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(
+              T::Array[Phoebe::Models::Ref::Taxonomy::LocaleListResponseItem]
+            )
+          end
+          def list(accept_language: nil, request_options: {})
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/ref/taxonomy/species_groups.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Ref
+      class Taxonomy
+        class SpeciesGroups
+          # Get the list of species groups, e.g. terns, finches, etc. #### Notes Merlin puts
+          # like birds together, with Falcons next to Hawks, whereas eBird follows taxonomic
+          # order.
+          sig do
+            params(
+              species_grouping:
+                Phoebe::Ref::Taxonomy::SpeciesGroupListParams::SpeciesGrouping::OrSymbol,
+              group_name_locale: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(
+              T::Array[
+                Phoebe::Models::Ref::Taxonomy::SpeciesGroupListResponseItem
+              ]
+            )
+          end
+          def list(
+            # The order in which groups are returned.
+            species_grouping,
+            # Locale for species group names. English names are returned for any non-listed
+            # locale or any non-translated group name.
+            group_name_locale: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Phoebe::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end