domain_config.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
 
#include "porytiles/domain/config/anim_key_frame_resolution_strategy.hpp"
#include "porytiles/domain/config/anim_palette_resolution_strategy.hpp"
#include "porytiles/domain/config/artifact_edit_mode.hpp"
#include "porytiles/domain/config/domain_config_validators.hpp"
#include "porytiles/domain/config/packing_strategy_params.hpp"
#include "porytiles/domain/config/packing_strategy_type.hpp"
#include "porytiles/domain/config/per_anim_overrides.hpp"
#include "porytiles/domain/config/tile_sharing_alignment.hpp"
#include "porytiles/domain/config/tile_sharing_packing.hpp"
#include "porytiles/domain/config/tiles_palette_mode.hpp"
#include "porytiles/domain/models/rgba32.hpp"
#include "porytiles/domain/packing/models/palette_hint.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
#include "porytiles/xcut/config/config_scope_type.hpp"
#include "porytiles/xcut/config/config_value.hpp"
#include "porytiles/xcut/config/xcut_config_validators.hpp"
 
namespace porytiles {
 
// NOTE: DO NOT EDIT THIS FILE DIRECTLY. It is AUTO-GENERATED from config_schema.yaml.
// To add new config values or make other changes, edit config_schema.yaml and regenerate via:
//
//   uv run scripts/generate_config.py
 
class ConfigProvider; // forward declaration to avoid domain -> infra dependency
 
class DomainConfig {
  public:
    virtual ~DomainConfig() = default;
 
    virtual void add_provider(std::unique_ptr<ConfigProvider> provider) = 0;
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    num_tiles_in_primary(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_tiles_in_primary_validated(type, scope);
        // Apply cross-field validators
        if (validated_val.has_value()) {
            validated_val = compare_less_equal<std::size_t>(
                validated_val.value(),
                *this,
                type,
                scope,
                "num_tiles_total",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) {
                    return cfg.num_tiles_total_validated(t, s);
                });
        }
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    num_tiles_total(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_tiles_total_validated(type, scope);
        // Apply cross-field validators
        if (validated_val.has_value()) {
            validated_val = compare_greater_equal<std::size_t>(
                validated_val.value(),
                *this,
                type,
                scope,
                "num_tiles_in_primary",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) {
                    return cfg.num_tiles_in_primary_validated(t, s);
                });
        }
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    num_metatiles_in_primary(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_metatiles_in_primary_validated(type, scope);
        // Apply cross-field validators
        if (validated_val.has_value()) {
            validated_val = compare_less_equal<std::size_t>(
                validated_val.value(),
                *this,
                type,
                scope,
                "num_metatiles_total",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) {
                    return cfg.num_metatiles_total_validated(t, s);
                });
        }
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    num_metatiles_total(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_metatiles_total_validated(type, scope);
        // Apply cross-field validators
        if (validated_val.has_value()) {
            validated_val = compare_greater_equal<std::size_t>(
                validated_val.value(),
                *this,
                type,
                scope,
                "num_metatiles_in_primary",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) {
                    return cfg.num_metatiles_in_primary_validated(t, s);
                });
        }
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    num_palettes_in_primary(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_palettes_in_primary_validated(type, scope);
        // Apply cross-field validators
        if (validated_val.has_value()) {
            validated_val = compare_less_equal<std::size_t>(
                validated_val.value(),
                *this,
                type,
                scope,
                "num_palettes_total",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) {
                    return cfg.num_palettes_total_validated(t, s);
                });
        }
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    num_palettes_total(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_palettes_total_validated(type, scope);
        // Apply cross-field validators
        if (validated_val.has_value()) {
            validated_val = compare_greater_equal<std::size_t>(
                validated_val.value(),
                *this,
                type,
                scope,
                "num_palettes_in_primary",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) {
                    return cfg.num_palettes_in_primary_validated(t, s);
                });
        }
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    max_map_data_size(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = max_map_data_size_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    num_tiles_per_metatile(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_tiles_per_metatile_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<Rgba32>>
    extrinsic_transparency(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = extrinsic_transparency_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<bool>>
    ignore_triple_layer_content(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = ignore_triple_layer_content_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<ArtifactEditMode>>
    tiles_edit_mode(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = tiles_edit_mode_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<ArtifactEditMode>>
    palettes_edit_mode(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = palettes_edit_mode_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<bool>>
    palette_hints_enabled(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = palette_hints_enabled_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::vector<PaletteHint>>>
    palette_hints(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = palette_hints_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<PackingStrategyType>>
    packing_strategy(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = packing_strategy_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<PackingStrategyParams>>
    packing_strategy_params(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = packing_strategy_params_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<TileSharingPacking>>
    tile_sharing_packing(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = tile_sharing_packing_validated(type, scope);
        // Apply cross-field validators
        if (validated_val.has_value()) {
            validated_val = require_packing_strategy_backtracking<TileSharingPacking>(
                validated_val.value(),
                *this,
                type,
                scope,
                "packing_strategy",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) {
                    return cfg.packing_strategy_validated(t, s);
                });
        }
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<TileSharingAlignment>>
    tile_sharing_alignment(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = tile_sharing_alignment_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<TilesPaletteMode>>
    tiles_palette_mode(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = tiles_palette_mode_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<AnimPaletteResolutionStrategy>>
    global_anim_palette_resolution_strategy(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = global_anim_palette_resolution_strategy_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<AnimKeyFrameResolutionStrategy>>
    global_anim_key_frame_resolution_strategy(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = global_anim_key_frame_resolution_strategy_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<AnimMultiPaletteSubtileResolutionStrategy>>
    global_anim_multi_palette_subtile_resolution_strategy(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = global_anim_multi_palette_subtile_resolution_strategy_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<FrameLinking>>
    global_frame_linking(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = global_frame_linking_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<PerAnimOverrides>>
    per_anim_overrides(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = per_anim_overrides_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<bool>>
    cross_tileset_anim_linking(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = cross_tileset_anim_linking_validated(type, scope);
        return validated_val;
    }
 
  protected:
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_tiles_in_primary_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_tiles_in_primary_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = size_t_val_greater_than_zero(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_tiles_in_primary_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_tiles_total_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_tiles_total_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = size_t_val_greater_than_zero(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_tiles_total_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_metatiles_in_primary_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_metatiles_in_primary_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = size_t_val_greater_than_zero(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_metatiles_in_primary_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_metatiles_total_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_metatiles_total_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = size_t_val_greater_than_zero(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_metatiles_total_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_palettes_in_primary_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_palettes_in_primary_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = size_t_val_greater_than_zero(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_palettes_in_primary_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_palettes_total_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_palettes_total_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = size_t_val_greater_than_zero(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_palettes_total_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    max_map_data_size_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = max_map_data_size_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = size_t_val_greater_than_zero(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    max_map_data_size_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_tiles_per_metatile_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_tiles_per_metatile_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = size_t_val_eight_or_twelve(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::size_t>>
    num_tiles_per_metatile_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<Rgba32>>
    extrinsic_transparency_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = extrinsic_transparency_raw(type, scope);
        // Apply validators in sequence
        if (raw_val.has_value()) {
            raw_val = rgba_alpha_component_opaque(raw_val.value());
        }
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<Rgba32>>
    extrinsic_transparency_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<bool>>
    ignore_triple_layer_content_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = ignore_triple_layer_content_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<bool>>
    ignore_triple_layer_content_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<ArtifactEditMode>>
    tiles_edit_mode_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = tiles_edit_mode_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<ArtifactEditMode>>
    tiles_edit_mode_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<ArtifactEditMode>>
    palettes_edit_mode_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = palettes_edit_mode_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<ArtifactEditMode>>
    palettes_edit_mode_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<bool>>
    palette_hints_enabled_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = palette_hints_enabled_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<bool>>
    palette_hints_enabled_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::vector<PaletteHint>>>
    palette_hints_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = palette_hints_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<std::vector<PaletteHint>>>
    palette_hints_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<PackingStrategyType>>
    packing_strategy_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = packing_strategy_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<PackingStrategyType>>
    packing_strategy_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<PackingStrategyParams>>
    packing_strategy_params_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = packing_strategy_params_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<PackingStrategyParams>>
    packing_strategy_params_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<TileSharingPacking>>
    tile_sharing_packing_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = tile_sharing_packing_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<TileSharingPacking>>
    tile_sharing_packing_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<TileSharingAlignment>>
    tile_sharing_alignment_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = tile_sharing_alignment_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<TileSharingAlignment>>
    tile_sharing_alignment_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<TilesPaletteMode>>
    tiles_palette_mode_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = tiles_palette_mode_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<TilesPaletteMode>>
    tiles_palette_mode_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimPaletteResolutionStrategy>>
    global_anim_palette_resolution_strategy_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = global_anim_palette_resolution_strategy_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimPaletteResolutionStrategy>>
    global_anim_palette_resolution_strategy_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimKeyFrameResolutionStrategy>>
    global_anim_key_frame_resolution_strategy_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = global_anim_key_frame_resolution_strategy_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimKeyFrameResolutionStrategy>>
    global_anim_key_frame_resolution_strategy_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimMultiPaletteSubtileResolutionStrategy>>
    global_anim_multi_palette_subtile_resolution_strategy_validated(
        ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = global_anim_multi_palette_subtile_resolution_strategy_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimMultiPaletteSubtileResolutionStrategy>>
    global_anim_multi_palette_subtile_resolution_strategy_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<FrameLinking>>
    global_frame_linking_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = global_frame_linking_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<FrameLinking>>
    global_frame_linking_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<PerAnimOverrides>>
    per_anim_overrides_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = per_anim_overrides_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<PerAnimOverrides>>
    per_anim_overrides_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<bool>>
    cross_tileset_anim_linking_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = cross_tileset_anim_linking_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<bool>>
    cross_tileset_anim_linking_raw(ConfigScopeType type, const std::string &scope) const = 0;
};
 
} // namespace porytiles