typedef std::list<RequestQueueData> mcx::parameter_server::RequestQueue;

using mcx::parameter_server::LinkGroups = typedef typename std::vector<LinkGroup>;

using mcx::parameter_server::param_map_t = typedef std::map<std::string, Parameter*, std::less<> >;

using mcx::parameter_server::param_vector_t = typedef std::vector<Parameter*>;

using mcx::parameter_server::link_vector_t = typedef std::vector<LinkData>;

using mcx::parameter_server::OverwriteBuffer = typedef OutputBuffer;

std::unique_ptr< FileSerialization > selectSerialization(
    const std::string & file_name
)

bool load(
    const std::string & file_name,
    Parameter * root,
    bool is_relative
)

bool load(
    const std::string & file_name,
    Parameter * root,
    cmd_line::SystemMode system_mode,
    bool is_relative
)

bool save(
    const std::string & file_name,
    Parameter * root,
    size_t max_number_of_trials,
    size_t delay_us,
    bool force_update
)

bool link(
    const std::string & file_name,
    Parameter * root,
    cmd_line::SystemMode system_mode
)

bool setParameter(
    const std::string & path,
    const SetParam & set_param,
    Parameter * root
)

std::string readValue(
    const nlohmann::json & json
)

template <typename SRC_TYPE ,
typename DST_TYPE >
void convertClbBool(
    uint8_t * dst,
    const uint8_t * src,
    uint32_t size,
    const ConversionData & conversion
)

template <typename SRC_TYPE ,
typename DST_TYPE >
void convertClampClb(
    uint8_t * dst,
    const uint8_t * src,
    uint32_t size,
    const ConversionData & conversion
)

template <typename SRC_TYPE ,
typename DST_TYPE >
void convertClb(
    uint8_t * dst,
    const uint8_t * src,
    uint32_t size,
    const ConversionData & conversion
)

template <typename SRC_TYPE ,
typename DST_TYPE >
ConversionData::CoversionClb selectClamped(
    bool clamp
)

template <typename SRC_TYPE >
bool selectDst(
    DataType dst_type,
    bool clamp,
    ConversionData::CoversionClb * clb
)

bool selectConversionHelper(
    DataType src_type,
    DataType dst_type,
    bool clamp,
    ConversionData::CoversionClb * clb
)

size_t removeSurroundingSlash(
    char * dest,
    const char * source,
    size_t source_len
)

size_t rfindSingleSlash(
    const char * source,
    size_t length
)

size_t lfindSingleSlash(
    const char * source,
    size_t length
)

size_t normalizePath(
    char * normalized_path,
    size_t max_length,
    const char * base_path,
    const char * relative_path
)

constexpr auto MAX_BUFFER_SIZE = 1024u;

constexpr const char * PATH {"Path"};

constexpr const char * PARAM {"Param"};

constexpr const char * PARAMLIST {"ParamList"};

static constexpr size_t MAX_ACTION_BUFFER_LENGTH {1024};

static constexpr size_t DEFAULT_INPUT_BUFFER_LENGTH {4};

static constexpr size_t MAX_PATH_LENGTH {sizeof(motorcortex_ParameterInfo::path) - 1};

static constexpr size_t MAX_NAME_LENGTH {128};

constexpr uint32_t OVERWRITE_IS_ACTIVE = static_cast<uint32_t>(ParameterFlag::OVERWRITE_IS_ACTIVE);

constexpr uint32_t LINK_IS_ACTIVE = static_cast<uint32_t>(ParameterFlag::LINK_IS_ACTIVE);

constexpr UserGroup default_group = UserGroup::undefined;

constexpr uint32_t read_permissions = static_cast<uint32_t>(Permission::U_R) + static_cast<uint32_t>(Permission::G_R) +
                                      static_cast<uint32_t>(Permission::O_R);

constexpr uint32_t write_permissions = static_cast<uint32_t>(Permission::U_W) + static_cast<uint32_t>(Permission::G_W) +
                                       static_cast<uint32_t>(Permission::O_W);

constexpr uint32_t execute_permissions = static_cast<uint32_t>(Permission::U_E) +
                                         static_cast<uint32_t>(Permission::G_E) +
                                         static_cast<uint32_t>(Permission::O_E);

constexpr uint32_t default_permissions = motorcortex_Permission::motorcortex_Permission_permission_undefined;