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_pal_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_pal_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_pals_in_primary(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_pals_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_pals_total",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) { return cfg.num_pals_total_validated(t, s); }
            );
        }
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::size_t>>
    num_pals_total(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = num_pals_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_pals_in_primary",
                [](const DomainConfig &cfg, ConfigScopeType t, const std::string &s) { return cfg.num_pals_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<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>>
    pals_edit_mode(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = pals_edit_mode_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<bool>>
    pal_hints_enabled(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = pal_hints_enabled_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<std::vector<PaletteHint>>>
    pal_hints(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = pal_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<TilesPalMode>>
    tiles_pal_mode(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = tiles_pal_mode_validated(type, scope);
        return validated_val;
    }
 
    // Public method with cross-field validation only (Tier 3)
    [[nodiscard]] ChainableResult<ConfigValue<AnimPalResolutionStrategy>>
    global_anim_pal_resolution_strategy(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = global_anim_pal_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<AnimMultiPalSubtileResolutionStrategy>>
    global_anim_multi_pal_subtile_resolution_strategy(ConfigScopeType type, const std::string &scope) const
    {
        auto validated_val = global_anim_multi_pal_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_pals_in_primary_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_pals_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_pals_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_pals_total_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = num_pals_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_pals_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<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>>
    pals_edit_mode_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = pals_edit_mode_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<ArtifactEditMode>>
    pals_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>>
    pal_hints_enabled_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = pal_hints_enabled_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<bool>>
    pal_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>>>
    pal_hints_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = pal_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>>>
    pal_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<TilesPalMode>>
    tiles_pal_mode_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = tiles_pal_mode_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<TilesPalMode>>
    tiles_pal_mode_raw(ConfigScopeType type, const std::string &scope) const = 0;
 
    // Protected method with single-value validation only (Tier 2)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimPalResolutionStrategy>>
    global_anim_pal_resolution_strategy_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = global_anim_pal_resolution_strategy_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimPalResolutionStrategy>>
    global_anim_pal_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<AnimMultiPalSubtileResolutionStrategy>>
    global_anim_multi_pal_subtile_resolution_strategy_validated(ConfigScopeType type, const std::string &scope) const
    {
        auto raw_val = global_anim_multi_pal_subtile_resolution_strategy_raw(type, scope);
        return raw_val;
    }
 
    // Protected virtual method that fetches raw value from provider (Tier 1)
    [[nodiscard]] virtual ChainableResult<ConfigValue<AnimMultiPalSubtileResolutionStrategy>>
    global_anim_multi_pal_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