phoebe 0.1.0.pre.alpha.1

data/rbi/phoebe/request_options.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module Phoebe
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Phoebe::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias { T.any(Phoebe::RequestOptions, Phoebe::Internal::AnyHash) }
+
+    # @api private
+    sig { params(opts: Phoebe::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig { params(values: Phoebe::Internal::AnyHash).returns(T.attached_class) }
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/phoebe/resources/data/observations/geo/recent/notable.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Geo
+          class Recent
+            class Notable
+              # Get the list of notable observations (up to 30 days ago) of birds seen at
+              # locations within a radius of up to 50 kilometers, from a given set of
+              # coordinates. Notable observations can be for locally or nationally rare species
+              # or are otherwise unusual, for example over-wintering birds in a species which is
+              # normally only a summer visitor.
+              sig do
+                params(
+                  lat: Float,
+                  lng: Float,
+                  back: Integer,
+                  detail:
+                    Phoebe::Data::Observations::Geo::Recent::NotableListParams::Detail::OrSymbol,
+                  dist: Integer,
+                  hotspot: T::Boolean,
+                  max_results: Integer,
+                  spp_locale: String,
+                  request_options: Phoebe::RequestOptions::OrHash
+                ).returns(T::Array[Phoebe::Data::Observation])
+              end
+              def list(
+                lat:,
+                lng:,
+                # The number of days back to fetch observations.
+                back: nil,
+                # Include a subset (simple), or all (full), of the fields available.
+                detail: nil,
+                # The search radius from the given position, in kilometers.
+                dist: nil,
+                # Only fetch observations from hotspots
+                hotspot: nil,
+                # Only fetch this number of observations
+                max_results: nil,
+                # Use this language for species common names
+                spp_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
+  end
+end

data/rbi/phoebe/resources/data/observations/geo/recent/species.rbi

@@ -0,0 +1,70 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Geo
+          class Recent
+            class Species
+              # Get all observations of a species, seen up to 30 days ago, at any location
+              # within a radius of up to 50 kilometers, from a given set of coordinates. Results
+              # include only the most recent observation from each location in the region
+              # specified.
+              #
+              # #### URL parameters
+              #
+              # | Name        | Description             |
+              # | ----------- | ----------------------- |
+              # | speciesCode | The eBird species code. |
+              #
+              # #### Notes
+              #
+              # The species code is typically a 6-letter code, e.g. horlar for Horned Lark. You
+              # can get complete set of species code from the GET eBird Taxonomy end-point.
+              sig do
+                params(
+                  species_code: String,
+                  lat: Float,
+                  lng: Float,
+                  back: Integer,
+                  dist: Integer,
+                  hotspot: T::Boolean,
+                  include_provisional: T::Boolean,
+                  max_results: Integer,
+                  spp_locale: String,
+                  request_options: Phoebe::RequestOptions::OrHash
+                ).returns(T::Array[Phoebe::Data::Observation])
+              end
+              def list(
+                # The eBird species code.
+                species_code,
+                lat:,
+                lng:,
+                # The number of days back to fetch observations.
+                back: nil,
+                # The search radius from the given position, in kilometers.
+                dist: nil,
+                # Only fetch observations from hotspots
+                hotspot: nil,
+                # Include observations which have not yet been reviewed.
+                include_provisional: nil,
+                # Only fetch this number of observations
+                max_results: nil,
+                # Use this language for species common names
+                spp_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
+  end
+end

data/rbi/phoebe/resources/data/observations/geo/recent.rbi

@@ -0,0 +1,76 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Geo
+          class Recent
+            sig do
+              returns(
+                Phoebe::Resources::Data::Observations::Geo::Recent::Species
+              )
+            end
+            attr_reader :species
+
+            sig do
+              returns(
+                Phoebe::Resources::Data::Observations::Geo::Recent::Notable
+              )
+            end
+            attr_reader :notable
+
+            # Get the list of recent observations (up to 30 days ago) of birds seen at
+            # locations within a radius of up to 50 kilometers, from a given set of
+            # coordinates. Results include only the most recent observation for each species
+            # in the region specified.
+            sig do
+              params(
+                lat: Float,
+                lng: Float,
+                back: Integer,
+                cat:
+                  Phoebe::Data::Observations::Geo::RecentListParams::Cat::OrSymbol,
+                dist: Integer,
+                hotspot: T::Boolean,
+                include_provisional: T::Boolean,
+                max_results: Integer,
+                sort:
+                  Phoebe::Data::Observations::Geo::RecentListParams::Sort::OrSymbol,
+                spp_locale: String,
+                request_options: Phoebe::RequestOptions::OrHash
+              ).returns(T::Array[Phoebe::Data::Observation])
+            end
+            def list(
+              lat:,
+              lng:,
+              # The number of days back to fetch observations.
+              back: nil,
+              # Only fetch observations from these taxonomic categories
+              cat: nil,
+              # The search radius from the given position, in kilometers.
+              dist: nil,
+              # Only fetch observations from hotspots
+              hotspot: nil,
+              # Include observations which have not yet been reviewed.
+              include_provisional: nil,
+              # Only fetch this number of observations
+              max_results: nil,
+              # Sort observations by taxonomy or by date, most recent first.
+              sort: nil,
+              # Use this language for species common names
+              spp_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
+end

data/rbi/phoebe/resources/data/observations/geo.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Geo
+          sig { returns(Phoebe::Resources::Data::Observations::Geo::Recent) }
+          attr_reader :recent
+
+          # @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/data/observations/nearest/geo_species.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Nearest
+          class GeoSpecies
+            # Find the nearest locations where a species has been seen recently. #### Notes
+            # The species code is typically a 6-letter code, e.g. barswa for Barn Swallow. You
+            # can get complete set of species code from the GET eBird Taxonomy end-point.
+            sig do
+              params(
+                species_code: String,
+                lat: Float,
+                lng: Float,
+                back: Integer,
+                dist: Integer,
+                hotspot: T::Boolean,
+                include_provisional: T::Boolean,
+                max_results: Integer,
+                spp_locale: String,
+                request_options: Phoebe::RequestOptions::OrHash
+              ).returns(T::Array[Phoebe::Data::Observation])
+            end
+            def list(
+              # The eBird species code.
+              species_code,
+              lat:,
+              lng:,
+              # The number of days back to fetch observations.
+              back: nil,
+              # Only fetch observations within this distance of the provided lat/lng
+              dist: nil,
+              # Only fetch observations from hotspots
+              hotspot: nil,
+              # Include observations which have not yet been reviewed.
+              include_provisional: nil,
+              # Only fetch up to this number of observations
+              max_results: nil,
+              # Use this language for species common names
+              spp_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
+end

data/rbi/phoebe/resources/data/observations/nearest.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Nearest
+          sig do
+            returns(Phoebe::Resources::Data::Observations::Nearest::GeoSpecies)
+          end
+          attr_reader :geo_species
+
+          # @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/data/observations/recent/historic.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Recent
+          class Historic
+            # Get a list of all taxa seen in a country, region or location on a specific date,
+            # with the specific observations determined by the "rank" parameter (defaults to
+            # latest observation on the date).
+            #
+            # #### Notes Responses may be cached for 30 minutes
+            sig do
+              params(
+                d: Integer,
+                region_code: String,
+                y_: Integer,
+                m: Integer,
+                cat:
+                  Phoebe::Data::Observations::Recent::HistoricListParams::Cat::OrSymbol,
+                detail:
+                  Phoebe::Data::Observations::Recent::HistoricListParams::Detail::OrSymbol,
+                hotspot: T::Boolean,
+                include_provisional: T::Boolean,
+                max_results: Integer,
+                r: T::Array[String],
+                rank:
+                  Phoebe::Data::Observations::Recent::HistoricListParams::Rank::OrSymbol,
+                spp_locale: String,
+                request_options: Phoebe::RequestOptions::OrHash
+              ).returns(T::Array[Phoebe::Data::Observation])
+            end
+            def list(
+              # Path param:
+              d,
+              # Path param: The country, subnational1, subnational2 or location code.
+              region_code:,
+              # Path param:
+              y_:,
+              # Path param:
+              m:,
+              # Query param: Only fetch observations from these taxonomic categories
+              cat: nil,
+              # Query param: Include a subset (simple), or all (full), of the fields available.
+              detail: nil,
+              # Query param: Only fetch observations from hotspots
+              hotspot: nil,
+              # Query param: Include observations which have not yet been reviewed.
+              include_provisional: nil,
+              # Query param: Only fetch this number of observations
+              max_results: nil,
+              # Query param: Fetch observations from up to 50 locations
+              r: nil,
+              # Query param: Include latest observation of the day, or the first added
+              rank: nil,
+              # Query param: Use this language for species common names
+              spp_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
+end

data/rbi/phoebe/resources/data/observations/recent/notable.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Recent
+          class Notable
+            # Get the list of recent, notable observations (up to 30 days ago) of birds seen
+            # in a country, region or location. Notable observations can be for locally or
+            # nationally rare species or are otherwise unusual, e.g. over-wintering birds in a
+            # species which is normally only a summer visitor.
+            sig do
+              params(
+                region_code: String,
+                back: Integer,
+                detail:
+                  Phoebe::Data::Observations::Recent::NotableListParams::Detail::OrSymbol,
+                hotspot: T::Boolean,
+                max_results: Integer,
+                r: T::Array[String],
+                spp_locale: String,
+                request_options: Phoebe::RequestOptions::OrHash
+              ).returns(T::Array[Phoebe::Data::Observation])
+            end
+            def list(
+              # The country, subnational1, subnational2 or location code.
+              region_code,
+              # The number of days back to fetch observations.
+              back: nil,
+              # Include a subset (simple), or all (full), of the fields available.
+              detail: nil,
+              # Only fetch observations from hotspots
+              hotspot: nil,
+              # Only fetch this number of observations
+              max_results: nil,
+              # Fetch observations from up to 10 locations
+              r: nil,
+              # Use this language for species common names
+              spp_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
+end

data/rbi/phoebe/resources/data/observations/recent/species.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Recent
+          class Species
+            # Get the recent observations, up to 30 days ago, of a particular species in a
+            # country, region or location. Results include only the most recent observation
+            # from each location in the region specified.
+            #
+            # #### Notes
+            #
+            # The species code is typically a 6-letter code, e.g. cangoo for Canada Goose. You
+            # can get complete set of species code from the GET eBird Taxonomy end-point.
+            #
+            # When using the _r_ query parameter set the _regionCode_ URL parameter to an
+            # empty string.
+            sig do
+              params(
+                species_code: String,
+                region_code: String,
+                back: Integer,
+                hotspot: T::Boolean,
+                include_provisional: T::Boolean,
+                max_results: Integer,
+                r: T::Array[String],
+                spp_locale: String,
+                request_options: Phoebe::RequestOptions::OrHash
+              ).returns(T::Array[Phoebe::Data::Observation])
+            end
+            def retrieve(
+              # Path param: The eBird species code.
+              species_code,
+              # Path param: The country, subnational1, subnational2 or location code.
+              region_code:,
+              # Query param: The number of days back to fetch observations.
+              back: nil,
+              # Query param: Only fetch observations from hotspots
+              hotspot: nil,
+              # Query param: Include observations which have not yet been reviewed.
+              include_provisional: nil,
+              # Query param: Only fetch this number of observations
+              max_results: nil,
+              # Query param: Fetch observations from up to 10 locations
+              r: nil,
+              # Query param: Use this language for species common names
+              spp_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
+end

data/rbi/phoebe/resources/data/observations/recent.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        class Recent
+          sig do
+            returns(Phoebe::Resources::Data::Observations::Recent::Notable)
+          end
+          attr_reader :notable
+
+          sig do
+            returns(Phoebe::Resources::Data::Observations::Recent::Species)
+          end
+          attr_reader :species
+
+          sig do
+            returns(Phoebe::Resources::Data::Observations::Recent::Historic)
+          end
+          attr_reader :historic
+
+          # Get the list of recent observations (up to 30 days ago) of birds seen in a
+          # country, state, county, or location. Results include only the most recent
+          # observation for each species in the region specified.
+          sig do
+            params(
+              region_code: String,
+              back: Integer,
+              cat: Phoebe::Data::Observations::RecentListParams::Cat::OrSymbol,
+              hotspot: T::Boolean,
+              include_provisional: T::Boolean,
+              max_results: Integer,
+              r: T::Array[String],
+              spp_locale: String,
+              request_options: Phoebe::RequestOptions::OrHash
+            ).returns(T::Array[Phoebe::Data::Observation])
+          end
+          def list(
+            # The country, subnational1, subnational2 or location code.
+            region_code,
+            # The number of days back to fetch observations.
+            back: nil,
+            # Only fetch observations from these taxonomic categories
+            cat: nil,
+            # Only fetch observations from hotspots
+            hotspot: nil,
+            # Include observations which have not yet been reviewed
+            include_provisional: nil,
+            # Only fetch this number of observations
+            max_results: nil,
+            # Fetch observations from up to 10 locations
+            r: nil,
+            # Use this language for species common names
+            spp_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

data/rbi/phoebe/resources/data/observations.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      class Observations
+        sig { returns(Phoebe::Resources::Data::Observations::Recent) }
+        attr_reader :recent
+
+        sig { returns(Phoebe::Resources::Data::Observations::Geo) }
+        attr_reader :geo
+
+        sig { returns(Phoebe::Resources::Data::Observations::Nearest) }
+        attr_reader :nearest
+
+        # @api private
+        sig { params(client: Phoebe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/data.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Data
+      sig { returns(Phoebe::Resources::Data::Observations) }
+      attr_reader :observations
+
+      # @api private
+      sig { params(client: Phoebe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/phoebe/resources/product/checklist.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Phoebe
+  module Resources
+    class Product
+      class Checklist
+        # Get the details and observations of a checklist.
+        #
+        # #### Notes Do NOT use this to download large amounts of data. You will be banned if you do. In the fields for each observation, the following fields are duplicates or obsolete and will be removed at a future date: _howManyAtleast_, _howManyAtmost_, _hideFlags_, _projId_, _subId_, _subnational1Code_ and _present_.
+        sig do
+          params(
+            sub_id: String,
+            request_options: Phoebe::RequestOptions::OrHash
+          ).returns(Phoebe::Models::Product::ChecklistViewResponse)
+        end
+        def view(
+          # The checklist identifier.
+          sub_id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Phoebe::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end