phoebe 0.1.0.pre.alpha.1

data/lib/phoebe/resources/ref/hotspot/info.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+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.
+          #
+          # @overload retrieve(loc_id, request_options: {})
+          #
+          # @param loc_id [String] The location code.
+          #
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Phoebe::Models::Ref::Hotspot::InfoRetrieveResponse]
+          #
+          # @see Phoebe::Models::Ref::Hotspot::InfoRetrieveParams
+          def retrieve(loc_id, params = {})
+            @client.request(
+              method: :get,
+              path: ["ref/hotspot/info/%1$s", loc_id],
+              model: Phoebe::Models::Ref::Hotspot::InfoRetrieveResponse,
+              options: params[:request_options]
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/hotspot.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Phoebe
+  module Resources
+    class Ref
+      class Hotspot
+        # @return [Phoebe::Resources::Ref::Hotspot::Geo]
+        attr_reader :geo
+
+        # @return [Phoebe::Resources::Ref::Hotspot::Info]
+        attr_reader :info
+
+        # Hotspots in a region
+        #
+        # @overload list(region_code, back: nil, fmt: nil, request_options: {})
+        #
+        # @param region_code [String] The country, subnational1 or subnational2 code.
+        #
+        # @param back [Integer] The number of days back to fetch hotspots.
+        #
+        # @param fmt [Symbol, Phoebe::Models::Ref::HotspotListParams::Fmt] Fetch the records in CSV or JSON format.
+        #
+        # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Array<Phoebe::Models::Ref::HotspotListResponseItem>]
+        #
+        # @see Phoebe::Models::Ref::HotspotListParams
+        def list(region_code, params = {})
+          parsed, options = Phoebe::Ref::HotspotListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: ["ref/hotspot/%1$s", region_code],
+            query: parsed,
+            model: Phoebe::Internal::Type::ArrayOf[Phoebe::Models::Ref::HotspotListResponseItem],
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Phoebe::Client]
+        def initialize(client:)
+          @client = client
+          @geo = Phoebe::Resources::Ref::Hotspot::Geo.new(client: client)
+          @info = Phoebe::Resources::Ref::Hotspot::Info.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/region/adjacent.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+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
+          #
+          # @overload list(region_code, request_options: {})
+          #
+          # @param region_code [String] The country, subnational1 or subnational2 code.
+          #
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Array<Phoebe::Models::Ref::Region::AdjacentListResponseItem>]
+          #
+          # @see Phoebe::Models::Ref::Region::AdjacentListParams
+          def list(region_code, params = {})
+            @client.request(
+              method: :get,
+              path: ["ref/adjacent/%1$s", region_code],
+              model: Phoebe::Internal::Type::ArrayOf[Phoebe::Models::Ref::Region::AdjacentListResponseItem],
+              options: params[:request_options]
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/region/info.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+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     |
+          #
+          # @overload retrieve(region_code, delim: nil, region_name_format: nil, request_options: {})
+          #
+          # @param region_code [String] The major region, country, subnational1 or subnational2 code, or locId
+          #
+          # @param delim [String] The characters used to separate elements in the name.
+          #
+          # @param region_name_format [Symbol, Phoebe::Models::Ref::Region::InfoRetrieveParams::RegionNameFormat] Control how the name is displayed.
+          #
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Phoebe::Models::Ref::Region::InfoRetrieveResponse]
+          #
+          # @see Phoebe::Models::Ref::Region::InfoRetrieveParams
+          def retrieve(region_code, params = {})
+            parsed, options = Phoebe::Ref::Region::InfoRetrieveParams.dump_request(params)
+            @client.request(
+              method: :get,
+              path: ["ref/region/info/%1$s", region_code],
+              query: parsed.transform_keys(region_name_format: "regionNameFormat"),
+              model: Phoebe::Models::Ref::Region::InfoRetrieveResponse,
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/region/list.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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.
+          #
+          # @overload list(parent_region_code, region_type:, fmt: nil, request_options: {})
+          #
+          # @param parent_region_code [String] Path param: The country or subnational1 code, or 'world'.
+          #
+          # @param region_type [String] Path param: The region type: 'country', 'subnational1' or 'subnational2'.
+          #
+          # @param fmt [Symbol, Phoebe::Models::Ref::Region::ListListParams::Fmt] Query param: Fetch the records in CSV or JSON format.
+          #
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Array<Phoebe::Models::Ref::Region::ListListResponseItem>]
+          #
+          # @see Phoebe::Models::Ref::Region::ListListParams
+          def list(parent_region_code, params)
+            parsed, options = Phoebe::Ref::Region::ListListParams.dump_request(params)
+            region_type =
+              parsed.delete(:region_type) do
+                raise ArgumentError.new("missing required path argument #{_1}")
+              end
+            @client.request(
+              method: :get,
+              path: ["ref/region/list/%1$s/%2$s", region_type, parent_region_code],
+              query: parsed,
+              model: Phoebe::Internal::Type::ArrayOf[Phoebe::Models::Ref::Region::ListListResponseItem],
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/region.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Phoebe
+  module Resources
+    class Ref
+      class Region
+        # @return [Phoebe::Resources::Ref::Region::Adjacent]
+        attr_reader :adjacent
+
+        # @return [Phoebe::Resources::Ref::Region::Info]
+        attr_reader :info
+
+        # @return [Phoebe::Resources::Ref::Region::List]
+        attr_reader :list
+
+        # @api private
+        #
+        # @param client [Phoebe::Client]
+        def initialize(client:)
+          @client = client
+          @adjacent = Phoebe::Resources::Ref::Region::Adjacent.new(client: client)
+          @info = Phoebe::Resources::Ref::Region::Info.new(client: client)
+          @list = Phoebe::Resources::Ref::Region::List.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/taxonomy/ebird.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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.
+          #
+          # @overload retrieve(cat: nil, fmt: nil, locale: nil, species: nil, version: nil, request_options: {})
+          #
+          # @param cat [String] Only fetch records from these taxonomic categories.
+          #
+          # @param fmt [Symbol, Phoebe::Models::Ref::Taxonomy::EbirdRetrieveParams::Fmt] Fetch the records in CSV or JSON format.
+          #
+          # @param locale [String] Use this language for common names.
+          #
+          # @param species [String] Only fetch records for these species.
+          #
+          # @param version [String] Fetch a specific version of the taxonomy.
+          #
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Array<Phoebe::Models::Ref::Taxonomy::EbirdRetrieveResponseItem>]
+          #
+          # @see Phoebe::Models::Ref::Taxonomy::EbirdRetrieveParams
+          def retrieve(params = {})
+            parsed, options = Phoebe::Ref::Taxonomy::EbirdRetrieveParams.dump_request(params)
+            @client.request(
+              method: :get,
+              path: "ref/taxonomy/ebird",
+              query: parsed,
+              model: Phoebe::Internal::Type::ArrayOf[Phoebe::Models::Ref::Taxonomy::EbirdRetrieveResponseItem],
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/taxonomy/forms.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+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.
+          #
+          # @overload list(species_code, request_options: {})
+          #
+          # @param species_code [String] The eBird species code.
+          #
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Array<String>]
+          #
+          # @see Phoebe::Models::Ref::Taxonomy::FormListParams
+          def list(species_code, params = {})
+            @client.request(
+              method: :get,
+              path: ["ref/taxon/forms/%1$s", species_code],
+              model: Phoebe::Internal::Type::ArrayOf[String],
+              options: params[:request_options]
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/taxonomy/locales.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+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.
+          #
+          # @overload list(accept_language: nil, request_options: {})
+          #
+          # @param accept_language [String]
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Array<Phoebe::Models::Ref::Taxonomy::LocaleListResponseItem>]
+          #
+          # @see Phoebe::Models::Ref::Taxonomy::LocaleListParams
+          def list(params = {})
+            parsed, options = Phoebe::Ref::Taxonomy::LocaleListParams.dump_request(params)
+            @client.request(
+              method: :get,
+              path: "ref/taxa-locales/ebird",
+              headers: parsed.transform_keys(accept_language: "accept-language"),
+              model: Phoebe::Internal::Type::ArrayOf[Phoebe::Models::Ref::Taxonomy::LocaleListResponseItem],
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/taxonomy/species_groups.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Phoebe
+  module Resources
+    class Ref
+      class Taxonomy
+        class SpeciesGroups
+          # Some parameter documentations has been truncated, see
+          # {Phoebe::Models::Ref::Taxonomy::SpeciesGroupListParams} for more details.
+          #
+          # 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.
+          #
+          # @overload list(species_grouping, group_name_locale: nil, request_options: {})
+          #
+          # @param species_grouping [Symbol, Phoebe::Models::Ref::Taxonomy::SpeciesGroupListParams::SpeciesGrouping] The order in which groups are returned.
+          #
+          # @param group_name_locale [String] Locale for species group names. English names are returned for any non-listed lo
+          #
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Array<Phoebe::Models::Ref::Taxonomy::SpeciesGroupListResponseItem>]
+          #
+          # @see Phoebe::Models::Ref::Taxonomy::SpeciesGroupListParams
+          def list(species_grouping, params = {})
+            parsed, options = Phoebe::Ref::Taxonomy::SpeciesGroupListParams.dump_request(params)
+            @client.request(
+              method: :get,
+              path: ["ref/sppgroup/%1$s", species_grouping],
+              query: parsed.transform_keys(group_name_locale: "groupNameLocale"),
+              model: Phoebe::Internal::Type::ArrayOf[Phoebe::Models::Ref::Taxonomy::SpeciesGroupListResponseItem],
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/taxonomy/versions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Phoebe
+  module Resources
+    class Ref
+      class Taxonomy
+        class Versions
+          # Returns a list of all versions of the taxonomy, with a flag indicating which is
+          # the latest.
+          #
+          # @overload list(request_options: {})
+          #
+          # @param request_options [Phoebe::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Array<Phoebe::Models::Ref::Taxonomy::VersionListResponseItem>]
+          #
+          # @see Phoebe::Models::Ref::Taxonomy::VersionListParams
+          def list(params = {})
+            @client.request(
+              method: :get,
+              path: "ref/taxonomy/versions",
+              model: Phoebe::Internal::Type::ArrayOf[Phoebe::Models::Ref::Taxonomy::VersionListResponseItem],
+              options: params[:request_options]
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Phoebe::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref/taxonomy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Phoebe
+  module Resources
+    class Ref
+      class Taxonomy
+        # @return [Phoebe::Resources::Ref::Taxonomy::Ebird]
+        attr_reader :ebird
+
+        # @return [Phoebe::Resources::Ref::Taxonomy::Forms]
+        attr_reader :forms
+
+        # @return [Phoebe::Resources::Ref::Taxonomy::Locales]
+        attr_reader :locales
+
+        # @return [Phoebe::Resources::Ref::Taxonomy::Versions]
+        attr_reader :versions
+
+        # @return [Phoebe::Resources::Ref::Taxonomy::SpeciesGroups]
+        attr_reader :species_groups
+
+        # @api private
+        #
+        # @param client [Phoebe::Client]
+        def initialize(client:)
+          @client = client
+          @ebird = Phoebe::Resources::Ref::Taxonomy::Ebird.new(client: client)
+          @forms = Phoebe::Resources::Ref::Taxonomy::Forms.new(client: client)
+          @locales = Phoebe::Resources::Ref::Taxonomy::Locales.new(client: client)
+          @versions = Phoebe::Resources::Ref::Taxonomy::Versions.new(client: client)
+          @species_groups = Phoebe::Resources::Ref::Taxonomy::SpeciesGroups.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/phoebe/resources/ref.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Phoebe
+  module Resources
+    class Ref
+      # @return [Phoebe::Resources::Ref::Region]
+      attr_reader :region
+
+      # @return [Phoebe::Resources::Ref::Hotspot]
+      attr_reader :hotspot
+
+      # @return [Phoebe::Resources::Ref::Taxonomy]
+      attr_reader :taxonomy
+
+      # @api private
+      #
+      # @param client [Phoebe::Client]
+      def initialize(client:)
+        @client = client
+        @region = Phoebe::Resources::Ref::Region.new(client: client)
+        @hotspot = Phoebe::Resources::Ref::Hotspot.new(client: client)
+        @taxonomy = Phoebe::Resources::Ref::Taxonomy.new(client: client)
+      end
+    end
+  end
+end

data/lib/phoebe/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Phoebe
+  VERSION = "0.1.0.pre.alpha.1"
+end