analytics_ops 0.1.0 → 0.2.0

data/lib/analytics_ops/configuration/writer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "securerandom"
+
+module AnalyticsOps
+  module Configuration
+    # Safely creates the smallest valid configuration after interactive setup.
+    class Writer
+      # Immutable description of a configuration write or no-op.
+      class Result
+        attr_reader :path
+
+        def initialize(path:, created:)
+          raise ArgumentError, "created must be true or false" unless [true, false].include?(created)
+
+          @path = path.to_s.dup.freeze
+          @created = created
+          freeze
+        end
+
+        def created?
+          @created
+        end
+
+        def to_h
+          { "path" => path, "created" => created? }
+        end
+      end
+
+      def write_minimal(path, profile:, property_id:)
+        state = validated_state(profile, property_id)
+        expanded = File.expand_path(path)
+        return existing_result(expanded, state) if File.exist?(expanded)
+
+        FileUtils.mkdir_p(File.dirname(expanded))
+        temporary = temporary_path(expanded)
+        File.open(temporary, File::WRONLY | File::CREAT | File::EXCL, 0o644) do |file|
+          file.write(document(state))
+          file.flush
+          file.fsync
+        end
+        begin
+          File.link(temporary, expanded)
+        rescue Errno::EEXIST
+          raise ConfigurationError, "Configuration #{Redaction.message(path)} was created by another process"
+        end
+        Result.new(path: expanded, created: true)
+      rescue AnalyticsOps::Error
+        raise
+      rescue SystemCallError => error
+        raise ConfigurationError,
+              "Cannot write configuration #{Redaction.message(path)}: #{Redaction.message(error.message)}"
+      ensure
+        File.unlink(temporary) if temporary && File.exist?(temporary)
+      end
+
+      private
+
+      def validated_state(profile, property_id)
+        unless property_id.is_a?(String)
+          raise ConfigurationError, "property_id must be a numeric identifier encoded as a string"
+        end
+
+        Validator.new(
+          "version" => 1,
+          "profiles" => { profile.to_s => { "property_id" => property_id } }
+        ).call.profile(profile)
+      end
+
+      def existing_result(path, state)
+        configuration = Configuration.load(path)
+        unless configuration.profiles.key?(state.profile)
+          raise ConfigurationError,
+                "Configuration #{Redaction.message(path)} already exists without profile " \
+                "#{state.profile.inspect}; setup will not rewrite it"
+        end
+
+        existing = configuration.profile(state.profile)
+        unless existing.property_id == state.property_id
+          raise ConfigurationError,
+                "Profile #{state.profile.inspect} already targets property #{existing.property_id}; " \
+                "setup will not overwrite it"
+        end
+
+        Result.new(path:, created: false)
+      end
+
+      def document(state)
+        <<~YAML
+          version: 1
+
+          profiles:
+            #{state.profile}:
+              property_id: #{JSON.generate(state.property_id)}
+        YAML
+      end
+
+      def temporary_path(path)
+        File.join(File.dirname(path), ".#{File.basename(path)}.#{Process.pid}.#{SecureRandom.hex(6)}.tmp")
+      end
+    end
+  end
+end

data/lib/analytics_ops/configuration.rb

@@ -6,6 +6,7 @@ require_relative "configuration/document"
 require_relative "configuration/loader"
 require_relative "configuration/validator"
 require_relative "configuration/schema"
+require_relative "configuration/writer"
 
 module AnalyticsOps
   # Strict versioned desired-state loading.

data/lib/analytics_ops/connection.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module AnalyticsOps
+  # Configuration-free Google connection used by discovery and setup.
+  class Connection
+    PROPERTY_ID = /\A\d{1,50}\z/
+
+    # Immutable proof that both APIs can read the selected property.
+    class Verification
+      attr_reader :property
+
+      def initialize(property:)
+        unless property.is_a?(Resources::Property)
+          raise ArgumentError, "property must be an AnalyticsOps::Resources::Property"
+        end
+
+        @property = property
+        freeze
+      end
+
+      def to_h
+        { "property" => property.to_h, "admin_api" => true, "data_api" => true }
+      end
+    end
+
+    def initialize(admin: nil, data: nil, service_account: nil, transport: :grpc, timeout: nil, logger: nil)
+      unless service_account.nil? || service_account.is_a?(ServiceAccount)
+        raise ConfigurationError, "service_account must be an AnalyticsOps::ServiceAccount"
+      end
+
+      @admin = admin
+      @data = data
+      @service_account = service_account
+      @transport = transport
+      @timeout = timeout
+      @logger = logger
+    end
+
+    def discover
+      admin.discover
+    end
+
+    def properties
+      admin.discover(include_streams: false)
+    end
+
+    def verify(property_id)
+      unless property_id.is_a?(String) && PROPERTY_ID.match?(property_id)
+        raise ConfigurationError, "Invalid property ID; expected a numeric string"
+      end
+
+      property = admin.property_access(property_id)
+      data.run(property.id, connectivity_definition)
+      Verification.new(property:)
+    end
+
+    private
+
+    def admin
+      @admin ||= Clients::Admin.new(
+        service_account:,
+        access: :read,
+        transport: @transport,
+        timeout: @timeout,
+        logger: @logger
+      )
+    end
+
+    def data
+      @data ||= Clients::Data.new(
+        service_account:,
+        transport: @transport,
+        timeout: @timeout,
+        logger: @logger
+      )
+    end
+
+    def service_account
+      @service_account ||= ServiceAccount.load
+    end
+
+    def connectivity_definition
+      @connectivity_definition ||= Reports::Definition.new(
+        name: "setup_connectivity",
+        kind: "standard",
+        dimensions: ["date"],
+        metrics: ["activeUsers"],
+        date_ranges: [{ "start_date" => "today", "end_date" => "today" }],
+        limit: 1
+      )
+    end
+  end
+end

data/lib/analytics_ops/desired_state.rb

@@ -11,8 +11,8 @@ module AnalyticsOps
 
     def initialize(profile:, property_id:, streams:, retention:, key_events:, custom_dimensions:, custom_metrics:,
                    manual_requirements:, google_signals:)
-      @profile = profile.freeze
-      @property_id = property_id.freeze
+      @profile = Canonical.immutable(profile)
+      @property_id = Canonical.immutable(property_id)
       @streams = Canonical.immutable(streams)
       @retention = Canonical.immutable(retention)
       @key_events = Canonical.immutable(key_events)

data/lib/analytics_ops/plan.rb

@@ -24,15 +24,19 @@ module AnalyticsOps
     CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/
     SECRET_KEY = Configuration::Validator::SECRET_KEY
     RETENTION_VALUES = Configuration::Validator::RETENTION_VALUES
+    USER_RETENTION_VALUES = Configuration::Validator::USER_RETENTION_VALUES
     DIMENSION_SCOPES = Configuration::Validator::DIMENSION_SCOPES
     METRIC_UNITS = Configuration::Validator::METRIC_UNITS
+    RESTRICTED_METRIC_TYPES = Configuration::Validator::RESTRICTED_METRIC_TYPES
 
     RESOURCE_FIELDS = {
       "data_stream" => %w[id name display_name type default_uri measurement_id],
       "retention" => %w[name event_data user_data reset_on_new_activity],
       "key_event" => %w[event_name counting_method],
       "custom_dimension" => %w[parameter_name display_name description scope disallow_ads_personalization],
-      "custom_metric" => %w[parameter_name display_name description scope measurement_unit]
+      "custom_metric" => %w[
+        parameter_name display_name description scope measurement_unit restricted_metric_types
+      ]
     }.freeze
     NAMED_DEFINITION_FIELDS = {
       "custom_dimension" => ["name", *RESOURCE_FIELDS.fetch("custom_dimension")],
@@ -307,7 +311,8 @@ module AnalyticsOps
     end
 
     def self.printable_string(value, path, minimum: 1, maximum: 500)
-      unless value.is_a?(String) && value.length.between?(minimum, maximum) && !CONTROL_CHARACTERS.match?(value)
+      unless value.is_a?(String) && value.length.between?(minimum, maximum) && !CONTROL_CHARACTERS.match?(value) &&
+             !Redaction.credential_shaped?(value)
         raise InvalidPlanError, "Invalid #{path}"
       end
 
@@ -380,7 +385,7 @@ module AnalyticsOps
       after = payload_hash(change.after, "#{path}.after")
       fields = RESOURCE_FIELDS.fetch(change.resource_type)
       self.class.exact_keys!(after, fields, "#{path}.after")
-      validate_resource_values!(change.resource_type, after, "#{path}.after", named: false)
+      validate_resource_values!(change.resource_type, after, "#{path}.after", named: false, desired: true)
       validate_identity!(change, after, path)
     end
 
@@ -388,8 +393,8 @@ module AnalyticsOps
       fields = NAMED_DEFINITION_FIELDS.fetch(change.resource_type, RESOURCE_FIELDS.fetch(change.resource_type))
       self.class.exact_keys!(before, fields, "#{path}.before")
       self.class.exact_keys!(after, fields, "#{path}.after")
-      validate_resource_values!(change.resource_type, before, "#{path}.before", named: true)
-      validate_resource_values!(change.resource_type, after, "#{path}.after", named: true)
+      validate_resource_values!(change.resource_type, before, "#{path}.before", named: true, desired: false)
+      validate_resource_values!(change.resource_type, after, "#{path}.after", named: true, desired: true)
       validate_identity!(change, after, path)
       validate_immutable_fields!(change.resource_type, before, after, path)
       validate_property_resource_name!(change.resource_type, before, path)
@@ -402,40 +407,81 @@ module AnalyticsOps
       hash
     end
 
-    def validate_resource_values!(resource_type, payload, path, named:)
+    def validate_resource_values!(resource_type, payload, path, named:, desired:)
       case resource_type
       when "data_stream"
-        id_string!(payload.fetch("id"), "#{path}.id")
-        resource_name!(payload.fetch("name"), "dataStreams", "#{path}.name")
-        text!(payload.fetch("display_name"), "#{path}.display_name", minimum: 0, maximum: 100)
-        enum!(payload.fetch("type"), %w[web android ios unspecified], "#{path}.type")
-        optional_uri!(payload.fetch("default_uri"), "#{path}.default_uri")
-        optional_text!(payload.fetch("measurement_id"), "#{path}.measurement_id", maximum: 64)
+        validate_data_stream_values!(payload, path, desired:)
       when "retention"
-        resource_name!(payload.fetch("name"), "dataRetentionSettings", "#{path}.name", singleton: true)
-        enum!(payload.fetch("event_data"), RETENTION_VALUES, "#{path}.event_data")
-        enum!(payload.fetch("user_data"), RETENTION_VALUES, "#{path}.user_data")
-        boolean!(payload.fetch("reset_on_new_activity"), "#{path}.reset_on_new_activity")
+        validate_retention_values!(payload, path)
       when "key_event"
-        event_name!(payload.fetch("event_name"), "#{path}.event_name")
-        enum!(payload.fetch("counting_method"), %w[once_per_event once_per_session], "#{path}.counting_method")
+        validate_key_event_values!(payload, path)
       when "custom_dimension"
-        resource_name!(payload.fetch("name"), "customDimensions", "#{path}.name") if named
-        parameter_name!(payload.fetch("parameter_name"), "#{path}.parameter_name")
-        text!(payload.fetch("display_name"), "#{path}.display_name", minimum: 1, maximum: 82)
-        text!(payload.fetch("description"), "#{path}.description", minimum: 0, maximum: 150)
-        enum!(payload.fetch("scope"), DIMENSION_SCOPES, "#{path}.scope")
-        boolean!(payload.fetch("disallow_ads_personalization"), "#{path}.disallow_ads_personalization")
+        validate_custom_dimension_values!(payload, path, named:, desired:)
       when "custom_metric"
-        resource_name!(payload.fetch("name"), "customMetrics", "#{path}.name") if named
-        parameter_name!(payload.fetch("parameter_name"), "#{path}.parameter_name")
-        text!(payload.fetch("display_name"), "#{path}.display_name", minimum: 1, maximum: 82)
-        text!(payload.fetch("description"), "#{path}.description", minimum: 0, maximum: 150)
-        enum!(payload.fetch("scope"), ["event"], "#{path}.scope")
-        enum!(payload.fetch("measurement_unit"), METRIC_UNITS, "#{path}.measurement_unit")
+        validate_custom_metric_values!(payload, path, named:, desired:)
       end
     end
 
+    def validate_data_stream_values!(payload, path, desired:)
+      id_string!(payload.fetch("id"), "#{path}.id")
+      resource_name!(payload.fetch("name"), "dataStreams", "#{path}.name")
+      text!(payload.fetch("display_name"), "#{path}.display_name", minimum: 0, maximum: 100)
+      enum!(payload.fetch("type"), ["web"], "#{path}.type")
+      optional_uri!(payload.fetch("default_uri"), "#{path}.default_uri")
+      raise InvalidPlanError, "Invalid #{path}.default_uri" if desired && payload.fetch("default_uri").nil?
+
+      optional_text!(payload.fetch("measurement_id"), "#{path}.measurement_id", maximum: 64)
+    end
+
+    def validate_retention_values!(payload, path)
+      resource_name!(payload.fetch("name"), "dataRetentionSettings", "#{path}.name", singleton: true)
+      enum!(payload.fetch("event_data"), RETENTION_VALUES, "#{path}.event_data")
+      enum!(payload.fetch("user_data"), USER_RETENTION_VALUES, "#{path}.user_data")
+      boolean!(payload.fetch("reset_on_new_activity"), "#{path}.reset_on_new_activity")
+    end
+
+    def validate_key_event_values!(payload, path)
+      event_name!(payload.fetch("event_name"), "#{path}.event_name")
+      enum!(payload.fetch("counting_method"), %w[once_per_event once_per_session], "#{path}.counting_method")
+    end
+
+    def validate_custom_dimension_values!(payload, path, named:, desired:)
+      resource_name!(payload.fetch("name"), "customDimensions", "#{path}.name") if named
+      scope = payload.fetch("scope")
+      maximum = scope == "user" ? 24 : 40
+      parameter_name!(payload.fetch("parameter_name"), "#{path}.parameter_name", maximum:)
+      display_name!(payload.fetch("display_name"), "#{path}.display_name", desired:)
+      text!(payload.fetch("description"), "#{path}.description", minimum: 0, maximum: 150)
+      enum!(scope, DIMENSION_SCOPES, "#{path}.scope")
+      disallow_ads = payload.fetch("disallow_ads_personalization")
+      boolean!(disallow_ads, "#{path}.disallow_ads_personalization")
+      return unless disallow_ads && scope != "user"
+
+      raise InvalidPlanError, "#{path}.disallow_ads_personalization is valid only for user scope"
+    end
+
+    def validate_custom_metric_values!(payload, path, named:, desired:)
+      resource_name!(payload.fetch("name"), "customMetrics", "#{path}.name") if named
+      parameter_name!(payload.fetch("parameter_name"), "#{path}.parameter_name")
+      display_name!(payload.fetch("display_name"), "#{path}.display_name", desired:)
+      text!(payload.fetch("description"), "#{path}.description", minimum: 0, maximum: 150)
+      enum!(payload.fetch("scope"), ["event"], "#{path}.scope")
+      measurement_unit = payload.fetch("measurement_unit")
+      enum!(measurement_unit, METRIC_UNITS, "#{path}.measurement_unit")
+      restricted_types = payload.fetch("restricted_metric_types")
+      enum_array!(restricted_types, RESTRICTED_METRIC_TYPES, "#{path}.restricted_metric_types")
+      validate_restricted_metric_types!(measurement_unit, restricted_types, path)
+    end
+
+    def validate_restricted_metric_types!(measurement_unit, restricted_types, path)
+      if measurement_unit == "currency" && restricted_types.empty?
+        raise InvalidPlanError, "#{path}.restricted_metric_types is required for a currency metric"
+      end
+      return if measurement_unit == "currency" || restricted_types.empty?
+
+      raise InvalidPlanError, "#{path}.restricted_metric_types is valid only for a currency metric"
+    end
+
     def validate_identity!(change, payload, path)
       expected = case change.resource_type
                  when "data_stream"
@@ -456,7 +502,7 @@ module AnalyticsOps
 
     def validate_immutable_fields!(resource_type, before, after, path)
       mutable = MUTABLE_FIELDS.fetch(resource_type)
-      changed = before.keys.reject { |key| before[key] == after[key] }
+      changed = (before.keys | after.keys).reject { |key| before[key] == after[key] }
       forbidden = changed - mutable
       raise InvalidPlanError, "#{path} changes immutable field #{forbidden.first}" unless forbidden.empty?
       raise InvalidPlanError, "#{path} update does not change any mutable field" if changed.empty?
@@ -516,14 +562,29 @@ module AnalyticsOps
       self.class.pattern_string(value, path, EVENT_NAME)
     end
 
-    def parameter_name!(value, path)
-      self.class.pattern_string(value, path, PARAMETER_NAME)
+    def parameter_name!(value, path, maximum: 40)
+      self.class.pattern_string(value, path, PARAMETER_NAME, maximum:)
     end
 
     def text!(value, path, minimum:, maximum:)
       self.class.printable_string(value, path, minimum:, maximum:)
     end
 
+    def display_name!(value, path, desired:)
+      text!(value, path, minimum: 1, maximum: 82)
+      return unless desired && !Configuration::Validator::DISPLAY_NAME.match?(value)
+
+      raise InvalidPlanError, "Invalid #{path}"
+    end
+
+    def enum_array!(value, allowed, path)
+      self.class.array(value, path)
+      unless value.all? { |item| item.is_a?(String) && allowed.include?(item) }
+        raise InvalidPlanError, "Invalid #{path}"
+      end
+      raise InvalidPlanError, "Duplicate values in #{path}" unless value.uniq.length == value.length
+    end
+
     def optional_text!(value, path, maximum:)
       return if value.nil?
 

data/lib/analytics_ops/planner.rb

@@ -90,6 +90,13 @@ module AnalyticsOps
       end
 
       current = remote.to_h
+      unless Plan::RETENTION_VALUES.include?(current.fetch("event_data")) &&
+             Plan::USER_RETENTION_VALUES.include?(current.fetch("user_data"))
+        finding("drift", "retention_unsupported", "property:#{@desired.property_id}:retention",
+                "Google returned a retention duration that Analytics Ops cannot safely change")
+        return
+      end
+
       after = current.merge(desired)
       return if equivalent?(current, after, %w[event_data user_data reset_on_new_activity])
 
@@ -153,9 +160,10 @@ module AnalyticsOps
 
         before = current.to_h
         if before.fetch("scope") != desired.fetch("scope") ||
-           before.fetch("measurement_unit") != desired.fetch("measurement_unit")
+           before.fetch("measurement_unit") != desired.fetch("measurement_unit") ||
+           before.fetch("restricted_metric_types") != desired.fetch("restricted_metric_types")
           finding("drift", "immutable_metric_conflict", "metric:#{identity}",
-                  "Custom metric scope or measurement unit differs and will not be recreated automatically")
+                  "Custom metric scope, unit, or restricted-data classification differs and will not be recreated")
           next
         end
 

data/lib/analytics_ops/rails/railtie.rb

@@ -26,30 +26,25 @@ module AnalyticsOps
 
   # Optional Rails hooks. Defining this class performs no Google API calls.
   class Railtie < Rails::Railtie
+    OPERATOR_TASKS = {
+      doctor: "Validate Analytics Ops configuration, credentials, and API access",
+      audit: "Audit configured Google Analytics state without changing it",
+      plan: "Write a deterministic Analytics Ops plan",
+      verify: "Verify that managed Google Analytics state converges",
+      overview: "Show the selected property's Analytics overview"
+    }.freeze
+
     generators do
       require_relative "../../generators/analytics_ops/install_generator"
     end
 
     rake_tasks do
       namespace :analytics do
-        desc "Validate Analytics Ops configuration, credentials, and API access"
-        task doctor: :environment do
-          RailsTasks.run("doctor")
-        end
-
-        desc "Audit configured Google Analytics state without changing it"
-        task audit: :environment do
-          RailsTasks.run("audit")
-        end
-
-        desc "Write a deterministic Analytics Ops plan"
-        task plan: :environment do
-          RailsTasks.run("plan")
-        end
-
-        desc "Verify that managed Google Analytics state converges"
-        task verify: :environment do
-          RailsTasks.run("verify")
+        OPERATOR_TASKS.each do |name, description|
+          desc description
+          task name => :environment do
+            RailsTasks.run(name.to_s)
+          end
         end
 
         desc "Run a built-in report: rake analytics:report[NAME]"

data/lib/analytics_ops/redaction.rb

@@ -13,20 +13,25 @@ module AnalyticsOps
         access[_ -]?token|refresh[_ -]?token|client[_ -]?(?:id|secret)|
         private[_ -]?key|password|api[_ -]?key|credentials?
       )
-      \s*([:=]\s*|=>\s*)["']?[^\s,"';}]+
+      ["']?\s*(?:[:=]\s*|=>\s*)(?:["'][^"'\r\n]*["']|[^\s,;\r\n}]+)
     /ix
-    CONTROL_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/
+    CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/
 
     module_function
 
+    def credential_shaped?(value)
+      text = value.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+      [PRIVATE_KEY, AUTHORIZATION, BEARER, SECRET_ASSIGNMENT].any? { |pattern| pattern.match?(text) }
+    end
+
     def message(value)
-      value.to_s
-           .gsub(PRIVATE_KEY, "[REDACTED]")
-           .gsub(AUTHORIZATION, "Authorization: [REDACTED]")
-           .gsub(BEARER, "Bearer [REDACTED]")
-           .gsub(SECRET_ASSIGNMENT) { "#{Regexp.last_match(1)}=[REDACTED]" }
-           .gsub(CONTROL_CHARACTERS, "?")
-           .slice(0, 1_000)
+      text = value.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+      text.gsub(PRIVATE_KEY, "[REDACTED]")
+          .gsub(AUTHORIZATION, "Authorization: [REDACTED]")
+          .gsub(BEARER, "Bearer [REDACTED]")
+          .gsub(SECRET_ASSIGNMENT) { "#{Regexp.last_match(1)}=[REDACTED]" }
+          .gsub(CONTROL_CHARACTERS, "?")
+          .slice(0, 1_000)
     end
   end
 

data/lib/analytics_ops/reports/catalog.rb

@@ -4,7 +4,13 @@ module AnalyticsOps
   module Reports
     # Small built-in catalog focused on acquisition and calculator outcomes.
     module Catalog
-      STANDARD_DATE_RANGE = [{ "start_date" => "28daysAgo", "end_date" => "yesterday" }].freeze
+      STANDARD_DATE_RANGE = Canonical.immutable(
+        [{ "start_date" => "28daysAgo", "end_date" => "yesterday" }]
+      )
+      ALIASES = {
+        "traffic" => "traffic_acquisition",
+        "landing-pages" => "landing_pages"
+      }.freeze
       CALCULATOR = "customEvent:calculator_slug"
       EVENT_FILTER = lambda do |value, match_type = "exact"|
         { "field" => "eventName", "match_type" => match_type, "value" => value }
@@ -73,7 +79,7 @@ module AnalyticsOps
           name: "realtime_events",
           kind: "realtime",
           dimensions: %w[eventName],
-          metrics: %w[eventCount activeUsers],
+          metrics: %w[eventCount],
           order_bys: [{ "metric" => "eventCount", "desc" => true }],
           limit: 100
         )
@@ -82,8 +88,11 @@ module AnalyticsOps
       module_function
 
       def fetch(name, kind: nil)
-        definition = DEFINITIONS.fetch(name.to_s) do
-          raise InvalidRequestError, "Unknown report #{name.inspect}; available reports: #{names.join(", ")}"
+        requested = name.to_s
+        canonical = ALIASES.fetch(requested, requested)
+        definition = DEFINITIONS.fetch(canonical) do
+          available = (names + ALIASES.keys).sort.join(", ")
+          raise InvalidRequestError, "Unknown report #{name.inspect}; available reports: #{available}"
         end
         if kind && definition.kind != kind.to_s
           raise InvalidRequestError, "Report #{name} is #{definition.kind}, not #{kind}"
@@ -93,7 +102,15 @@ module AnalyticsOps
       end
 
       def names
-        DEFINITIONS.keys.sort
+        DEFINITIONS.keys.sort.freeze
+      end
+
+      def aliases
+        ALIASES.dup.freeze
+      end
+
+      def overview
+        Overview::DEFINITIONS
       end
     end
   end